Archives

Derive the Z-combinator from self-application using simple program transformations, then discover its relationship to the Y-combinator.

Learn how to express recursion in FUN even though it lacks recursive bindings.

Fix a subtle problem with currying and free variables by changing what FUN stores in a function value, uncovering closures along the way.

Extend LET with first-class functions, then use currying and partial application to uncover an unexpected consequence of how function calls are evaluated.

LETDEP gives multiple-binding let expressions dependency-ordered binding semantics: initializer dependencies determine the evaluation order, allowing forward references while rejecting duplicate names and cyclic bindings.

LETSEQ gives multiple-binding let expressions sequential binding semantics: bindings are evaluated in source order, with each new binding becoming available to the ones that follow it.

LETPAR gives multiple-binding let expressions parallel binding semantics: every initializer is evaluated in the incoming environment, so sibling bindings cannot see one another.

Extend LET so a single let expression can contain multiple bindings, updating the grammar, AST, and parser before deciding what those bindings mean.

LET extends VAR with let expressions, allowing programs to introduce local bindings and showing how environments determine their scope and support shadowing.

VAR extends IF with variable expressions and environments, making evaluation depend on context as variable names are looked up in the current environment.

IF extends ZERO with conditional expressions, using Boolean conditions to choose which of two branches to evaluate while leaving the other unevaluated.

See how grammar and AST design in a tiny Elm interpreter can turn runtime type errors into syntax errors, simplify evaluation, and connect to GADTs.

ZERO extends DIFF with the zero? predicate and Boolean values, then introduces runtime type errors for expressions that use values of the wrong type.

Learn how lexeme parsers simplify whitespace handling in elm/parser by consuming trailing whitespace and keeping parsers close to the grammar.

Learn why recursive Elm parsers create cyclic definitions, how Parser.lazy breaks the cycle, and when recursive parsers do and don't need it.

DIFF extends CONST with difference expressions whose operands are themselves expressions, revealing the same recursive structure in the grammar, AST, parser, and evaluator.

Set up a reproducible Elm interpreter project with a Nix flake, Elm tooling, helper commands, source and test structure, and grammar documentation.

Learn how to test an Elm interpreter with elm-test at the lexer, parser, and interpreter boundaries, then extract a reusable testValue helper.

CONST is a tiny Elm interpreter for non-negative integer constants, showing the path from source text through an AST to an evaluated value.