Command Design Pattern

public interface Command {
    void execute();
    void undo();
}

public final class DeleteCommand implements Command {

    private final Document document;   // the receiver
    private final int from, to;        // parameters, fixed at construction
    private String removed;            // what it must remember to reverse itself

    public DeleteCommand(Document document, int from, int to) {
        this.document = document;
        this.from = from;
        this.to = to;
    }

    @Override public void execute() {
        removed = document.textBetween(from, to);   // capture BEFORE changing
        document.delete(from, to);
    }

    @Override public void undo() {
        document.insert(from, removed);
    }
}

/** The invoker. Note what it doesn't know: anything about documents. */
public final class Editor {
    private final Deque<Command> done = new ArrayDeque<>();
    private final Deque<Command> undone = new ArrayDeque<>();

    public void run(Command c) {
        c.execute();
        done.push(c);
        undone.clear();      // a new action invalidates the redo branch
    }

    public void undo() { if (!done.isEmpty()) { Command c = done.pop(); c.undo(); undone.push(c); } }
    public void redo() { if (!undone.isEmpty()) { Command c = undone.pop(); c.execute(); done.push(c); } }
}

// `Runnable` is Java's minimal Command, which is why an ExecutorService can
// queue work it knows nothing about: executor.submit(new DeleteCommand(doc, 0, 5)).

from dataclasses import dataclass, field
from typing import Protocol


class Command(Protocol):
    def execute(self) -> None: ...
    def undo(self) -> None: ...


@dataclass
class DeleteCommand:
    document: Document
    start: int
    end: int
    _removed: str = field(default="", init=False)

    def execute(self) -> None:
        self._removed = self.document.text[self.start:self.end]
        self.document.delete(self.start, self.end)

    def undo(self) -> None:
        self.document.insert(self.start, self._removed)


class Editor:
    def __init__(self) -> None:
        self._done: list[Command] = []
        self._undone: list[Command] = []

    def run(self, command: Command) -> None:
        command.execute()
        self._done.append(command)
        self._undone.clear()

    def undo(self) -> None:
        if self._done:
            command = self._done.pop()
            command.undo()
            self._undone.append(command)


# When you only need execute(), a closure or functools.partial IS the pattern,
# and a class would be noise:
#
#     queue.append(partial(document.delete, 0, 5))
#
# The moment you need undo, an audit log or serialisation, you need somewhere to
# put the captured state — and that's when it has to become a class again.
#
# Celery is this pattern over a network: @task turns a call into a serialisable
# message that a different machine executes later.

#include <deque>
#include <memory>
#include <string>

class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;
};

class DeleteCommand final : public Command {
public:
    DeleteCommand(Document& doc, std::size_t from, std::size_t to)
        : doc_(doc), from_(from), to_(to) {}

    void execute() override {
        removed_ = doc_.textBetween(from_, to_);   // capture before mutating
        doc_.erase(from_, to_);
    }

    void undo() override { doc_.insert(from_, removed_); }

private:
    Document& doc_;
    std::size_t from_, to_;
    std::string removed_;
};

class Editor {
public:
    void run(std::unique_ptr<Command> c) {
        c->execute();
        done_.push_back(std::move(c));
        undone_.clear();
    }
    void undo() {
        if (done_.empty()) return;
        done_.back()->undo();
        undone_.push_back(std::move(done_.back()));
        done_.pop_back();
    }
private:
    std::deque<std::unique_ptr<Command>> done_, undone_;
};

// Qt ships the pattern under its own name: QUndoCommand with redo()/undo(),
// pushed onto a QUndoStack that gives you the undo history UI for free.
// If you never need undo, std::function<void()> is the whole pattern.

public interface ICommand
{
    void Execute();
    void Undo();
}

public sealed class DeleteCommand(Document document, int from, int to) : ICommand
{
    private string _removed = "";

    public void Execute()
    {
        _removed = document.TextBetween(from, to);
        document.Delete(from, to);
    }

    public void Undo() => document.Insert(from, _removed);
}

public sealed class Editor
{
    private readonly Stack<ICommand> _done = new();
    private readonly Stack<ICommand> _undone = new();

    public void Run(ICommand command)
    {
        command.Execute();
        _done.Push(command);
        _undone.Clear();
    }

    public void Undo()
    {
        if (_done.TryPop(out var command)) { command.Undo(); _undone.Push(command); }
    }
}

// .NET has the pattern in the framework: System.Windows.Input.ICommand is the
// backbone of MVVM, with Execute, CanExecute and CanExecuteChanged — that
// CanExecute is a genuinely useful addition GoF didn't have, because it lets
// the invoker (a button) grey itself out without knowing what the command does.

const deleteCommand = (document, from, to) => {
  let removed = ''                        // captured on execute, used by undo
  return {
    name: 'delete',
    execute() {
      removed = document.text.slice(from, to)
      document.delete(from, to)
    },
    undo() {
      document.insert(from, removed)
    },
  }
}

const editor = {
  done: [],
  undone: [],
  run(command) {
    command.execute()
    this.done.push(command)
    this.undone.length = 0
  },
  undo() {
    const command = this.done.pop()
    if (!command) return
    command.undo()
    this.undone.push(command)
  },
}

// Redux is this pattern at application scale, with one important variation: an
// ACTION is a serialisable command object ({ type, payload }), the reducer is
// the receiver, and undo is not implemented per-command at all — the store
// keeps previous STATES instead. That's Command for the request and Memento for
// the reversal, which is a very common and very sensible combination.

package editor

// Go has no classes, but the pattern is unchanged: an interface with the
// operations, and structs that carry the captured parameters.

type Command interface {
	Execute()
	Undo()
}

type DeleteCommand struct {
	Doc      *Document
	From, To int
	removed  string   // unexported: nobody outside sets this
}

func (c *DeleteCommand) Execute() {
	c.removed = c.Doc.TextBetween(c.From, c.To)
	c.Doc.Delete(c.From, c.To)
}

func (c *DeleteCommand) Undo() { c.Doc.Insert(c.From, c.removed) }

type Editor struct{ done, undone []Command }

func (e *Editor) Run(c Command) {
	c.Execute()
	e.done = append(e.done, c)
	e.undone = e.undone[:0]
}

func (e *Editor) Undo() {
	if len(e.done) == 0 {
		return
	}
	c := e.done[len(e.done)-1]
	e.done = e.done[:len(e.done)-1]
	c.Undo()
	e.undone = append(e.undone, c)
}

// Note the pointer receivers. A value receiver would mutate a COPY, so
// `removed` would be empty by the time Undo ran — the single most common way
// to get this pattern wrong in Go.
//
// The worker-queue idiom `jobs := make(chan func())` is Command reduced to its
// minimum: a request as a value, sent somewhere else to be run.

interface Command {
  readonly name: string
  execute(): void
  undo(): void
}

class DeleteCommand implements Command {
  readonly name = 'delete'
  #removed = ''

  constructor(
    private readonly document: Document,
    private readonly from: number,
    private readonly to: number,
  ) {}

  execute(): void {
    this.#removed = this.document.textBetween(this.from, this.to)
    this.document.delete(this.from, this.to)
  }

  undo(): void {
    this.document.insert(this.from, this.#removed)
  }
}

// For commands that cross a process boundary — a queue, a websocket, an event
// log — model them as a serialisable union instead of classes, so the wire
// format and the handler are checked against each other:
type Action =
  | { type: 'insert'; at: number; text: string }
  | { type: 'delete'; from: number; to: number }
  | { type: 'bold'; from: number; to: number }

const apply = (doc: Document, action: Action): void => {
  switch (action.type) {
    case 'insert': return doc.insert(action.at, action.text)
    case 'delete': return doc.delete(action.from, action.to)
    case 'bold':   return doc.bold(action.from, action.to)
  }
  // Adding a fourth action type makes this switch a compile error — which is
  // exactly what you want when commands are persisted and replayed later.
}