The Memento Pattern for Undo/Redo

In this lesson, you will learn how to implement transactional undo/redo history by using the Memento pattern to capture and restore consistent snapshots of your data structures.

The Core Concept

The Memento pattern provides a way to save the internal state of an object so that it can be restored later without violating encapsulation. In Rust, we achieve this by defining a Snapshot trait. When our domain object needs to be "undoable," we create a lightweight struct—the Memento—that captures the necessary fields. By maintaining a stack of these snapshots, we can roll back the state of our application to any previous point in time.

Implementing Transactional Snapshots

To ensure consistency, we use a trait to define how an object interacts with its history.

trait Memento {
    type State;
    fn save(&self) -> Self::State;
    fn restore(&mut self, state: Self::State);
}

struct Editor {
    content: String,
    history: Vec<String>,
}

impl Memento for Editor {
    type State = String;
    
    fn save(&self) -> Self::State {
        self.content.clone()
    }
    
    fn restore(&mut self, state: Self::State) {
        self.content = state;
    }
}

By decoupling the state (the String in this example) from the logic, we create a system where "undo" is simply the act of popping a state from a Vec and passing it to restore. This pattern is particularly powerful because it treats the "undo" operation as a first-class citizen of your type system. Rather than tracking changes (like "delete character"), you are tracking snapshots of truth.

Why this works

This approach is highly idiomatic for Rust because it relies on explicit ownership of the state data. When you save, you clone the data into the history stack, ensuring that the history has its own copy of the world as it existed then. When you restore, the current instance takes ownership of that past state, effectively overwriting its current, potentially incorrect data. This guarantees that your application state remains predictable, even if the "undo" stack grows quite large.

Key Takeaway: The Memento pattern creates a robust undo system by transforming state transitions into a stack of immutable snapshots, allowing you to restore any previous consistent version of your object.