Type inferencing in a subset of Haskell that contains overloading (but not pattern matching) is described. The process involves adding extra parameters to overloaded functions, thus making the previously implicit typing explicit. Rules are provided for translating Haskell source into a target language (a typed lambda calculus with type abstraction and application).

A type class is a parameterized type with defined operations, possibly inheriting operations from another such class. When type classes are introduced in Haskell, environments are augmented to hold information about bindings. There are environments for six different kinds of objects. The translation of an expression requires extracting information from these environments to resolve the type of the expression, which is added to the translation.

I was left feeling vaguely uneasy. The outline discussing classes and instances is fine, and the translation approach as an implementation technique seems reasonable. However, computing has a long history of language features being defined by translation (for example, if-then-else defined via jumps), which can be a sign that the appropriate level of abstraction for the language feature has not yet been found. This concern was reinforced by the observation in the paper that Haskell proper has over 100 translation rules for types.

Leaving that aside, the paper should be of value to language designers and high-level implementors who want to learn techniques for managing types with inheritance. As the style is not particularly readable, it would probably not be of great interest to the casual computer scientist.