programming musings
06 Aug 2014

# spj's y-combinator in scheme

Recently i bought a second-hand copy of Simon Peyton Jones' classic The implementation of functional programming languages, and i've been having some very pleasant reading hours during the last week.

For instance, i've enjoyed Simon's clear and to-the-point introduction to the lambda calculus and, more concretely, his really lucid explanation of the workings of recursion and the Y combinator. As a matter of fact, i've enjoyed it so much that i just wanted to briefly reproduce it here, paraphrased in my surely poorer style, just for the fun of it.

In the pure lambda calculus, there's no direct way of defining a function that refers to itself: all you have is the ability to define anonymous lambda abstractions. Using Scheme's syntax, that means that you can use `lambda` as much as you want, as in

```((lambda (x) (+ 1 x)) 3)
```

but `define` (recursive or not) is not available. For instance, you cannot define a `list-length` recursive function like this:

```(define list-length
(lambda (lst) (if (null? lst) 0 (+ 1 (list-length (cdr lst))))))
```

the main problem being the appearance of `list-length` in the lambda expression's body. So the general issue we want to solve is how to define a function `f` of the form

```f = (... f ...)
```

without referring to `f` in the body. When all you have is lambda calculus, everything looks like a function: we can rewrite the right hand side of the above equation as a lambda application:

```f = ((lambda (x) (... x ...)) f) := (h f)
```

where we've defined `h := (lambda (x) (... x ...))`. For instance, in our length example, `h` is the function

```h = (lambda (x)
(lambda (lst)
(if (null? lst) 0 (+ 1 (x (cdr lst))))))
```

and we're trying to solve the equation `(h list-length) = list-length`. In other words, you give me `h`, a function taking a function as argument and returning another function, and i need to give you back an `f` that is its fixed point, i.e., an `f` satisfying `f = (h f)`.

So all i need to do is finding a function (let's call it `Y`) that takes `h` as its argument and returns `f`, that is, by definition of `Y`:

```f = (Y h)
```

but, as we've seen `f` equals `(h f)`, which in turn is `(h (Y h))` which gives us the defining equation of `Y`:

```(h (Y h)) = (Y h)
```

If i had that magic `Y` function (or combinator, since it won't use any global variables), i could for instance immediately compute `list-length` as:

```(Y (lambda (x) (lambda (lst) (if (null? lst) 0 (+ 1 (x (cdr lst)))))))
```

The nicest kind of wishful thinking is the one that comes true: we actually know of a lambda expression that satifies the Y combinator's defining equation `(Y h) = (h (Y h))`, namely:

```(lambda (h) ((lambda (x) (h (x x))) (lambda (y) (h (y y)))))
```

You can check it by yourself: `(Y h)` is just the body of the expression above:

```(Y h) => ((lambda (x) (h (x x))) (lambda (y) (h (y y))))
```

and now apply the first lambda to its argument (the second lambda) to obtain:

```=> (h ((lambda (y) (h (y y))) (lambda (y) (h (y y)))))
=> (h (Y h))
```

as desired! The only wrinkle left is that, as defined, our Y combinator cannot be directly coded in Scheme, because Scheme is a strict language and those pesky `(x x)` and `(y y)` applications cause an infinite recursion.

But that's just an accidental difficulty due to Scheme's evaluation strategy being too eager that has a standard solution: a beta abstraction. If you have a function `F` in Scheme, you can define a totally equivalent function `G` by `(define G (lambda (x) (F x)))`. We say that G is a beta abstraction of F, or that F is a beta reduction of G. And the usual reason you would beta abstract a function in Scheme is in order to delay the evaluation of its body, just what the doctor ordered.

Remember, `h` is a function taking another function as an argument, so `(x x)` and `(y y)`, which are used as `h`'s arguments, must be functions, so they're equivalent to `(lambda (a) ((x x) a))` and `(lambda (a) ((y y) a))`, so we can define Y, if we're so inclined, also as:

```(define Y
(lambda (h)
((lambda (x) (h (lambda (a) ((x x) a))))
(lambda (x) (h (lambda (a) ((x x) a)))))))
```

and now

```(define list-length
(Y (lambda (f) (lambda (lst) (if (null? lst) 0 (+ 1 (f (cdr lst))))))))
```

As you see, `list-length`'s body doesn't mention itself and, as you can check by yourself with your favourite interpreter, the last two definitions are valid and working scheme code.

In case you still feel a bit unsure as to how our `Y` is pulling its trick, you can dispel any misgivings just by seeing how the combinator transforms the given `h` step by step, always reproducing `h` in the process (it's only the branch in `h` that doesn't call its argument, the recursion's base case, that breaks the implicit infinite loop induced by `Y`). Let's do it with our `list-length` example, reducing its application to, say, the list '(1 2), step by step:

```(define W (lambda (f) (lambda (a) ((f f) a))))

(list-length '(1 2))
;; definition of list-length as (Y h)
=> ((Y h) '(1 2))
;; definiton of Y and W
=> (((lambda (f) (h (W f))) (lambda (f) (h (W f)))) '(1 2))
;; beta-reduction of the first lambda applied to the second
=> ((h (W (lambda (f) (h (W f))))) '(1 2))
;; definition of h for the case of list-length
=> ((lambda (lst)
(if (null? lst) 0 (+ 1 ((W (lambda (f) (h (W f)))) (cdr lst)))))
'(1 2))
;; function application
=> (+ 1 ((W (lambda (f) (h (W f)))) '(2)))
;; definition of W
=> (+ 1 (((lambda (f) (h (W f))) (lambda (f) (h (W f)))) '(2)))
```

and notice what just happened: we started with

```(((lambda (f) (h (W f))) (lambda (f) (h (W f)))) '(1 2))
```

and, after one iteration of the implicit recursion, reduced it to:

```(+ 1 (((lambda (f) (h (W f))) (lambda (f) (h (W f)))) '(2)))
```

i.e., 1 plus the same form we started with but applied to the list `(2)` instead of the list `(1)`. By following the exact same reduction steps, we can simplify the above to:

```(+ 1 1 (((lambda (f) (h (W f))) (lambda (f) (h (W f)))) '()))
```

and now, when expanding the same form to the right applied to the empty list, the base case of the recursion (the true branch of the `(null? lst)` test in `h`), will kick in and reduce the above to

```(+ 1 1 0) => 2
```

avoiding that the self-reproducing Y forms keep reappearing ad infinitum. 