1 / 30

Type Inference II

Type Inference II. David Walker COS 441. Type Inference. Goal: Given unannotated program, find its type or report it does not type check Overview: generate type constraints (equations) from unannotated programs solve equations. Constraint Generation.

Download Presentation

Type Inference II

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Type Inference II David Walker COS 441

  2. Type Inference • Goal: • Given unannotated program, find its type or report it does not type check • Overview: • generate type constraints (equations) from unannotated programs • solve equations

  3. Constraint Generation Typing rules for annotated programs: G |-- e : t Note: given G and e, at most one type t Typing rules for unannotated programs: G |-- u => e : t, q Note: given G and u, there may be many possible types for u; the many possibilities represented using type schemes u has a type t if q has a solution Remember: fun f (x) = f x

  4. Rule comparison implicit equality easy to implement because t can’t contain variables G |-- e1 : bool G |-- e2 : t G |-- e3 : t ---------------------------------------------------------------- G |-- if e1 then e2 else e3 : t G |-- u1 ==> e1 : t1, q1 G |-- u2 ==> e2 : t2, q2 G |-- u3 ==> e3 : t3, q3 ------------------------------------------------------------------- G |-- if u1 then u2 else u3 ==> if e1 then e2 else e3 : a, q1 U q2 U q3 U {t1 = bool, a = t2, a = t3} equality harder to implement because t2, t3 can contain variables that may be further constrained elsewhere

  5. Non-local Constraints Does this type check? fun f (x) = fun g (y) = (if true then x else y, ...) It depends: fun f (x) = fun g (y) = (if true then x else y, x + (if y then 3 else 4)) fun f (x) = fun g (y) = (if true then x else y, x + y)

  6. Non-local Constraints But remember, it was easy to check when types were declared in advance: fun f (x:int) = fun g (y:bool) = (if true then x else y, x + (if y then 3 else 4)) fun f (x:int) = fun g (y:int) = (if true then x else y, x + y)

  7. Solving Constraints • A solution to a system of type constraints is a substitution S S |= q iff applying S makes left- & right-hand sides of each equation equal • A solution S is better than T if it is “more general” • intuition: S makes fewer or less-defined substitutions (leaves more variables alone) • T <= S if and only if T = U o S for some U

  8. Most General Solutions • S is the principal (most general) solution of a constraint q if • S |= q (it is a solution) • if T |= q then T <= S (it is the most general one) • Lemma: If q has a solution, then it has a most general one • We care about principal solutions since they will give us the most general types for terms

  9. principal solutions • principal solutions give rise to most general reconstruction of typing information for a term: • fun f(x:a):a = x • is a most general reconstruction • fun f(x:int):int = x • is not

  10. Unification • Unification: An algorithm that provides the principal solution to a set of constraints (if one exists) • If one exists, it will be principal

  11. Unification • Unification: Unification systematically simplifies a set of constraints, yielding a substitution • during simplification, we maintain (S,q) • S is the solution so far • q are the constraints left to simplify • Starting state of unification process: (I,q) • Final state of unification process: (S, { }) identity substitution is most general

  12. Unification Machine • We can specify unification as a transition system: • (S,q) -> (S’,q’) • Base types & simple variables: -------------------------------- (S,{int=int} U q) -> (S, q) ------------------------------------ (S,{bool=bool} U q) -> (S, q) ----------------------------- (S,{a=a} U q) -> (S, q)

  13. Unification Machine • Functions: • Variable definitions ---------------------------------------------- (S,{s11 -> s12= s21 -> s22} U q) -> (S, {s11 = s21, s12 = s22} U q) --------------------------------------------- (a not in FV(s)) (S,{a=s} U q) -> ([s/a] o S, [s/a]q) -------------------------------------------- (a not in FV(s)) (S,{s=a} U q) -> ([s/a] o S, [s/a]q)

  14. Occurs Check • What is the solution to {a = a -> a}?

  15. Occurs Check • What is the solution to {a = a -> a}? • There is none! • The “occurs check” detects this situation -------------------------------------------- (a not in FV(s)) (S,{s=a} U q) -> ([a=s] o S, [s/a]q) occurs check

  16. Irreducible States • Recall: final states have the form (S, { }) • Stuck states (S,q) are such that every equation in q has the form: • int = bool • s1 -> s2 = s (s not function type) • a = s (s contains a) • or is symmetric to one of the above • Stuck states arise when constraints are unsolvable

  17. Termination • We want unification to terminate (to give us a type reconstruction algorithm) • In other words, we want to show that there is no infinite sequence of states • (S1,q1) -> (S2,q2) -> ...

  18. Termination • We associate an ordering with constraints • q < q’ if and only if • q contains fewer variables than q’ • q contains the same number of variables as q’ but fewer type constructors (ie: fewer occurrences of int, bool, or “->”) • This is a lexicographic ordering • There is no infinite decreasing sequence of constraints • To prove termination, we must demonstrate that every step of the algorithm reduces the size of q according to this ordering

  19. Termination • Lemma: Every step reduces the size of q • Proof: By cases (ie: induction) on the definition of the reduction relation. -------------------------------- (S,{int=int} U q) -> (S, q) ------------------------------------ (S,{bool=bool} U q) -> (S, q) ---------------------------------------------- (S,{s11 -> s12= s21 -> s22} U q) -> (S, {s11 = s21, s12 = s22} U q) ------------------------ (a not in FV(s)) (S,{a=s} U q) -> ([s/a] o S, [s/a]q) ----------------------------- (S,{a=a} U q) -> (S, q)

  20. Correctness • we know the algorithm terminates • we want to prove that a series of steps: (I,q1) -> (S2,q2) -> (S3,q3) -> ... -> (S,{}) solves the initial constraints q1 • we’ll do that by induction on the length of the sequence, but we’ll need to define the invariants that are preserved from step to step

  21. Defining the invariants A complete solution for (S,q) is a substitution T such that • T <= S • T |= q Intuition: T extends S and solves q A principal solution T for (S,q) is complete for (S,q) and • for all T’ such that 1. and 2. hold, T’ <= T Intuition: T is the most general solution (it’s the least restrictive)

  22. Properties of Solutions • Lemma 1: • Every final state (S, { }) has a complete solution. • It is S since: • S <= S • S |= { } every substitution is a solution to the empty set of constraints

  23. Properties of Solutions • Lemma 2 • No stuck state has a complete solution (or any solution at all) • it is impossible for a substitution to make the necessary equations equal • int  bool • int t1 -> t2 • ...

  24. Properties of Solutions • If (S,q) -> (S’,q’) then 1. T is complete for (S,q) iff T is complete for (S’,q’) 2. T is principal for (S,q) iff T is principal for (S’,q’) • Proof: By induction (cases) on the definition of (S,q) -> (S’, q’) • in the forward direction, this is the preservation theorem for the unification machine!

  25. Proof cases If T is complete for (S,{int=int} U q) then (by definition): (1) T <= S and (2) T |= {int=int} U q To prove T is complete for (S,q), we show: T <= S (by (1)) T |= q (by (2) and definition of |= ) -------------------------------- (S,{int=int} U q) -> (S, q)

  26. Proof cases If T is complete for (S, {a=s} U q) then (by definition): (1) T <= S (2) T |= {a=s} U q To prove T is complete for ([a=s] o S, q[s/a]), we show: T <= [s/a] o S T |= q (by (2) and definition of |= ) How? Maybe for homework! ---------------------------------------------- (a not in FV(s)) (S,{a=s} U q) -> ([s/a] o S, [s/a]q)

  27. Summary: Unification • By termination, (I,q) ->* (S,q’) where (S,q’) is irreducible. Moreover: • If q’ = { } then • S is principal for (S,{}) (by lemma 1) • S is principal for (I,q) (by lemma 3) • Since S is principal for (I,q), S is more general than any other solution T for q such that T <= I. Since all T <= I, T <= S for all solutions to q. Hence, S is a principal solution for q.

  28. Summary: Unification (cont.) • ... Moreover: • If q’ is not { } (and (I,q) ->* (S,q’) where (S,q’) is irreducible) then • (S,q) is stuck. Consequently, (S,q) has no complete solution. By lemma 3, even (I,q) has no complete solution and therefore q has no solution at all.

  29. Summary: Type Inference • Type inference algorithm. • Given a context G, and untyped term u: • Find e, t, q such that G |- u ==> e : t, q • Find principal solution S of q via unification • if no solution exists, there is no reconstruction • Apply S to e, ie our solution is S(e) • S(e) contains schematic type variables a,b,c, etc that may be instantiated with any type • Since S is principal, S(e) characterizes all reconstructions.

  30. End

More Related