CMSC 631 Program Analysis and Understanding Fall Type Systems

Transcription

1 Program Analysis and Understanding Fall 2017 Type Systems

2 Type Systems A type system is a tractable syntactic method for proving the absence of certain program behaviors by classifying phrases according to the kinds of values they compute. --Pierce They are good for Detecting errors (don t add an integer and a string) Abstraction (hiding representation details) Documentation (tersely summarize an API) Designs trade off efficiency, readability, power 2

3 Review: Simply-typed λ-calculus e ::= x n λx:τ.e e e τ ::= int τ τ Γ ::= Γ,x:τ Γ `e : τ in type environment Γ, expression e has type τ x dom(γ) Γ `n : int Γ ` x : Γ(x) Γ Γ, τ:x `e : τ `λx:τ.e : τ τ Γ ` e1 : τ τ Γ ` e2 : τ Γ ` e1 e2 : τ 3

4 Type Safety (Soundness) If e : τ then either there exists a value v of type τ such that e * v, or e diverges (doesn t terminate) Corollary: e will never get stuck never evaluates to a normal form that is not a value Proof by induction on the typing derivation 4

5 More types See: Practical Foundations of Programming Languages Preprint:

6 Data Products (Records); p. 92 τ ::= τ1* τ2 e ::= (e1,e2) fst e snd e Sums (Variants, Unions); p. 98 τ ::= τ1+ τ2 e ::= inl e inr e case e l.x e1 else r.x e2 Applications: void, unit, booleans, options, enumerations 6

7 Products: Typing Γ e1 : τ1 Γ e2 : τ2 Γ (e1,e2) : τ1*τ2 Γ e : τ1*τ2 Γ fst e : τ1 Γ e : τ1*τ2 Γ snd e : τ2 Γ () : unit 7

8 Sums: Typing Γ e : τ1 Γ inl e : τ1+τ2 Γ e : τ2 Γ inr e : τ1+τ2 Γ,x:τ1 e1 : τ Γ e : τ1+τ2 Γ,x:τ2 e2 : τ Γ case e l.x e1 else r.x e2 : τ bool def= unit+unit α option def= unit+α 8

9 Polymorphism (Generics): System F Universally quantified types (p. 113) τ ::= α α.τ e ::= Λα.e e τ Typing Type environments Δ ::= Δ,α Judgments - Δ τ ( τ is a well-formed type in Δ ) - Δ; Γ e : τ ( e has type τ in Γ and Δ ) 9

10 System F: Typing WF Δ int α Δ Δ α Δ,α τ Δ α.τ Δ τ Δ τ Δ τ τ 10

11 System F: Typing Δ,α; Γ e : τ Δ; Γ Λα.e : α.τ x dom(γ) Δ; Γ x : Γ(x) Δ; Γ e : α.τ Δ τ Δ; Γ e τ : τ[α τ ] Δ; Γ,x:τ e : τ Δ τ Δ; Γ λx:τ.e : τ τ Δ; Γ e1 : τ τ Δ; Γ e2 : τ Δ; Γ e1 e2 : τ 11

12 System F Examples: What type? makepair def= Λα. Λβ. λx:α. λy:β. (x,y) first def= Λα. Λβ. λp:α*β. fst x app2 def= Λα. λf:α α. λx:α. f (f x) makepair int bool 1 true first int int (app2 int*int (λx:int*int. (snd x,fst x)) (1,2)) 12

13 System F Examples: What term? α. α α α. β. α*β β*α α. β. (α β) α β α. int α. α α. (α α) α α. β. α α 13

14 System F Metatheory Highly expressive Can encode products, sums, natural numbers Type safety Strong normalization All System F terms will terminate Parametricity Useful theorems about an expression knowing only its type (in detail: Chap 48) 14

15 Abstract Data Types Existential types (p. 123) τ ::= α.τ e ::= pack τ with e as α.τ (hide type) unpack e1 as α with x:τ in e2 (use module) Typing same judgment form as System F Surprise! Existential types can be encoded with universal types (add no expressivity) 15

16 Existential Type Example: Counter type τ : α. (unit α)*(α α)*(α bool) body1 : ((λ_:unit. false), (λx:bool. if x then false else true), (λx:bool. x)) let x = pack bool with body1 as τ in unpack x as α with y:τ in let c = (fst y) () in let c = (fst (snd y)) c in print (snd (fst y)) c -- prints false 16

17 Existential Type Example: Counter type : α. (unit α)*(α α)*(α bool) body2 : ((λ_:unit. 0), let x = pack int with body2 as τ in unpack x as α with y:τ in let c = (fst y) () in (λx:int. x+1), let c = (fst (snd y)) c in print (snd (fst y)) c (λx:int. isodd x)) -- prints false Different implementation, same outcome 17

18 Existential Types: Typing Δ,α τ Δ α.τ Δ τ Δ,α τ Δ;Γ e : τ [α τ] Δ; Γ pack τ with e as α.τ : α.τ Δ τ2 Δ;Γ e1 : α.τ Δ,α; Γ,x:τ e2 : τ2 Δ; Γ unpack e1 as α with x:τ in e2 : τ2 18

19 Existential types: Encoding α.τ def= β.( α.τ β) β assume α τ pack τ with e as α.τ def= Λβ. λx:( α.τ β). x τ e unpack e1 as α with x:τ in e2 def= e1 τ2 (Λα. λx:τ. e2) τ2 is the final type of e2 τ is the abstract type α s definition 19

20 Representation Independence Essence of type abstraction Replacing one representation with another will not affect clients of abstract type Defined in terms of a relation R, parametrized by different ADT implementations Terms operating on these different implementations will have the same behavior Follows from parametricity in System F 20

21 Recursive Types Recursive types (p. 144) τ ::= μα.τ e ::= fold e unfold e Typing: same judgment form as System F Semantics: fold and unfold are no-ops Make type checking easier Nominal types (e.g., in C, Java) often recursive Global type names are like μ-bound type variables 21

22 Recursive Types: Typing Δ,α τ Δ μα.τ Δ; Γ e : τ[α μα.τ] Δ; Γ fold e : μα.τ Δ; Γ e : μα.τ Δ; Γ unfold e : τ[α μα.τ] 22

23 Recursive type example: Lists α list def= α. μβ. unit+(α*β) nil def= Λα. fold (inl ()) cons def= Λα. λx:α. λl:α list. fold (inr (x,l)) match def= Λα. λl:α list. case (unfold l) l.x e1 else r.x e2 23

24 Recursive functions Fix combinator (p. 134) e ::= fix x:τ is e Semantics fix x:τ is e e[x fix x:τ is e] Typing Γ,x:τ e : τ Γ fix x:τ is e : τ factorial def= fix x:int int is λy:int. if y=0 then 1 else y*(x (y-1)) 24

25 Recursive types more powerful Can encode fixpoint combinator (e.g., Y) In OCaml: type 'a recc = Fold of ('a recc -> 'a) let unfold (Fold x) = x let y f = (fun x a -> f (unfold x x) a) (Fold (fun x a -> f (unfold x x) a)) let fact = y (fun g b -> if b=0 then 1 else b*(g (b-1))) 25