Modal Editing — Modes

Now the vi heart of the course. Everything so far — raw input, painted frames, a buffer — could become a notepad: keys insert themselves, arrows move. vi's founding idea is stranger and, once learned, unshakeable: the same key means different things depending on mode. In normal mode the keyboard is a command console — x deletes, w hops a word, nothing inserts. In insert mode it's a typewriter. In command-line mode (after :) you're typing an instruction to be executed on Enter.

The lineage explains the shape. Bill Joy grew vi (1976) out of the line editor ex, itself descended from ed — on printing terminals, where "editing" was a command language (ed still answers your typos with a lone ?). When video terminals arrived, Joy put a live viewport on top of ex; the command-language soul stayed. The hardware left fingerprints too: Joy's terminal was a Lear Siegler ADM-3A, whose keyboard had arrows printed on H, J, K, L — that's why those keys move the cursor — and whose Esc key sat where Tab does today, an easy pinky reach. Modern keyboards moved Esc; the mode-switch key stayed, and generations of vi users remap Caps Lock to chase it. :wq, hjkl, the ~ — none of it is arbitrary; all of it is 1976 preserved in muscle memory.

Why does modality survive? Because it turns editing into a composable language. Next lesson: motions as nouns. The one after: operators as verbs, and d w — "delete a word" — as a sentence. None of that grammar works if every printable key is busy meaning itself, which is exactly what insert mode is for: a mode where keys mean themselves, entered deliberately, left with Esc.

The mode machine

Mechanically, modes are a small state machine that sits in front of everything you've built: each decoded Key is dispatched first on the current mode. The transitions:

• Normal → Insert: i (insert here), I (insert at first non-blank), a (append after cursor), A (append at end of line), o (open a line below), O (open above). Six doors into the same mode, differing only in where they put the cursor first — the cursor moves are the editor core's job (final challenge); the transition is the machine's.
• Insert → Normal: Esc. The only door out. (vi's deep bet: you spend most of your time in normal mode, so leaving insert must be one keystroke, always the same one.)
• Normal → Command: : opens the command line at the bottom of the screen. Keys now build up a string, shown as you type. Enter executes it; Esc abandons it; Backspace erases — and backspacing past the start cancels back to normal mode, a small authentic vi behavior the tests check.

std::visit earns its keep here: dispatching a Key variant means handling each alternative, and the overloaded-lambdas idiom is the standard C++ pattern for it:

template <class... Ts> struct overloaded : Ts... { using Ts::operator()...; };

std::visit(overloaded{
    [&](char c)        { /* printable key  */ },
    [&](CtrlKey k)     { /* control chord  */ },
    [&](SpecialKey k)  { /* Esc, Enter ... */ },
}, key);

Forget one alternative and it doesn't compile — the sum-type payoff: the compiler enforces that every kind of key has a decided meaning in every mode. An if/else chain over holds_alternative compiles fine with a case missing; the visit does not.

The machine below returns the executed command string and leaves interpreting it to a parser — the second challenge, where std::variant appears on the output side: a parsed command is one-of-several shapes, exactly what a variant is for.