Church numeral

In mathematics, Church encoding is a means of representing data and operators in the lambda calculus. The Church numerals are a representation of the natural numbers using lambda notation. The method is named for Alonzo Church, who first encoded data in the lambda calculus this way.

Terms that are usually considered primitive in other notations (such as integers, booleans, pairs, lists, and tagged unions) are mapped to higher-order functions under Church encoding. The Church-Turing thesis asserts that any computable operator (and its operands) can be represented under Church encoding. In the untyped lambda calculus the only primitive data type is the function.

Use

A straightforward implementation of Church encoding slows some access operations from $O(1)$ to $O(n)$, where $n$ is the size of the data structure, making Church encoding impractical. Research has shown that this can be addressed by targeted optimizations, but most functional programming languages instead expand their intermediate representations to contain algebraic data types. Nonetheless Church encoding is often used in theoretical arguments, as it is a natural representation for partial evaluation and theorem proving. Operations can be typed using higher-ranked types, and primitive recursion is easily accessible. The assumption that functions are the only primitive data types streamlines many proofs.

Church encoding is complete but only representationally. Additional functions are needed to translate the representation into common data types, for display to people. It is not possible in general to decide if two functions are extensionally equal due to the undecidability of equivalence from Church's theorem. The translation may apply the function in some way to retrieve the value it represents, or look up its value as a literal lambda term. Lambda calculus is usually interpreted as using intensional equality. There are potential problems with the interpretation of results because of the difference between the intensional and extensional definition of equality.

Church numerals

Church numerals are the representations of natural numbers under Church encoding. The higher-order function that represents natural number ''n'' is a function that maps any function $f$ to its ''n''-fold composition. In simpler terms, the "value" of the numeral is equivalent to the number of times the function encapsulates its argument.

: $f^ = \underbrace_.\,$

All Church numerals are functions that take two parameters. Church numerals 0, 1, 2, ..., are defined as follows in the lambda calculus.

''Starting with'' 0 ''not applying the function at all, proceed with'' 1 ''applying the function once, 2 ''applying the function twice, 3 ''applying the function three times, etc.'':

:$\begin \text & \text & \text \\ \hline 0 & 0\ f\ x = x & 0 = \lambda f.\lambda x.x \\ 1 & 1\ f\ x = f\ x & 1 = \lambda f.\lambda x.f\ x \\ 2 & 2\ f\ x = f\ (f\ x) & 2 = \lambda f.\lambda x.f\ (f\ x) \\ 3 & 3\ f\ x = f\ (f\ (f\ x)) & 3 = \lambda f.\lambda x.f\ (f\ (f\ x)) \\ \vdots & \vdots & \vdots \\ n & n\ f\ x = f^n\ x & n = \lambda f.\lambda x.f^\ x \end$

The Church numeral 3 represents the action of applying any given function three times to a value. The supplied function is first applied to a supplied parameter and then successively to its own result. The end result is not the numeral 3 (unless the supplied parameter happens to be 0 and the function is a successor function). The function itself, and not its end result, is the Church numeral 3. The Church numeral 3 means simply to do anything three times. It is an ostensive demonstration of what is meant by "three times".

Calculation with Church numerals

Arithmetic operations on numbers may be represented by functions on Church numerals. These functions may be defined in lambda calculus, or implemented in most functional programming languages (see converting lambda expressions to functions).

The addition function $\operatorname(m, n)= m+n$ uses the identity $f^(x)=f^(f^(x))$.

: $\operatorname \equiv \lambda m.\lambda n.\lambda f.\lambda x. m\ f\ (n\ f\ x)$

The successor function $\operatorname(n)=n+1$ is β-equivalent to $(\operatorname\ 1)$.

: $\operatorname \equiv \lambda n.\lambda f.\lambda x. f\ (n\ f\ x)$

The multiplication function $\operatorname(m, n) = m*n$ uses the identity $f^(x) = (f^)^(x)$.

: $\operatorname \equiv \lambda m.\lambda n.\lambda f.\lambda x. m\ (n\ f)\ x$

The exponentiation function $\operatorname(m, n) = m^n$ is given by the definition of Church numerals, $n\ h\ x = h^n\ x$. In the definition substitute $h \to m, x \to f$ to get $n\ m\ f = m^n\ f$ and,
: $\operatorname\ m\ n = m^n = n\ m$
which gives the lambda expression,
: $\operatorname \equiv \lambda m.\lambda n. n\ m$

The $\operatorname(n)$ function is more difficult to understand.

: $\operatorname \equiv \lambda n.\lambda f.\lambda x. n\ (\lambda g.\lambda h. h\ (g\ f))\ (\lambda u. x)\ (\lambda u. u)$

A Church numeral applies a function ''n'' times. The predecessor function must return a function that applies its parameter ''n - 1'' times. This is achieved by building a container around ''f'' and ''x'', which is initialized in a way that omits the application of the function the first time. See predecessor for a more detailed explanation.

The subtraction function can be written based on the predecessor function.

: $\operatorname \equiv \lambda m.\lambda n. (n \operatorname)\ m$

Table of functions on Church numerals

* Note that in the Church encoding,
* $\operatorname(0) = 0$
* $m \le n \to m - n = 0$

Derivation of predecessor function

The predecessor function used in the Church encoding is,

:$\operatorname(n) = \begin 0 & \mboxn=0, \\ n-1 & \mbox\end$.

To build the predecessor we need a way of applying the function 1 fewer time. A numeral applies the function times to . The predecessor function must use the numeral to apply the function times.

Before implementing the predecessor function, here is a scheme that wraps the value in a container function. We will define new functions to use in place of and , called and . The container function is called . The left hand side of the table shows a numeral applied to and .

:$\begin \text & \text & \text \\ \hline 0 & \operatorname = \operatorname\ x & \\ 1 & \operatorname\ \operatorname = \operatorname\ (f\ x) & \operatorname\ \operatorname = \operatorname\ x \\ 2 & \operatorname\ (\operatorname\ \operatorname) = \operatorname\ (f\ (f\ x)) & \operatorname\ (\operatorname\ \operatorname) = \operatorname\ (f\ x) \\ 3 & \operatorname\ (\operatorname\ (\operatorname\ \operatorname)) = \operatorname\ (f\ (f\ (f\ x))) & \operatorname\ (\operatorname\ (\operatorname\ \operatorname)) = \operatorname\ (f\ (f\ x)) \\ \vdots & \vdots & \vdots \\ n & n \operatorname\ \operatorname = \operatorname\ (f^n\ x) = \operatorname\ (n\ f\ x) & n \operatorname\ \operatorname = \operatorname\ (f^\ x) = \operatorname\ ((n-1)\ f\ x) \\ \end$

The general recurrence rule is,
:$\operatorname\ (\operatorname\ v) = \operatorname\ (f\ v)$

If there is also a function to retrieve the value from the container (called ),
:$\operatorname\ (\operatorname\ v) = v$

Then may be used to define the function as,
: $\operatorname = \lambda n.\lambda f.\lambda x.\operatorname\ (n \operatorname \operatorname) = \lambda n.\lambda f.\lambda x.\operatorname\ (\operatorname\ (n\ f\ x)) = \lambda n.\lambda f.\lambda x.n\ f\ x = \lambda n.n$

The function is not intrinsically useful. However, as delegates calling of to its container argument, we can arrange that on the first application receives a special container that ignores its argument allowing to skip the first application of . Call this new initial container . The right hand side of the above table shows the expansions of . Then by replacing with in the expression for the function we get the predecessor function,

: $\operatorname = \lambda n.\lambda f.\lambda x.\operatorname\ (n \operatorname \operatorname) = \lambda n.\lambda f.\lambda x.\operatorname\ (\operatorname\ ((n-1)\ f\ x)) = \lambda n.\lambda f.\lambda x.(n-1)\ f\ x = \lambda n.(n-1)$

As explained below the functions , , , and may be defined as,
:$\begin \operatorname &= \lambda v.(\lambda h.h\ v) \\ \operatorname k &= k\ \lambda u.u \\ \operatorname &= \lambda g.\lambda h.h\ (g\ f) \\ \operatorname &= \lambda h.h\ x \\ \operatorname &= \lambda u.x \end$

Which gives the lambda expression for as,
: $\operatorname = \lambda n.\lambda f.\lambda x.n\ (\lambda g.\lambda h.h\ (g\ f))\ (\lambda u.x)\ (\lambda u.u)$

Another way of defining pred

Pred may also be defined using pairs:
:$\begin \operatorname =&\ \lambda p.\ \operatorname\ (\operatorname\ p)\ (\operatorname\ (\operatorname\ p)) \\ \operatorname =&\ (\lambda f.\lambda x.\ x) \\ \operatorname =&\ \operatorname\ \operatorname\ \operatorname \\ \operatorname =&\ \lambda n.\ \operatorname\ (n\ \operatorname\ \operatorname) \\ \end$

This is a simpler definition, but leads to a more complex expression for pred.
The expansion for $\operatorname \operatorname$:
:$\begin \operatorname \operatorname =&\ \operatorname\ (\operatorname\ (\operatorname\ (\operatorname\ (\operatorname\ \operatorname\ \operatorname)))) \\ =&\ \operatorname\ (\operatorname\ (\operatorname\ (\operatorname\ \operatorname\ \operatorname))) \\ =&\ \operatorname\ (\operatorname\ (\operatorname\ \operatorname\ \operatorname)) \\ =&\ \operatorname\ (\operatorname\ \operatorname\ \operatorname) \\ =&\ \operatorname \end$

Division

Division of natural numbers may be implemented by,

: $n/m = \operatorname\ n \ge m\ \operatorname\ 1 + (n-m)/m\ \operatorname\ 0$

Calculating $n-m$ takes many beta reductions. Unless doing the reduction by hand, this doesn't matter that much, but it is preferable to not have to do this calculation twice. The simplest predicate for testing numbers is ''IsZero'' so consider the condition.
: $\operatorname\ (\operatorname\ n\ m)$
But this condition is equivalent to $n \le m$, not n. If this expression is used then the mathematical definition of division given above is translated into function on Church numerals as,
: $\operatorname\ n\ m\ f\ x = (\lambda d.\operatorname\ d\ (0\ f\ x)\ (f\ (\operatorname\ d\ m\ f\ x)))\ (\operatorname\ n\ m)$

As desired, this definition has a single call to $\operatorname\ n\ m$. However the result is that this formula gives the value of $(n-1)/ m$.

This problem may be corrected by adding 1 to ''n'' before calling ''divide''. The definition of ''divide'' is then,
: $\operatorname\ n = \operatorname\ (\operatorname\ n)$

''divide1'' is a recursive definition. The Y combinator may be used to implement the recursion. Create a new function called ''div'' by;
* In the left hand side $\operatorname \rightarrow \operatorname \ c$
* In the right hand side $\operatorname \rightarrow c$
to get,
: $\operatorname = \lambda c.\lambda n.\lambda m.\lambda f.\lambda x.(\lambda d.\operatorname\ d\ (0\ f\ x)\ (f\ (c\ d\ m\ f\ x)))\ (\operatorname\ n\ m)$

Then,
:$\operatorname = \lambda n.\operatorname\ (\operatorname\ n)$
where,
: $\begin \operatorname &= Y\ \operatorname \\ \operatorname &= \lambda n.\lambda f.\lambda x. f\ (n\ f\ x) \\ Y &= \lambda f.(\lambda x.f\ (x\ x))\ (\lambda x.f\ (x\ x)) \\ 0 &= \lambda f.\lambda x.x\\ \operatorname &= \lambda n.n\ (\lambda x.\operatorname)\ \operatorname \end$
:: $\begin \operatorname &\equiv \lambda a.\lambda b.a\\ \operatorname &\equiv \lambda a.\lambda b.b \end$
: $\begin \operatorname &= \lambda m.\lambda n.n \operatorname m\\ \operatorname &= \lambda n.\lambda f.\lambda x.n\ (\lambda g.\lambda h.h\ (g\ f))\ (\lambda u.x)\ (\lambda u.u) \end$
Gives,
: $\scriptstyle \operatorname = \lambda n.((\lambda f.(\lambda x.x\ x)\ (\lambda x.f\ (x\ x)))\ (\lambda c.\lambda n.\lambda m.\lambda f.\lambda x.(\lambda d.(\lambda n.n\ (\lambda x.(\lambda a.\lambda b.b))\ (\lambda a.\lambda b.a))\ d\ ((\lambda f.\lambda x.x)\ f\ x)\ (f\ (c\ d\ m\ f\ x)))\ ((\lambda m.\lambda n.n (\lambda n.\lambda f.\lambda x.n\ (\lambda g.\lambda h.h\ (g\ f))\ (\lambda u.x)\ (\lambda u.u)) m)\ n\ m)))\ ((\lambda n.\lambda f.\lambda x. f\ (n\ f\ x))\ n)$

Or as text, using \ for ,
divide = (\n.((\f.(\x.x x) (\x.f (x x))) (\c.\n.\m.\f.\x.(\d.(\n.n (\x.(\a.\b.b)) (\a.\b.a)) d ((\f.\x.x) f x) (f (c d m f x))) ((\m.\n.n (\n.\f.\x.n (\g.\h.h (g f)) (\u.x) (\u.u)) m) n m))) ((\n.\f.\x. f (n f x)) n))

For example, 9/3 is represented by
divide (\f.\x.f (f (f (f (f (f (f (f (f x))))))))) (\f.\x.f (f (f x)))

Using a lambda calculus calculator, the above expression reduces to 3, using normal order.
\f.\x.f (f (f (x)))

Signed numbers

One simple approach for extending Church Numerals to signed numbers is to use a Church pair, containing Church numerals representing a positive and a negative value. The integer value is the difference between the two Church numerals.

A natural number is converted to a signed number by,

:$\operatorname_s = \lambda x.\operatorname\ x\ 0$

Negation is performed by swapping the values.

:$\operatorname_s = \lambda x.\operatorname\ (\operatorname\ x)\ (\operatorname\ x)$

The integer value is more naturally represented if one of the pair is zero. The ''OneZero'' function achieves this condition,

:$\operatorname = \lambda x.\operatorname\ (\operatorname\ x)\ x\ (\operatorname\ (\operatorname\ x)\ x\ (\operatorname\ \operatorname\ (\operatorname\ (\operatorname\ x))\ (\operatorname\ (\operatorname\ x))))$

The recursion may be implemented using the Y combinator,
:$\operatorname = \lambda c.\lambda x.\operatorname\ (\operatorname\ x)\ x\ (\operatorname\ (\operatorname\ x)\ x\ (c\ \operatorname\ (\operatorname\ (\operatorname\ x))\ (\operatorname\ (\operatorname\ x))))$

:$\operatorname = Y \operatorname$

Plus and minus

Addition is defined mathematically on the pair by,
:x + y = _p, x_n+ _p, y_n= x_p - x_n + y_p - y_n = (x_p + y_p) - (x_n + y_n) = _p + y_p, x_n + y_n

The last expression is translated into lambda calculus as,
:$\operatorname_s = \lambda x.\lambda y.\operatorname\ (\operatorname\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y))\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y)))$

Similarly subtraction is defined,
:x - y = _p, x_n- _p, y_n= x_p - x_n - y_p + y_n = (x_p + y_n) - (x_n + y_p) = _p + y_n, x_n + y_p

giving,
:$\operatorname_s = \lambda x.\lambda y.\operatorname\ (\operatorname\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y))\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y)))$

Multiply and divide

Multiplication may be defined by,
:x*y = _p, x_n _p, y_n=(x_p - x_n)*(y_p - y_n) = (x_p*y_p + x_n*y_n) - (x_p*y_n + x_n*y_p) = _p*y_p + x_n*y_n, x_p*y_n + x_n*y_p/math>
The last expression is translated into lambda calculus as,
:$\operatorname_s = \lambda x.\lambda y.\operatorname\ (\operatorname\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y))\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y)))\ (\operatorname\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y))\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y)))$

A similar definition is given here for division, except in this definition, one value in each pair must be zero (see ''OneZero'' above). The ''divZ'' function allows us to ignore the value that has a zero component.
:$\operatorname = \lambda x.\lambda y.\operatorname\ y\ 0 \ (\operatorname\ x\ y)$

''divZ'' is then used in the following formula, which is the same as for multiplication, but with ''mult'' replaced by ''divZ''.

:$\operatorname_s = \lambda x.\lambda y.\operatorname\ (\operatorname\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y))\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y)))\ (\operatorname\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y))\ (\operatorname\ (\operatorname\ x)\ (\operatorname\ y)))$

Rational and real numbers

Rational and computable real numbers may also be encoded in lambda calculus. Rational numbers may be encoded as a pair of signed numbers. Computable real numbers may be encoded by a limiting process that guarantees that the difference from the real value differs by a number which may be made as small as we need.
The references given describe software that could, in theory, be translated into lambda calculus. Once real numbers are defined, complex numbers are naturally encoded as a pair of real numbers.

The data types and functions described above demonstrate that any data type or calculation may be encoded in lambda calculus. This is the Church-Turing thesis.

Translation with other representations

Most real-world languages have support for machine-native integers; the ''church'' and ''unchurch'' functions convert between nonnegative integers and their corresponding Church numerals. The functions are given here in Haskell, where the \ corresponds to the λ of Lambda calculus. Implementations in other languages are similar.

type Church a = (a -> a) -> a -> a

church :: Integer -> Church Integer
church 0 = \f -> \x -> x
church n = \f -> \x -> f (church (n-1) f x)

unchurch :: Church Integer -> Integer
unchurch cn = cn (+ 1) 0

Church Booleans

''Church Booleans'' are the Church encoding of the Boolean values ''true'' and ''false.'' Some programming languages use these as an implementation model for Boolean arithmetic; examples are Smalltalk and Pico.

Boolean logic may be considered as a choice. The Church encoding of ''true'' and ''false'' are functions of two parameters:
* ''true'' chooses the first parameter.
* ''false'' chooses the second parameter.

The two definitions are known as Church Booleans:
: $\begin \operatorname &\equiv \lambda a.\lambda b.a\\ \operatorname &\equiv \lambda a.\lambda b.b \end$

This definition allows predicates (i.e. functions returning logical values) to directly act as if-clauses. A function returning a Boolean, which is then applied to two parameters, returns either the first or the second parameter:
: $\operatornamex\ \operatorname\ \operatorname$
evaluates to ''then-clause'' if ''predicate-x'' evaluates to ''true'', and to ''else-clause'' if ''predicate-x'' evaluates to ''false''.

Because ''true'' and ''false'' choose the first or second parameter they may be combined to provide logic operators. Note that there are multiple possible implementations of ''not''.
: $\begin \operatorname &= \lambda p.\lambda q.p\ q\ p\\ \operatorname &= \lambda p.\lambda q.p\ p\ q\\ \operatorname_1 &= \lambda p.\lambda a.\lambda b.p\ b\ a\\ \operatorname_2 &= \lambda p.p\ (\lambda a.\lambda b. b)\ (\lambda a.\lambda b. a) = \lambda p.p \operatorname \operatorname\\ \operatorname &= \lambda a.\lambda b.a\ (\operatorname\ b)\ b\\ \operatorname &= \lambda p.\lambda a.\lambda b.p\ a\ b \end$

Some examples:

: $\begin \operatorname \operatorname \operatorname &= (\lambda p.\lambda q.p\ q\ p)\ \operatorname\ \operatorname = \operatorname \operatorname \operatorname = (\lambda a.\lambda b.a) \operatorname \operatorname = \operatorname \\ \operatorname \operatorname \operatorname &= (\lambda p.\lambda q.p\ p\ q)\ (\lambda a.\lambda b.a)\ (\lambda a.\lambda b.b) = (\lambda a.\lambda b.a)\ (\lambda a.\lambda b.a)\ (\lambda a.\lambda b.b) = (\lambda a.\lambda b.a) = \operatorname \\ \operatorname_1\ \operatorname &= (\lambda p.\lambda a.\lambda b.p\ b\ a) (\lambda a.\lambda b.a) = \lambda a.\lambda b.(\lambda a.\lambda b.a)\ b\ a = \lambda a.\lambda b.(\lambda c.b)\ a = \lambda a.\lambda b.b = \operatorname \\ \operatorname_2\ \operatorname &= (\lambda p.p\ (\lambda a.\lambda b. b) (\lambda a.\lambda b. a)) (\lambda a.\lambda b. a) = (\lambda a.\lambda b. a) (\lambda a.\lambda b. b) (\lambda a.\lambda b. a) = (\lambda b. (\lambda a.\lambda b. b))\ (\lambda a.\lambda b. a) = \lambda a.\lambda b.b = \operatorname \end$

Predicates

A ''predicate'' is a function that returns a Boolean value. The most fundamental predicate is $\operatorname$, which returns $\operatorname$ if its argument is the Church numeral $0$, and $\operatorname$ if its argument is any other Church numeral:
: $\operatorname = \lambda n.n\ (\lambda x.\operatorname)\ \operatorname$

The following predicate tests whether the first argument is less-than-or-equal-to the second:
: $\operatorname = \lambda m.\lambda n.\operatorname\ (\operatorname\ m\ n)$,

Because of the identity,
: $x = y \equiv (x \le y \land y \le x)$
The test for equality may be implemented as,
: $\operatorname = \lambda m.\lambda n.\operatorname\ (\operatorname\ m\ n)\ (\operatorname\ n\ m)$

Church pairs

Church pairs are the Church encoding of the pair (two-tuple) type. The pair is represented as a function that takes a function argument. When given its argument it will apply the argument to the two components of the pair. The definition in lambda calculus is,

: $\begin \operatorname &\equiv \lambda x.\lambda y.\lambda z.z\ x\ y \\ \operatorname &\equiv \lambda p.p\ (\lambda x.\lambda y.x) \\ \operatorname &\equiv \lambda p.p\ (\lambda x.\lambda y.y) \end$

For example,
: $\begin & \operatorname\ (\operatorname\ a\ b) \\ = & (\lambda p.p\ (\lambda x.\lambda y.x))\ ((\lambda x.\lambda y.\lambda z.z\ x\ y)\ a\ b) \\ = & (\lambda p.p\ (\lambda x.\lambda y.x))\ (\lambda z.z\ a\ b) \\ = & (\lambda z.z\ a\ b)\ (\lambda x.\lambda y.x) \\ = & (\lambda x.\lambda y.x)\ a\ b = a \end$

List encodings

An ( immutable) list is constructed from list nodes. The basic operations on the list are;

We give four different representations of lists below:
* Build each list node from two pairs (to allow for empty lists).
* Build each list node from one pair.
* Represent the list using the right fold function.
* Represent the list using Scott's encoding that takes cases of match expression as arguments

Two pairs as a list node

A nonempty list can be implemented by a Church pair;
* ''First'' contains the head.
* ''Second'' contains the tail.

However this does not give a representation of the empty list, because there is no "null" pointer. To represent null, the pair may be wrapped in another pair, giving free values,
* ''First'' - Is the null pointer (empty list).
* ''Second.First'' contains the head.
* ''Second.Second'' contains the tail.

Using this idea the basic list operations can be defined like this:

In a ''nil'' node ''second'' is never accessed, provided that head and tail are only applied to nonempty lists.

One pair as a list node

Alternatively, define
: $\begin \operatorname &\equiv \operatorname \\ \operatorname &\equiv \operatorname \\ \operatorname &\equiv \operatorname \\ \operatorname &\equiv \operatorname \\ \operatorname &\equiv \lambda l.l (\lambda h.\lambda t.\lambda d.\operatorname) \operatorname \end$
where the last definition is a special case of the general
: $\operatorname \equiv \lambda l.l (\lambda h.\lambda t.\lambda d. \operatorname) \operatorname$

Represent the list using ''right fold''

As an alternative to the encoding using Church pairs, a list can be encoded by identifying it with its right fold function. For example, a list of three elements x, y and z can be encoded by a higher-order function that when applied to a combinator c and a value n returns c x (c y (c z n)).

: $\begin \operatorname &\equiv \lambda c.\lambda n.n\\ \operatorname &\equiv \lambda l.l\ (\lambda h.\lambda t.\operatorname)\ \operatorname\\ \operatorname &\equiv \lambda h.\lambda t.\lambda c.\lambda n.c\ h\ (t\ c\ n)\\ \operatorname &\equiv \lambda l.l\ (\lambda h.\lambda t.h)\ \operatorname\\ \operatorname &\equiv \lambda l.\lambda c.\lambda n.l\ (\lambda h.\lambda t.\lambda g.g\ h\ (t\ c))\ (\lambda t.n)\ (\lambda h.\lambda t.t) \end$

This list representation can be given type in System F.

Represent the list using Scott encoding

An alternative representation is Scott encoding, which uses the idea of continuations and can lead to simpler code. (see also Mogensen–Scott encoding).

In this approach, we use the fact that lists can be observed using pattern matching expression. For example, using Scala notation, if list denotes a value of type List with empty list Nil and constructor Cons(h, t) we can inspect the list and compute nilCode in case the list is empty and consCode(h, t) when the list is not empty:

list match

The 'list' is given by how it acts upon 'nilCode' and 'consCode'. We therefore define a list as a function that accepts such 'nilCode' and 'consCode' as arguments, so that instead of the above pattern match we may simply write:
: $\operatorname\ \operatorname\ \operatorname$

Let us denote by 'n' the parameter corresponding to 'nilCode' and by 'c' the parameter corresponding to 'consCode'.
The empty list is the one that returns the nil argument:
: $\operatorname \equiv \lambda n. \lambda c.\ n$
The non-empty list with head 'h' and tail 't' is given by
: $\operatorname\ h\ t\ \ \equiv\ \ \lambda n.\lambda c.\ c\ h\ t$

More generally, an algebraic data type with $m$ alternatives becomes a function with $m$ parameters. When the $i$th constructor has $n_i$ arguments, the corresponding parameter of the encoding takes $n_i$ arguments as well.

Scott encoding can be done in untyped lambda calculus, whereas its use with types requires a type system with recursion and type polymorphism. A list with element type E in this representation that is used to compute values of type C would have the following recursive type definition, where '=>' denotes function type:

type List =
C => // nil argument
(E => List => C) => // cons argument
C // result of pattern matching

A list that can be used to compute arbitrary types would have a type that quantifies over C. A list generic in E would also take E as the type argument.

See also

* Lambda calculus
*System F for Church numerals in a typed calculus
*Mogensen–Scott encoding
* Von Neumann definition of ordinals — another way to encode natural numbers: as sets

Notes

References

*
*
* All about Church and other similar encodings, including how to derive them and operations on them, from first principles
Some interactive examples of Church numerals

{{Mathematical logic

Lambda calculus