Type Reconstruction Sven Woop woopps unisb de Goal

Type Reconstruction Sven Woop woop@ps. uni-sb. de

Goal u Calculating a principle type of a not type-annotated term. More Formally: Given a pair ( , t), compute the most general type T such that > t : T es well typed. u Example: u 2 Steps u Derive a set of contraints u find the principal unifier for these constraints u We compute principal types, not principal typings. Seminar: Types and Programming Languages

Index z Basics y. Standard Unification y. Nonstandard Unification y. Typing-rules for simply typed -calculus z Type Reconstruction y. Constraint typing rules for -calculus y. CT-Rules and Recursive types z Polymorphism y. Let-Polymorphism z Overview Seminar: Types and Programming Languages

Unification • Unification, [Robinson, 1965] • Unification in linear space complexity [Martelli, Montanary, 1984]

Standard Unification z More precisely: syntactic equational unification z We define the set of terms as: s, t : = x | f(t 1, . . . , tn) with x Var, f Func. Symbols z Given an equation s t we search a substitution such that s= t z is called a unifier for s t Seminar: Types and Programming Languages

Standard Unification z We call a unifier 1 more general than a unifier 2 iff there is a substitution such that 1 = 2. We write 1 2. z A principal unifier of s t is a unifier such that for all unifiers ‘ of s t we have ‘. Unification Theorem: Each equation s t has a principal unifier if it is unifiable. Seminar: Types and Programming Languages

Example z f(x, y) f(a, y) z 1 = { x : = a, y : = b } is a unifier as 1 f(x, y) = 1 f(a, y) f(a, b) = f(a, b) z 2 = { x : = a } is a principal unifier 2 f(x, y) = 2 f(a, y) = f(a, y) z { y : = b } 2 = 1 Seminar: Types and Programming Languages

Example z f(x) g(a) is not unifiable z x f(x) is not unifiable by standard unification !!!! Seminar: Types and Programming Languages

Motivation x f(x) is not unifiable with a finite term. But the following regular tree is an infinite solution: f x= finite representation: f f f. . . Seminar: Types and Programming Languages

Equivalence Test s : = fun eq(n, m) = if {n, m} s then true else if Label(n) Label(m) or Arity(n) Arity(m) false else s : = s { {n, m} } Arity(n) eq(n. i, m. i) i = 1 Seminar: Types and Programming Languages

Nonstandard Unification See the unification problem t 1 t 2 as a graph unification problem. Let eq be a function that computes the equivalence between two nodes in a graph. While not eq(t 1, t 2) do let (n, m) be a pair of nodes with Label(n) Label(m) or Arity(n) Arity(m) if Label(n) = f and Label(m) = g and f g or Arity(n) Arity(m) then return else if Label(n) = x then subst(x, m) else if Label(m) = x then subst(x, n) Seminar: Types and Programming Languages Note: No occurence check !!!!!! Solutions are infinite regular trees.

Example: f(g(x)) f(x) f f f [ x: = a ] g x a b x Seminar: Types and Programming Languages g a f

Typing rules for simply typed lambda calculus

Typing Rules Note: Abstractions and recursions are type annotated!!!! Seminar: Types and Programming Languages

Example x. y. x y x: Bool. y: Bool. x y : (Bool Bool) Bool x: Nat Bool. y: Nat. x y : (Nat Bool) Nat Bool x: Bool Y. y: Bool. x y : (Bool Y) Bool Y x: X Y. y: X. x y : (X Y) X Y Supposition: It exists a principal type annotation. Seminar: Types and Programming Languages

Constraint typing rules Principal Types, Curry and Feys [1958] Algorithm to compute principal types, Hindley [1969] Type reconstruction, Algorithm W, Damas and Milner [1982]

Goal u Calculating a principle type of a not type-annotated term. More Formally: Given a pair ( , t), compute the most general type T such that > t : T es well typed. u Example: u 2 Steps u Derive a set of contraints u find the principal unifier for these constraints u We compute principal types, not principal typings. Seminar: Types and Programming Languages

CT-Rules by Pierce Seminar: Types and Programming Languages

Constraint typing rules Let all Xi be fresh type variables. Seminar: Types and Programming Languages

Idea u Do just the same as the standard typing rules. u Introduce fresh type variables each time a type can‘t be computed directly. u Construct constraints consisting of the conditions the typing rules check. Seminar: Types and Programming Languages

CT-Var Ty-Var CT-Var Seminar: Types and Programming Languages

CT-Rec Ty-Rec Seminar: Types and Programming Languages

CT-Abs Ty-Abs CT-Abs Seminar: Types and Programming Languages

CT-App Ty-App Seminar: Types and Programming Languages

Example Seminar: Types and Programming Languages

Recursive Types u CT-Rules can be maintained u Use the Nonstandard Unification Algorithm Seminar: Types and Programming Languages

Simple Example Seminar: Types and Programming Languages

Unification Seminar: Types and Programming Languages

Unification Most general type of is Seminar: Types and Programming Languages

Advanced Example Seminar: Types and Programming Languages

Correctness Note: It exists a principal type annotation. Seminar: Types and Programming Languages

Let-Polymorphism Let-polymorphism, Milner [1978]

Polymorphism is a language mechanism that allow a single part of a program to be used with different types in different contexts. Seminar: Types and Programming Languages

Let-Polymorphism Naive Let-Rule: let id = x. x id : X 1 in id 1; X 1=Nat id true X 1=Bool end type clash Seminar: Types and Programming Languages

Solution: type scheme Let X 1, . . . , Xn be the free type variables of T that do not occur in . We define: Seminar: Types and Programming Languages

Example Now, the program is well typed. let id = x. x id : X 1: X 1 in id 1; id : X 11=Nat id true id : X 12=Bool end Seminar: Types and Programming Languages

Problem: side effects let r = ref( x. x) r : X 1: (X 1 X 1)Ref r: = x: Nat. succ x; r : (X 11)Ref X 11=Nat (!r) true r : (X 12)Ref X 12=Bool in end no type clash Seminar: Types and Programming Languages

Solution Only if t 1 is a value !!!!! Note: The type scheme is introduced after the typechecking of the term x=t 1. This means, that you can not use x polymorphically in the term t 1 itself (no polymorphic recursion). Seminar: Types and Programming Languages

Example no value no type scheme let r = ref( x. x) r : (X 1 X 1)Ref r: = x: Nat. succ x; r : (X 1 X 1)Ref X 1=Nat (!r) true r : (X 1 X 1)Ref X 1=Bool in end type clash Seminar: Types and Programming Languages

Restriction You can not compute a polymorphic function. E. g: val f = let val i = ref true in fn x => fn y => (if !i then x else y) before i : = not(!i) end f is no polymorphic function. Seminar: Types and Programming Languages

Runtime is Exponential The following program is well typed but takes a long time to typecheck. let val f 0 = fun x => (x, x) in let val f 1 = fun y => f 0 (f 0 y) in let val f 2 = fun y => f 1 (f 1 y) in let val f 3 = fun y => f 2 (f 2 y) in let val f 4 = fun y => f 3 (f 3 y) in f 4 (fun z => z) end end end Seminar: Types and Programming Languages

Runtime Analysis Program let val f 0 = Derived Type Size X 0: X 0*X 0 Constraints 20 0 22 2 24 4 28 8 216 16 fun x => (x, x) in let val f 1 = fun y => X 1: X 1 (X 1*X 1)*(X 1*X 1) f 0 (f 0 y) in let val f 2 = fun y => X 2: X 2 ((((X 2*X 2)*(X 2*X 2))* f 1 (f 1 y) in let val f 3 = fun y => ((X 2*X 2)*(X 2*X 2)))* (((X 2*X 2)*(X 2*X 2))* f 2 (f 2 y) in ((X 2*X 2)*(X 2*X 2)))) let val f 4 = fun y => f 3 (f 3 y) in f 4 (fun z => z) end end end Seminar: Types and Programming Languages (. . . )

Overview z Unification, Nonstandard Unification z Constraint typing rules for -calculus (similar to standard typing rules) z It exists a principal type annotation as the solution of a set of constraints (Unification Theorem) z Constraint typing rules and recursive types z Let-Polymorphism Seminar: Types and Programming Languages

Historical Context z Unification, [Robinson, 1965] z Unification in linear space complexity [Martelli, Montanary, 1984] z Nonstandard Unification ? ? ? z Principal Types, Curry and Feys [1958] z Algorithm to compute principal types, Hindley [1969] z Type reconstruction, Algorithm W, Damas and Milner [1982] z Type Reconstruction with Recursive Types [Huet, 1975, 1976] z Let-polymorphism, Milner [1978] Seminar: Types and Programming Languages

Questions? Seminar: Types and Programming Languages