As a beginner, it's not obvious to me why this is not allowed:
data Pair = Pair a b
That is, why do
Pair 5 "foo" and
Pair 'C'  HAVE to produce different types? Why is it not allowed for them both to create values of type
I'm learning from "Learn you a", RWH, and the Haskell WikiBook, but have not been able to find the kind of precise, wonky language describing parametrized types that I'm looking for.
Fundamentally, the issue is that you would have no information about the contents of
Pair. If all you know is that it contains a value of any type, the only real function you could use on it would be
id, which is pretty useless!
The problem is that, since each value could be anything, you have no guarantees about them at all. So you couldn't even use
==: what if the value was a function? You can't compare functions for equality!
Imagine writing a function acting on your hypothetical
fn (Pair a b) = ...
What other functions could you use on
Anything with any sort of concrete type (e.g.
Int -> Int or something) wouldn't work because you can't tell if
a is an
Int. More complicated types like
Num n => n -> n wouldn't work because you don't even know if
a is a number. The only functions that would work are ones with types like
t1 -> t1 or
t1 -> t2. However, the only reasonable function of the first type is
id and there is no reasonable function of the second type at all.
Now, you could just say "I'm going to try this function, if the type doesn't work, throw an error." But this would then be dynamic typing and would basically be throwing away the type system entirely. This sounds horrible, but it might make sense sometimes, so you can use
Data.Dynamic to accomplish something like that. However, you shouldn't worry about it as a beginner and chance are you will never need to use it--I haven't, so far. I'm just including it for the sake of completeness.