Simply Typed Lambda Calculus

Transcription

1 Simply Typed Lambda Calculus

2 Language (ver1) Lambda calculus with boolean values t ::= x variable x : T.t abstraction tt application true false boolean values if ttt conditional expression Values v ::= true false x : T.t Types T ::= Bool T! T

3 Evaluation Rules t 1! t 0 1 t 1 t 2! t 0 1 t 2 t 2! t 0 2 v 1 t 2! v 1 t 0 2 E-App1 E-App2 ( x : T.t 12 ) v 2! [x 7! v 2 ]t 12 E-AppAbs if true t 2 t 3! t 2 if false t 2 t 3! t 3 E-IfTrue E-IfFalse t 1! t 0 1 if t 1 t 2 t 3! if t 0 1 t 2 t 3 E-If

4 Normal form When does the evaluation terminate? It terminates when no rules apply to it if true (if true false false) false! if true false false! false 6! if true (if x.false false false ) false! if x.false false false 6! A term t is in normal form if no evaluation rule applies to it Is every value in normal form? Is every normal form a value?

5 Stuck Terms in normal form but not a value Runtime errors situations where the operational semantics does not know what to know machine failures (segmentation faults, execution of illegal instructions, etc)

6 Static Type System Verify that given terms will not get stuck Without actually evaluating the term. By checking that the term is well-typed We can prove that well-typed terms do go wrong However, not all ill-typed terms get stuck

7 Static Type System Defined by type inference rules Intuition x + y + 1 ` t : T Γ Id fin Type if evaluating t terminates, the final result has T type

8 Inference Rules (Typing rules) (x) =T ` x : T T-Var [x 7! T 1 ] ` t 2 : T 2 ` x : T 1.t 2 : T 1! T 2 T-Abs ` t 1 : T 11! T 12 ` t 2 : T 11 ` t 1 t 2 : T 12 T-App ` true : Bool ` false : Bool T-True T-False ` t 1 : Bool ` t 2 : T ` t 3 : T ` if t 1 t 2 t 3 : T T-If

9 Examples well-typed term ` [x 7! Bool](x) =Bool T-Var [x 7! Bool] ` x : Bool T-Abs x : Bool.x : Bool! Bool ` true : Bool ` ( x : Bool.x) true : Bool T-True T-App ill-typed term [x 7! Bool] ` x : Bool! x : Bool.x : Bool! Bool ` true : Bool ` false : Bool ` if x : Bool.x then true else false :

10 The type system is incomplete Terms that do not have types may not go well

11 The type system is safe (sound) If type checking succeeds, terms never go wrong

12 Safety = Progress + Preservation progress: a well-typed term is not stuck (either it is a value or it can take a step according to the evaluation rules) preservation: if a well-typed term takes a step of evaluation, then the resulting term is also well-typed

13 Safety = Progress + Preservation ` Lemma 1 (Progress). Suppose t is a closed term. If t is well-typed (i.e., ` t : T for some T ), then either t is a value or there is some t 0 with t! t 0 : ` t : T =) t is a value or 9t 0.t! t 0 Lemma 2 (Preservation). If ` t : T and t! t 0, then ` t 0 : T. Theorem 1 (Type Safety). Suppose t is a closed term. If ` t : T, then t does not get stuck during evaluation. Furthermore, if t reaches a value v, then v is of the T type. Proof. By the Progress and Preservation Lemmas. ut

14 Proofs

15 Type Checking Algorithm Easy, thanks to the type annotations TC(,x)= TC :(Id! Type) t! Type (x) TC(, x : T 1.t 2 )=lett 2 = TC( [x 7! T 1 ],t 2 ) in T 1! T 2 TC(,t 1 t 2 )=lett 1 = TC(,t 1 ) let T 2 = TC(,t 2 ) in if T 1 = T 11! T 12 and T 11 = T 2 then T 12 else Error TC(, true) =Bool TC(, false) =Bool TC(, if t 1 t 2 t 3 )=iftc(,t 1 )=Bool and TC(, t 2 )=TC(, t 3 ) then TC(,t 2 ) else Error

16 Simply Typed Lambda Calculus (ver2) Lambda calculus without type annotations Language values: types: t ::= x variable x.t abstraction tt application true false boolean values if ttt conditional expression v ::= true false x.t T ::= Bool T! T

17 Evaluation rules! t 1! t 0 1 t 1 t 2! t 0 1 t 2 t 2! t 0 2 v 1 t 2! v 1 t 0 2 E-App1 E-App2 ( x.t 12 ) v 2! [x 7! v 2 ]t 12 E-AppAbs if true t 2 t 3! t 2 if false t 2 t 3! t 3 E-IfTrue E-IfFalse t 1! t 0 1 if t 1 t 2 t 3! if t 0 1 t 2 t 3 E-If

18 Typing rules (sound) (x) =T ` x : T T-Var [x 7! T 1 ] ` t : T 2 ` x.t : T 1! T 2 T-Abs ` t 1 : T 11! T 12 ` t 2 : T 11 ` t 1 t 2 : T 12 T-App ` true : Bool ` false : Bool T-True T-False ` t 1 : Bool ` t 2 : T ` t 3 : T ` if t 1 t 2 t 3 : T T-If

19 Implementation is not easy (x) =T ` x : T T-Var [x 7! T 1 ] ` t : T 2 ` x.t : T 1! T 2 T-Abs ` t 1 : T 11! T 12 ` t 2 : T 11 ` t 1 t 2 : T 12 T-App ` true : Bool ` false : Bool T-True T-False ` t 1 : Bool ` t 2 : T ` t 3 : T ` if t 1 t 2 t 3 : T T-If

20 Two s Type annotations x : T.t used in languages like C, C++, Java, etc helpful for design and documentation but tedious Automatic type inference used in languages like ML, Haskell, Scala, etc compiler figure out the types of expressions

21 Quiz)Type Inference ( x.x) 1 ( x.x 1) x. y.x

22 Automatic Type Inference Figure out types of expressions by observing how they are used For a carefully designed language, compiler can always infer the types of any expression! Two steps setup: While scanning the program, generate a system of equations between unknown types solving: Unification algorithm

23 Example 1: ( x.x) 1 1. setup 1-1. Put labels on every sub-expression of the program ( x. x ) 1 {z} {z}

24 Example 1: ( x.x) 1 1. setup 1-2. For each expression and bound variable, generate unknowns that denote the types of them {z} {z} ( x. x ) 1 {z} {z} , 2, 3, 4, x

25 Example 1: ( x.x) 1 1. setup 1-3. Based on the type rules, generate equations that must hold between the unknowns ex) What equation does the T-Abs rule dictate? ` {z} {z} [x 7! T 1 ] ` t : T 2 ` x.t : T 1! T 2 T-Abs x.t = x! t `! ` ex) What equation does the T-App rule dictate? `!! ` t 1 : T 11! T 12 ` t 2 : T 11 ` t 1 t 2 : T 12 T-App t1 = t2! (t1 t 2 )

26 Example 1: ( x.x) 1 1. setup 1-3. Based on the type rules, generate equations that must hold between the unknowns ( x. x ) 1 {z} {z} 1 2 {z} 3 4 {z} 2 = x! 1 2 = 3! 4 3 = int 1 = x 1, 2, 3, 4, x

27 Example 1: ( x.x) 1 2. solving Find a solution that satisfies all equations. (s expressed by substitutions) equation 2 = x! 1 2 = 3! 4 3 = int 1 = x solution 1 7! int 2 7! int! int 3 7! int 4 7! int x 7! int

28 Example 1: ( x.x) 1 2. solving Initially, all of the equations are to be solved and the substitution(solution) is empty. 2 = x! 1 2 = 3! 4 3 = int 1 = x! Consider 2 = x! 1 true. We add it Generate substitution 2 7! x! 1

29 Example 1: ( x.x) 1 Move it to the solution (with update): 2 = 3! 4 3 = int 1 = x 2 7! x! 1 Update equation:! x! 1 = 3! 4 3 = int 1 = x 2 7! x! 1

30 Example 1: ( x.x) 1! Consider x! 1 = 3! 4 3 = int 1 = x 2 7! x! 1 Generate substitution x! 1 = 3! 4.! x! x 7! 3 and 1 7! 4. 3 = int 2 7! 3! 4 1 = x 7! 3 x 1 7! 4

31 Example 1: ( x.x) 1 Update equation: Next, 3 = int 2 7! 3! 4 4 = x 7! ! 4 7! 7! 4 = int 2 7! int! 4 x 7! int 1 7! 4 3 7! int

32 Example 1: ( x.x) 1 7! 4 = int 2 7! int! 4 x 7! int 1 7! 4 3 7! int Finally, 2 7! int! int x 7! int 1 7! int 3 7! int 4 7! int

33 Inferred type ( x. x ) 1 {z} {z} ! int 2 7! int! int 3 7! int 4 7! int x 7! int

34 Example 2: x.(x 1) 1. setup 1-1. Put labels on every sub-expression of the program {z} {z x. ( x {z} 1 1 ) {z} 0 2 {z } 3

35 Example 2: x.(x 1) 1. setup x. ( x {z} 1 1 ) {z} 0 2 {z } 3 {z} {z {z} {z} 3 = x! 2 1 = int! 2 x = 1

36 Example 2: x.(x 1) 1. solving {z} {z 3 = x! 2 1 = int! 2 x = 1 1 = int! 2 x = 1 3 7! x! 2

37 Example 2: x.(x 1) 1. solving {z} {z x = int! 2 3 7! x! 2 1 7! int! 2! 7!! 3 7! (int! 2 )! 2 1 7! int! 2 x 7! int! 2

38 Inferred type x. ( x {z} 1 1 ) {z} 0 2 {z } 3 3 7! (int! 2 )! 2 1 7! int! 2 x 7! int! 2! The types are polymorphic in 2

39 Example 3: if x then x 1 else 0 {z 0 = bool if x {z} 0 then x 1 1 else 0 {z} = 2 3 = 1 2 = int 1 = int x = int

40 Example 3: if x then x 1 else 0 0 = bool 1 = 2 3 = 1 2 = int 1 = int x = int x = 0 1 = 2 3 = 1 2 = int 1 = int x = int x = bool 0 7! bool

41 Example 3: if x then x 1 else 0 3 = 2 2 = int 1 = int x = int x = bool 2 = int 1 = int x = int x = bool 1 7! 2 0 7! bool 3 7! 2 1 7! 2 0 7! bool

42 Example 3: if x then x 1 else 0 7! 1 = int x = int x = bool x = int x = bool 2 7! int 3 7! int 1 7! int 0 7! bool 2 7! int 3 7! int 1 7! int 0 7! bool

43 Example 3: if x then x 1 else 0 7! 7! int = bool 2 7! int 3 7! int 1 7! int 0 7! bool x 7! int

44 Example 4: x.(x x) {z} {z} {z} {z x. ( x {z} 1 x ) {z} 2 3 {z } 4 x = 1 x = 2 4 = x! 3 1 = 2! 3

45 Example 4: x.(x x) x = 1 x = 2 4 = x! 3 1 = 2! 3 {z} {z 1 = 2 4 = 1! 3 1 = 2! 3 x 7! 1

46 Example 4: x.(x x)! {z} {z 4 = 2! 3 2 = 2! 3 1 7! 2 x 7! 1

47 Example 4: x.(x x)! 7! {z} {z 2 = 2! 3 4 7! 2! 3 1 7! 2 x 7! 1 Occurrence check: check if, in an equation of form α = T, the type variable α occurs in the type T