Why does GHC produce an equality constraint error rather than a type match error here?

Question

Following up from this question , I'm not sure why these two code snippets produce completely different errors:

f :: a -> b
f x = x
-- Couldn't match expected type `b' with actual type `a'
-- In the expression: x

g :: Monad m => a -> m b
g x = return x
-- Could not deduce (a ~ b) from the context (Monad m)
-- In the first argument of `return', namely `x'.

What is the rule giving rise to this behavior?

It's not very readable, even to someone familiar with standard Haskell; the equality constraint (a ~ b) requires a language extension.

Note that, as chi pointed out, the mere presence of a constraint triggers the constraint error:

class C a

h :: C a => a -> b
h x = x
-- Could not deduce...

(An empty constraint, () => a -> b , gives the match not the constraint error.)

Answer 1

I don't think there's a shorter answer than digging into GHC internals to understand why.

If you run GHC with the -ddump-tc-trace switch, you can get quite a lengthy log of the typechecking process. In particular, if you run it on this code:

f :: a -> b
f x = x

class C a

h :: C c => c -> d
h x = x

you can see that typechecking a vs b , and typechecking c vs d progresses exactly the same way in both cases, culminating in the following two unsolved constraints (output is from GHC 7.8.2):

tryReporters { [[W] cobox_aJH :: c ~ d (CNonCanonical)]
...
tryReporters { [[W] cobox_aJK :: a ~ b (CNonCanonical)]

By following the rabbit hole a bit more in TcErrors , you can see that for equalities on skolems, tryReporters eventually gets to creating the error message via misMatchOrCND , which has an explicit special case for empty contexts:

misMatchOrCND :: ReportErrCtxt -> Ct -> Maybe SwapFlag -> TcType -> TcType -> SDoc
-- If oriented then ty1 is actual, ty2 is expected
misMatchOrCND ctxt ct oriented ty1 ty2
  | null givens ||
    (isRigid ty1 && isRigid ty2) ||
    isGivenCt ct
       -- If the equality is unconditionally insoluble
       -- or there is no context, don't report the context
  = misMatchMsg oriented ty1 ty2
  | otherwise
  = couldNotDeduce givens ([mkTcEqPred ty1 ty2], orig)