Question

Is it recommended to always have exhaustive pattern matches in Haskell, even for “impossible” cases?

For example, in the following code, I am pattern matching on the “accumulator” of a foldr. I am in complete control of the contents of the accumulator, because I create it (it is not passed to me as input, but rather built within my function). Therefore, I know certain patterns should never match it. If I strive to never get the “Pattern match(es) are non-exhaustive” error, then I would place a pattern match for it that simply error’s with the message “This pattern should never happen.” Much like an assert in C#. I can’t think of anything else to do there.

What practice would you recommend in this situation and why?

Here’s the code:

gb_groupBy p input = foldr step [] input
   where
      step item acc = case acc of
           []                           -> [[item]]
           ((x:xs):ys)                  -> if p x item
                                           then (item:x:xs):ys
                                           else [item]:acc

The pattern not matched (as reported by the interpreter) is:

Warning: Pattern match(es) are non-exhaustive
In a case alternative: Patterns not matched: [] : _

Answer 1

This is probably more a matter of style than anything else. Personally, I would put in a

_ -> error "Impossible! Empty list in step"

if only to silence the warning 🙂