Question

Note to other potential contributors: Please don’t hesitate to use abstract or mathematical notations to make your point. If I find your answer unclear, I will ask for elucidation, but otherwise feel free to express yourself in a comfortable fashion.

To be clear: I am not looking for a “safe” head, nor is the choice of head in particular exceptionally meaningful. The meat of the question follows the discussion of head and head', which serve to provide context.

I’ve been hacking away with Haskell for a few months now (to the point that it has become my main language), but I am admittedly not well-informed about some of the more advanced concepts nor the details of the language’s philosophy (though I am more than willing to learn). My question then is not so much a technical one (unless it is and I just don’t realize it) as it is one of philosophy.

For this example, I am speaking of head.

As I imagine you’ll know,

Prelude> head []    
*** Exception: Prelude.head: empty list

This follows from head :: [a] -> a. Fair enough. Obviously one cannot return an element of (hand-wavingly) no type. But at the same time, it is simple (if not trivial) to define

head' :: [a] -> Maybe a
head' []     = Nothing
head' (x:xs) = Just x

I’ve seen some little discussion of this here in the comment section of certain statements. Notably, one Alex Stangl says

‘There are good reasons not to make everything “safe” and to throw exceptions when preconditions are violated.’

I do not necessarily question this assertion, but I am curious as to what these “good reasons” are.

Additionally, a Paul Johnson says,

‘For instance you could define “safeHead :: [a] -> Maybe a”, but now instead of either handling an empty list or proving it can’t happen, you have to handle “Nothing” or prove it can’t happen.’

The tone that I read from that comment suggests that this is a notable increase in difficulty/complexity/something, but I am not sure that I grasp what he’s putting out there.

One Steven Pruzina says (in 2011, no less),

“There’s a deeper reason why e.g ‘head’ can’t be crash-proof. To be polymorphic yet handle an empty list, ‘head’ must always return a variable of the type which is absent from any particular empty list. It would be Delphic if Haskell could do that…”.

Is polymorphism lost by allowing empty list handling? If so, how so, and why? Are there particular cases which would make this obvious? This section amply answered by @Russell O’Connor. Any further thoughts are, of course, appreciated.

I’ll edit this as clarity and suggestion dictates. Any thoughts, papers, etc., you can provide will be most appreciated.

Answer 1

Is polymorphism lost by allowing empty
list handling? If so, how so, and why?
Are there particular cases which would
make this obvious?

The free theorem for head states that

f . head = head . $map f

Applying this theorem to [] implies that

f (head []) = head (map f []) = head []

This theorem must hold for every f, so in particular it must hold for const True and const False. This implies

True = const True (head []) = head [] = const False (head []) = False

Thus if head is properly polymorphic and head [] were a total value, then True would equal False.

PS. I have some other comments about the background to your question to the effect of if you have a precondition that your list is non-empty then you should enforce it by using a non-empty list type in your function signature instead of using a list.