Why is this type variable ambiguous?

Cabbage.hs:

module Cabbage where 
class Cabbage a
  where foo :: a -> String      -- the parameter is only present for its type,
                                -- the parameter value will be ignored
        bar :: String -> a
quux :: Cabbage a => String -> a
quux s = bar (s ++ foo (undefined :: a))

When I compile (with ghc) I get this error message:

Cabbage.hs:7:19:
    Ambiguous type variable `a' in the constraint:
      `Cabbage a' arising from a use of `foo' at Cabbage.hs:7:19-38
    Probable fix: add a type signature that fixes these type variable(s)

I don't understand why a is ambiguous. Surely the a in line 7 is the same as the a in line 6? How do I fix this?

Alternatively, is there a better way of declaring a per-instance constant?

From stackoverflow

• The problem is that Haskell doesn't know which instance of Cabbage that foo corresponds to there. So far as I know, it doesn't match the a in (undefined :: a) with the a in quux :: Cabbage a => String -> a

  Assuming that's what you want, you can do this:

  quux :: Cabbage a => String -> a
  quux s = result
      where result = bar (s ++ foo result)
  

  This ties foo and bar together so that it uses the same instance for both, and since you don't actually need the value of the input for foo, it bottoms out. I don't know of a better way of doing per-instance constants though. Hopefully someone else will come along who does.

• Using scoped type variables you can let GHC know that the undefined :: a should be the same (otherwise a is just a shorthand for forall a. a). Scoped type variables must then be explicitly forall-qualified:

  {-# LANGUAGE ScopedTypeVariables #-}
  module Cabbage where 
  class Cabbage a
    where foo :: a -> String      -- the parameter is only present for its type,
                                  -- the parameter value will be ignored
          bar :: String -> a
  quux :: forall a. Cabbage a => String -> a
  quux s = bar (s ++ foo (undefined :: a))
  

• you can extract out the polymorphic part as a function

  quux :: Cabbage a => String -> a
  quux s = quux' undefined
      where quux' :: Cabbage a => a -> a
            quux' x = bar (s ++ foo x)