ML Type Inference and Unification Arlen Cox Research Goals Easy - PowerPoint PPT Presentation

ML Type Inference and Unification Arlen Cox

Research Goals  Easy to use, high performance parallel programming  Primary contributions in backend and runtime  Need a front end to target backend  ML offers ease of use and safety

ML Type Inference  Hindley/Milner Type Inference  Statically typed language with no mandatory annotations  Three phases to determining types − Constraint generation − Unification − Annotation

An Example let rec apply = fun f v t -> if t = 0 then v else apply f (f v) (t - 1) fi

An Example let rec apply = fun f v t -> if t = 0 then v else apply f (f v) (t - 1) fi val apply: ('a->'a)->'a->int->'a

Constraint Generation Constraints let rec apply = fun f v t -> if t = 0 then v else apply f (f v) (t - 1) fi Variables

Constraint Generation Constraints let rec apply = fun f v t -> if t = 0 then v else apply f (f v) (t - 1) fi Variables apply: 'a

Constraint Generation Constraints let rec apply = fun f v t -> if t = 0 then v else apply f (f v) (t - 1) fi Variables apply: 'a f: 'b v: 'c t: 'd

Constraint Generation Constraints let rec apply = fun f v t -> 'a = 'b → 'e if t = 0 then v else apply f (f v) (t - 1) fi Variables apply: 'a f: 'b v: 'c t: 'd

Constraint Generation Constraints let rec apply = fun f v t -> 'a = 'b → 'e if t = 0 then 'b = 'c → 'f v else apply f (f v) (t - 1) fi Variables apply: 'a f: 'b v: 'c t: 'd

Constraint Generation Constraints let rec apply = fun f v t -> 'a = 'b → 'e if t = 0 then 'b = 'c → 'f 'e = 'f → 'g v else apply f (f v) (t - 1) fi Variables apply: 'a f: 'b v: 'c t: 'd

Constraint Generation Constraints let rec apply = fun f v t -> 'a = 'b → 'e if t = 0 then 'b = 'c → 'f 'e = 'f → 'g v 'd = int else apply f (f v) (t - 1) fi Variables apply: 'a f: 'b v: 'c t: 'd

Constraint Generation Constraints let rec apply = fun f v t -> 'a = 'b → 'e if t = 0 then 'b = 'c → 'f 'e = 'f → 'g v 'd = int else 'g = int → 'h apply f (f v) (t - 1) fi Variables apply: 'a f: 'b v: 'c t: 'd

Constraint Generation Constraints let rec apply = fun f v t -> 'a = 'b → 'e if t = 0 then 'b = 'c → 'f 'e = 'f → 'g v 'd = int else 'g = int → 'h apply f (f v) (t - 1) 'd = int bool = bool fi Variables apply: 'a f: 'b v: 'c t: 'd

Constraint Generation Constraints let rec apply = fun f v t -> 'a = 'b → 'e if t = 0 then 'b = 'c → 'f 'e = 'f → 'g v 'd = int else 'g = int → 'h apply f (f v) (t - 1) 'd = int bool = bool fi 'c = 'h Variables apply: 'a f: 'b v: 'c t: 'd

Constraint Generation Constraints let rec apply = fun f v t -> 'a = 'b → 'e if t = 0 then 'b = 'c → 'f 'e = 'f → 'g v 'd = int else 'g = int → 'h apply f (f v) (t - 1) 'd = int bool = bool fi 'c = 'h 'a = 'b → 'c → 'd → 'c Variables apply: 'a f: 'b v: 'c t: 'd

Constraint Solving - Unification Constraints Mapping 'a = 'b → 'e 'b = 'c → 'f 'e = 'f → 'g 'd = int 'g = int → 'h 'd = int bool = bool 'c = 'h 'a = 'b → 'c → 'd → 'c

Constraint Solving - Unification Constraints Mapping 'b = 'c → 'f 'a = 'b → 'e 'e = 'f → 'g 'd = int 'g = int → 'h 'd = int bool = bool 'c = 'h 'b → 'e = 'b → 'c → 'd → 'c

Constraint Solving - Unification Constraints Mapping 'e = 'f → 'g 'a = ('c → 'f) → 'e 'b = 'c → 'f 'd = int 'g = int → 'h 'd = int bool = bool 'c = 'h ('c → 'f) → 'e = ('c → 'f) → 'c → 'd → 'c

Constraint Solving - Unification Constraints Mapping 'a = ('c → 'f) → 'f → 'g 'd = int 'b = 'c → 'f 'g = int → 'h 'e = 'f → 'g 'd = int bool = bool 'c = 'h ('c → 'f) → 'f → 'g = ('c → 'f) → 'c → 'd → 'c

Constraint Solving - Unification Constraints Mapping 'g = int → 'h 'a = ('c → 'f) → 'f → 'g 'b = 'c → 'f int = int 'e = 'f → 'g bool = bool 'c = 'h 'd = int ('c → 'f) → 'f → 'g = 'c → ('f → 'c) → int → 'c

Constraint Solving - Unification Constraints Mapping 'a = ('c → 'f) → 'f → int → 'h int = int 'b = 'c → 'f bool = bool 'e = 'f → int → 'h 'c = 'h ('c → 'f) → 'f → int → 'h = ('c → 'f) → 'c → int → 'c 'd = int 'g = int → 'h

Constraint Solving - Unification Constraints Mapping 'a = ('c → 'f) → 'f → int → 'h 'c = 'h ('c → 'f) → 'f → int → 'h = ('c → 'f) → 'c → int → 'c 'b = 'c → 'f 'e = 'f → int → 'h 'd = int 'g = int → 'h

Constraint Solving - Unification Constraints Mapping ('c → 'f) → 'f → int → 'c = ('c → 'f) → 'c → int → 'c 'a = ('c → 'f) → 'f → int → 'c 'b = 'c → 'f 'e = 'f → int → 'c 'd = int 'g = int → 'c 'h = 'c

Constraint Solving - Unification Constraints Mapping 'c → 'f = 'c → 'f 'a = ('c → 'f) → 'f → int → 'c 'b = 'c → 'f 'f = 'c 'e = 'f → int → 'c int = int 'c = 'c 'd = int 'g = int → 'c 'h = 'c

Constraint Solving - Unification Constraints Mapping 'a = ('c → 'f) → 'f → int → 'c 'c = 'c 'b = 'c → 'f 'f = 'f 'e = 'f → int → 'c 'f = 'c int = int 'd = int 'g = int → 'c 'c = 'c 'h = 'c

Constraint Solving - Unification Constraints Mapping 'a = ('c → 'f) → 'f → int → 'c 'f = 'c 'b = 'c → 'f int = int 'e = 'f → int → 'c 'c = 'c 'd = int 'g = int → 'c 'h = 'c

Constraint Solving - Unification Constraints Mapping 'a = ('c → 'c) → 'c → int → 'c int = int 'b = 'c → 'c 'c = 'c 'e = 'c → int → 'c 'd = int 'g = int → 'c 'h = 'c 'f = 'c

Constraint Solving - Unification Constraints Mapping 'a = ('c → 'c) → 'c → int → 'c 'b = 'c → 'c 'e = 'c → int → 'c 'd = int 'g = int → 'c 'h = 'c 'f = 'c

Type Annotation Mapping let rec apply = fun f v t -> 'a = ('c → 'c) → 'c → int → 'c if t = 0 then 'b = 'c → 'c 'e = 'c → int → 'c v 'd = int else 'g = int → 'c apply f (f v) (t - 1) 'h = 'c 'f = 'c fi Variables apply: 'a f: 'b v: 'c t: 'd

Type Annotation Mapping let rec apply = fun f v t -> 'a = ('c → 'c) → 'c → int → 'c if t = 0 then 'b = 'c → 'c 'e = 'c → int → 'c v 'd = int else 'g = int → 'c apply f (f v) (t - 1) 'h = 'c 'f = 'c fi Variables apply: ('c → 'c) → 'c → int → 'c f: 'c → 'c v: 'c t: int

Type Annotation let rec apply : ('c -> 'c) -> 'c -> int -> 'c = fun (f:'c -> 'c) (v:'c) (t:int) -> if t = 0 then v else apply f (f v) (t - 1) fi Variables apply: ('c → 'c) → 'c → int → 'c f: 'c → 'c v: 'c t: int

Difficulties  Polymorphic function application  Matching  Reference Types

Polymorphic Function Application let f : 'a->'a = fun (x: 'a) -> x let t1 = f true let t2 = f 3

Polymorphic Function Application let f : 'a->'a = fun (x: 'a) -> x let t1 = f true 'a = bool let t2 = f 3 'a = int

Solution  Copy the type of f every time f is used let f : 'a->'a = fun (x: 'a) -> x let t1 = f true 'b = bool let t2 = f 3 'c = int

Matching  Different types for expression being matched and that used with unions: type 'a list = | Nil | Cons of 'a * 'a list let map = fun f l -> case l | Nil -> Nil | Cons(h,t) -> Cons(f h, map f t) esac

Matching  Different types for expression being matched and that used with unions: type 'a list = | Nil | Cons of 'a * 'a list let map = fun f l -> l : 'a list case l | Nil -> Nil | Cons(h,t) -> Cons(f h, map f t) esac

Matching  Different types for expression being matched and that used with unions: type 'a list = | Nil | Cons of 'a * 'a list Cons(h,t) : let map = fun f l -> 'a *'a list case l | Nil -> Nil | Cons(h,t) -> Cons(f h, map f t) esac

Solution  Folding and Unfolding  l is folded  Cons(h,t) is unfolded  Implicit in ML

Reference Types  Classical ML Bug: let r = ref (fun x -> x) r := (fun x -> x + 1) !r true

Solution  Value Restriction − SML − Only allow values  Modified Value Restriction − OCaml − Value assigned at first use − Monomorphic in use, polymorphic at initial definition

Conclusion  In restricted type systems, full inference can be performed through unification − Allows code compactness and static type safety  Type rules contain constraint generation  Unification uses constraints to reduce potential solutions to the one correct one

References  Krishnamurthi, Shriram, Programming Languages: Application and Interpretation, http://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/  Benjamin C. Pierce, Types and Programming Languages  SML/NJ Type Checking Documentation, http://www.smlnj.org/doc/Conversion/types.html  Francois Pottier, A modern eye on ML type inference, September 2005, http://gallium.inria.fr/~fpottier/publis/fpottier-appsem-2005.pdf