CBV and CBN. Eduardo Bonelli. TP para LP 2012C1 1/55

Transcription

1 CBV and CBN Eduardo Bonelli TP para LP 2012C1 1/55

2 Reduction Strategies Call-By-Value Call-by-Name Relating CBN and CBV λ-calculus Continuation Passing Style Bibliography 2/55

3 Reduction Strategies Reduction in λ-calculus is non-deterministic A term may have more than one redex Reduction-as-computation requires fixing a reduction strategy Criterion for selecting a redex Example strategies Call-by-value (CBV) Call-by-name (CBN) Call-by-need 3/55

4 Origins of CBV/CBN Plotkin [Plo75] introduced CBV/CBN in an effort to study correct program equivalences Programming language theory Calculus: determines notions of equality between expressions Computation (abstract machine/operational semantics): determines how programs are executed Computational soundness (of the calculus): expressions identified by the calculus behave the same computationally Plotkin departed from an abstract machine (Peter Landin s ISWIM [Lan64] 1 and proposed a calculus (the CBV lambda calculus) that is computationally sound for the SECD abstract machine (which implements ISWIM). 1 If You See What I Mean 4/55

5 Origins of CBV/CBN Programming language theory Calculus: determines notions of equality between expressions Usually specified in terms of equations or rewrite rules Computation (abstract machine/operational semantics): determines how programs are executed Usually specified via small-step operational semantics Abstract machines are instance Computational soundness (of the calculus): expressions identified by the calculus behave the same computationally behave the same computationally usually taken to be Morris-style contextual equivalence We ll take a closer look at CBV lambda calculus Note: We work in an untyped setting 5/55

6 Computation - The SECD Machine 2 Due to Peter Landin [Lan64] Carries out CBV evaluation of closed λ-terms Simple enough that its basic instructions can be easily implemented Machine configuration (Stack,Environment,Code,Dump) Dynamics described in terms of transitions over configurations All transitions are at the root which is characteristic of abstract machine reduction 2 We follow presentation of [Gun93] 6/55

7 The SECD Machine Machine Configuration Machine configuration (Stack,Environment,Code,Dump) Code: List of instructions (instruction is λ-term or constant ap) Environment: partial function that assigns closures to identifiers Closure: pair (M, E) where M is a λ-term; and E is an environment that is defined on all free identifiers of M Stack: stack of closures Dump: empty or (S, E, C, D ) Initial mach. config. for M closed (denoted Load(M)): Final mach. config-: (nil,, M, empty) (Cl :: S, E, nil, empty) 7/55

8 The SECD Machine Transitions for CBV pure lambda calculus M ::= x M M λx.m (Cl :: S, E, nil, (S, E, C, D )) (Cl :: S, E, C, D ) (S, E, x :: C, D) (E(x) :: S, E, C, D) (S, E, (λx.m) :: C, D) ((λx.m, E) :: S, E, C, D) ((λx.m, E ) :: Cl :: S, E, ap :: C, D) (nil, E [x Cl], M, (S, E, C, D)) (S, E, (M N) :: C, D) (S, E, N :: M :: ap :: C, D) 8/55

9 The SECD Machine Transitions Extension to defined constants (applicative style) M ::= zero succ x M M λx.m (S, E, n :: C, D) ((n, ) :: S, E, C, D) (S, E, succ :: C, D) ((succ, ) :: S, E, C, D) ((succ, E 1 ) :: (n, E 2 ) :: S, E, ap :: C, D) ((n + 1, ) :: S, E, C, D) 9/55

10 The SECD Machine Transitions Example nil (λx. mul x ((λy.dbl y) 5)) 3 empty 10/55

11 The SECD Machine Environments Required for Static Scoping Let M be the λ-term: let x = 5 in let f = λy. (add x y) in let x = 3 in f x nil M empty 11/55

12 Other abstract machines SMC [Plo81] CEK [FF86] Cardelli AM (CAM) Chemical AM (CHAM) Krivine AM (KAM) [Kri07] Zinc (Xavier Leroy) Survey: [DHS00] 12/55

13 Computation - Big-Step Semantics Switching from closures to substitution Higher-level description Yields what is presently called big-step semantics Notation: a value (V ) is an abstraction λx.m V λx.m M V λx.m N V N M {x := N } V P M N V P Note: M V N implies N is unique and is a value 13/55

14 Computation - Equivalence with SECD Machine Eval V (M) def = V iff Load(M) reduces to a final configuration that has (V, E ) as topmost closure in the stack, for some E eval V (M) def = V iff M V V for some V λx.m V λx.m M V λx.m N V N M {x := N } V P Theorem Eval V (M) = α eval V (M). M N V P 14/55

15 Calculus Reasoning about Computation The λ V -calculus Since the calculus deals with equality of program fragments we extend values with variables: V ::= λx.m x λ V -calculus: The reflexive, symmetric, transitive closure of (λx.p) V. = P{x := V } M =. N C any λ-context Cong C[M] =. C[N] λ V -equality: We write λv M =. N if the judgement M =. N is derivable in λ V λ V -reduction: λ V -equality without symmetry and denoted λv β V 15/55

16 Contextual equivalence In what sense is λv M. = N true with regards to program computation? Contextual equivalence: M V N iff for every context C s.t. C[M] and C[N] are closed, eval V (C[M]) and eval V (C[N]) are either both undefined or else both defined. Note that M and N are program fragments Two phrases of a programming language are contextually equivalent if any occurrences of the first phrase in a complete program can be replaced by the second phrase without affecting the observable results of executing the program (Andrew Pitts, notes) 16/55

17 Contextual equivalence Contextual equivalence: M V N iff for every context C s.t. C[M] and C[N] are closed, eval V (C[M]) and eval V (C[N]) are either both undefined or else both defined. Examples: Note that requiring that both closed terms evaluate to the same value is too simplistic Take 2 and succ 1 as Church Numerals as an example 2 V succ 1 (λx.p) V V P{x := V } 1 V 2 17/55

18 Contextual equivalence Coinductive techinques for contextual equivalence See slides of the course Fundamentos de concurrencia y movilidad Available here 18/55

19 Computational soundness - Proof idea Corollary (Cor.2.1(1) in [Plo75]) For any closed term M: V s.t. λv M =. V iff eval V (M) defined Theorem (Computational soundness) λv M =. N implies M V N Proof: 1. Take any C s.t. C[M] and C[N] closed 2. Suppose eval V (C[M]) defined and equal to V 3. Then λv C[N] =. C[M] =. V 4. Then by the above cor., eval V (C[N]) is defined 19/55

20 Computational soundness - Proof idea Corollary (Cor.2.1(1) in [Plo75]) For any closed term M: V s.t. λv M. = V iff eval V (M) defined Proof relies on a number of results: 1. CR( λv ) 2. Standardization of λv 3. Fact that a standard reduction to a value consists of head steps ( λ h V ) 4. M λ h V V iff eval V (M) defined (for closed M and value V ) 20/55

21 λ h V CBV reduction (as a computation rule) is the following system: (λx.p) V V h P{x := V } β V M V h M µ M N V h M N N V h N V N V h V N ν V Pick leftmost redex, not under a constructor λ is a constructor Thus, no reduction under λ Would be considered code optimization rather than computation We speak of weak reduction 21/55

22 λ h V Examples Examples: 1. (λx.x x) (I I ) V h (λx.x x) I V h I I V h I 2. λx.i I is in normal form 3. x (I I ) V h x I 4. x I (I I ) is in normal form 5. x I is in normal form 6. Ω V h Ω V h Ω V h... 22/55

23 Failure of Computational Completeness Example: ω = λx.x x ω y = λx.(x x) y ω ω V ω y ω y (trivially). λv ω ω = ω y ω y Example: λx.x (λy.x y) V ω. λv λx.x (λy.x y) = ω 23/55

24 Reduction Strategies Call-By-Value Call-by-Name Relating CBN and CBV λ-calculus Continuation Passing Style Bibliography 24/55

25 Computation - Big-Step Semantics Notation: a value (V ) is an abstraction. λx.m N λx.m M N λx.m M {x := N} N P Note: M N N P M N N implies N is unique and is a value eval N (M) def = V iff M N V for some V 25/55

26 Calculus Reasoning about Computation The λ N -calculus Since the calculus deals with equality of program fragments we extend values with variables: V ::= λx.m x λ N -calculus: The reflexive, symmetric, transitive closure of (λx.p) Q. = P{x := Q} M =. N C any λ-context Cong C[M] =. C[N] λ N -equality: We write λn M =. N if the judgement M =. N is derivable in λ N λ N -reduction: λ N -equality without symmetry and denoted λn β N 26/55

27 Contextual equivalence In what sense is λn M. = N true with regards to program computation? Contextual equivalence: M N N iff for every context C s.t. C[M] and C[N] are closed, eval N (C[M]) and eval N (C[N]) are either both undefined or else both defined. Note that M and N are program fragments Theorem (Computational soundness) λn M. = N implies M N N 27/55

28 CBN λ h N -calculus Values V ::= λx.m Reduction (λx.p) Q N h P{x := Q} β N h M N h M µ M N N h M N 28/55

29 CBN λ-calculus - Sample reduction sequence 1. (λx.x x) (I I ) N (I I ) (I I ) N I (I I ) N I I N I 2. λx.i I is in normal form 3. x (I I ) is in normal form 4. (λx.i ) Ω N I 5. Ω N Ω N Ω N... 29/55

30 Reduction Strategies Call-By-Value Call-by-Name Relating CBN and CBV λ-calculus Continuation Passing Style Bibliography 30/55

31 Reduction Strategies Call-By-Value Call-by-Name Relating CBN and CBV λ-calculus Continuation Passing Style Bibliography 31/55

32 Relating CBN and CBV λ-calculus Reduction in the CBN λ-calculus can be simulated in the CBV λ-calculus and viceversa Essentially they differ in how they deal with arguments CBV in CBN: must force eval. of arguments CBN in CBV: freeze arguments into values Can be achieved in two ways Using continuations [Plo75] Using thunks [HD97] We develop the first 32/55

33 Introduction fact 4 = 4 * (fact 3) = 4 * (3 * (fact 2)) = 4 * (3 * (2 * (fact 1))) = 4 * (3 * (2 * (1 * (fact 0)))) = 4 * (3 * (2 * (1 * 1))) = 4 * (3 * (2 * 1)) = 4 * (3 * 2) = 4 * 6 = 24 Control context increments with each call This context may be seen as a continuation of the computation: it is left pending for the recursive call to return 33/55

34 Introduction In CPS programming style continuations become first class citizens (just like data) a function never returns: it passes its result to its continuation can achieve fast, iterative behaviour any function can be converted to CPS Example - Factorial in CPS fact 0 c = c 1 fact (n+1) c = fact n (\x-> c ((n+1)*x)) 34/55

35 Introduction prod [] = 1 prod (x:xs) = x * prod xs Fast prod in CPS prod [3,2,0,7] = 3 * prod [2,0,7] = 3 * (2 * prod [0,7]) = 3 * (2 * (0 * prod[7])) = 3 * (2 * (0 * (7 * prod[]))) = 3 * (2 * (0 * (7 * 1))) = 3 * (2 * (0 * 7)) = 3 * (2 * 0) = 3 * 0 = 0 fastprod [] c = c 1 fastprod (x:xs) c = if x==0 then 0 else fastprod xs (\y -> c (x*y)) 35/55

36 Example - Simple Interpreter in CPS type Cont = Int -> Int eval1 :: Exp -> Env String Int -> Cont -> Int eval1 (LitExp n) env c = c n eval1 (VarExp id) env c = c (lookupenv env id) eval1 (DobleExp e1) env c = eval1 e1 env (\x -> c (2*x)) eval1 (DivExp e1 e2) env c = eval1 e1 env (\x -> eval1 e2 env (\y -> c (x div y))) eval1 (IfExp testexp trueexp falseexp) env c = eval1 testexp env (\x -> if istruevalue x then eval1 trueexp env c else eval1 falseexp env c) eval1 (LetExp id e1 body) env c = eval1 e1 env (\v -> eval1 body (extendenv id v env) c) eval1 (AbortExp e) env c = eval1 e env (\x -> x) 36/55

37 Example Simple Interpreter in CPS data Exp =... Try e1 e2 Raise eval2 :: Exp -> Env String Int -> Cont -> Cont -> Int eval2 (LitExp n) env c cerr = c n eval2 (VarExp id) env c cerr = c (lookupenv env id)... eval2 (AbortExp e) env c cerr = eval2 e env (\x -> x) cerr eval2 (TryExp a b) env c cerr = eval2 b env c (\x -> eval2 a env c cerr) eval2 (RaiseExp) env c cerr = cerr (-1) 37/55

38 Example Simple Interpreter in CPS data Exp =... TryR e RaiseR e eval3 :: Exp -> Env String Int -> Cont -> Cont -> Int eval3 (LitExp n) env c ctry = c n eval3 (VarExp id) env c ctry = c (lookupenv env id)... eval3 (AbortExp e) env c ctry = eval3 e env (\x -> x) ctry eval3 (TryRExp a) env c ctry = eval3 a env c c eval3 (RaiseRExp a) env c ctry = eval3 a env ctry ctry 38/55

39 Relating CBN and CBV CBN and CBV are equivalent in a precise sense We introduce two translations due to Plotkin [Plo75] 1. CBN CPS transform [ ] NinV Evaluation of terms in CBN, can be correctly simulated in CBV 2. CBV CPS transform [ ] VinN Evaluation of terms in CBV, can be correctly simulated in CBN Notation: e 1 e 2 for meta-language expressions e 1, e 2 means either both are undefined or else both are defined and denote α-equivalent terms 39/55

40 Simulating CBN in CBV - Plotkin s CBN CPS transformation [ ] NinV : T λ T λ [x] NinV = λk.x k [λx.m] NinV = λk.k (λx.[m] NinV ) [M N] NinV = λk.[m] NinV (λv.v [N] NinV k) An abstraction is already a value, so just pass it on to topmost continuation (k) In an application M N first compute M, then pass-on the result (as v) to the continuation (λv.v [N] NinV k), then apply x to [N]NinV (note [N] NinV is a value), then pass final result to topmost continuation (k) 40/55

41 Simulating β N in CBV (λx.m) N N M{x := N} (λk 1.[λx.M] NinV (λv.v [N] NinV k 1 )) k V [λx.m] NinV (λv.v [N] NinV k) = (λk 2.k 2 (λx.[m] NinV )) (λv.v [N] NinV k) V (λv.v [N] NinV k) (λx.[m] NinV ) V (λx.[m] NinV ) [N] NinV k [M] NinV {x := [N] NinV } k V Does [ ] NinV commute with substitution? I.e. [M{x := N}] NinV k = [M] NinV {x := [N] NinV } k? No (e.g. take M = x and N = y) However, [M] NinV {x := [N] NinV } k V [M{x := N}] NinV k 41/55

42 Theorem - Simulation of CBN in CBV For all closed terms M T λ, where Note: [eval N (M)] NVal I V eval V ([M] NinV I ) [ ] NVal : Values N T λ [λx.m] NVal = λx.[m] NinV I plays role of topmost continuation 42/55

43 CPS Terms and Indifference CPS terms: set of terms in the range of [ ] NinV, closed under β reduction CBN and CBV coincide on CPS terms (Indifference) CPS terms are tail-recursive: no argument is an application. Therefore there is at most one redex which is not inside the scope of an abstraction and thus CBV evaluation coincides with outermost or CBN evaluation [MW85] [ ] NinV : T λ T λ [x] NinV = λk.x k [λx.m] NinV = λk.k (λx.[m] NinV ) [M N] NinV = λk.[m] NinV (λv.v [N] NinV k) 43/55

44 Theorem - Indifference For all closed terms M T λ, eval N ([M] NinV I ) eval V ([M] NinV I ) I plays role of topmost continuation 44/55

45 Simulating CBV in CBN - Plotkin s CBV CPS transformation [ ] VinN : T λ T λ [x] VinN = λk.k x [λx.m] VinN = λk.k (λx.[m] VinN ) [M N] VinN = λk.[m] VinN (λv.[n] VinN (λw.v w k)) Variables and abstractions are values, so just pass them on to topmost continuation (k) In an application M N first compute M (call the result v), then compute N (call the result w), then apply v to w, then pass final result to topmost continuation (k) 45/55

46 Notational Variation [ ] VinN : T λ T λ [x] VinN = λk.k x [λx.m] VinN = λk.k (λx.[m] VinN ) [M N] VinN = λk.[m] VinN (λv.[n] VinN (λw.v w k)) Notationally more convenient [ ] VinN : T λ T λ [V ] VinN = λk.k [V ] VVal [M N] VinN = λk.[m] VinN (λv.[n] VinN (λw.v w k)) [ ] VVal : Values V T λ [x] VVal = x [λx.m] VVal = λx.[m] VinN 46/55

47 Simulating β V in CBN (λx.m) V V M{x := V } (λk 1.[λx.M] VinN (λv.[v ] VinN (λw.v w k 1 ))) k N [λx.m] VinN (λv.[v ] VinN (λw.v w k)) = (λk 2.k 2 (λx.[m] VinN )) (λv.[v ] VinN (λw.v w k)) N (λv.[v ] VinN (λw.v w k)) (λx.[m] VinN ) N [V ] VinN (λw.(λx.[m] VinN ) w k) = (λh.h [V ] VVal ) (λw.(λx.[m] VinN ) w k) N (λw.(λx.[m] VinN ) w k) [V ] VVal N (λx.[m] VinN ) [V ] VVal k N [M] VinN {x := [V ] VVal } k = [M{x := V }] VinN k All but last step regarded as administrative: does not correspond to reduction of source terms 47/55

48 Theorem - Simulation of CBV in CBN For all closed terms M T λ : [eval V (M) I ] VVal eval N ([M] VinN I ) Note: I plays role of topmost continuation, as before 48/55

49 Theorem - Indifference CPS terms: set of terms which is in the range of [ ] VinN, closed under β reduction CBN and CBV coincide on CPS terms (Indifference) For all closed terms M T λ eval N ([M] VinN I ) eval V ([M] VinN I ) 49/55

50 Further Reading History behind discovery of continuations: [Rey93] Applications of continuations: [Fri88, FS99] Introduction to continuations and CPS: [FWH01] In-depth analysis of CPS: [DF92] 50/55

51 Reduction Strategies Call-By-Value Call-by-Name Relating CBN and CBV λ-calculus Continuation Passing Style Bibliography 51/55

52 Bibliography I Olivier Danvy and Andrzej Filinski. Representing control: A study of the cps transformation. MSCS, 2: , Stephan Diehl, Pieter H. Hartel, and Peter Sestoft. Abstract machines for programming language implementation. Future Generation Comp. Syst., 16(7): , M. Felleisen and D. P. Friedman. Control operators, the secd machine, and the λ-calculus. Formal Description of Programming Concepts III, Daniel Friedman. Applications of continuations. Invited Tutorial to POPL 88, Available from /55

53 Bibliography II Matthias Felleisen and Amr Sabry. Continuations in programming practice: Introduction and survey. Available from Daniel P. Friedman, Mitchell Wand, and Christopher T. Haynes. Essentials of Programming Languages. MIT Press, Carl A. Gunter. Semantics of programming languages - structures and techniques. Foundations of computing. MIT Press, /55

54 Bibliography III John Hatcliff and Olivier Danvy. Thunks and the lambda-calculus. Journal of Functional Programming, 7(3): , Jean-Louis Krivine. A call-by-name lambda-calculus machine. Higher-Order and Symbolic Computation, 20(3): , Peter J. Landin. The mechanical evaluation of expressions. Computer Journal, 6(4), Albert R. Meyer and Mitchell Wand. Continuation semantics in typed lambda-calculi. In Rohit Parikh, editor, Proc. of Logic of Programs, volume 193 of LNCS, pages Springer Verlag, /55

55 Bibliography IV Gordon Plotkin. Call-by-name, call-by-value and the λ-calculus. Theoretical Computer Science, 1: , Gordon Plotkin. A structural approach to operational semantics. Technical Report DAIMI FN-19, Aarhus University, John Reynolds. The discoveries of continuations. LISP and Symbolic Computation, 6(3-4): , /55