The Y Combinator, a Lightning Talk from GoLab 2025

RECURSION THE HARD WAY
Y
ELEANOR MCHUGH
@feyeleanor
...AN EXTRACT FROM...

A NAMED FUNCTION CAN CALL ITSELF
package main
func main() {
main()
}
11.GO
github://feyeleanor/y_recursion_the_hard_way
this recurses because main() is a named function

BUT CAN AN ANONYMOUS FUNCTION CALL ITSELF
package main
func main() {
func(x) {
...
}
}
but how do we make an anonymous function recurse?

BUT CAN AN ANONYMOUS FUNCTION CALL ITSELF
package main
func main() {
g := func(x) {
g()
}
}
works if we run it in the scope where it's created?
otherwise it's not an option

ANONYMOUS FUNCTIONS ARE THE MATHEMATICAL BASIS OF COMPUTATION

ANONYMOUS FUNCTIONS AND THE LAMBDA CALCULUS

A FIXED POINT IS WHEN A FUNCTION RETURNS THE VALUE PASSED TO IT
in untyped lambda calculus functions are anonymous
but every function has a
fi
xed point
which is not the general case in mathematics
so given f(x) = x2 - 3x + 4
f(2) = 2 is a
fi
xed point
meaning that calculating f for a value returns that value unchanged
so given f(x) = x
f(2) = 2 is also a
fi
xed point

INTRODUCING THE Y COMBINATOR
Y g = (λf.(λx.f (x x)) (λx.f (x x))) g
= (λx.g (x x)) (λx.g (x x))
= g ((λx.g (x x)) (λx.g (x x)))
= g (Y g)
the Y combinator uses
fi
xed points
to express recursion
for an anonymous function
this is good math but hard to read!

THE UNTYPED Y COMBINATOR IN GO
func Y(g func(any) any) func(any) any {
return func(f any) func(any) any {
return f.(func(any) any)(f).(func(any) any)
}(func(f any) any {
return g(func(x any) any {
return f.(func(any) any)(f).(func(any) any)(x)
})
})
}
25.GO
WTAF?!?!?!?!
it's even worse in go because of types

THE UNTYPED Y COMBINATOR IN GO (PRE-GENERICS)
func Y(g func(interface{}) interface{}) func(interface{}) interface{} {
return func(f interface{}) func(interface{}) interface{} {
return f.(func(interface{}) interface{})(f).(func(interface{}) interface{})
}(func(f interface{}) interface{} {
return g(func(x interface{}) interface{} {
return f.(func(interface{}) interface{})(f).(func(interface{}) interface{})(x)
})
})
}
25.GO
WTAF?!?!?!?!
!!!and it used to be even worse!!!

COMPUTING FACTORIALS IS A CLASSIC RECURSIVE PROBLEM

THE UNTYPED Y COMBINATOR
func main() {
...
factorial := Y(func(g any) any {
return func(n any) (r any) {
if n, ok := n.(int); ok {
switch {
case n == 0, n == 1:
return 1
case n > 1:
return n * g.(func(any) any)(n-1).(int)
}
}
panic(n)
}
})
...
}
}(func(f any) any {
})
})
}
25.GO

INTRODUCING GO TYPES TO THE Y COMBINATOR
type Function func(any) any
}(func(f any) any {
})
})
}
func Y(g Function) Function {
return func(f any) Function {
return f.(Function)(f).(Function)
}(func(f any) any {
return f.(Function)(f).(Function)(x)
})
})
}
26.GO
becomes

func Recursor(f any) Function {
}
return func(f any) Function {
}(func(f any) any {
return f.(Function)(f).(Function)(x)
})
})
}
return Recursor(
func(f any) any {
return Recursor(f)(x)
})
})
}
26.GO
becomes

}
type Transformer func(Function) Function
return Recursor(
func(f any) any {
})
})
}
func Y(g Transformer) Function {
return Recursor(
func(f any) any {
})
})
}
26.GO
becomes

}
func main() {
...
factorial := Y(func(g Function) Function {
switch {
case n == 0, n == 1:
return 1
case n > 1:
return n * g(n-1).(int)
}
}
panic(n)
}
})
...
}
func Y(g Transformer) Function {
return Recursor(
func(f any) any {
})
})
}
27.GO

SIMPLIFYING THE TYPED Y COMBINATOR
Y g = (λf.(λx.f (x x)) (λx.f (x x))) g
= (λx.g (x x)) (λx.g (x x))
= g ((λx.g (x x)) (λx.g (x x)))
= g (Y g)

SIMPLIFYING THE TYPED Y COMBINATOR
type Recursor func(Recursor) Function
func (r Recursor) Apply(t Transformer) Function {
return t(r(r))
}
func Y(t Transformer) Function {
g := func(r Recursor) Function {
return func(x any) any {
return r.Apply(t)(x)
}
}
return g(g)
}
func main() {
...
factorial := Y(func(g Function) Function {
switch {
case n == 0, n == 1:
return 1
case n > 1:
return n * g(n-1).(int)
}
}
panic(n)
}
})
...
}
28.GO

THE Y COMBINATOR WITH GENERIC TYPES
type Function[T, R any] func(T) R
type Transformer[T, R any] func(Function[T, R]) Function[T, R]
type Recursor[T, R any] func(Recursor[T, R]) Function[T, R]
func (r Recursor[T, R]) Apply(t Transformer[T, R]) Function[T, R] {
return t(r(r))
}
func Y[T, R any](t Transformer[T, R]) Function[T, R] {
g := func(r Recursor[T, R]) Function[T, R] {
return func(x T) R {
return r.Apply(t)(x)
}
}
return g(g)
}
func main() {
...
factorial := Y(func(g Function[int, int]) Function[int, int] {
return func(n int) (r int) {
switch {
case n < 0:
panic(n)
case n > 1:
return n * g(n - 1)
}
return 1
}
})
...
}
29.GO

THE GENERIC Y COMBINATOR WITH AUTOMATIC RESULT CACHING
func Y[T comparable, R any](t Transformer[T, R]) Function[T, R] {
m := make(map[T]R)
g := func(r Recursor[T, R]) Function[T, R] {
return func(x T) (v R) {
var ok bool
if v, ok = m[x]; ok {
return v
}
v = r.Apply(t)(x)
m[x] = v
fmt.Printf("Y: setting m[%v] = %vn", x, v)
return v
}
}
return g(g)
}
func main() {
...
factorial := Y(func(g Function[int, int]) Function[int, int] {
return func(n int) (r int) {
switch {
case n < 0:
panic(n)
case n > 1:
return n * g(n-1)
}
return 1
}
})
...
}
30.GO

LEANPUB://GONOTEBOOK [GITHUB | SLIDESHARE]://FEYELEANOR

The Y Combinator, a Lightning Talk from GoLab 2025

More Related Content

Similar to The Y Combinator, a Lightning Talk from GoLab 2025

More from Eleanor McHugh

Recently uploaded

The Y Combinator, a Lightning Talk from GoLab 2025