| This is incorrect. Haskell and OCaml both support parametric polymorphism, but Haskell also supports ad-hoc polymorphism, whereas OCaml does not. Modular implicits, it seems, are OCaml's solution to the problem of reducing the set of valid types in a polymorphic function. Haskell: concat :: [a] -> [a] -> [a] OCaml: val concat : 'a list -> 'a list -> 'a list = <fun> Both are parametrically polymorphic. However, in Haskell, I can use a type class to support ad-hoc polymorphism: concat :: (Num a) => [a] -> [a] -> [a] Now concat works forall a, as long as a is an instance of Num. This is important for arithmetic operators: (+) :: (Num a) => a -> a -> a Now I can have (+) be defined in a meaningful way, since Int, Integer, Float, etc. are all instances of Num, and implement (+). An easy way to think of this (since it's all it is, really) is operator/method overloading. In Haskell, (+) is overloaded for every type that you would want it to work for (the details of this are actually probably different, but are not important for learning). In OCaml, if I have val (+) : 'a -> 'a -> 'a = <fun> There is actually only two implementations of that function: let (+) a b = a or let (+) a b = b Since I cannot restrict the set of types to the function, I can't do anything with the arguments. I don't know what the types are! Ad-hoc polymorphism allows for restricting the set of types, which allows for Haskell to use + for any Num-like thing. |