From last time. News. Example. Example. Typechecking let. Typechecking let. Pick up your first two quizzes after class. Assignment #2 due tomorrow

Transcription

1 News Pick up your first two quizzes after class Assignment #2 due tomorrow From last time Old: e1:int e2:int e1+e2:int new: Γ e1:int Γ e2:int Γ e1+e2:int Assignment #3 will be up tomorrow night e : T2 (fun x -> e ) : T1 T2 Γ, x:t1 e : T2 Γ (fun x -> e ) : T1 T2 1 x:t Γ Γ x : T 2 Example Example Γ, x:t1 e : T2 Γ (fun x -> e ) : T1 T2 x:t Γ Γ x : T Γ, x:t1 e : T2 Γ (fun x -> e ) : T1 T2 x:t Γ Γ x : T Γ e1:int Γ e2:int Γ e1+e2:int Γ i:int Γ e1:int Γ e2:int Γ e1+e2:int Γ i:int 3 4 Typechecking let Typechecking let Γ let x = e 1 in e 2 : T Γ e 1 :T 1 Γ, x:t 1 e 2 :T Γ let x = e 1 in e 2 : T 5 6 1

2 Typechecking match Typechecking match type DT = Case 1 of T 1... Case n of T n type DT = Case 1 of T 1... Case n of T n Γ match e with Case 1 x 1 -> e 1... Case n x n -> e n : T Γ e:dt Γ, x 1 :T 1 e 1 :T... Γ, x n :T n e n :T Γ match e with Case 1 x 1 -> e 1... Case n x n -> e n : T 7 8 What is the deal with a? Parametric types aka: what s up with those a??? These meta-functions have strange types: map: ( a b) a list b list filter: ( a bool) a list a list Why? 9 10 Polymorphism Instantiation at Use Poly = many, morph = kind map: ( a b) a list b list let swap (x,y) = (y,x) a * b b * a a and b are type variables! For-all types: For all a, b: a * b b * a let f x = x + 10;; let fm = map f;; a, b can be instantiated with any type: w/ int,string : int * string string * int w/ char, int list : char * int list int list * char w/ int int, bool :(int int) * bool bool * (int int) 11 let f x = x^ like ;; let fm = map f [ cat ; dog ; burrito ];; 12 2

3 Instantiation at Use: be Careful map: ( a b) a list b list let f x = x^ like ;; let fm = map f [1;2;3;4];; Polymorphic ML types Implict for-all at the left of all types Never printed out, or specified map: For all a, b. ( a b) a list b list Typing rule: Γ e: a.t Polymorphic ML types Implict for-all at the left of all types Never printed out, or specified map: Typing rule: For all a, b. ( a b) a list b list Example Γ e: a.t Γ e:t [ a a T f ] Γ e1:t1 Γ e2:t2 Γ en: Tn Γ (e1,e2,,en) : T1 * T2* * Tn Assume: Γ swap: a. b. a * b b * a Γ e1:t1 T2 Γ e2: T1 Γ e1 e2 : T2 Γ i:int Γ s:string Γ e: a.t Γ e:t [ a a T f ] where T f does not contain type vars already in T 15 Show: Γ swap(1, a ) : string * int 16 Example Γ e: a.t Γ e:t [ a a T f ] Γ e1:t1 T2 Γ e2: T1 Γ e1 e2 : T2 Polymorphism enables Reuse Can reuse generic functions: Γ e1:t1 Γ e2:t2 Γ en: Tn Γ (e1,e2,,en) : T1 * T2* * Tn Assume: Γ swap: a. b. a * b b * a Γ i:int Γ s:string swap : a * b b * a rev: a list a list length: a list int filter: ( a bool) a list a list partition: ( a bool) a list ( a list * a list) map: ( a b) a list b list Show: Γ swap(1, a ) : string * int

4 Not just functions Not just functions Data types are also polymorphic! Data types are also polymorphic! type a list = Nil Cons of ( a * a list) type a list = Nil Cons of ( a * a list) Type is instantiated for each use: Cons(1,Cons(2,Nil)) : Type is instantiated for each use: Cons(1,Cons(2,Nil)) : int list Cons( a,cons( b,nil)) : Cons( a,cons( b,nil)) : string list Cons((1,2),Cons((3,4),Nil)) : Cons((1,2),Cons((3,4),Nil)) : int*int list Nil : 19 Nil : a list 20 Datatypes with many type variables Multiple type variables type ( a, b) tree = Leaf of ( a * b) Node of ( a, b) tree * ( a, b) tree Type is instantiated for each use: Leaf( joe,1) : Leaf( william,2) : Node(, ) : Datatypes with many type variables Multiple type variables type ( a, b) tree = Leaf of ( a * b) Node of ( a, b) tree * ( a, b) tree Type is instantiated for each use: Leaf( joe,1) : (string,int) tree Leaf( william,2) : (string,int) tree Node(, ) : (string,int) tree Node(Leaf( joe,1),leaf(3.14, pi )): 21 Node(Leaf( joe,1),leaf(3.14, pi )) 22 Polymorphic Data Structures Other kinds of polymorphisms Container data structures independent of type! Appropriate type is instantiated at each use: That was OCaml... a list ( a, b) Tree ( a, b) Hashtbl Appropriate type instantiated at use No casting as in Java But what about other kinds of polymorphisms.. Static type checking catches errors early Cannot add int key to string hashtable Generics: feature of newest versions of Java,C#

5 Other kinds of polymorphisms Sub-type polymorphism void f(shape s) Can pass in any sub-type of Shape Parametric polymorphism void pocess_list_elems(list[t]) can pass in ANY T this is the kind in OCaml! Other kinds of polymorphisms Bounded polymorphism Like parametric, except can provide a bound void pocess_list_elems(list[t]) WHERE T < Printable Wait... But isn t this subtype polymorphism??? Summary of polymorphism Subtype Back to OCaml Polymorphic types allow us to reuse code Parametric Bounded However, not always obvious from staring at code But... Types never entered w/ program! Example 1 Type inference aka: how in the world does Ocaml figure out all the types for me??? let x = 2 + 3;; let y = string_of_int x;;

6 Example 2 let x = 2 + 3;; let inc y = x + y;; Example 2 let x = 2 + 3;; let inc y = x + y;; Example 3 let foo x = let (y,z) = x in z-y;; Example 3 let foo x = let (y,z) = x in z-y;; Example 4 Example 4 ML doesn t know what the function does, or even that it terminates. ML only knows its type! let rec cat l = [] -> h::t -> h^(cat t) let rec cat l = [] -> h::t -> h^(cat t)

7 Example 5 let rec map f l = [] -> [] h::t ->(f h)::(map f t) Example 5 let rec map f l = [] -> [] h::t ->(f h)::(map f t) Inferring types with a Introduce unknown type vars Example 6 let compose (f,g) x = f (g x) Figure out equalities that must hold, and solve these equalities Remaining types vars get a forall and thus become the a, b, etc Example 6 let compose (f,g) x = f (g x) Example 7 let rec fold f cur l = [] -> cur h::t -> fold f (f h cur) t

8 Example 7 let rec fold f cur l = [] -> cur h::t -> fold f (f h cur) t 43 8