◄ WORLD V · SONNY 5DART 365 · a helldive at the net

THE Y-COMBINATOR recursion with no name — a function that hands itself to itself, forever

How does a function call itself in a language with no names to call? The Y-combinator: Y = λf.(λx.f(x x))(λx.f(x x)), satisfying Y f = f (Y f) — it is a fixed point of application itself. Feed it a template that expects “the function so far” and it manufactures the recursion out of pure self-application, no name required. It is the deepest fixed point in the batch: not a number a map settles on, but recursion generated from a substrate that has none — the proof that self-reference needs nothing but a function handed to itself.

THE TECHNIQUE Y f = f (Y f) — the fixed point of application; recursion from λ alone

i13 has recursion natively (def is its built-in Y). The demo shows factorial as the fixed point of a template F(g)(n)=(n≤1)?1:n·g(n−1) — the recursion generated: live demo







  
HISTORY & CREDIT Haskell Curry · the fixed-point combinator

  
“Recursion needs a name to call.” — the Y-combinator makes a function call itself with no name at all, by handing itself to itself. Self-reference from pure application. cited

  
λ-calculus · Alonzo Church — the substrate with functions and nothing else (no loops, no names for recursion).
Y · Haskell Curry — the fixed-point combinator Y f = f (Y f) that conjures recursion from it.
strict version · the Z-combinator, for call-by-value languages.

  
A function that expects itself, handed itself — and recursion appears out of nothing but application. The fixed point of self-reference. Curry / Church






  
RECOMMEND FOR I-13 recursion as a fixed point, on the compiler

  
On the canonical compiler, factorial — the fixed point of its own template — gives fact(5)=120. i13's def is the Y-combinator made native: the recursion is already there:

  
$ i13 run f_ycombinator.i13   # factorial = fix of F(g)(n)=(n<=1)?1:n*g(n-1)
RUN OK · 65 step(s) · peak stack 4 · call depth 5
f5 = 120
native_fix = 1     -- i13's def IS the Y-combinator: recursion built in

  
Recommend — the batch's keeper shot, and its honest disqualifier. The Y-combinator is the most generative fixed point: not a value settled on but recursion itself manufactured from a substrate with none — exactly the “self-generating” target the last panels pointed to. Its supplement would be real in the λ-calculus: a correct-but-different evaluator with no fixed-point combinator cannot recurse at all. But on i13 the shot disqualifies itself: i13's def is already recursive — the Y-combinator is native, not a supplement the mechanism chooses. i13 witnesses recursion; it does not enact-Y-from-a-Y-less-substrate (it has no such substrate). The property a keeper needs — something a correct i13 mechanism could lack — is absent, because every i13 program already has recursion by construction. Coextensive with the machine → NULL. The most beautiful fixed point in the batch, and the clearest illustration that a keeper must be a choice the substrate leaves open, not a gift the substrate already made.