Exploring Dynamic Scopes and Types in Lambda Calculus: A JavaScript Translation Approach

1. A Fix for Dynamic Scope Ravi Chugh U. of California, San Diego

2. Backstory Goal: Types for “Dynamic” Languages Syntax and Semantics of JavaScript Translation à la Guha et al.(ECOOP 2010) Core λ-Calculus + Extensions

3. Backstory Goal: Types for “Dynamic” Languages • Approach: Type Check Desugared Programs • Simple Imperative, RecursiveFunctions are Difficult to Verify Core λ-Calculus + Extensions

4. varfact = function(n) { if (n<= 1) {return 1;} else {returnn* fact(n-1);} }; • Translate to statically typed calculus?

5. varfact = function(n) { if (n <= 1) {return 1; } else { return n* fact(n-1);} }; • Translate to statically typed calculus? • Option 1: λ-Calculus (λ) ✗ letfact =λn. if n<= 1 then 1 else n * fact(n-1) • fact is not bound yet…

6. varfact = function(n) { if (n <= 1) {return 1; } else { return n* fact(n-1);} }; • Translate to statically typed calculus? • Option 2: λ-Calculus + Fix (λfix) ✗ letfact = fix (λfact. λn. if n<= 1 then 1 else n * fact(n-1) ) • Desugared fact should be mutable…

7. varfact = function(n) { if (n <= 1) {return 1; } else { return n* fact(n-1);} }; • Translate to statically typed calculus? • Option 3: λ-Calculus + Fix + Refs (λfix,ref) ✗ letfact = ref (fix (λfact. λn. if n<= 1 then 1 else n * fact(n-1) )) • Recursive call doesn’t go through reference… • Okay here, but prevents mutual recursion

8. varfact = function(n) { if (n <= 1) {return 1; } else { return n* fact(n-1);} }; • Translate to statically typed calculus? • Option 4: λ-Calculus + Fix + Refs (λref) ✓ letfact = ref (λn. if n<= 1 then 1 else n * !fact(n-1) ) • Yes, this captures the semantics! • But how to type check ???

9. letfact = ref (λn. if n<= 1 then 1 else n * !fact(n-1) )

10. Backpatching Pattern in λref • fact :: Ref (Int  Int) letfact = ref (λn. 0) in fact := λn. if n<= 1 then 1 else n * !fact(n-1) ; • Assignment relies on and guaranteesthe reference invariant

11. Backpatching Pattern in λref • Simple types suffice if reference isinitialized with dummy function… letfact = ref (λn. 0) in fact := λn. if n <= 1 then 1 else n * !fact(n-1) ; • But we want to avoid initializers to: • Facilitate JavaScript translation • Have some fun!

12. Proposal: Open Types for λref fact :: (fact :: Ref (Int  Int)) Ref (Int  Int) Assuming fact points to an integer function, fact points to an integer function letfact = ref (λn. if n<= 1 then 1 else n * !fact(n-1) )

13. Proposal: Open Types for λref fact :: (fact :: Ref (Int  Int)) Ref (Int  Int) Assuming fact points to an integer function, fact points to an integer function letfact = ref (λn. if n<= 1 then 1 else n * !fact(n-1) ) in !fact(5) • Type system must checkassumptions at every dereference

14. Proposal: Open Typesfor λref Motivated by λref programs that result fromdesugaring JavaScript programs letfact = ref (λn. if n<= 1 then 1 else n * !fact(n-1) )

15. Proposal: Open Typesfor λref Motivated by λref programs that result from desugaring JavaScript programs Proposal also applies to, and is easier to show for,the dynamically-scoped λ-calculus (λdyn) letfact =λn. if n<= 1 then 1 else n * fact(n-1) • Bound at the time of call… • No need for fix or references

16. Lexical vs. Dynamic Scope λ • Environment at definition is frozen in closure… • And is used to evaluate function body • Explicit evaluation rule for recursion

17. Lexical vs. Dynamic Scope λ λdyn • Bare lambdas, so allfree variables resolved in calling environment

18. Lexical vs. Dynamic Scope λ λdyn • No need forfix construct

19. Open Types for λdyn Types (Base or Arrow) Open Types Type Environments Open Type Environments

20. Open Types for λdyn • Open function type describes environment for function body Open Typing

21. Open Types for λdyn • Open function type describes environment for function body • Type environment at function definition is irrelevant Open Typing

22. Open Types for λdyn Open Typing • In some sense, extreme generalization of [T-Fix] STLC + Fix

23. Open Types for λdyn Open Typing STLC + Fix

24. Open Types for λdyn For every • Rely-set contains • Guarantee-set contains (most recent, if multiple) Open Typing

25. Open Types for λdyn For every • Rely-set contains • Guarantee-set contains (most recent, if multiple) Open Typing Open Typing • Discharge all assumptions

26. Open Types for λdyn Open Typing

27. Examples letfact =λn. if n<= 1 then 1 else n * fact(n-1) in fact 5 fact :: (fact :: Int  Int) Int  Int

28. Examples letfact = λn. if n <= 1 then 1 else n * fact(n-1) in fact 5 fact :: (fact :: Int  Int) Int  Int Guarantee Rely ✓

29. Examples lettick n = if n> 0 then “tick ” ++ tock n else “” in tick 2; Error: var [tock] not found

30. Examples lettick n = if n> 0 then “tick ” ++ tock n else “” in tick 2; tick :: (tock :: Int  Str) Int  Str

31. Examples lettick n = if n > 0 then “tick ” ++ tock n else “” in tick 2; tick :: (tock :: Int  Str) Int  Str ✗ Guarantee Rely

32. Examples lettick n = if n> 0 then “tick ” ++ tock n else “” in let tock n = “tock ” ++ tick (n-1) in tick 2; “tick tock tick tock ”

33. Examples lettick n = if n> 0 then “tick ” ++ tock n else “” in let tock n = “tock ” ++ tick (n-1) in tick 2; tick :: (tock :: Int  Str) Int  Str tock :: (tick :: Int  Str) Int  Str

34. Examples lettick n = if n > 0 then “tick ” ++ tock n else “” in let tock n = “tock ” ++ tick (n-1) in tick 2; tick :: (tock :: Int  Str) Int  Str tock :: (tick :: Int  Str) Int  Str Guarantee Rely ✓

35. Examples lettick n = if n> 0 then “tick ” ++ tock n else “” in let tock n = “tock ” ++ tick (n-1) in let tock = “bad” in tick 2; Error: “bad” not a function

36. Examples lettick n = if n> 0 then “tick ” ++ tock n else “” in let tock n = “tock ” ++ tick (n-1) in let tock = “bad” in tick 2; tick :: (tock :: Int  Str) Int  Str tock :: (tick :: Int  Str) Int  Str tock :: Str

37. Examples lettick n = if n > 0 then “tick ” ++ tock n else “” in let tock n = “tock ” ++ tick (n-1) in let tock = “bad” in tick 2; tick :: (tock :: Int  Str) Int  Str tock :: (tick :: Int  Str) Int  Str tock :: Str Guarantee Rely ✗

38. Examples lettick n = if n> 0 then “tick ” ++ tock n else “” in let tock n = “tock ” ++ tick (n-1) in let tock = tick (n-1) in tick 2; “tick tick ”

39. Examples lettick n = if n> 0 then “tick ” ++ tock n else “” in let tock n = “tock ” ++ tick (n-1) in let tock = tick (n-1) in tick 2; tick :: (tock :: Int  Str) Int  Str tock :: (tick :: Int  Str) Int  Str tock :: (tick :: Int  Str) Int  Str

40. Examples lettick n = if n > 0 then “tick ” ++ tock n else “” in let tock n = “tock ” ++ tick (n-1) in let tock = tick (n-1) in tick 2; tick :: (tock :: Int  Str) Int  Str tock :: (tick :: Int  Str) Int  Str tock :: (tick :: Int  Str) Int  Str Guarantee Rely ✓

41. Recap • Open Types capture“late packaging” of recursive definitions indynamically-scoped languages • (Metatheory has not yet been worked) • Several potential applications inlexically-scoped languages…

42. Open Types for λref • References in λrefare similar to dynamically-scoped bindings in λdyn • For open types in this setting,type system must supportstrong updates to mutable variables • e.g. Thiemann et al. (ECOOP 2010), Chugh et al. (OOPSLA 2012)

43. Open Types for λref lettick = ref null in lettock = ref null in tick :=λn. if n> 0 then “tick ” ++ !tock(n) else “”; tock :=λn. “tock ” ++ !tick(n-1); !tick(2); tick :: Ref Null tick :: Ref Null tock :: Ref Null tick :: (tock :: Ref (Int  Str)) Ref (Int  Str) tock :: Ref Null tick :: (tock :: Ref (Int  Str)) Ref (Int  Str) tock :: (tick :: Ref (Int  Str)) Ref (Int  Str) Guarantee Rely ✓ tick :: (tock :: Ref (Int  Str)) Ref (Int  Str) tock :: (tick :: Ref (Int  Str)) Ref (Int  Str)

44. Open Types for Methods lettick n = if n> 0 then “tick ” ++ this.tock(n) else “” in let tock n = “tock ” ++ this.tick(n-1) in let obj = {tick=tick; tock=tock} in obj.tick(2); tick :: (this :: {tock: Int  Str}) Int  Str tock :: (this :: {tick: Int  Str}) Int  Str

45. Related Work • Dynamic scope in lexical settings for: • Software updates • Dynamic code loading • Global flags • Implicit Parameters of Lewis et al. (POPL 2000) • Open types mechanism resembles their approach • We aim to support recursion and references • Other related work • Bierman et al. (ICFP 2003) • Dami (TCS 1998), Harper (Practical Foundations for PL) • …

46. Thanks! Open Types for Checking Recursion in: • Dynamically-scoped λ-calculus • Lexically-scoped λ-calculus with references • Thoughts? Questions?

47. EXTRA SLIDES

48. Higher-Order Functions • Disallows function arguments with free variables • This restriction precludes “downwards funarg problem” • To be less restrictive:

49. Partial Environment Consistency letnegateInt () = 0 - x in letnegateBool () = not x in letx = 17 in negateInt (); • Safe at run-timeeven though not all assumptions satisfied -17 negateInt :: (x :: Int) Unit  Int negateBool :: (x :: Bool) Unit  Bool x :: Int

50. Partial Environment Consistency • To be less restrictive: • Only andits transitivedependencies in