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.