Haskell类型错误消息

Question

I am interested in the way Haskell generates type error messages. In particular, I am interested in the way it suggests program expressions the user might want to fix in order for the error to go away. Examples should make this more clear. Consider the first example.

main = zprint 2
zprint x = putStrLn x

The corresponding error message is:

No instance for (Num String)
  arising from the literal `2'
Possible fix: add an instance declaration for (Num String)
In the first argument of `zprint', namely `2'
In the expression: zprint 2
In an equation for `main': main = zprint 2

The way I am interpreting this is that the compiler is telling me that I should fix the parameter being passed 2 , or the whole function call zprint 2 , or even the whole main = zprint 2 , but it does report putStrLn saying I am using it in a wrong way and I should use some other function. Likewise, we have the following example:

main = zprint 2
idn x = x
zprint x = putStrLn (idn x)

The message is the same:

No instance for (Num String)
  arising from the literal `2'
Possible fix: add an instance declaration for (Num String)
In the first argument of `zprint', namely `2'
In the expression: zprint 2
In an equation for `main': main = zprint 2

But, we could also change the second line to idn x = show x and the program is now well typed. Hence, I can see the pattern in the way Haskell lists those expressions, but I would like to see the actual algorithm if it is written down somewhere, but not the compiler source code. Note that I am not an expert in Haskell, more of an OCaml person. GJC version I am using is 7.4.1.

Answer 1

Hence, I can see the pattern in the way Haskell lists those expressions, but I would like to see the actual algorithm if it is written down somewhere, but not the compiler source code.

There isn't a formal algorithm for error reporting, it's really an engineering detail of the compiler implementation and different Haskell compilers approach it differently. So I'm afraid if you want to understand the gritty details of GHC the only way to do so is read the literate Haskell in the compiler or SPJ's notes on the Trac wiki.

Like BenjaminKovach said, the algorithm and the error reporting is not significantly different than what you'd do in vanilla Hindley Milner. The typechecker tracks position information and when the unifier fails to find a solution it reports the provenance of the terms which generated constraints that failed. One minor detail is that it also tries to apply available partial solutions on the free variables in the types of the error message.

The type system itself is an evolution of HM(X) ( see Chapter 10 of Advanced Topics in Types and Programming Languages ). The latest paper outlining the typechecker is OutsideIn(X) which is more or less how it works in latest GHC sans some of bleeding egde work.

Answer 2

Haskell uses a modified form of a Hindley-Milner type system , and GHC uses a modified version of Damas-Hindley-Milner type inference in order to type-check and generate error messages.

There are tutorial implementations of Algorithm W out there, as well as a long-winded discussion about how Haskell in particular is type checked, located here .

I can't guarantee that these resources will be super accessible, but that's because type inference isn't easy, type systems in general require a little bit of study to fully grasp, and GHC uses Haskell's complex type system to generate the error messages you're seeing.