Lazy Evaluation of Function Arguments. Lazy Evaluation of Function Arguments. Evaluation with Lazy Arguments. Evaluation with Lazy Arguments

Transcription

1 Lazy Evaluation o Function Arguments Lazy Evaluation o Function Arguments let = proc()0 in ( +(1,+(2,+(3,+(4,+(5,6)))))) The computed 21 is never used. What i we were lazy about computing unction arguments (in case they aren t used)? One way to laziness: let = proc(thunk)0 in ( proc()+(1,+(2,+(3,+(4,+(5,6)))))) let = proc(thunk)-((thunk), 7) in ( proc()+(1,+(2,+(3,+(4,+(5,6)))))) By using proc to delay evaluation, we can avoid unnecessary computation. How about making the language compute unction arguments lazily in all applications? 0 let = proc()0 in ( +(1,2)) let = proc()0 in ( +(1,2)) 1-9

2 0 +(1,2) 0 Application creates a new kind o green bo, with two slots: a thunk let = proc()0 in ( +(1,2)) let = proc()0 in ( +(1,2)) 0 The result is 0 let = proc()0 in ( +(1,2)) let = proc()-(,1) in ( +(1,2)) 10-13

3 +(1,2) let = proc()-(,1) in ( +(1,2)) let = proc()-(,1) in ( +(1,2)) lookup o orces evaluation o the thunk let = proc()-(,1) in ( +(1,2)) let = proc()-(,1) in ( +(1,2)) 14-17

4 so 3 is the value o The result is 2 let = proc()-(,1) in ( +(1,2)) let = proc()-(,1) in ( +(1,2)) Lazy epression that needs its environment... let = proc()-(,1) in ( ) let = proc()-(,1) in ( ) 18-21

5 y 7 y 7 let = proc()-(,1) in ( ) let = proc()-(,1) in ( ) y 7 y 7 Evaluation o orces the thunk... Triggering evaluation with the thunk s enviornment, not the current one let = proc()-(,1) in ( ) let = proc()-(,1) in ( ) 22-25

6 y 7 (The result will be 7) What i the right-hand side or y is an epression, instead o a value? let = proc()-(,1) in ( ) let = proc()-(,1) in ( ) y +(3,4) Added thunk or the value o y let = proc()-(,1) in ( ) let = proc()-(,1) in ( ) 26-29

7 y +(3,4) y +(3,4) Another thunk or the argument o Evaluation o orces a thunk... let = proc()-(,1) in ( ) let = proc()-(,1) in ( ) y +(3,4) y +(3,4) which, in turn, orces another thunk... and so on (to get 7) let = proc()-(,1) in ( ) let = proc()-(,1) in ( ) 30-33

8 Implementing Lazy Evaluation Call-by-Name and Call-by-Need Interpreter changes: Change eval-un-rands to create thunks Change variable lookup to orce thunk evaluation (Implement in DrScheme) The lazy strategy we just implemented is call-by-name Advantage: unneeded arguments are not computed Disadvantage: needed arguments may be computed many times let = proc()+(,+(,)) in ( +(1,+(2,+(3,+(4,+(5,6)))))) Best o both worlds: call-by-need Evaluates each lazy epression once, then remembers the result Start as beore... let = proc()-(,) in ( +(1,2)) let = proc()-(,) in ( +(1,2)) 34-39

9 +(1,2) lookup o... let = proc()-(,) in ( +(1,2)) let = proc()-(,) in ( +(1,2)) 3... orces evaluation o the thunk to get 3 so change to which is the essence o call-by-need let = proc()-(,) in ( +(1,2)) let = proc()-(,) in ( +(1,2)) 40-43

10 3 3 lookup o again gets 3 (The result is 0) let = proc()-(,) in ( +(1,2)) let = proc()-(,1) in ( +(1,2)) Implementing Call-by-Need Calling Convention Terminology Interpreter changes: Change variable lookup to replace thunks in locations with their values (Implement in DrScheme) Call-by-name and call-by-need = lazy evaluation Call-by-value = eager evaluation Call-by-reerence can augment either 44-47

11 Popular Calling-Convention Choices Popularity o Laziness Most languages are call-by-value C, C++, Pascal, Scheme, Java, ML, Smalltalk... Some provide call-by-reerence C++, Pascal A ew are call-by-need Why don t more languages provide lazy evaluation? Disadvantage: evaluation order is not obvious let = 0 =... in let y = set =1 z = set =2 in { ( y z) ; } Haskell Practically no languages are call-by-name Popularity o Laziness Laziness and Eagerness Why do some languages provide lazy evaluation? Evaluation order does not matter i the language has no set orm Such languages are called purely unctional Note: call-by-reerence is meaningless in a purely unctional language A language with set can be called imperative Even in a purely unctional language, lazy and eager evaluation can produce dierent results Eager answer: none Lazy answer: 0 let = proc()0 in ( [loop orever]) 48-53