Formal Methods Lecture 8. (B. Pierce's slides for the book Types and Programming Languages )

Transcription

1 Formal Methods Lecture 8 (B. Pierce's slides for the book Types and Programming Languages )

2 Erasure and Typability

3 Erasure We can transform terms in λ to terms of the untyped lambda-calculus simply by erasing type annotations on lambda-abstractions. erase(x) erase(λx:t 1. t 2 ) erase(t 1 t 2 ) = x = λx. erase(t 2 ) = erase(t 1 ) erase(t 2 )

4 Typability Conversely, an untyped λ-term m is said to be typable if there is some term t in the simply typed lambda-calculus, some type T, and some context Γ such that erase(t ) = m and Γ t : T. This process is called type reconstruction or type inference.

5 Typability Conversely, an untyped λ-term m is said to be typable if there is some term t in the simply typed lambda-calculus, some type T, and some context Γ such that erase(t ) = m and Γ t : T. This process is called type reconstruction or type inference. Example: Is the term λx. x x typable?

6 The Curry-Howard Correspondence

7 Intro vs. elim forms An introduction form for a given type gives us a way of constructing elements of this type. An elimination form for a type gives us a way of using elements of this type.

8 T he Curry-Howard Correspondence In constructive logics, a proof of P must provide evidence for P. law of the excluded middle P P not recognized. A proof of P Q is a pair of evidence for P and evidence for Q. A proof of P Q is a procedure for transforming evidence for P into evidence for Q.

9 Propositions as Types Lo g ic propositions proposition P Q proposition P Q proof of proposition P proposition P is provable proof simplification (a.k.a. cut elimination ) P r o g r a mmin g l a n g u a g e s types type P Q type P Q term t of type P type P is inhabited (by some term) evaluation

10 On to real programming languages...

11 Base types Up to now, we ve formulated base types (e.g. Nat) by adding them to the syntax of types, extending the syntax of terms with associated constants (zero) and operators (succ, etc.) and adding appropriate typing and evaluation rules. We can do this for as many base types as we like. For more theoretical discussions (as opposed to programming) we can often ignore the term-level inhabitants of base types, and just treat these types as uninterpreted constants. E.g., suppose B and C are some base types. Then we can ask (without knowing anything more about B or C) whether there are any types S and T such that the term ( λf : S. λg:t. f g) ( λx:b. x) is well typed.

12 The Uni t type T ::=... Unit New typing rules types unit type Γ t : T Γ unit : Unit (T -Unit )

13 Sequencing t ::=... t 1 ; t 2 terms

14 Sequencing t ::=... t 1 ; t 2 terms t 1 t 1 t 1 ; t 2 t ; t 2 1 (E -Se q ) u n i t ; t 2 t 2 (E -Se q Ne x t ) Γ t 1 : Unit Γ t 2 : T 2 Γ t 1 ; t 2 : T 2 (T -Se q )

15 Derived forms Syntatic sugar Internal language vs. external (surface) language

16 Sequencing as a derived form t 1 ; t 2 def = ( λx: Unit.t 2 ) t 1 where x FV(t 2 )

17 Ascription New syntactic forms t ::=... t as T New evaluation rules terms ascription t t New typing rules v 1 as T v 1 t 1 t 1 t 1 as T t 1 Γ t 1 : T as T Γ t 1 as T : T (E -Asc r ibe) (E -Asc r ibe1) Γ t : T (T -Asc r ibe)

18 Ascription as a derived form def t as T = ( λx:t. x) t

19 Let-bindings New syntactic forms t ::=... l e t x=t in t New evaluation rules terms let binding t t l e t x=v 1 in t 2 [x v 1 ]t 2 (E -Le t V) New typing rules t 1 t 1 l e t x=t 1 in t 2 l e t x=t in t 2 1 (E -Le t ) Γ t : T Γ t 1 : T 1 Γ, x:t 1 t 2 : T 2 Γ l e t x=t 1 in t 2 : T 2 (T -Le t )

20 Pairs, tuples, and records

21 Pairs t. 1 t. 2 first projection second projection

22 Evaluation rules for pairs {v 1, v 2 }.1 v 1 {v 1, v 2 }.2 v 2 t 1 t 1 t 1.1 t.1 1 t 1 t 1 t 1.2 t.2 1 t 1 t 1 { t 1, t 2 } { t, t 2 } 1 t 2 t 2 {v 1, t 2 } {v 1, t } 2 (E -Pa ir B e t a 1) (E -Pa ir B e t a 2) (E -P r o j 1) (E -P r o j 2) (E -Pa ir 1) (E -Pa ir 2)

23 Typing rules for pairs Γ t 1 : T 1 Γ t 2 : T 2 Γ { t 1, t 2 } : T 1 T 2 (T -Pa ir ) Γ t 1 : T 11 T 12 Γ t 1.1 : T 11 (T -P r o j 1) Γ t 1 : T 11 T 12 Γ t 1.2 : T 12 (T -P r o j 2)

24 Tuples t ::=... { t i i 1..n } t. i v ::=... { v i i 1..n } T ::=... {T i i 1..n } terms tuple projection values tuple value types tuple type

25

26 Typing rules for tuples for each i Γ t i : T i i 1..n i 1..n Γ { t i } : {T i } (T -T u pl e ) Γ t 1 : {T i i 1..n } Γ t 1. j : T j (T -P r o j )

27 Records t ::=... { l i =t i i 1..n } t. l v ::=... { l i =v i i 1..n } T ::=... { l i :T i i 1..n } terms record projection values record value types type of records

28

29 Typing rules for records for each i Γ t i : T i Γ { l i =t i i 1..n } : { l i :T i i 1..n } (T -R c d ) Γ t 1 : { l i :T i i 1..n } Γ t 1. l j : T j (T -P r o j )

30 Sums and variants

31 Sums motivating example PhysicalAddr = { f i r s t l a s t : S t r i n g, addr:string} VirtualAddr = {name:string, em ail: String} Addr = PhysicalAddr + VirtualAddr i n l : PhysicalAddr PhysicalAddr+VirtualAddr i n r : VirtualAddr PhysicalAddr+VirtualAddr getname = λa:addr. case a of i n l x x. f i r s t l a s t i n r y y.name;

32 New syntactic forms t ::=... i n l t i n r t case t of i n l x t i n r x t terms tagging (left) tagging (right) case v ::=... i n l v i n r v values tagged value (left) tagged value (right) T 1 +T 2 is a disjoint union of T 1 and T 2 (the tags i n l and i n r ensure disjointness)

33

34 New typing rules Γ t : T Γ t 1 : T 1 Γ i n l t 1 : T 1 +T 2 (T -In l ) Γ t 1 : T 2 Γ i n r t 1 : T 1 +T 2 (T -In r ) Γ t 0 : T 1 +T 2 Γ, x 1 :T 1 t 1 : T Γ, x 2 :T 2 t 2 : T Γ case t 0 of i n l x 1 t 1 i n r x 2 t 2 : T (T -C a se )

35 Sums and Uniqueness of Types Problem: If t has type T, then inl t has type T+U for every U. I.e., we ve lost uniqueness of types. Possible solutions: Infer U as needed during typechecking Give constructors different names and only allow each name to appear in one sum type (requires generalization to variants, which we ll see next) OCaml s solution Annotate each i n l and i n r with the intended sum type. For simplicity, let s choose the third.

36 New syntactic forms t ::=... i n l t as T i n r t as T v ::=... i n l v as T i n r v as T terms tagging (left) tagging (right) values tagged value (left) tagged value (right) Note that as T here is not the ascription operator that we saw before i.e., not a separate syntactic form: in essence, there is an ascription built into every use of i n l or i n r.

37 New typing rules Γ t : T Γ t 1 : T 1 Γ i n l t 1 as T 1 +T 2 : T 1 +T 2 (T -In l ) Γ t 1 : T 2 Γ i n r t 1 as T 1 +T 2 : T 1 +T 2 (T -In r )

38 Evaluation rules ignore annotations: t t case ( i n l v 0 as T 0 ) of i n l x 1 t 1 i n r x 2 t 2 [x 1 v 0 ]t 1 (E -C a se In l ) case ( i n r v 0 as T 0 ) of i n l x 1 t 1 i n r x 2 t 2 [x 2 v 0 ]t 2 (E -C a se In r ) t 1 t 1 i n l t 1 as T 2 i n l t 1 as T 2 (E -In l ) t 1 t 1 i n r t 1 as T 2 i n r t 1 as T 2 (E -In r )

39 Variants Just as we generalized binary products to labeled records, we can generalize binary sums to labeled variants.

40 New syntactic forms t ::=... <l=t> as T case t of <l i =x i > t i i 1..n T ::=... < l i :T i i 1..n > terms tagging case types type of variants

41 New evaluation rules t t case ( < l j =v j > as T) of <l i =x i > t i i 1..n [x j v j ]t j (E -C a se Va r ia n t ) t 0 t 0 i 1..n case t 0 of <l i =x i > t i case t i 1..n of <l i =x i > t i 0 t i t i <l i =t i > as T <l i =t > as T i (E -C a se ) (E -Va r ia n t )

42 New typing rules Γ t j : T j Γ <l j =t j > as <l i :T i i 1..n > : <l i :T i i 1..n > i 1..n Γ t 0 : <l i :T i > for each i Γ, x i :T i t i : T Γ case t 0 of <l i =x i > t i i 1..n : T Γ t : T (T -Va r ia n t ) (T -C a se )

43 Example Addr = <physical:physicaladdr, virt ual: Virt ualadd r>; a = <physical=pa> as Addr; getname = λa:addr. case a of <physical=x> x. f i r s t l a s t <virtual=y> y.name;

44 Options Just like in OCaml... OptionalNat = <none:unit, some:nat>; Table = Nat OptionalNat; emptytable = λn:nat. <none=unit> as OptionalNat; extendtable = λt:table. λm:nat. λv:nat. λn:nat. i f equal n m then <some=v> as OptionalNat else t n; x = case t ( 5 ) of <none=u> 999 <some=v> v;

45 Enumerations Weekday = <monday:unit, tuesday:unit, wednesday:unit, thursday:unit, friday:unit>; nextbusinessday = λw:weekday. case w of <monday=x> <tuesday=unit> as Weekday <tuesday=x> <wednesday=unit> as Weekday <wednesday=x> <thursday=unit> as Weekday <thursday=x> <friday=unit> as Weekday <friday=x> <monday=unit> as Weekday;

46 Recursion

47 Recursion in λ In λ, all programs terminate. Hence, untyped terms like omega and f i x are not typable. But we can extend the system with a (typed) fixed-point operator...

48 Example f f = λie:nat Bool. λx:nat. i f iszero x then true else i f iszero (pred x) then false else i e (pred (pred x ) ) ; iseven = f i x f f ; iseven 7;

49 New syntactic forms t ::=... f i x t terms fixed point of t New evaluation rules t t f i x ( λx:t 1. t 2 ) [x ( f i x ( λx:t 1. t 2 ) ) ]t 2 (E -F ix B e t a ) t 1 t 1 f i x t 1 f i x t 1 (E -F ix )

50 New typing rules Γ t : T Γ t 1 : T 1 T 1 Γ f i x t 1 : T 1 (T -F ix )

51 A more convenient form def letrec x:t 1 =t 1 in t 2 = l e t x = f i x ( λx:t 1. t 1 ) in t 2 letrec iseven : Nat Bool = λx:nat. i f iszero x then true else i f iszero (pred x) then false else iseven (pred (pred x ) ) i n iseven 7;