Question

This is what I’m trying to do:

data X = I Int | D Double deriving (Show, Eq, Ord)

{-
-- A normal declaration which works fine
instance Num X where
  (I a) + (I b) = I $ a + b
  (D a) + (D b) = D $ a + b
  -- ...   
-}                                          

coerce :: Num a => X -> X -> (a -> a -> a) -> X
coerce (I a) (I b) op = I $ a `op` b
coerce (D a) (D b) op = D $ a `op` b

instance Num X where
  a + b = coerce a b (+)

When compiling I get an error:

 tc.hs:18:29:
     Couldn't match type `Double' with `Int'
     In the second argument of `($)', namely `a `op` b'
     In the expression: I $ a `op` b
     In an equation for `coerce': coerce (I a) (I b) op = I $ a `op` b

In coerce I’d like to interpret op as both Int -> Int -> Int and Double -> Double -> Double. I think I should be able to do this because op is of type Num a => a -> a -> a.

My main goal is to abstract away the repetition needed in the functioning Num subclass: I’d much rather write it like I did in the uncommented version.

Answer 1

Your definition of coerce restricts type of op to Int -> Int -> Int by first definition and Double -> Double -> Double by second. If you really want to say that op is polymorphic in a for all Num class then you should use Rank2Types to make it work.

coerce :: X -> X -> (forall a . Num a => a -> a -> a) -> X
coerce (I a) (I b) op = I $ a `op` b
coerce (D a) (D b) op = D $ a `op` b
coerce (I a) (D b) op = D $ op (fromIntegral a) b
coerce (D a) (I b) op = D $ op a (fromIntegral b)