CITS3211 FUNCTIONAL PROGRAMMING

Transcription

1 CITS3211 FUNCTIONAL PROGRAMMING 9. The λ calculus Summary: This lecture introduces the λ calculus. The λ calculus is the theoretical model underlying the semantics and implementation of functional programming languages. R.L. While, , modified by R. Davies

2 The λ calculus The λ calculus is the theoretical model underlying the semantics and implementation of functional languages in a sense, it is the simplest possible functional language Real FP languages are often described as sugared λ calculus the semantics of Haskell is defined by translation into a kernel language that is similar to the λ calculus Despite its simplicity, the λ calculus is powerful enough to express all computable functions it is Turing equivalent to all other languages CITS3211 Functional Programming 2 9. The λ calculus

3 The syntax of the λ calculus Expressions in the λ calculus ( λ expressions ) come in four forms E ::= c built in constant x variable E E application λx.e λ abstraction parentheses group expressions e.g. (λx.x) c by convention, capital letters (e.g. E, M, N) denote λ expressions and small letters denote variables and constants (e.g. x, y, z and c, d respectively) λ abstractions represent anonymous functions λx. E is a function that takes an argument called x and returns E (which may depend on x) λx. + x 1 is a function that adds one to its argument \x -> x + 1 is the same function in Haskell function application is always prefix in the λ calculus Nested λ abstractions are sometimes abbreviated λx.λy.λz. x (+ y z) abbrev s to λxyz. x (+ y z) Syntactically, λ abstractions extend as far as possible to the right subject to the presence of brackets (this is important!) (λx.x 3) = λx.x 3 (λx.x) 3 CITS3211 Functional Programming 3 9. The λ calculus

4 Bound and free variables The x in the abstraction λx.e is the bound variable of the abstraction Consider the expression λx.x (λz.x y z) (y z) x is the bound variable of the outer abstraction the two xs refer to the same value y is not bound by any abstraction y is a free variable the two ys refer to the same value z is the bound variable of the inner abstraction the first z refers to this bound variable the second z is a free variable the two zs can refer to different values The free variables in an expression E are given by fv (E) fv (c) = {} fv (x) = {x} fv (E E ) = fv (E) fv (E ) fv (λx.e) = fv (E) {x} fv ((E)) = fv (E) An expression with no free variables is a closed expression we will normally consider only closed expressions, but variables can still occur free in sub expressions e.g. x is bound in λx.λy.λz. x (+ y z) but free in λy.λz. x (+ y z) A λ abstraction with no free variables is a combinator CITS3211 Functional Programming 4 9. The λ calculus

5 Substitution An fundamental operation in the study and implementation of functional languages is substitution substitution is the consistent replacement of a variable by an expression Given an expression M, the result of substituting the expression E for all free occurrences of the variable x in M is denoted by M[E/x], read M with E for x c[e/x] = c x[e/x] = E y[e/x] = y (M N)[E/x] = (M[E/x]) (N[E/x]) (λx.m)[e/x] = λx.m (λy.m)[e/x] = λy.(m[e/x]) (M)[E/x] = (M[E/x]) e.g. (* x ((λx.x y) (+ x)))[+ y 4/x] = * (+ y 4) ((λx.x y) (+ (+ y 4))) CITS3211 Functional Programming 5 9. The λ calculus

6 Conversion rules conversion rules allow us convert one λ expression into another one that has the same meaning α conversion allows us to rename the bound variable in a λ abstraction λx.e α λy.e[y/x] if y fv (E) c.f. renaming an argument to a function β conversion allows us to reduce an application of a λ abstraction (λx.e) E β E[E /x] c.f. function application/instantiation η conversion allows us to eliminate a redundant λ abstraction λx.e x η E if x fv (E) and E is a function c.f. the difference between sum xs = foldr (+) 0 xs and sum = foldr (+) 0 Note that all of the conversion rules are bi directional left to right they are used as reduction rules right to left they are used as expansion rules CITS3211 Functional Programming 6 9. The λ calculus

7 Extensionality Proving the equivalence of two functions can be difficult and/or tedious Functions can be equal intensionally or extensionally two functions are intensionally equal if they are syntactically identical two functions are extensionally equal if, whenever they are applied to a given value, they return the same result e.g. λx.* x 2 = ext λx.+ x x So to prove that f = ext g, prove that f x == g x for arbitrary x e.g. prove that if true ((λx.x) 3) = ext λy.3 if true ((λx.x) 3) w β (λx.x) 3 β 3 (λy.3) w β 3 This technique is useful because it involves only β reduction alternative techniques also involve η reduction (as does the justification of this technique) CITS3211 Functional Programming 7 9. The λ calculus

8 Reduction A redex is a reducible expression i.e. an application either an application of an abstraction, or an application of a built in function to arguments in the appropriate form A redex r1 contains a redex r2 if r2 occurs in the argument of r1 or in the body of the abstraction of r1 An innermost redex is a redex that contains no other redex An outermost redex is a redex that is contained by no other redex A λ expression is in normal form if it contains no redexes A λ expression is in weak head normal form (WHNF) if it is one of a constant, a variable, an abstraction (possibly containing redexes), or a partial application of a built in function CITS3211 Functional Programming 8 9. The λ calculus

9 Reduction orders Evaluation is basically the process of taking an expression and reducing its redexes until there are none left When there is more than one redex in an expression, we have to decide which one to reduce first Applicative order reduction is defined as reduce the innermost redexes at each stage c.f. eager evaluation Normal order reduction is defined as reduce the outermost redexes at each stage c.f. lazy evaluation Haskell uses leftmost outermost reduction, i.e. it is normal order The Church Rosser Theorem says if an expression can be reduced in two different ways to two normal forms, the normal forms must be α equivalent The Standardisation Theorem says if an expression has a normal form, reducing the outermost redexes at each stage (i.e. normal order reduction) is guaranteed to reach that normal form Proofs can be found in The λ calculus its syntax and semantics, by H.P. Barendregt, North Holland 1984 CITS3211 Functional Programming 9 9. The λ calculus

10 Strictness and laziness A function is strict if it is sure to need the value of its argument conversely, if a strict function is applied to the undefined value, the result is undefined i.e. f is strict iff f = e.g. not is strict: not = A function is lazy if it is not strict e.g. three is lazy: three :: a > Int three x = 3 three This idea generalises in the obvious way to functions of several arguments e.g. g is strict in its second argument iff g x z = e.g. + is strict in both of its arguments: + y = x + = e.g. if is strict in its first argument, but not in its other arguments: if x y = if false y = y if true x = x CITS3211 Functional Programming The λ calculus