Improving type-error messages in functional languages

Size: px

Start display at page:

Download "Improving type-error messages in functional languages"

Shana Willis
7 years ago
Views:

1 Improving type-error messages in Bastiaan Heeren Universiteit Utrecht January 5, 200

2 Contents Introduction Constraints Type inference rules Solving constraints Solving inconsistencies Future work Conclusion 2

3 Introduction Example of an erroneous expression: f = \x -> case x of 0 -> False -> one 2 -> two 3 -> three Error message produced by Hugs: ERROR example.hs (line ): Type error in case expression *** Term : one *** Type : String *** Does not match : Bool 3

4 Introduction Problems in current type inferencing algorithms: local approach error message is only a brief explanation only one error message is reported Improvements: global approach a better explanation of the type conflict multiple error messages are reported 4

5 Expression language Expression language: data Expr = Variable String Literal String Apply Expr Expr Lambda String Expr Case Expr Alternatives Let String Expr Expr data Alternatives = Empty Alternative Expr Expr Alternatives no syntactic sugar simplified let expression 5

6 Type language Type language: data Type = TVar Int TCon String TApp Type Type type arrow ( ) is represented as a constant no quantifiers 6

7 Constraints Equality constraint: represents the unification of two types for example : a Int b Instance constraint: represents an instantiation of a (polymorphic) type contains a set of monomorphic variables for example : a< Int b 7

8 Type inference rules [VAR] [LIT] aisfresh - x : a, [x a] - literal : primitive type, no constraints no constraints [APP] aisfresh - f : tf, Af - e : te, Ae [ABS] aisfresh - e : t, A - (f e) : a, Af Ae - (\x e) : a t,a\ x tf te a {s a (x s) A} 8

9 Type inference rules [CASE] aandbarefresh - p : tp, Ap - pi :tpi,api for i [..n] - ei :tei,aei for i [..n] - (case p of p e; ;pn en;) : b, Ap (Ae -Ap) (Aen -Apn) a tp a tpi b tei {s t (x s) Api,(x t) Aei } for i [..n] for i [..n] for i [..n] 9

10 Type inference rules [LET] aisfresh - e : te, Ae - b : tb, Ab - (let x = e in b) : tb, (Ae Ab) \ x a te {s a (x s) Ae } {s<m a (x s) Ab } where M=Ae\x 0

11 Example [VAR] [VAR] - i : t3, [i t3] - i : t4, [i t4] - ii:,[i t3, i t4] [APP] t3 t4 - x :, [x ] - \x x:t, [VAR] [ABS] t - let i = \x xinii:, t3 < t2 t4 < t2 t2 t [LET]

12 Solving constraints Equality graph: vertex edge : type variable or type constant : equality constraint Each type variable occurs exactly once in a vertex Initial state for the expression let i = \x xinii result type errors set of constraints : t : t2 t #3 : t3 t4 : t3 < t2 #5 : t4 < t2 equality graph t t2 t3 t4 2

13 Solving constraints Equality constraints: a rule for each combination TCon c TCon c2 if c and c2 are equal then remove else error TCon c TVar v addanedgebetweencandv TCon c TApp t t2 error TVar v TVar v2 addanedgebetweenvandv2 TApp t t2 TApp t3 t4 split constraint into (t t3) and (t2 t4) TVar v TApp t t2 decomposition of v 3

14 Solving constraints result type t3 errors set of constraints : t Int Int... equality graph t t2 t3 #7 t4 Substitution: [t := t6, t2 := t7 t8, t3 := t9 t0, t4 := t t2] result type set of constraints equality graph t9 t0 : t6 Int Int... t7 t6 t8 errors t9 #7 t t0 #7 t2 substituted 4

15 Solving constraints Instance constraints: t <M t2 is changed into an equality constraint as soon as t2 is fixed (a fixed type does not change during the rest of the computation) A type is fixed if all the type variables it contains are fixed. A type variable is fixed if: - it does not occur in an equality constraint - it does not occur on the left hand side of an instance constraint - all the type variables in its connected component are fixed 5

16 Example simplify #3 #5 t t2 t3 t3 t4 < < t t4 t2 t2 t t3 t2 t4 6

17 Example decompose #3 #5 t t2 t3 t3 t4 < < t t4 t2 t2 t t3 t2 substitution t2 := t6 t7 t4 7

18 Example simplify #3 #5 t t6 t7 t3 t3 t4 < < t t4 t6 t7 t6 t7 t t3 t7 t6 substitution t2 := t6 t7 t4 8

19 Example instantiate #3 #5 t t6 t7 t3 t3 t4 < < t t4 t6 t7 t6 t7 t t3 t7 t6 t4 9

20 Example decompose #3 #5 t t6 t7 t3 t3 t4 t t4 t8 t8 t9 t9 t t3 t7 t6 t8 substitution t9 t4 t3 := t0 t 20

21 Example simplify #3 #5 t t6 t7 t0 t t0 t t4 t t4 t8 t8 t9 t9 t t7 t6 t0 t8 t substitution t9 t4 t3 := t0 t 2

22 Example simplify #3 #5 t t6 t7 t0 t t0 t t4 t t4 t8 t8 t9 t9 t t7 t6 t9 t0 t8 t #3 #3 t4 22

23 Example decompose #3 #5 t t6 t7 t0 t t0 t t4 t t4 t8 t8 t9 t9 substitution t t7 t4 := t2 t3 := t4 t8 := t6 t7 t0 := t8 t9 t := t20 t2 t6 t9 t0 t8 t #3 #3 t4 23

24 Example simplify #3 #5 t t6 t7 t0 t t0 t t2 t3 t4 t t4 t8 t8 t9 t9 t t8 t6 t20 #3 #3 t7 t6 t2 t4 substitution t4 := t2 t3 := t4 t8 := t6 t7 t0 := t8 t9 t := t20 t2 t9 t9 t7 t2 #3 #3 t3 24

25 Example result type #3 #5 t t6 t7 t0 t t0 t t2 t3 t4 t t4 t8 t8 t9 t9 a a t t8 t6 t20 #3 #3 t7 t6 t2 t4 #5 t9 #5 t9 t7 t2 #3 #3 t3 25

26 Solving inconsistencies Int : t Int Int t #3 t2 t3 Int Bool wrong paths: {,,#3,} {,,#3,} decompose paths: {,,} {,,} {,#3,} 26

27 Solving inconsistencies Int : t Int Int t #3 t2 t3 Int Bool wrong paths: {,,#3,} {,,#3,} decompose paths: {,,} {,,} {,#3,} minimal set {,} {,} {,} {,#3} {,} {#3,} 27

28 Solving inconsistencies Int : t Int Int t #3 t2 t3 Int Bool removal cost minimal set #3 good good paths: {,} {,} {,} {,} {,#3} {,} {#3,} 28

29 Solving inconsistencies Int : t Int Int t #3 t2 t3 Int Bool removal cost minimal set #3 good trust 5 5 each constraint has a trust value {,} {,} {,} {,#3} {,} {#3,} 29

30 Solving inconsistencies Int : t Int Int t #3 t2 t3 Int Bool removal cost minimal set #3 good trust 5 5 cost ( + good) * trust {,} {,} {,} {,#3} {,} {#3,} 30

31 Solving inconsistencies Int : t Int Int t #3 t2 t3 Int Bool removal cost minimal set total cost #3 good trust 5 5 cost remove the constraints in the set with the lowest total cost {,} {,} {,} {,#3} {,} {#3,}

32 Solving inconsistencies Int t t2 t3 Int Bool the inconsistency is removed 32

33 Future work Explicit typing Type synonyms Type classes Kindinferencing Type tracing Advanced output BANE 33

34 Conclusion Left-to-right bias is completely removed Several heuristics increase the exactness of the error message considerably Possibility to add more heuristics 34

Chapter 7: Functional Programming Languages

Chapter 7: Functional Programming Languages Aarne Ranta Slides for the book Implementing Programming Languages. An Introduction to Compilers and Interpreters, College Publications, 2012. Fun: a language