A notation for describing computations that focuses. Allows convenient denition and manipulation of

Transcription

1 Introduction to -calculus A notation for describing computations that focuses on function denition and application. Allows convenient denition and manipulation of functions as \rst-class" values. Eample: a function that adds 1 to its argument (.( + 1)) Invented b Church in the 1930's to stud computabilit questions, but now primaril of interest in programming language communit. In itself, serves as a basic functional language. Practical FLs = -calculus + \sntactic sugar." Can also serve (in restricted or specialized form) as intermediate language in compilers (esp. for functional languages). ( Meta-notation for denotational semantics.) We will take a pragmatic, rather than theoretical, approach to -calculus. In particular, we will treat the calculus as a sntactic game, and won't worr about models.

2 Snta -calculus is an epression calculus, with the following concrete snta: Built-in constants <variable> Variable names (<ep> <ep>) Function applications (<variable>.<ep>) Function abstractions <ep> := <constant> A <variable> is ordinaril denoted b a lower-case letter, e.g.,,,z,f. We tpicall use upper-case letters (e.g., M,N,P,Q) as metavariables ranging over epressions (e.g., (.M)). Pure -calculus has no constants. We will tpicall etend the -calculus with some set of \built-in" constants and functions (an applied -calculus): 0,1,2,... Integer constants +-*/ Integer operators true,false Boolean constants and,or,not Boolean operators if If-then-else operator pair Pair constructor fst, snd Pair selectors cons, nil List constructors hd, tl List selectors null List empt predicate

3 Eamples: (f a) (+ 3 2).(+ 1) (.(+ 1)) 17..pair (snd ) (fst ) f..pair (f (fst )) (f (snd )).if (null ) 0 (hd ) We often cheat and use several abbreviations in our concrete snta: Function application associates to the left. The bod of a -abstraction etends as far to the right as possible. Drop parentheses where not needed. A sequence of consecutive abstractions can be written with a single. Eample: S z.( z)( z) could have been written with fewer parentheses as z. z( z) Its full form is (.(.(z.(( z)( z)))))

4 Tree representation For epression of an size, it is best to write down the abstract snta tree of the epression to avoid confusion. (This will prove more deepl useful later on.) Eamples: (.(+ 1)) (.(.(z.(( z)( z))))) z z z

5 More on Functions -abstractions are fundamentall the same thing as fn epressions in ML; e.g.,.+ 1 corresponds to fn => + 1. Thus we can view -calculus epressions as a subset of ML epressions. (Of course, we haven't said anthing et about how epressions are supposed to behave computationall.) Notice that all -calculus functions are written in pre notation and take eactl one argument. What do we do about functions that naturall require more than one, such as addition? Recall that when we wrote (+ 3 4) this was reall an abbreviation for ((+ 3) 4). That is, + is a function that takes a single integer argument and returns a new function whose eect is to add to its argument! This trick is called curring after the logician Haskell Curr, who made etensive use of it. Alternativel, we could dene the built-in + function to take a single pair of integers as argument. (But the built-in pair constructor will still need to take its arguments in curried form.) This is the approach taken in ML.

6 Reductions We evaluate a -calculus epression b repeatedl selecting a reducible (sub-)epression (rede) and reducing it, according to a reduction rule. Pure -calculus has the -rule, which describes how to appl a -abstraction to an argument. Informall: the result of appling a -abstraction to an argument is an instance of the bod of the abstraction in which (free) occurrences of the formal parameter in the bod are replaced with (copies of) the argument. Each applied -calculus also has -rules describing how to reduce epressions involving the built-in functions and constants. Eamples: * 2 3! 6 (.+ 1) 4! + 4 1! 5 (.+ ) 5! + 5 5! 10 (.3) 5! 3

7 (.(.- )) 4 5! (.- 4) 5! - 5 4! 1-4 5! - 4 5! - 5 4! 1 (f.f 3)(.+ 1)! (.+ 1) 3! + 3 1! 4 f f 3 + 1! + 1 3! + 3 1! 4

8 Bound and Free Variables In an abstraction.m, we sa the binds the variable in the bod M, meaning that is just a placeholder for a value that will be lled in when the abstraction is applied. An occurrence of a variable in an epression is bound if there is an enclosing abstraction that binds it; otherwise it is free. Note that these denitions are relative to a particular occurrence and a particular epression. Eample.+ ((.+ z) 7) + + z 7 Here and occur bound in the overall epression, but z occurs free.

9 Eample + ((.+ 1) 4) Here the rst occurrence of is free but the second is bound. If M is an epression we write: F V (M) set of free variables in M BV (M) set of bound variables in M An epression M such that F V (M) = ; is said to be closed.

10 -reduction, more carefull If the same name appears in several -bindings, we want to use idea of nested scopes from block-structured languages. I.e., when doing -reduction, we should onl substitute for free occurrences of the formal parameter variable. Eample (.(.- (- 1)) 3 ) 9! (.- (- 1)) 3 9! - (- 3 1) 9! ! !!

11 The following is wrong! (.(.- (- 1)) 3 ) 9 6! (.- (- 9 1)) 3 9! - (- 9 1) 9! ! !!

12 Variable Capture Our revised denition of -reduction still isn't adequate; here's another name-clash problem. f f Naive substitution leads to but this is obviousl wrong: the right-hand, originall free in the epression, has been \captured" b the. We must conclude that a -reduction of (.M)N is onl valid if F V (N) do not clash with an formal parameters in M. We will see several was to cope with this problem.

13 -Conversion and -Conversion We can avoid name-clash problems b uniforml changing the names of bound variables where necessar. Intuitivel, changing names is justiable because the are onl formal parameters. Formall, we call such name changes -conversion. Eample (. + 1) $ (. + 1) Of course, the new name must not appear free in the bod of the abstraction. (. + ) 6$ (. + ) In general, we'd like to dene two epressions as interconvertible if the \mean the same thing" (intuitivel). To do this, we must dene two other forms of conversion relation. -conversion is the smmetric closure of -reduction (the inverse operation is -abstraction). Eample $ (.+ 1) 4

14 Substitution We can avoid all name-clash problems and give simple denitions of both - and -conversion via a careful denition of capture-avoiding substitution. We write [M/] N for the substitution of M for in N. (Other similar notations are also in common use, e.g., N [M/].) [M/] c = c [M/] = M [M/] = ( 6= ) [M/] (Y Z) = ([M/] Y)([M/] Z) [M/].Y =.Y [M/].Z =.[M/]Z ( 62 F V (Z) or 62 F V (M)) [M/].Z = w.[m/]([w/]z) (w 62 F V (Z) [F V (M)) Then we can dene.z $.[/]Z ( 62 F V (Z)) (.M) N $ [N/]M

15 de Bruijn Notation Another wa to solve name clash problems is to do awa with names altogether! In the tree for a closed epression, ever variable occurrence names a variable bound at some -binding on the path between the occurrence node and the root. We can uniquel identif a variable b counting the number of -bindings that intervene between its mention and its dening binding. Eample..+ (* )..+ 1 (* 0 0) * * 0 It is now fairl straightforward to dene -reduction in terms of this representation. (Since there are no names, we don't need -conversion!)

16 -Reduction and -Conversion Consider these two epressions:.+ 1 (+ 1) The \mean the same thing" in the sense that the behave the same wa when applied to an argument (i.e., the add 1 to it). This is the concept of functional etensionalit. To formalize this, we add an -reduction rule: (.F )! F provided 62 F V (F). -reduction tends to simplif an epression, but its inverse, -epansion can also be useful. Their combination is called -conversion, written $. The -rules cannot be deduced from the -rules. We will generall appeal to the -rules to justif program transformations, rather than to perform computation.

17 Reduction Order To evaluate a -epression, we keep performing reductions as long as a rede eists. An epression containing no redees is said to be in normal form. But an epression ma contain more than one rede, so evaluation ma proceed b dierent routes. Eample: (.(.+ ) 3) 2 can be reduced in two was: !! ! + 2! + 2 Fortunatel, both reduction orders lead to the same result in this eample. Will this alwas happen? 3! 5 3! 5

18 Non-terminating reductions Not ever epression has a normal form at all. Consider (D D), where D.. The evaluation of this epression never terminates because (D D)! (D D)! In other words, evaluation enters an innite loop. Such a computation is said to diverge. For some epressions, one reduction sequence ma terminate while another does not. Eample: (.3)(D D) If we perform the application of (.3) to (D D) rst, we immediatel get 3 and stop. But if we keep tring to evaluate the argument (D D) rst, we keep getting (D D) again. So choice of reduction order can aect whether we get an answer!

19 Church-Rosser Theorem It turns out that all reduction sequences that terminate will give the same result, at least for the pure -calculus. Thus, if an epression has an normal form, that normal form is unique. This happ result is a consequence of the Church- Rosser Theorem: If E 1 $ E 2 then 9 E, such that E 1! E and E 2! E. (An sstem (not necessaril related to the -calculus) for which this theorem is true is said to be \Church- Rosser.") Corollar Suppose now that E 0! E 1 and E 0! E 2 and that both E 1 and E 2 are in normal form. Then, since E 1 $ E 2, C-R sas 9 E such that E 1! E and E 2! E. But since E 1 and E 2 are alread both in normal form, this can onl mean that E 1 = E = E 2. (If we are using names, the normal form is unique \up to -conversion".) The Church-Rosser theorem for -calculus is surprisingl dicult to prove. (It isn't necessaril true for applied -calculi, but this is not a problem in practice.)

20 Specifing Reduction Order No reduction sequence can give us a wrong answer, but some sequences might fail to terminate even when a normal form eists. To dene reduction orders, we need to characterize rede positions in an epression. An outermost rede of an epression is one that is not contained within an other rede (i.e., within either the argument or the function bod). An innermost rede of an epression is one that contains no other rede. The leftmost outermost rede is the outermost rede whose (for a -rede) or function constant (for a -rede) is furthest to the left (in the string or tree representation). Leftmost innermost is de- ned similarl. Two important reduction strategies are: applicative order, which sas to alwas reduce the leftmost innermost rede rst; normal order, which sas to alwas reduce the leftmost outermost rede rst.

21 Normalization Theorem The normal order reduction strateg alwas leads to a normal form, if one eists. Applicative order, which corresponds to the idea of evaluating a function's arguments before invoking the function, does not have this propert. Eample revisited: (.3)(D D) 3 z z z Here the rede is the (onl) outermost one and the rede is the (onl) innermost one. Normalorder reduction sas to do the reduction rst, so (D D) is never evaluated. Applicative order reduction sas to evaluate (D D) repeatedl. Intuitivel, normal order evaluation wins over applicative order here because the function.3 doesn't use its argument, so there's no point in tring to evaluate it (fruitlessl). A function that uses its argument is said to be strict in that argument; e.g.,.3 is not strict in, but. is.

22 Eager or Laz? The applicative order strateg corresponds to callb-value, as used in most imperative languages. In FL's this is usuall called eager evaluation. The normal order strateg corresponds to call-bname (as found in Algol-60). Although the normal order strateg appears better (it computes something useful more often) it is signicantl less ecient to implement. Intuitivel, this is because if the argument is a complicated epression, call-b-name must transmit the entire epression including the values of its free variables, whereas call-b-value needs onl to transmit the value of the epression, which ma be much simpler. There's another obvious problem with call-b-name: if an argument is needed, it ma be needed at several points in the bod, and hence get reduced several times. Practical implementations avoid this problem b sharing the result of evaluating the argument at all points where it is used. This combination of call-b-name with sharing is called callb-need or (loosel) laz evaluation. (To model sharing, we need to change our tree representation of -epressions to a graph.) Well-known laz functional languages include Miranda and Haskell; eager functional languages include the (pure subsets of) Scheme and ML.

23 Weak Head Normal Form In real programming languages, we don't epect the bod of a function to be evaluated (even in part) before the function has been called, i.e., before the formal parameters have been assigned values. (If it happens, we tend to think of it as an optimization, as with a loop invariant.) But either of our strategies, as dened so far, ma do such reductions. An applicative order eample: (.+ (+ 2 3) ) 8 The leftmost innermost rede is (+ 2 3), so this will be -reduced to 5 before the top-level reduction occurs. To avoid this behavior, most functional languages implementations \don't evaluate under a." Technicall, we stop evaluating when we reach weak head normal form (WHNF). A consequence of this implementation approach is that we never have name clash problems, since we never reduce an epression containing free variables (assuming we started with a closed epression).

24 Recursion Suppose we wish to dene a recursive function, such as the factorial function: FAC = (n.if (= n 0) 1 (* n (FAC (- n 1)))) This denition is fault: it relies on a abilit to name a -epression (FAC) and refer to that name from within the epression itself. The problem is that -abstractions are anonmous. (We've named -epressions before, but onl as an abbreviation mechanism which could be easil \unfolded.") The onl names a -abstraction can refer to are those of its arguments (or the arguments to enclosing abstractions). So the trick is to rewrite the recursive function so that it takes itself as an etra argument! We do this b -abstraction: FAC $ n.(: : :FAC: : :) becomes FAC $ f.(n.(: : :f: : :)) FAC We can rewrite this as: FAC $ H FAC where H f.(n.(: : :f: : :)) Note that H is a perfectl ordinar -abstraction that does not involve recursion.

25 Fied Points The factorial function FAC is a solution to the equation FAC $ H FAC i.e., it is a function FAC such that the result of appling H to FAC is just FAC. We sa that FAC is a ed point of the function H. It is eas to nd ed points for some functions. For eample the function.* has both 0 and 1 as ed points. In general, a function ma have 0, 1, some, or innitel man ed points. It's not so eas to see what a ed point of H should look like, but for a moment let's just assume the eistence of a function Y that takes an function as argument and returns a ed point of that function as result. That is, for an function F, F (Y F) $ Y F Then, in particular, we have H (Y H) $ Y H, so FAC Y H is a solution to our equation for for the factorial function that doesn't involve recursion!

26 Eample With our denitions FAC Y H H f.n.if (= n 0) 1 (* n (f (- n 1))) we can now compute, e.g., factorial(1): FAC 1 = Y H 1 $ H (Y H) 1 = (f.n.if (= n 0) 1 (* n (f (- n 1)))) (Y H) 1! (n.if (= n 0) 1 (* n (Y H (- n 1)))) 1! if (= 1 0) 1 (* 1 (Y H (- 1 1)))! * 1 (Y H 0) $ * 1 (H (Y H) 0) = * 1 ((f.n.if (= n 0) 1 (* n (f (- n 1)))) (Y H) 0)! * 1 ((n.if (= n 0) 1 (* n (Y H (- n 1)))) 0)! * 1 (if (= 0 0) 1 (* n (Y H (- 0 1))))! * 1 1! 1

27 Dening Y We have seen that recursion can be epressed wholl in terms of a ed-point combinator Y. But how do we dene Y? We could build it into our applied -calculus as a special function with a suitable -rule. In fact, this is more or less what we will do in practice. Amazingl, it is also possible to dene Y as an ordinar epression in the pure -calculus! Here is one denition: Y h.(.h ( ))(.h ( )) Let's check it out: Y H = (.h.(.h ( ))(.h ( ))) H $ (.H ( ))(.H ( )) $ H ((. H ( ))(. H ( ))) $ H ((.h.(.h ( ))(.h ( ))) H) = H (Y H) Note the similarit between this denition of Y and the looping epression (D D). In fact, this version of Y doesn't work with call-b-value evaluation because it goes into an innite loop! Fortunatel, there are man was to write Y; here's one that does work with call-b-value: Y f.(.f(. ))(.f (. ))

28 Pure Fun In principle, we can do without built-in constants and -rules altogether b encoding useful tpes and operators directl in the pure -calculus. In general, this means using -abstractions to represent values. For eample, to model booleans we need a wa of representing true and false, functions correspondig to and, or, etc., and an equivalent of if that selects one of two epressions based on the value of the boolean. Here's how: true.. false.. if f...f and.. false : : : Eample if true 0 1 = (f...f ) true 0 1! (..true ) 0 1! (.true 0 ) 1! true 0 1 = (..) 0 1! (.0) 1! 0

29 Church Numerals 0 f.. 1 f..f 2 f..f(f ) : : : n n times z } { f.. f(f : : : (f ): : :) succ n.f..f(n f ) iszero n.n(.false) true : : : Eample succ 2 = (n.f..f(n f )) 2! f..f(2 f ) = f..f((f..f(f )) f )! f..f((.f(f )) )! f..f(f(f )) = 3

30 Data Constructors pair..f.f fst p.p(..) snd p.p(..) Eample pair 1 2 = (..f.f ) 1 2! f.f 1 2 so fst (pair 1 2) = (p.p(..))(f.f 1 2)! (f.f 1 2)(..)! (..) 1 2! 1 Note that pairs and booleans are encoded in essentiall the same wa!