http://stackoverflow.com/questions/6364409/why-does-haskells-head-crash-on-an-empty-list-or-why-doesnt-it-return-an

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

So why shouldn't head [] return []? Because we want _head_ to play well with _map_
for all lists including [] and all map-able functions including constants.
This is known as "the free theorem" of functors. For head we expect that

  f . head = head . map f

meaning that for  List a  and a function  f :: a -> a  taking the head of the list
first and then applying f to it should produce the same result as map-ing f over the list
and then taking the head of the resulting list. For example, we expect the same result of

  sq . head $ [2, 3]    -- equivalently, (sq.head)[2,3]  that is sq(head [2,3])
 
and

  head . map sq $ [2, 3]  -- equivalently, (head.map sq)[2,3]  that is  (head.(map sq))[2,3]  that is head(map sq [2,3])

(Syntactically, recall that (.) is  infixr 9  whereas ($) is  infixr 0. This means
 that $ binds the weakest, and . is second to only the function application).

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.
A contradiction.