The memento design pattern in Kotlin

I started playing with the memento pattern for a use case I was researching when I realized that the Kotlin implementation had a, potentially, show stopper in comparison with the Java one:

I could not use a private property from within the same file

Why was that a show stopper? We’ll see, but first, what is the memento pattern?

Memento pattern

This pattern is a good way to implement a functionality that helps in restoring previous states. One good example is the undo in our text editors. You can write, edit, delete and then, by hitting undo, take each action back.

There are three main ingredients for this pattern:

1. the originator that holds the current state and creates snapshots of itself,
2. the memento that, in essence, is the snapshot with perhaps some additional metadata and
3. the caretaker that orchestrates the backup/restore of the state

So in our example the originator is the editor which knows what the text is, the carets position etc, the memento a copy of those values and the caretaker can be the interface between the user and the editor.

Java implementation

Lets try to have an overly simplified version of the above example in Java:

	public final class Editor {
	private final List<String> text;
	private int caretPosition;
	public Editor() {
	this.text = new ArrayList<>();
	this.caretPosition = 0;
	}
	public void write(final String sentence) {
	text.add(sentence);
	caretPosition = calculateCaretPositionInEndOf(text);
	}
	public void edit(final int index, final String newSentence) {
	text.remove(index);
	text.add(index, newSentence);
	final List<String> subText = text.subList(0, index + 1);
	caretPosition = calculateCaretPositionInEndOf(subText);
	}
	public void delete(final int index) {
	final List<String> subText = new ArrayList<>(text.subList(0, index));
	text.remove(index);
	caretPosition = calculateCaretPositionInEndOf(subText);
	}
	public void render(final Screen screen) {
	final String allText = String.join("", text);
	screen.render(allText);
	screen.renderCaretAt(caretPosition);
	}
	public Memento backup() {
	return new Memento(text, caretPosition);
	}
	public void restore(final Memento memento) {
	text.clear();
	text.addAll(memento.text);
	caretPosition = memento.caretPosition;
	}
	private int calculateCaretPositionInEndOf(final List<String> lines) {
	return lines.stream().mapToInt(String::length).sum() + 1;
	}
	public static final class Memento {
	private final List<String> text;
	private final int caretPosition;
	public Memento(List<String> text, int caretPosition) {
	this.text = new ArrayList<>(text);
	this.caretPosition = caretPosition;
	}
	}
	}

view raw memento__originator_memento_in_java.java hosted with ❤ by GitHub

Here the editor, besides manipulating text, is able to produce snapshots of its state in a way that only itself can access the state’s values. The Memento class might be public, in order to allow the caretaker to handle instances of it, but its fields are private and only the originator can read them.
A great way to copy something while having the smallest possible API surface and maximum privacy.

As a matter of fact, here is the caretaker and its usage:

	class UI(
	private val screen: Screen
	) {
	private val editor = Editor()
	private val backups = mutableListOf<Memento>()
	fun write(text: String) {
	backups.add(0, editor.backup())
	editor.write(text)
	editor.render(screen)
	}
	fun edit(index: Int, text: String) {
	backups.add(0, editor.backup())
	editor.edit(index, text)
	editor.render(screen)
	}
	fun delete(index: Int) {
	backups.add(0, editor.backup())
	editor.delete(index)
	editor.render(screen)
	}
	fun undo() {
	val memento = backups.removeAt(0)
	editor.restore(memento)
	editor.render(screen)
	}
	}
	fun main() {
	val screen = StdoutScreen()
	val ui = UI(screen)
	with(ui) {
	write("Hello, there! ")
	write("How are you? ")
	write("I hope you feel good :)")
	edit(1, "Kotlin! ")
	delete(1)
	undo()
	undo()
	undo()
	undo()
	undo()
	}
	}
	/* which produces this:
	Hello, there! |
	Hello, there! How are you? |
	Hello, there! How are you? I hope you feel good :)|
	Hello, there! Kotlin! |I hope you feel good 🙂
	Hello, there! |I hope you feel good 🙂
	Hello, there! Kotlin! |I hope you feel good 🙂
	Hello, there! How are you? I hope you feel good :)|
	Hello, there! How are you? |
	Hello, there! |
	|
	/*

view raw memento__caretaker_usage.kt hosted with ❤ by GitHub

As you can see the UI uses the editor to write, edit, delete but before that it saves a backup with the editor’s state in order to restore it every time the user hits undo!

Kotlin implementation

So lets move originator and memento to Kotlin. Ctrl+Alt+Shift+K and boom.. we have a problem:

Kotlin, in contrast with Java, does not allow accessing private properties when in the same file.

What do we do? Well we can always make the properties public:

	class Memento(text: List<String>, caretPosition: Int) {
	val text: List<String>
	val caretPosition: Int
	init {
	this.text = ArrayList(text)
	this.caretPosition = caretPosition
	}
	}

view raw memento__memento_with_public_properties.kt hosted with ❤ by GitHub

but this way we, indirectly, expose the editors state:

Another way to implement the pattern is to have Memento as an interface with no state for the public API and have a private implementation of it for internal usage:

	class Editor {
	// …
	fun backup(): Memento {
	return ActualMemento(text, caretPosition)
	}
	fun restore(memento: Memento) {
	if (memento !is ActualMemento) return
	text.clear()
	text.addAll(memento.text)
	caretPosition = memento.caretPosition
	}
	// …
	interface Memento
	private class ActualMemento(text: List<String>, caretPosition: Int) : Memento {
	val text: List<String>
	val caretPosition: Int
	init {
	this.text = ArrayList(text)
	this.caretPosition = caretPosition
	}
	}
	}

view raw memento__memento_with_interface.kt hosted with ❤ by GitHub

this way we do not expose any state but we do open a bit our API. We now have an interface that can be implemented and given to the restore() function.

Inner classes

Fortunately Kotlin has inner classes. An inner class can access the outer class’s members but, most importantly, can be extended only from within the outer class. This means that this:

	class Editor {
	// …
	fun backup(): Memento {
	return ActualMemento(text, caretPosition)
	}
	fun restore(memento: Memento) {
	memento as ActualMemento
	text.clear()
	text.addAll(memento.text)
	caretPosition = memento.caretPosition
	}
	// …
	open inner class Memento
	private inner class ActualMemento(text: List<String>, caretPosition: Int) : Memento() {
	val text: List<String>
	val caretPosition: Int
	init {
	this.text = ArrayList(text)
	this.caretPosition = caretPosition
	}
	}
	}

view raw memento__memento_with_inner_class.kt hosted with ❤ by GitHub

checks all our boxes. We keep the originator’s state private and our overall API small!