This is a visual, interactive tutorial on parser combinators — the functional programming pattern where you build complex parsers by snapping together small, composable ones like LEGO bricks. There is essentially no prose. The teaching happens through type signatures, input/output examples, and animated diagrams that show how each parser consumes a prefix of a string and passes the remainder to the next parser in the chain. The core pedagogical move is showing the Parser type — a function from string to [T, string] — and then demonstrating how pSeq, pMap, and repetition emerge naturally from that single abstraction. Each concept gets a visual beat: pHello chews off "Hello" and leaves " 100". pIgnoreWhitespace eats the space. pInteger grabs "100". Chain them with pSeq, and you get a tuple. Wrap with pMap, and you get a structured object. The ping-output example at the end shows where this leads: real-world text parsed into a clean JSON structure. The fold/unfold framing at the close is the sharpest move. Parsing is presented as the inverse of serialization — unfolding structure from flat text, the mirror image of folding structure into a flat string via reduce. That's a genuine conceptual insight delivered in two diagrams and zero sentences. What works: the progressive disclosure is nearly perfect. Each example adds exactly one concept. The type annotations serve as both documentation and proof. The ping example earns its complexity because every building block was established earlier. If you already know what a parser combinator is, this won't teach you anything new — but if you've bounced off textual explanations, the visual approach may be the version that finally clicks. What's missing: error handling, backtracking, choice (the or combinator), and any discussion of when parser combinators are the wrong tool. The tutorial stops at the happy path. There's no mention of PEG grammars, Packrat parsing, or how this relates to lexer/parser separation in real compilers. It's a taste, not a meal. The format itself — a scrollable visual explainer with no words — is a bet on the reader's willingness to slow down and read diagrams carefully. It rewards that patience handsomely but will lose anyone who skims. The ping example is the payoff that justifies the climb. As a piece of technical pedagogy, this is a small, polished gem that does one thing well: it makes the core abstraction of parser combinators feel obvious. It doesn't try to be comprehensive, and that restraint is its greatest strength.
