Lambda Calculus — Schlac

PLAI §22 (we do much more)

We know that many constructs that are usually thought of as primitives are not really needed — we can implement them ourselves given enough tools. The question is how far can we go?

The answer: as far as we want. For example:

We begin with a very minimal language, which is based on the Lambda Calculus. In this language we get a very minimal set of constructs and values.

In DrRacket, this we will use the Schlac language level (stands for “SchemeRacket as Lambda Calculus”). This language has a Racket-like syntax, but don’t be confused — it is very different from Racket. The only constructs that are available in this language are: lambda expressions of at least one argument, function application (again, at least one argument), and simple definition forms which are similar to the ones in the “Broken define” language — definitions are used as shorthand, and cannot be used for recursive function definition. They’re also only allowed at the toplevel — no local helpers, and a definition is not an expression that can appear anywhere. The BNF is therefore:

Since this language has no primitive values (other than functions), Racket numbers and booleans are also considered identifiers, and have no built-in value that come with the language. In addition, all functions and function calls are curried, so

is actually shorthand for

The rules for evaluation are simple, there is one very important rule for evaluation which is called “beta reduction”:

where substitution in this context requires being careful so you won’t capture names. This requires you to be able to do another kind of transformation which is called “alpha conversion”, which basically says that you can rename identifiers as long as you keep the same binding structure (eg, a valid renaming does not change the de-Bruijn form of the expression). There is one more rule that can be used, eta conversion which says that (lambda (x) (f x)) is the same as f (we used this rule above when deriving the Y combinator).

One last difference between Schlac and Racket is that Schlac is a lazy language. This will be important since we do not have any built-in special forms like if.

Here is a Schlac definition for the identity function:

and there is not much that we can do with this now:

(In the last expression, note that (id id id) is shorthand for ((id id) id), and since (id id) is the identity, applying that on id returns it again.)

Something to think about: are we losing anything because we have no no-argument functions?

Church Numerals

So far, it seems like it is impossible to do anything useful in this language, since all we have are functions and applications. We know how to write the identity function, but what about other values? For example, can you write code that evaluates to zero?

What’s zero? I only know how to write functions!

(Turing Machine / Assembly programmer: “What’s a function? — I only know how to write 0s and 1s!”)

The first thing we therefore need is to be able to encode numbers as functions. For zero, we will use a function of two arguments that simply returns its second value:

or, more concisely

This is the first step in an encoding that is known as Church Numerals: an encoding of natural numbers as functions. The number zero is encoded as a function that takes in a function and a second value, and applies the function zero times on the argument (which is really what the above definition is doing). Following this view, the number one is going to be a function of two arguments, that applies the first on the second one time:

and note that 1 is just like the identity function (as long as you give it a function as its first input, but this is always the case in Schlac). The next number on the list is two — which applies the first argument on the second one twice:

We can go on doing this, but what we really want is a way to perform arbitrary arithmetic. The first requirement for that is an add1 function that increments its input (an encoded natural number) by one. To do this, we write a function that expects an encoded number:

and this function is expected to return an encoded number, which is always a function of f and x:

Now, in the body, we need to apply f on x n+1 times — but remember that n is a function that will do n applications of its first argument on its second:

and all we have left to do now is to apply f one more time, yielding this definition for add1:

Using this, we can define a few useful numbers:

This is all nice theoretically, but how can we make sure that it is correct? Well, Schlac has a few additional built-in functions that translate Church numerals into Racket numbers. To try our definitions we use the ->nat (read: to natural number):

You can now verify that the identity function is really the same as the number 1:

We can even write a test case, since Schlac contains the test special form, but we have to be careful in that — first of all, we cannot test whether functions are equal (why?) so we must use ->nat, but

will not work since 7 is undefined. To overcome this, Schlac has a back-door for primitive Racket values — just use a quote:

We can now define natural number addition — one simple idea is to get two encoded numbers m and n, then start with x, apply f on it n times by using it as a function, then apply f m more times on the result in the same way:

or equivalently:

Another idea is to use add1 and increment n by m using add1:

We can also define multiplication of m and n quite easily — begin with addition — (lambda (x) (+ n x)) is a function that expects an x and returns (+ x n) — it’s an increment-by-n function. But since all functions and applications are curried, this is actually the same as (lambda (x) ((+ n) x)) which is the same as (+ n). Now, what we want to do is repeat this operation m times over zero, which will add n to zero m times, resulting in m * n. The definition is therefore:

An alternative approach is to consider

for some encoded number n and a function f — this function is like f^n (f composed n times with itself). But remember that this is shorthand for

and we know that (lambda (x) (foo x)) is just like foo (if it is a function), so this is equivalent to just

So (n f) is f^n, and in the same way (m g) is g^m — if we use (n f) for g, we get (m (n f)) which is n self-compositions of f, self-composed m times. In other words, (m (n f)) is a function that is like m*n applications of f, so we can define multiplication as:

which is the same as

The same principle can be used to define exponentiation (but now we have to be careful with the order since exponentiation is not commutative):

And there is a similar alternative here too —

• a Church numeral m is the m-self-composition function,

• and (1 m) is just like m^1 which is the same as m (1=identity)

• and (2 m) is just like m^2 — it takes a function f, self composes it m times, and self composes the result m times — for a total of f^(m*m)

• and (3 m) is similarly f^(m*m*m)

• so (n m) is f^(m^n) (note that the first ^ is self-compositions, and the second one is a mathematical exponent)

• so (n m) is a function that returns m^n self-compositions of an input function, Which means that (n m) is the Church numeral for m^n, so we get:

  (define ^ (lambda (m n) (n m)))

which basically says that any number encoding n is also the ?^n operation.

All of this is was not too complicated — but all so far all we did is write functions that increment their inputs in various ways. What about sub1? For that, we need to do some more work — we will need to encode booleans.

More Encodings

Our choice of encoding numbers makes sense — the idea is that the main feature of a natural number is repeating something a number of times. For booleans, the main property we’re looking for is choosing between two values. So we can encode true and false by functions of two arguments that return either the first or the second argument:

Note that this encoding of #f is really the same as the encoding of 0, so we have to know what type to expect an use the proper operations (this is similar to C, where everything is just integers). Now that we have these two, we can define if:

it expects a boolean which is a function of two arguments, and passes it the two expressions. The #t boolean will simply return the first, and the #f boolean will return the second. Strictly speaking, we don’t really need this definition, since instead of writing (if c t e), we can simply write (c t e). In any case, we need the language to be lazy for this to work. To demonstrate this, we’ll intentionally use the quote back-door to use a non-functional value, using this will normally result in an error:

But testing our if definition, things work just fine:

and we see that DrRacket leaves the second addition expression in red, which indicates that it was not executed. We can also make sure that even when it is defined as a function, it is still working fine because the language is lazy:

What about and and or? Simple, or takes two arguments, and returns either true or false if one of the inputs is true:

but (if b #t #f) is really the same as just b because it must be a boolean (we cannot use more than one “truty” or “falsy” values):

also, if a is true, we want to return #t, but that is exactly the value of a, so:

and finally, we can get rid of the if (which is actually breaking the if abstraction, if we encode booleans in some other way):

Similarly, you can convince yourself that the definition of and is:

Schlac has to-Racket conversion functions for booleans too:

and

A not function is quite simple — one alternative is to choose from true and false in the usual way:

and another is to return a function that switches the inputs to an input boolean:

which is the same as

We can now put numbers and booleans together: we define a zero? function.

(Good question: is this fast?)

(Note that it is better to test that the value is explicitly #t, if we just use (test (->bool ...)) then the test will work even if the expression in question evaluated to some bogus value.)

The idea is simple — if n is the encoding of zero, it will return it’s second argument which is #t:

if n is an encoding of a bigger number, then it is a self-composition, and the function that we give it is one that always returns #f, no matter how many times it is self-composed. Try 2 for example:

Now, how about an encoding for compound values? A minimal approach is what we use in Racket — a way to generate pairs (cons), and encode lists as chains of pairs with a special value at the end (null). There is a natural encoding for pairs that we have previously seen — a pair is a function that expects a selector, and will apply that on the two values:

Or, equivalently:

To extract the two values from a pair, we need to pass a selector that consumes two values and returns one of them. In our framework, this is exactly what the two boolean values do, so we get:

We can even do this:

or write a list-ref function:

Note that we don’t need a recursive function for this: our encoding of natural numbers makes it easy to “iterate N times”. What we get with this encoding is essentially free natural-number recursion.

We now need a special null value to mark list ends. This value should have the same number of arguments as a cons value (one: a selector/boolean function), and it should be possible to distinguish it from other values. We choose

Testing the list encoding:

And as with natural numbers and booleans, Schlac has built-in facility to convert encoded lists to Racket values, except that this requires specifying the type of values in a list so it’s a higher-order function:

which (“as usual”) can be written as

We can even do this:

Defining null? is now relatively easy (and it’s actually already used by the above ->listof conversion). The following definition

works because if x is null, then it simply ignores its argument and returns #t, and if it’s a pair, then it uses the input selector, which always returns #f in its turn. Using some arbitrary A and B:

We can use the Y combinator to create recursive functions — we can even use the rewrite rules facility that Schlac contains (the same one that we have previously seen):

and using it:

And to complete this, um, journey — we’re still missing subtraction. There are many ways to solve the problem of subtraction, and for a challenge try to come up with a solution yourself. One of the clearer solutions uses a simple idea — begin with a pair of two zeroes <0,0>, and repeat this transformation n times: <a,b> -> <b,b+1>. After n steps, we will have <n-1,n> — so we get:

And from this the road is short to general subtraction, m-n is simply n applications of sub1 on m:

We now have a normal-looking language, and we’re ready to do anything we want. Here are two popular examples:

To get generalized arithmetic capability, Schlac has yet another built-in facility for translating Racket natural numbers into Church numerals:

… and to get to that frightening expression in the beginning, all you need to do is replace all definitions in the fib definition over and over again until you’re left with nothing but lambda expressions and applications, then reformat the result into some cute shape. For extra fun, you can look for immediate applications of lambda expressions and reduce them manually.

All of this is in the following code:

Alternative Church Encoding

Finally, note that this is just one way to encode things — other encodings are possible. One alternative encoding is in the following code — it uses a list of N falses as the encoding for N. This encoding makes it easier to add1 (just cons another #f), and to sub1 (simply cdr). The tradeoff is that some arithmetics operations becomes more complicated, for example, the definition of + requires the fixpoint combinator. (As expected, some people want to see what can we do with a language without recursion, so they don’t like jumping to Y too fast.)

Implementing define-type & cases in Schlac

(The following explanation originates from Chris Okasaki.)

Another interesting way to implement lists follows the pattern matching approach, where both pairs and the null value are represented by a function that serves as a kind of a match dispatcher. This function takes in two inputs — if it is the representation of null then it will return the first input, and if it is a pair, then it will apply the second input on the two parts of the pair. This is implemented as follows (with type comments to make it clear):

This might seem awkward, but it follows the intended use of pairs and null as a match-like construct. Here is an example, with the equivalent Racket code on the side:

In fact, it’s easy to implement our selectors and predicate using this:

The same approach can be used to define any kind of new data type in a way that looks like our own define-type definitions. For example, consider a much-simplified definition of the AE type we’ve seen early in the semester, and a matching eval definition as an example for using cases:

We can follow the above approach now to write Schlac code that more than being equivalent, is also very similar in nature. Note that the type definition is replaced by two definitions for the two constructors:

We can even take this further: the translations from define-type and cases are mechanical enough that we could implement them almost exactly via rewrites (there are a subtle change in that we’re list field names rather than types):

And using that, an evluator is simple: