Interoperation for Lazy and Eager Evaluation

Transcription

1 Interoperation for Lazy and Eager Evaluation 1

2 Matthews & Findler New method of interoperation Type safety, observational equivalence & transparency Eager evaluation strategies Lazy vs. eager 2

3 Lambda calculus Typing Model Interoperation Laziness Solution 3

4 Syntax Expressions, e (1) x e v = λ x. e (2) M e λ x. M e e = x v e e (3) M, N e M N e 4

5 z by (1) (1) x (2) λ x. e (3) e e λ z. z by (1), (2) (λ z. z) (λ z. z) by (1), (2), (3) 5

6 Syntactic sugar λ x. x x λ x. (x x) (λ x. x) x λ x x. e λ x. λ x. e e e e (e e ) e 6

7 Semantics Reduction relation, e e e e e e e 7

8 (λ x. e) v e [ v / x ] e e e e e e e e e e e e e e v e v e e e v e v e 8

9 term [ term argument / term parameter ] = term x [ e / x ] = e x [ e / x ] = x (λ x. e) [ e / x ] = λ x. e (λ x. e) [ e / x ] = λ x. (e [ e / x ]) (e e ) [ e / x ] = (e [ e / x ]) (e [ e / x ]) 9

10 y λ y. ( y ) Free variable Bound variable y λ y. y Open term Closed term 10

11 Errors error condition error e e e e e e e error e e error e e v e v e e error v e error 11

12 Evaluation contexts, E E = [ ] E e v E E = [ ] E [ e ] = e E [ (λ x. e) v ] E [ e [ v / x ] ] E [ error condition ] error 12

13 v = λ x. e n e = x v e e +/- e e if0 e e e fun? e num? e wrong string E = [ ] E e v E +/- E e +/- v E if0 E e e fun? E num? E 13

14 E [ wrong string ] Error: string E [ + n n ] E [ n + n ] E [ - n n ] E [ max(n - n, 0) ] E [ if0 0 e e ] E [ e ] E [ if0 n e e ] E [ e ] E [ fun? (λ x. e) ] E [ 0 ] E [ fun? v ] E [ 1 ] E [ num? n ] E [ 0 ] E [ num? v ] E [ 1 ] 14

15 Lambda calculus Typing Model Interoperation Laziness Solution 15

16 Simple types Types, t t = N t t λ x : t. e t t t t (t t) 16

17 Judgments, e : t ( e, t ) Γ xn : tn,, x1 : t1 λ xn : tn. ( λ x1 : t1. e) Γ e : t e : t Γ t t 17

18 Number type N Function type Γ t Γ t Γ t t Number n : N Variable Γ, x : t x : t Function Γ, x : t e : t Γ λ x : t. e : t t Application Γ e : t t Γ e : t Γ e e : t 18

19 Arithmetic Γ e : N Γ e : N Γ +/- e e : N Condition Γ e : N Γ e /e : t Γ if0 e e e : t Error Γ t Γ wrong t string : t 19

20 Closed-term typing Type Γ T Number Γ n : T Variable Γ, x : T x : T Application Γ e : T Γ e : T Γ e e : T 20

21 Function Γ, x : T e : T Γ λ x. e : T Arithmetic Γ e : T Γ e : T Γ +/- e e Predicate Γ e : T Γ fun?/num? e : T Error Γ wrong string : T 21

22 Type abstraction Type variable y Universally-quantified types y. t Type abstraction Λ y. e Free & bound type variables Λ y. ( y ) Type application e t 22

23 Syntactic sugar Λ y y. e Λ y. Λ y. e e t t (e t ) t 23

24 Semantics E [ (Λ y. e) t ] E [ e [ t / y ] ] 24

25 Type-in-term substitution term [ type argument / type parameter ] = term x [ t / y ] = x (λ x : t. e) [ t / y ] = λ x : t [ t / y ]. e [ t / y ] (e e ) [ t / y ] = (e [ t / y ]) (e [ t / y ]) (+/- e e ) [ t / y ] = +/- (e [ t / y ]) (e [ t / y]) 25

26 if0 (e [ t / y ]) (if0 e e e ) [ t / y ] = if0 (e [ t / y ]) if0 (e [ t / y ]) (Λ y. e) [ t / y ] = Λ y. e (Λ y. e) [ t / y ] = Λ y. e [ t / y ] (e t ) [ t / y ] = (e [ t / y ]) t [ t / y ] 26

27 Type-in-type substitution type [ type argument / type parameter ] = type N [ t / y ] = N (t t ) [ t / y ] = t [ t / y ] t [ t / y ] y [ t / y ] = t y [ t / y ] = y 27

28 ( y. t) [ t / y ] = y. t ( y. t) [ t / y ] = y. t [ t / y ] 28

29 Lambda calculus Typing Model Interoperation Laziness Solution 29

30 ML & Scheme Numbers, arithmetic & conditions Function abstractions & applications Errors Eager evaluation Language subscripts m and s for nonterminals 30

31 ML Statically typed Parametric polymorphism 31

32 ML syntax tm = N ym tm tm ym. tm vm = n λ xm : tm. em Λ ym. em em = x m vm em em em tm +/- em em if0 em em em wrong tm string Em = [ ] m Em em vm Em Em tm +/- Em em +/- vm Em if0 Em em em 32

33 Scheme Dynamically typed Closed-term typing Ad-hoc polymorphism 33

34 Scheme syntax vs = n λ xs. es es = x s vs es es +/- es es if0 es es es fun? es num? es wrong string Es = [ ] s Es es vs Es +/- Es es +/- vs Es if0 Es es es fun? Es num? Es 34

35 Lambda calculus Typing Model Interoperation Laziness Solution 35

36 Syntax Converting from Scheme to ML em = ms tm es Em = ms tm Es Converting from ML to Scheme es = sm tm em Es = sm tm Em 36

37 Typing ML Scheme Γ m tm Γ s es : T Γ m ms tm es : tm Scheme ML Γ m tm Γ m em : tm tm = tm Γ s sm tm em : T 37

38 Converting numbers Outermost evaluation context, E E [ ms N n ]m E [ n ] E [ sm N n ]s E [ n ] E [ ms N vs ]m E [ wrong N Not a number ] 38

39 Converting functions es Fs es 39

40 Fm Fs em : tm es es em : tm tm tm 40

41 Fm Fs em : tm es es em : tm m s s m tm tm 41

42 Fm em : tm em : tm tm tm 42

43 Convert from ML to Scheme sm sm tm xm Apply the Scheme function app Fs sm Convert from Scheme to ML ms ms tm app Abstract the ML argument Fm λ xm : tm. ms Converted Scheme function in ML Fm λ xm : tm. ms tm (Fs (sm tm xm)) 43

44 E [ ms (tm tm ) (λ xs. es) ]m E [ λ xm : tm. ms tm ((λ xs. es) (sm tm xm)) ] E [ sm (tm tm ) vm ]s E [ λ xs. sm tm (vm (ms tm xs)) ] E [ ms (tm tm ) vs ]m E [ wrong (tm tm ) Not a function ] 44

45 (ms tm ((λ xs. es) (sm tm xm))) [ em / xm ] ML Scheme em xm 45

46 Boundary substitution (ms tm es) [ em / xm ] = ms tm (es [ em / xm ]) Foreign substitution ( es ) [ em / xm ] = es [ em / xm ] (sm tm em) [ em / xm ] = sm tm (em [ em / xm ]) 46

47 Converting type abstractions tm = L Γ m L vm = ms L vs E [ sm ( ym. tm) (Λ ym. em) ]s E [ sm tm [ L / ym ] em [ L / ym ] ] E [ sm L (ms L vs) ]s E [ vs ] 47

48 id Λ y. ms (y y) (λ x. x) id N behaves the same as id N N idm Λ y. ms (y y) (λ x. if0 (num? x) x 0) idm N behaves differently than idm N N 48

49 Conversion schemes idgood Λ y. ms (y y) (λ x. x) idgood N behaves the same as idgood N N idbad Λ y. ms (y y) (λ x. if0 (num? x) x 0) idbad N behaves differently than idbad N N 49

50 Conversion schemes, k km = L N ym km km ym. km b tm em = ms km es es = sm km em vs = sm km vm 50

51 Γ m km Γ s es : T Γ m ms km es : km E [ (Λ ym. em) tm ]m E [ em [ b tm / ym ] ] E [ ms (b tm) (sm (b tm) vm) ]m E [ vm ] E [ ms (b tm) vs ]m E [ wrong b tm Brand mismatch ] 51

52 b tm = tm L = L N = N ym = ym km km = km km ym. km = ym. km 52

53 (λ xm : tm. em) [ b tm / ym ] = λ xm : tm [ tm / ym ]. em [ b tm / ym ] (ms km es) [ b tm / ym ] = ms km [ b tm / ym ] es [ b tm / ym ] 53

54 Lambda calculus Typing Model Interoperation Laziness Solution 54

55 Haskell Eager vs. lazy evaluation Add Haskell to the mix Interoperation forces Haskell evaluation Applying converted functions in Haskell Converting values from Haskell Observational equivalence and transparency do not hold 55

56 Haskell syntax th = N yh th th yh. th kh = L N yh kh kh yh. kh b th vh = n λ xh : th. eh Λ yh. eh hs L vs eh = x h vh eh eh eh th +/- eh eh if0 eh eh eh wrong th string Eh = [ ] h Eh eh Eh th +/- Eh eh +/- vh Eh if0 Eh eh eh 56

57 Interoperation syntax eh = hm th tm em hs kh es em = mh tm th eh es = sh kh eh vh = hs L vs vs = sh kh eh 57

58 Eh = hm th tm Em hs kh Es Em = mh tm th Eh Es = sh kh Eh 58

59 Applying functions zeros λ x. 0 h zeroh : N N zeroh hs (N N) zeros broken wrong N Broken zeroh broken 0 zeroh broken * Error: Broken 59

60 zeroh broken (hs (N N) zeros) broken (λ x : N. hs N (zeros (sh N x))) broken hs N (zeros (sh N broken)) Error: Broken 60

61 Converting values eh = nil th cons eh eh hd eh tl eh null? eh th = { th } kh = { kh } Eh = hd Eh tl Eh null? Eh 61

62 Γ h th Γ h { th } Γ h eh : { th } Γ h hd eh : th Γ h th Γ h nil th : { th } Γ h eh : { th } Γ h tl eh : { th } Γ h eh : { th } Γ h null? eh : N Γ h eh : th Γ h eh : { th } Γ h cons eh eh : { th } 62

63 E [ hd (nil th) ]h E [ wrong th Empty list ] E [ hd (cons eh eh ) ]h E [ eh ] E [ tl (nil th) ]h E [ wrong { th } Empty list ] E [ tl (cons eh eh ) ]h E [ eh ] E [ null? (nil th) ]h E [ 0 ] E [ null? (cons eh eh ) ]h E [ 1 ] 63

64 E [ hs { th } nil ]h E [ nil th ] E [ hs { th } (cons vs vs ) ]h E [ cons (hs th vs) (hs { th } vs ] ] 64

65 vm = nil tm cons vm vm vs = nil cons vs vs Em = cons Em em cons vm Em Es = cons Es es cons vs Es 65

66 brokenh wrong N Broken emptyh nil N listh cons brokenh emptyh lists sh {N} listh lists cons brokens emptys lists * Error: Broken 66

67 lists sh {N} (cons brokenh emptyh) cons (sh N brokenh) (sh {N} emptyh) Error: Broken 67

68 Haskell & ML E [ hm ( yh. th) ( ym. tm) (Λ ym. em) ]h E [ Λ yh. hm th (tm [ L / ym ]) (em [ L / ym ]) ] vh = hm L tm vm vm = mh L th eh 68

69 Γ h th Γ m tm th tm Γ m em : tm tm = tm Γ h hm th tm em : th 69

70 x x x y y x x y y z x z th L tm L th = tm th tm 70

71 Lambda calculus Typing Model Interoperation Laziness Solution 71

72 Problematic contexts Applying converted functions in Haskell hs N (zeros (sh N broken)) vs Es Converting values from Haskell cons (sh N brokenh) ( ) cons Es es 72

73 Es = [ ]s num? Es Es es if0 Es es es vs Es cons Es es +/- Es es cons vs Es +/- vs Es hd Es fun? Es list? Es null? Es tl Es sh kh Eh sm km Em 73

74 Restrict forcing Rename Es to Us (unforced) Us = Es Factor Scheme Haskell out of Us (forced) Fs = Us sh kh Eh Rename vs to us (unforced) us = vs Factor Scheme Haskell out of us (forced) fs = us sh kh eh 74

75 Redefine Us in terms of Us, Fs, us, fs Us es Us = us Us cons Us es cons us Us 75

76 Redefine Us in terms of Us, Fs, us, fs Fs es Us = fs Us cons Us es cons us Us 76

77 Fm = Um mh tm th Eh Us = [ ]s fun? Fs cons Us es Fs es list? Fs cons us Us fs Es null? Fs hd Fs +/- Fs es num? Fs tl Fs +/- fs Fs if0 Fs es es sh kh Eh sm km Em 77

78 Rename E to F F [ (λ xm : tm. em) um ]m F [ em [um / xm] ] F [ hd (cons um um ) ]m F [ um ] F [ tl (cons um um ) ]m F [ um ] F [ null (cons um um ) ]m F [ 1 ] 78

79 Solution For incompatible evaluation contexts Mirrors laziness for Haskell boundaries Controls the forcing of Haskell evaluation Restores observational equivalence and transparency 79

80 Summary Matthews & Findler Lazy vs. eager Observational equivalence and transparency Incompatible evaluation contexts Laziness mirrored in eager evaluation 80

81 Questions 81