1. Type Inference II David Walker CS 510

2. ML-style Polymorphism 2 characteristics: prenex (let) polymorphism let f : all [a,b,c].t =... in e polymorphic quantifiers appear in outermost positions polymorphic values can’t be arguments/results of functions, can’t be stored reason: completeness of type inference value restriction let x = v in e reason: soundness of type inference

3. Value restriction Polymorphic generalization may occur over values only Generalization over non-values causes unsoundness Functions, lists, pairs,data cons. are values references, expressions that raise exns, perform I/O, function applications are not let x : (all [a]. (a -> a) ref) = ref (fn x => x) in x := (fn x => x + 1); (!x) true (* error *) not a value

4. 1st-Class Polymorphism Question: where to generalize values with (monomorphic) schematic types to polymorphic types eg: fn(x).fn(y).y has type all [a].all [b]. a -> b -> b all [a]. a -> (all [b]. b -> b) which one do we pick? the first can be an argument to (int -> bool -> bool) -> bool the second returns polymorphic functions z that can be applied to values with different types z true; z 3

5. Prenex Polymorphism Solution: restrict to prenex quantification (type inference for the general case undecideable) generalize at let-bound values: a polymorphic value is always instantiated: G |- v : t, q (I,q) -> (S,{}) a1,...,an = FV(S(t)) - FV(G) G,x:all[a1,...,an].S(t) |- e : t’,q’ ------------------------------------------------------------- G |- let x = v in e : t’,q’ G(f) = all[a1,...,an].t (a1,...,an are fresh) ----------------------------------------------------- G |- f : t,{}

6. Advanced Type Inf ML pushes the limit of complete type inf. 1st-class universal and existential poly, subtyping, bounded quantification make complete type inference impossible Nex step: Require some type annotations goal: require annotations where useful as documentation goal: omit type annotations where they are “obvious” and common Most languages (Java, C++, C) require some type annotations anyway

7. Some Stats [PT 98] Type instantiation occurs all the time every third line of code Anonymous function declarations occurs fairly often 1/10 lines to 1/100 lines depending on style Local variable declarations 1/12 lines Local functions bound to variables 1/66 lines

8. Consequences Type instantiation is the first priority every third line of ML-style code Anonymous function declarations are the next priority 1/10 lines to 1/100 lines depending on style Local variable declarations would be nice 1/12 lines 1/66 lines (functions)

9. Bi-directional Type Inf Two interacting judgements type checking G |- e <= t we can check that e has the type t type t is an input to the judgement type synthesis G |- e => t we can synthesize the most general type t from the expression e and context G type t is an output of the judgement Note: we have been doing type synthesis all along

10. More on Bi-Directional TI..... on your next homework!

11. End!