CITS3211 FUNCTIONAL PROGRAMMING. 10. Programming in the pure λ calculus

Transcription

1 CITS3211 FUNCTIONAL PROGRAMMING 10. Programming in the pure λ calculus Summary: This lecture demonstates the power of the pure λ calculus by showing that there are λ expressions that can be used to emulate some basic features of Haskell, namely definitions, booleans, pairs, lists, numbers and recursion. R.Davies

2 Pure λ calculus In the λ calculus we can use built in constants to represent primitive Haskell values like True, False, 0, 1, 2,..., ==, <, etc. We can even represent if... then... else... as a built in constant that is a primitive function taking three parameters: if True E E' E if False E E' E' This is what we'll do in later lectures when we consider implementing interpreters and compilers for Haskell. In this lecture we'll see that such constants are not essential. Instead the λ calculus is powerful enough that we can implement Booleans, pairs, numbers, lists, etc. and even recursion. When we restrict ourselves to λ expressions without constants we say that we are using the pure λ calculus. Historically, the pure λ calculus was studied first, by Alonzo Church in 1932 as a simple language that could express every computable function. CITS3211 Functional Programming Programming in the pure λ calculus

3 λ Expressions for Definitions We want to be able to write code in the pure λ calculus that is structured like a Haskell program. Suppose our program has a bunch of definitions. E.g. f x y = x g z = z Now, suppose we want to evaluate an expression. E.g. f g g We can turn the expression we want to evaluate into a function that takes expressions for f and g as arguments. λfg. f g g Then, the translation of the whole program is the application of this function to the translation of the definitions. (λfg. f g g) (λxy. x) (λz. z) The same technique can be used to translate local definitions (i. e. where definitions) into the λ calculus. CITS3211 Functional Programming Programming in the pure λ calculus

4 Booleans We want to implement True, False and if as closed λ expressions in such a way that: if True E E' β E if False E E' β E' Everything is a function in the pure λ calculus, so True and False must be some kind of functions. We can make True and False the functions that take two arguments and select the first/second argument. True = λxy.x False = λxy.y Then if is a higher order function that applies the first argument to the second and third. if = λbxy. b x y E.g. if True E E' = (λxyz. x y z) (λxy.x) E E' β ( λyz. (λxy.x) y z) E E' β E Evaluation is done by β-reduction. CITS3211 Functional Programming Programming in the pure λ calculus

5 Pairs To program with pairs, we need at least an operation mkpair to construct a pair from two expressions, and fst and snd to extract parts from a pair. As before, in the λ calculus pairs must be represented as some kind of functions. We can consider a pair to be a function that takes a Boolean as input, and returns either the first or second part of the pair. mkpair E E' True = E mkpair E E' False = E' Then we can represent mkpair by the λ expression: mkpair = λxyb. b x y fst and snd each apply the pair to a selector function (i.e. True or False): fst = λz.z (λxy.x) Then we can use β-reduction to show: fst (mkpair E E') β E snd (mkpair E E') β E' snd = λz.z (λxy.y) CITS3211 Functional Programming Programming in the pure λ calculus

6 Lists Lists are built using two constructor functions. Nil for the empty list ([]) Cons h t for the list with head h and tail t (h:t) We can represent lists using λ expressions by combining the techniques from Booleans and pairs. Nil is just the same selection function as True. Nil = λxy.x Cons h t is like the other select, but also combines features of similar to the pair (h, t). Cons h t = λxy. y h t Cons = λhtxy. y h t Compare this to: False = λxy.y mkpair = λxyz. z x y To check whether a list is empty, we can use the following function: null = λl.l True (λht. False) To take the head and tail of a list, or return a default d if the list is empty, we can use the following functions: head = λld. l d (λht. h) tail = λld. l d (λht. t) CITS3211 Functional Programming Programming in the pure λ calculus

7 Numbers As a first step in representing numbers using λ expressions, we show an inefficient representation of just the natural (non negative) numbers. Every natural number is either zero, or it is some other natural number plus one. In Haskell we could represent natural numbers using the data type: data Nat = Zero Successor Nat Zero is just the same selection function as True. Zero = λxy.x Successor a should be the other select, but also applies the second argument to a. Successor a = λxy. y a Successor = λaxy. y a To check whether a number is zero, we can use the following function: iszero = λn. n True (λm. False) To find the predecessor of a number or return default d if the number is zero, we can use the following function: predecessor = λnd. d (λm. m) We can then write recursive functions for +, -, *, div, ==, <, >, etc. CITS3211 Functional Programming Programming in the pure λ calculus

8 Recursion We can't write many interesting programs with lists or numbers unless we have recursion. E.g. we can't write the map function (or + or == for natural numbers). But the λ calculus doesn t allow recursive definitions Is there a way to emulate recursive definitions in the λ calculus? If we have a recursive definition like f = E with E already converted to a λ expression, then λf. E is a function that captures one step of the recursion, using the parameter f if further steps are required. Is there a λ expression Y that repeatedly applies a λ expression f to itself? Y f β f (Y f) β... β f (f (f (f...) ) ) Yes. Let Y be the following λ expression. Y = λf. (λx. f (x x)) (λx. f (x x)) This is all we need to write recursive functions using pure λ expressions. CITS3211 Functional Programming Programming in the pure λ calculus

9 Why Y? Why do we need Y? Suppose we try to translate the following Haskell code for the map function into a pure λ calculus expression. map f [] = [] map f (h:t) = (f h) : (map f t) We might try to translate this to the following expression for map. λf l. l Nil (λh t. Cons (f h) (map f t)) But, this isn't a λ calculus expression unless we know what term the map stands for! We know what Nil and Cons stand for, so the above expression is an abbreviation for: λf l. l (λxy.x) (λh t. (λabxy.y a b) (f h) (map f t)) But we don't know what to replace the map with. We'd like it to recursively stand for the whole expression! CITS3211 Functional Programming Programming in the pure λ calculus

10 Recursion using Y This is where we need to use Y. To map we add an extra parameter m. λm f l. l (λxy.x) (λh t. (λabxy.y a b) (f h) (m f t)) This is definitely a pure λ expression, so let's give it a name, and go back to using the abbreviations Nil, Cons. mapstep = λm f l. l Nil (λh t. Cons (f h) (m f t)) Now, mapstep doesn't do what we want unless we supply the argument m, which needs to be a function to do a map. Applying Y to mapstep does exactly this. Y mapstep β mapstep (Y mapstep)... β mapstep (mapstep (mapstep (...))) So, this pure λ expression does what we want, so lets call it map. map = Y mapstep Note: Y is equivalent to the recursive Haskell function y f = f (y f) Also, Y is known as a fixed point combinator, because it finds an object that f maps to itself. Such fixed points play a key role in mathematical semantics of programs and an in the study of computability. CITS3211 Functional Programming Programming in the pure λ calculus