The Essence Distilled: What Minimal ML Implementations Reveal About Language Design

In the landscape of programming language implementation, a curious phenomenon emerges: the persistent allure of minimal ML-family compilers and interpreters. These compact implementations—some under 500 lines of code—offer more than pedagogical value; they form crystalline structures that reveal the essential atoms of language design. Through their constraints, we gain unexpected clarity about what constitutes irreducible complexity in type systems, runtime mechanisms, and compiler architecture.

The Feature-Cost Matrix

The most striking revelation from analyzing dozens of implementations lies in their shared cost structure for language features. Certain constructs demand inherent implementation weight regardless of host language:

• Closures consistently require ~200 LOC for conversion and runtime support (MinCaml being the canonical example)
• Hindley-Milner type inference occupies ~300 LOC even in optimal implementations (Algorithm W)
• Algebraic effects add ~500-1500 LOC for handler machinery (Eff)
• Garbage collection imposes ~200 LOC even in Cheney's minimal design

This consistency across implementations—from OCaml (PLZoo poly) to Haskell (Ben Lynn's compiler chain)—suggests these are fundamental computational costs rather than implementation artifacts. The numbers form a kind of Planck's constant for language features: thresholds below which functionality cannot shrink.

The Minimalism Frontier

At the bleeding edge of compression, extraordinary specimens challenge assumptions:

• Hirrolot's CoC (gist) packs dependent types into 80 lines by embracing bidirectional checking
• MinCaml achieves native code generation in 2K LOC by omitting polymorphism—a deliberate tradeoff that exposes how type parameterization dominates compiler complexity
• Ben Lynn's bootstrap chain demonstrates how combinatory logic enables Haskell-like features without traditional closure machinery
• Simple-sub (repo) distills algebraic subtyping research into 500 LOC of Scala, proving advanced type theory needn't require complex implementations

These projects reveal counterintuitive truths: that dependent types can be simpler to implement than Haskell's typeclasses, and that closure conversion often contributes more implementation weight than the type system itself.

The Self-Hosting Paradox

Several implementations (mlml, aqaml) achieve self-hosting in under 5K LOC by stripping ML down to its ontological minimum—no type inference, just explicit annotations. This surgical reduction exposes ML's core as fundamentally simpler than its common extensions: pattern matching and algebraic data types require just ~200 LOC when divorced from type inference.

The implications resonate with 1ML's unification of module and core languages: when we remove layers of indirection, we discover that modules aren't inherently complex—it's their interaction with type inference that creates complexity.

The Production-Ready Exception

MicroHs stands as the anomaly that disproves the rule: (paper) a nearly complete Haskell implementation bootstrappable from C in under 30K LOC. Its existence demonstrates that production language features—typeclasses, do-notation, modules—can be implemented compactly when leveraging combinatory logic rather than traditional closure strategies. The tradeoff emerges in runtime performance rather than implementation size.

The Educational Imperative

These miniature implementations form an accidental curriculum:

• Write You a Haskell provides the sequential construction path
• Elaboration Zoo offers type checking masterclasses
• THIH distills Haskell's type system into 429 lines of executable specification

Together they create a ladder of understanding from lambda calculus to dependent types, each step validated by implementable code.

Counterperspective: The Cost of Omission

The minimalist approach inevitably sacrifices real-world utility:

1. Error messaging rarely fits in sub-500LOC type checkers
2. Optimization pipelines (like MinCaml's 50LOC DCE) handle only trivial cases
3. Ecosystem concerns (package management, FFI) are universally absent

Projects like Dhall (repo) reveal the tradeoff: termination checking requires significant implementation weight (~4K LOC) despite the language's simplicity.

Conclusion: Essence Before Accident

These miniature implementations collectively argue that programming languages possess inherent complexity nuclei—features whose implementation cost remains constant across paradigms. They remind us that before we build languages with millions of lines of infrastructure, we should first understand what cannot be minimized. In their constraints, we find the irreducible essence of computation: that closures demand representation, that type inference requires unification, and that some abstractions unavoidably consume their weight in code.

The next frontier may lie in Scrapscript's content-addressable model or EYG's effect-based FFI—projects proving that minimalism needn't mean stagnation. As Andreas Rossberg demonstrated with 1ML, sometimes radical simplification requires first building the smallest possible vehicle capable of carrying the idea.