After studying haskell as a hobby for some time now, I'm still "thinking OOP"... In particular I still don't find myself comfortable with Type Classes.
Extending Type Classes
Every time I use them I "feel" the need to write a Type Class that extends another one (as if they where c++ classes). But if you want to extend a Type Class you just need a plain function. Like in:
class T1 a where
m1 :: a -> Int
doubleM1 :: (T1 a) => a -> Int
doubleM1 x = 2 * m1 x
Of course if you can alter the Type Class definition itself you can add doubleM1' to the Type Class itself like in:
class T1 a where
m1 :: a -> Int
doubleM1' :: a -> Int
doubleM1' x = 2 * m1 x
This second form is more powerful because you can write different implementations for different instances, if so you desire. That is not always a good thing, see:
instance T1 Double where
doubleM1' x = 3 * m1 x
m1 = round
My Question
Suppose I have two Type Classes (e.g. they are not not my own Type Classes i.e. I can't modify them)
class T1 a where
m1 :: a -> Int
class T2 a where
m2 :: a -> Int
Can I write a Type Class member (or a plain function) that accepts any instance of T1 or T2 and gives back an Int? For instance like in:
class T a where
m :: => a -> Int
instance T AnyTypeThatHasAnInstanceForT1 where
m = m1
instance T AnyTypeThatHasAnInstanceForT2 where
m = m2
I think my OOP trained brain wants to use overloading in order to avoid writing all my instances twice. What is an idiomatic haskell way of solving such problem?
