[Haskell] question about a failure to generalize

[Norman Ramsey]

Dear Haskellers,

I've had a Haskell program rejected for reasons I don't understand.
Here's the relevant bit of code; the problem is that I expected the
type-inference engine to generalize the abbreviation 'fold' to an
overloaded function, but it doesn't---to make the code work, I had to
expand 'fold' into 'foldRegsUsed' everywhere it appears.  I'm baffled
because 'fold' isn't mutually recursive with anything, so I would have
expected ordinary Hindley-Milner style inference to generalize it to
something of the type

  UserOfLocalRegs a => (b -> LocalReg -> b) -> b -> a -> b

But that's not what happens.  This code fails to compile because the
compiler is willing to use 'fold' at only one type (CmmExpr as it happens):

  class UserOfLocalRegs a where
    foldRegsUsed :: (b -> LocalReg -> b) -> b -> a -> b

  instance UserOfLocalRegs Middle where
      foldRegsUsed f z m = middle m
        where middle (MidComment {})                = z
              middle (MidAssign _lhs expr)          = fold f z expr
              middle (MidStore addr rval)           = fold f (fold f z addr) rval
              middle (MidUnsafeCall tgt _ress args) = fold f (fold f z tgt) args
              middle (CopyIn _ _formals _)          = z
              middle (CopyOut _ actuals)            = fold f z actuals
              fold = foldRegsUsed


What rule of the language have I overlooked?



Norman