159.331 Programming Languages & Algorithms

1. 159.331 Programming Languages & Algorithms Lecture 24 - Functional Programming Languages - Part 6 Lambda Calculus Prog Lang & Alg

2. Lambda Calculus • Alonzo Church’s notation for studying types • Supposedly inspired by Whitehead and Russell notation for the class of all x’s such that f(x) ; to wit ^xf(x) - moved the carat ^ down and it became a lambda  • x.M is used for a function with parameter x and body M • So x.x*x is a function that maps 5 to 5 * 5 • Functions are written next to their arguments so f a is the application of function f to argument a • (x.x*x) 5 applies our function to 5 yielding 25 Prog Lang & Alg

3. We call formulas like (x.x*x) 5 terms • Church’s original formulation of -calculus was for general properties of functions not tied to any particular problem area. The integer 5 and the multiplication operator below to the problem area “arithmetic” and are not part of the pure calculus • A grammar for terms in the pure -calculus is: • M ::= x | (M1 M2 ) | (x.M) • We use letters f, x, y, z for variables and M, N,P, Q for terms • A term is a variable x, or an application (M N) of function M to N or an abstraction (x.M) Prog Lang & Alg

4. We are allowed constants such as c which can represent values like integers and operations on data structures like lists • c can stand for basic constants like true and nil or constant functions like head and + • Pure -calculus is untyped - Functions can be applied freely; and it even makes sense to write (x,x) where x is applied to itself • A functional programming language is essentially a -calculus with appropriate constants Prog Lang & Alg

5. Equality of Pure  Terms • Equality relation on terms - known historically as -equality. We write: • M = N if M and N are “beta-equal” • Informally if M = N, then M and N must have the same value • Beta-equality deals with idea of applying an abstraction (x.M) to an argument N - ie the notion of function call and parameter passing in programming languages. • An abstraction corresponds to a a function definition, an application to a function call. Prog Lang & Alg

6. For function square defined by: fun square(x) = x * x; • The function call square(5) is evaluated by substituting 5 for x in the body x*x • We say that square(5) = 5 * 5. Prog Lang & Alg

7. Syntactic Conventions • We drop parentheses from (M N) and (x.M) • In the absence of parentheses, function application groups from left to right, so that x y z abbreviates ((x y) z) , and the parentheses in x( y z) are necessary. • Function application has higher precedence than abstraction, so x. x z abbreviates (x. (x z)) . • We will use the following terms in examples: • I = x.x • K = xy.x • S = xyz. (x z) (y z) or in full: (x.(y.(z.((x z)(y z))))) • A pure  term without free variables is called a closed term or a combinator Prog Lang & Alg

8. Free and Bound Variables • Abstractions of the form x.M are referred to as bindings because they constrain the role of x in x.M. Variable x is said to be bound in x.M • The set free(M) of free variables of M, the set of variables that appear unbound in M is given by the following rules: free(x) = {x} free(M N) = free(M)  free(N) free (x.M) = free(M) - {x} • Variable x is free in the term x • Variable is free in M N if it is either free in M or free in N • With exception of x all other free variables of M are free in x.M Prog Lang & Alg

9. In (y.z) (z.z) z is a free variable because it is free in the term y.z (union rule above) • The occurrence of x to the right of  in x.M is called a binding occurrence or simply a binding of x. • All occurrences of x in x.M are bound within the scope of this binding. • All unbound occurrences of a variable in a term are free and each occurrence is either free or bound - it cannot be both. In: y .  z . x z ( y z ) • Lines go from a binding to bound occurrence(s) Prog Lang & Alg

10. Substitution • Result of applying an abstraction (x.M) to an argument N will be formalized by “substituting” N for x in M. Informally N replaces all free occurrences of x in M • A simple definition for substitution of a term N for a variable x in M is written as {N/x}M where: • If the free variables of N have no bound occurrences in M then the term {N/x}M is formed by replacing all free occurrences of x in M by N • Otherwise, if the variable y is free in N and bound in M, consistently replace the binding and corresponding bound occurrences of y in M by some fresh variable z. Repeat the renaming of bound variables until case 1 applies, then proceed as in 1. Prog Lang & Alg

11. In each of the following, M has no bound occurrences, so N replaces all occurrences of x in M to form {N/x}M {u/x} x = u {u/x} (x x) = (u u) {u/x} (x y) = (u y) {u/x} (x u) = (u u) {(x.x)/x} x = (x.x) • (read the “/” as “substitutes for” ) Prog Lang & Alg

12. In the following cases, M has no free occurrences of x, so {N/x} M is M itself. {u/x} y = y {u/x} (y z) = (y z) {u/x} (y.y) = (y.y) {u/x} (x.x) = (x.x) {(x.x)/x} y = y Prog Lang & Alg

13. In the following cases, free variable u in N has bound occurrences in M, so {N/x}M is formed by first renaming the bound occurrence of u in M: {u/x} (u.x) = {u/x} (z.y) = (z.u) {u/x} (u.u) = {u/x} (z.z) = (z.z) Prog Lang & Alg

14. Beta-Equality • The key axiom (beta axiom) of beta equality is: • (x.M) N = {N/x} M • So that (x.x) u = u and (x.y) u = y • The following axiom allows bound variables to be systematically renamed: • ( x.M) = z. {z/x}M , provided that z is not free in M (known as the alpha axiom) • So that x.x = y.y and xy.x = uv.u • Remaining rules for beta-equality formalize general properties: • Idempotence. A term M equals itself • Commutativity. If M equals N then N must equal M • Transitivity. If M equals N and N equals P then M equals P Prog Lang & Alg

15. Prog Lang & Alg

16. The replacement of equals for equals is formalised by the two congruence rules (6 & 7) • The first rule can be read as: If M = M and N = N then M N = M N • Furthermore: • If M = M , then x.M = x.M • Think of the axiom rule format written as a list of conditions on the numerator with the conclusion on the denominator Prog Lang & Alg

17. Prog Lang & Alg

18. Summary Prog Lang & Alg

19. Further Reading • See Bal & Grune Chapter 4 • See Sebesta Chapter 15 • See also Hudak’s ACM article on Conception, Evolution and Application of Functional Programming Languages Prog Lang & Alg