[Haskell-cafe] [Haskell] A puzzle and an annoying feature

[Martin Sulzmann]

[Discussion moved from Haskell to Haskell-Cafe]

Hi,

Regarding

- "lazy overlap resolution" aka unique instances

Well, if there's only instance which is not exported, then you can
use functional dependencies.

Assume

class C a
instance ... => C t

Internally, use

class C a | -> a
instance ... => C t
 

Furthermore, there seems to be an issue that has been overlooked so far.

- Providing sufficient type annotations

Recall

Lennart Augustsson writes:
 > Here is a small puzzle.
 > 
 > -- The following generates a type error:
 > f :: Char -> Char
 > f c =
 >      let x = g c
 >      in  h x
 > 

Lennart "magically" inserted a type annotation to resolve the ambiguity.

 > -- But this definition does not:
 > f :: Char -> Char
 > f c =
 >      let x :: Bool
 > 	x = g c
 >      in  h x
 > 

Clearly, there are a number of ways to resolve the ambiguity.
The Chameleon type debugger assists the user in identifying
which locations are responsible.

Here's the Chameleon type debugger error message generated
for the unannotated function f


temp.ch:2: ERROR: Inferred type scheme is ambiguous:
Type scheme: forall b. C b => Char -> Char
  Suggestion: Ambiguity can be resolved at these locations
              b: f :: Char -> Char
                 f c = let x = g c
                           ^   ^
                       in  h x
                           ^ ^
(The ^ correspond to highlightings of the Chameleon type debugger)


This may help the user to realize where and which annotations are
missing. E.g., each of the following annotations (there are more
possibilities) will do the job.

f :: Char -> Char
f c =
     let -- x :: Bool (1)
         x = g c
     in  h x -- h (x::Bool) (2)
             -- (h::Bool->Char) x (3)


Martin