Question

I tried writing a simple function that takes an Either type (possibly parameterized by two different types) and does one thing if it gets Left and another thing if it gets Right. the following code,

someFunc :: (Show a, Show b) => Either a b -> IO ()
someFunc (Left x) = print $ "Left " ++ show x
someFunc (Right x) = print $ "Right " ++ show x

main = do
  someFunc (Left "Test1")
  someFunc (Right "Test2")

However, this gives,

Ambiguous type variable `b0' in the constraint:
      (Show b0) arising from a use of `someFunc'
    Probable fix: add a type signature that fixes these type variable(s)
    In a stmt of a 'do' expression: someFunc (Left "Test1")

and

Ambiguous type variable `a0' in the constraint:
      (Show a0) arising from a use of `someFunc'
    Probable fix: add a type signature that fixes these type variable(s)
    In the expression: someFunc (Right "Test2")

If I understand correctly, when I call the function with Left x, it is complaining because it doesn’t know the type of the Right x variant, and vice-versa. However, this branch of the function is not used. Is there a better way to do this?

Answer 1

Well, that depends heavily on what you are trying to do, doesn’t it? As you already found out, in order to use Left constructor, you need to know the type it constructs. And full type requires information on both a and b.

Better way to achieve polymorphism in Haskell is to use type classes. You can easily provide different implementations of “methods” for different instances.

Good comparison of both object-orientation and type classes concepts can be found here.