The gradual typing approach to mixing static and dynamic typing

Transcription

1 1 / 38 The gradual typing approach to mixing static and dynamic typing Jeremy G. Siek University of Colorado = Indiana University TFP 2013 at Provo, Utah, May 2013

2 The Goals of Gradual Typing Enjoy the benefits of static & dynamic typing in different parts of the same program. Provide seamless interoperability between the static & dynamic parts. Static Typing Reliability & Efficiency Dynamic Typing Productivity 2 / 38

3 Overview Gradual Typing: Basics History Functions Objects Generics Mutable State The Future 3 / 38

4 How can Static and Dynamic Coexist? 1 def abs(n: int) int: return -n if n<0 else n def dist(x, y): return abs(x - y) 1 Gradual Typing for Functional Languages, Siek and Taha, SFP / 38

5 How can Static and Dynamic Coexist? 2 Consistency: def abs(n: int) int: return -n if n<0 else n T int int T str str def dist(x :, y : ) : return abs(x - y) int T 1 T 3 T 2 T 4 T 1 T 2 T 3 T 4 Type rule for application: Γ e 1 : T 1 T 3 Γ e 2 : T 2 T 1 T 2 Γ e 1 e 2 : T 3 2 Gradual Typing for Functional Languages, Siek and Taha, SFP / 38

6 6 / 38 Properly Catch Static Errors def abs(n: int) int: return -n if n<0 else n x : str = input_string()... abs(x) str int Consistency: T int int T str str T 1 T 3 T 2 T 4 T 1 T 2 T 3 T 4

7 Compiler Performs Cast Insertion def abs(n: int) int: return -n if n<0 else n def dist(x :, y : ) : return abs(x - y : int) : int dist(7 : int, 3 : int ) The dynamic semantics specifies the behavior of casts, e.g., (7 : int ) : int 7 (7 : int ) : str error 7 / 38

8 Overview Gradual Typing: Basics History Functions Objects Generics Mutable State The Future 8 / 38

9 The Prehistory of Gradual Typing Lisp, early 1980 s types as optimization hints Abadi et al., 1991 defined a dynamic type with explicit injection and projection terms. Cartwright & Fagan, 1991 soft typing: static analysis of dynamic programs Henglein, 1992 expressed dynamic casts using an algebra of coercions. Thatte, 1994 introduced implicit casts based on subtyping, which didn t quite work. Findler & Felleisen, 2002 designed contracts for higher-order functions. 9 / 38

10 History of Gradual Typing (Abbreviated) *Siek & Taha, 2006 implicit casts, consistency Herman et al., 2006 space-efficient casts *Siek & Taha, 2007 gradual typing & objects Adobe, 2006 ActionScript becomes gradual Sam TH & Felleisen, 2008 Typed Scheme Wadler & Findler, 2009 the Blame Theorem *Garcia et. al, 2009 space-efficient blame Larry Wall, 2009 Perl 6 becomes gradual Bierman et al, 2010 C# becomes gradual *Ahmed, et al., 2011 gradual typing & generics Hejlsberg, 2012 Microsoft releases TypeScript *Siek et al., 2012 gradual typing & mutable state 10 / 38

11 Overview Gradual Typing: Basics History Functions Objects Generics Mutable State The Future 11 / 38

12 12 / 38 Higher-Order Functions are Hard def deriv(d: float, f: float float) float: return lambda(x:float): (f(x+d)-f(x-d)) / (2.0*d) 1 def g(y): 2 if y > 0: 3 return y**3 - y else: 5 return "yikes" 6 7 deriv(0.01, g)(3.0) 8 deriv(0.01, g)(-3.0)

13 Higher-Order Functions and Blame def deriv(d: float, f: float float) float: return lambda(x:float): (f(x+d)-f(x-d)) / (2.0*d) 1 def g(y): 2 if y > 0: 3 return y**3 - y else: 5 return "yikes" 6 7 deriv(0.01, g)(3.0) 8 deriv(0.01, g)(-3.0) Casting a function creates a wrapper : g : 8 float float λp : float. g (p : float 8 ) : 8 float yikes : str 8 float blame 8 13 / 38

14 14 / 38 Is Gradual Typing Unsound? 3 4 adding type annotations at random places is unsound Matthias Felleisen, PLT Mailing List, June 10, 2008.

15 14 / 38 Is Gradual Typing Unsound? 3 4 adding type annotations at random places is unsound Matthias Felleisen, PLT Mailing List, June 10, Too weak: If e : T, then either e diverges, e v and v : T, or e error.

16 14 / 38 Is Gradual Typing Unsound? 3 4 adding type annotations at random places is unsound Matthias Felleisen, PLT Mailing List, June 10, Too weak: If e : T, then either e diverges, e v and v : T, or e error. Too strong: If e : T, then either e diverges or e v and v : T.

17 Is Gradual Typing Unsound? 3 4 adding type annotations at random places is unsound Matthias Felleisen, PLT Mailing List, June 10, Too weak: If e : T, then either e diverges, e v and v : T, or e error. Too strong: If e : T, then either e diverges or e v and v : T. Just right: If e : T, then either e diverges, e v and v : T, or e blame l where e = C[e : T 1 l T 2 ] and T 1 : T 2. 3 Well-typed Program s Can t be Blamed, Wadler & Findler, ESOP Exploring the Design Space of H.O. Casts, Siek et al., ESOP / 38

18 15 / 38 Blame and Subtyping Wadler & Finder, 2009: int <: int <: int <: T <: T <: T 3 <: T 1 T 2 <: T 4 T 1 T 2 <: T 3 T 4 Siek, Garcia, & Taha, 2009: int <: int T <: T 3 <: T 1 T 2 <: T 4 T 1 T 2 <: T 3 T 4

19 But Wrappers are Not Space Efficient 5 def even(n: int, k: Bool) Bool: if n == 0: return k(true) else: return odd(n - 1, k) def odd(n: int, k: Bool Bool) Bool: if n == 0: return k(false) else: return even(n - 1, k) 5 Space-Efficient Gradual Typing. Herman, et al., TFP / 38

20 17 / 38 Toward Efficient Casts: Reified Wrappers Regular wrappers: v ::=... λx : T. e v : T 1 T 2 T 3 T 4 λx : T 3. (v (x : T 3 T 1 )) : T 2 T 4 Reified wrappers: v ::=... λx : T. e v : T 1 T 2 T 3 T 4 (v 1 : T 1 T 2 T 3 T 4 ) v 2 (v 1 (v 2 : T 3 T 1 )) : T 2 T 4

21 Compressing a Sequence of Casts 6 v : str int int v : int str int int Define an information ordering: T int int str str T 1 T 3 T 2 T 4 T 1 T 2 T 3 T 4 Take the least upper bound to obtain a triple : e : T 1 T 2 T n 1 T n e : T 1 {T 2,..., T n 1 } T n 6 Threesomes, with and without blame. Siek & Wadler, POPL / 38

22 19 / 38 Space Efficiency Notation: e erases the casts from e. Theorem (Space Efficiency) For any program e there is a constant factor c such that if e e, then size(e ) c size( e ).

23 Overview Gradual Typing: Basics History Functions Objects Generics Mutable State The Future 20 / 38

24 21 / 38 Gradual Typing and Subtyping At the heart of most OO languages is a subsumption rule: Γ e : T 1 T 1 <: T 2 Γ e : T 2 Thatte s early attempt at gradual typing didn t use consistency but instead put the dynamic type at the top and bottom of the subtyping relation. T <: <: T

25 22 / 38 The Problem with Subtyping Subtyping is transitive, so we have: str <: <: int str <: int In general, for any types T 1 and T 2 we have T 1 <: T 2. So the type checker accepts all programs! (Even ones that get stuck.)

26 Consistency and Subtyping are Orthogonal 7 Let subtyping deal with object types: [l i : T i i 1..n+m ] <: [l i : T i i 1..n ] <: Let consistency deal with the dynamic type: T Include the subsumption rule T Γ e : T 1 T 1 <: T 2 Γ e : T 2 and use consistency instead of equality: Γ e 1 : T 1 T 3 Γ e 2 : T 2 T 1 T 2 Γ e 1 e 2 : T 3 7 Gradual Typing for Objects, Siek and Taha, ECOOP / 38

27 24 / 38 An Algorithmic Type System The usual trick is to remove the subsumption rule and use subtyping in place of equality. Γ e 1 : T 1 T 3 Γ e 2 : T 2 T 2 <: T 1 Γ e 1 e 2 : T 3 but for gradual typing, this would look like Γ e 1 : T 1 T 3 Γ e 2 : T 2 T 2 <: T 1 T 1 T 1 Γ e 1 e 2 : T 3 which is not syntax directed. We need a relation that composes the two: Γ e 1 : T 1 T 3 Γ e 2 : T 2 T 2 T 1 Γ e 1 e 2 : T 3

28 25 / 38 Consistent-Subtyping T T int int str str T 3 T 1 T 2 T 4 T i T i i 1..n T 1 T 2 T 3 T 4 [l i : T i 1..n+m i ] [l i : T (This is a more direct definition than the one I gave in Gradual Typing for Objects.) i i 1..n ]

29 Overview Gradual Typing: Basics History Functions Objects Generics Mutable State The Future 26 / 38

30 27 / 38 Gradual Typing & Polymorphism Review of System F: T ::=... X. T e ::=... ΛX. e e[t ] (ΛX. e)[t ] e[x:=t ] Γ, X e : T Γ ΛX. e : X. T Γ e : X. T 1 Γ e[t 2 ] : T 1 [X:=T 2 ]

31 Parametric Polymorphism (Generics) Ahmed, Findler, and Wadler proposed a design at STOP Their goals: Seamless interoperability. v : ( X. S) T v[ ] : S[X:= ] T v : S ( X. T ) ΛX. (v : S T ) Retain relational parametricity (i.e., theorems for free). Provide a natural subtyping relation and blame theorem. I helped refine the design for the POPL 2011 paper. 28 / 38

32 Challenges to Parametricity Consider two casts: K = (λx:.λy:.x) : K : m X. Y. X Y X K : l X. Y. X Y Y The second cast should lead to a cast failure. But a naive semantics lets it go through. (K : l X. Y. X Y Y )[int][int] 2 3 (K : l int int int) : int l int 2 29 / 38

33 Enforcement of Parametricity (K : l X. Y. X Y X)[int][int] 2 3 (νx:=int.νy :=int. K : l X Y X) 2 3 (νx:=int.νy :=int. 2 : X l X) 2 (K : l X. Y. X Y Y )[int][int] 2 3 (νx:=int.νy :=int. K : l X Y Y ) 2 3 (νx:=int.νy :=int. 2 : X l Y ) blame l This mechanism should work, but the parametricity theorem is an open problem. 30 / 38

34 Overview Gradual Typing: Basics History Functions Objects Generics Mutable State The Future 31 / 38

35 32 / 38 Gradual Typing & Mutable State Consider ML-style references T ::=... ref T e ::=... ref e e := e!e with a permissive rule for consistency of reference types: T 1 T 2 ref T 1 ref T 2

36 33 / 38 The Standard Semantics Incurs Overhead The Herman TFP 2006 semantics induces overhead, even in statically-typed regions of code. a N v ::=... a v : ref T 1 ref T 2 ref v µ a µ(a := v) if a / dom(µ) { µ(a) µ if v = a!v µ (!v ) : T 1 T 2 µ if v = v : ref T 1 ref T 2 { v 2 µ(a := v 2 ) if v 1 = a v 1 := v 2 µ v 1 := (v 2:T 2 T 1 ) µ if v 1 = v 1 : ref T 1 ref T 2

37 Monotonic References e ::=... ref e e := e!e e := e@t!e@t v ::=... a let r1 = ref (42 : int ) in let r2 = r1 : ref ref int in (!r1@,!r2) ref ref ref int (42 : int, ) (42, int) 34 / 38

38 35 / 38 Standard vs. Monotonic 1 let r1 = ref (1 : int ) in 2 let r2 = r1 : ref ref int in 3 let r3 = r1 : ref ref bool in 4 let x =!r2 in 5 r3 := true; 6 let y =!r3 in 7 (x,y) (1, true) (standard) blame 3 (monotonic)

39 e µ e ref T v µ a a := (v, T )!a µ µ(a) 1 ɛ Monotonic References a := v µ a a := (v, µ(a) 2 ) if a / dom(µ) a : ref T 1 ref T 2 µ error ɛ if T 2 µ(a) 2 a : ref T 1 ref T 2 µ a ɛ if T 2 µ(a) 2 a : ref T 1 ref T 2 µ a a := (e, µ(a) 2 T 2 ) if T 2 µ(a) 2, e = µ(a) 1 : µ(a) 2 µ(a) 2 T 2!a@T µ (µ(a) 1 : µ(a) 2 T ) ɛ a := v@t µ a a := (v : T µ(a) 2, µ(a) 2 ) e µ e µ e µ e e µ e (µ) µ(a)=(e 1, T ) e 1 µ e 1 e µ e (µ(a := (e 1, T ))) 36 / 38

40 Overview Gradual Typing: Basics History Functions Objects Generics Mutable State The Future 37 / 38

41 The Future Gradually-typed Python (Michael Vitousek) Monotonic references with blame (some ideas, not easy) Monotonic objects (draft) Putting it all together, e.g. can we maintain space efficiency with polymorphic blame? (no idea) Parametricity for the Polymorphic Blame Calculus (Amal Ahmed is part way there) Compiling and optimizing gradually-typed programs (e.g. Rastogi, Chaudhuri, and Hosmer, POPL 2012) Questions? 38 / 38