Partial Functions in Haskell Prelude

Partial functions are functions that are not defined for all possible arguments of its specified type.

The most common example of a partial function is head. It has the innocent-looking type signature of

head :: [a] -> a

head fails when an empty list is given:

head [1,2,3] -- 1
head []      -- Exception!

Because of Haskell’s type erasure, head doesn’t even know what the supplied type is, so there’s no way for it to return a value of type a when there are no values in the list (besides the obvious fact that there are no values in the list).

In Brent Yorgey’s CIS 194 Haskell course:

head is a mistake! It should not be in the Prelude. Other partial Prelude functions you should almost never use include tail, init, last, and (!!).

Haskell’s official wiki provides a complete list of partial functions in Prelude. Note that some of these functions are considered partial functions because they do not terminate if given an infinite list.

Given all that, I think using something like head is okay if composed with other functions that guarantee non-emptiness of the list, or if the function type signature is NonEmpty, a type class which guarantees a list with at least one element.

For example, consider lastItem, a function which returns the last item in a list:

lastItem :: [a] -> a
lastItem = head . reverse

lastItem [1,2] -- 2
lastItem []    -- Exception!

In addition, consider toDigits, a function which, when given an Integral value, returns a list of its constituent digits:

toDigits :: Integral a => a -> [a]
toDigits x
  | x < 0 = toDigits $ x * (-1)
  | x < 10 = [x]
  | otherwise = toDigits (div x 10) ++ [mod x 10]

toDigits 123   -- [1,2,3]
toDigits 0     -- [0]
toDigits (-43) -- [4,3]

A function like toDigits guarantees a non-empty list, and when combined with lastItem, we can get the last digit of an Integral value:

lastDigit :: Integral a => a -> Int
lastDigit = lastItem . digits

lastDigit 123   -- 3
lastDigit 01    -- 1
lastDigit (-1)  -- 1

Or consider (!!), which accesses an element in a list by index. If the index provided is too large, an exception is thrown:

(!!) [1,2,3] 0 -- 1
(!!) [1,2,3] 4 -- Exception!

An idea is to wrap (!!) with the Maybe data type in a function like this:

findByIndex :: [a] -> Int -> Maybe a
findByIndex xs index
  | index >= length xs = Nothing
  | otherwise          = Just ((!!) xs index)

findByIndex [1,2,3] 0 -- Just 1
findByIndex [1,2,3] 4 -- Nothing

I’m surprised that such commonly used functions in the Prelude are so dangerous, so it’s good to pay attention when using them. Partial functions like head are easy to replace with pattern matching, but others may be harder to supplant.