Martin Percossi wrote:
Bulat Ziganshin wrote:
this is called ad-hoc polymorphism which is not supported by Haskell. instead Haskell supports parametric polymorphism via type classes.
I think you are wrong here Bulat. In fact, I think a) Haskell supports parametric polymorphism, e.g. id :: t -> t id x = x b) Haskell supports ad-hoc polymorphism via type classes
Sometimes a distinction is made between ad-hoc polymorphism of the kind you'd get in C++ with method overloading, and "restricted parametric polymorphism" as in "Monad m =>" ie: 1) id :: t -> t -- Unrestricted parametric polymorphism 2) foo :: Monad m => m a -- Restricted parametric polymorphism for (m) and unrestricted for (a) 3) bar :: Int -> Int -> String bar :: Char -> Bool The only way to describe this is ad-hoc polymorphism, and the fact that any function is of the form A -> B means regardless of the arity of the overloaded functions it can also be supported by typeclasses (*) eg: class Bar a b where bar :: a -> b instance Bar Int (Int -> String) where ... instance Bar Char Bool where ... And a function or value in scope can be making use of unrestricted, restricted, and ad-hoc polymorphism at the same time eg: zap :: Monad m => Char -> m a zap :: Int -> String -> a String class Zap a b where zap :: a -> b instance Monad m => Zap Char (m a) where ... instance Zap Int (String -> a String) where ... (*) But there's one exception: you can't use typeclasses to resolve overloadings between values and functions because non-function values don't have a type of the form A -> B: cool :: Int cool :: Char -> String class Cool -- Ooops! fundamental problem encountered ;-) Regards, Brian. -- Logic empowers us and Love gives us purpose. Yet still phantoms restless for eras long past, congealed in the present in unthought forms, strive mightily unseen to destroy us. http://www.metamilk.com