Option type #

We introduce an important generic sum type, available in many languages, under a variety of names (Maybe, Option, optional, Optional, Nullable, etc.)

We will see in the dedicated sections that such a type can also be made a functor, and (perhaps most importantly) a monad. For now, we will use it without these extra features.

Motivation #

Problem. A programming language may not have a type that exactly fits the domain of a function that we want to implement.

Examples. A programming language may not have a type that exactly fits:

• positive integers,
• integers $\neq 0$,
• ASCII characters,
• nonempty lists (or nonempty arrays, nonempty sets, etc.),
• lists of distinct elements,
• valid phone numbers,
• etc.

Consequence. When we implement a function, we may need to handle undesired inputs.

Examples.

• A function that returns the head of a list may receive the empty list as input,
• a function that divides two numbers may receive 0 as input divisor,
• a function that maps a date to the average temperature in Bolzano on that day may receive a future date as input,
• etc.

null value and propagation #

A common way for a function $f$ to handle non-supported inputs consists in returning a special value. Depending on the language, this value may be called null, nil, undefined, etc.

Consequence. A function that calls $f$ must take this possibility into consideration:

• if $f$ returns null, take a special action (e.g. return null as well),
• otherwise proceed normally.

Drawback. Programmers often forget to check whether the value returned by $f$ is null. This is a well-known source of bugs (e.g. “null pointer exception”).

Illustration. Tony Hoare is often credited for inventing the null value (when working on the programming language ALGOL W). He notoriously said (in 2009):

“I call it my billion-dollar mistake. It was the invention of the null reference in 1965. […] I couldn’t resist the temptation to put in a null reference, […] This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.”

Second drawback. Handling null values creates boilerplate code (made worse by the fact that null is often propagated).
For instance (in Java):

Integer myMethod1 (Integer x){
    if(x == 0){
      return null;
    } else {
      ...
    }

String myMethod2 (Integer y){
    if(y < 0){
      return null;
    } else {
      x = myMethod1(myMethod3(y));
      if(x == null){
        return null;
      } else {
          ...
      }
    }
}

Option type #

Functional languages typically do not have a null value. Instead, they rely on one of several special types for optional values.

These are often called option types or maybe types.

Benefits. In a null-free language with option types:

1. The return type of a function indicates whether it may not return a value. This reduces:

   • the odds of a non-handled missing value, and
   • unnecessary checks.

2. Option types can be paired with higher-order functions that propagate “missing values” automatically (thus reducing boilerplate code). We will introduce such functions in the sections on functors and monads.

In Haskell #

Haskell uses a generic option type called Maybe.

Declaration. The type Maybe is declared as

data Maybe a = Nothing | Just a

Intuitively, an expression with type Maybe a may evaluate to either nothing, or a value of type a (where a is a type variable).

Example. The following function maps a nonempty list with head x to Just x, and the empty list to Nothing.

maybeHead :: [a] -> Maybe a
maybeHead [] = Nothing
maybeHead (x : _) = Just x

maybeLast :: [a] -> Maybe a

maybeLast :: [a] -> Maybe a
maybeLast [] = Nothing
maybeLast [x] = Just x
maybeLast (_ : xs) = maybeLast xs

maybeLast :: [a] -> Maybe a
maybeLast = maybeHead . reverse

find :: (a -> Bool) -> [a] -> Maybe a

find :: (a -> Bool) -> [a] -> Maybe a
find _ [] = Nothing
find f (x : xs) | f x = Just x
                | otherwise = find f xs