In
ML, the
sum type defined as:
datatype 'a option = SOME of 'a | NONE
where
'a (
pronounced "
alpha") is a
polymorphic type (
i.e., it can be any type we want as long as we're
consistent).
The
option is an
extremely powerful concept in that it
allows us to define
partial functions. That is, if the
function is
defined on the particular
input it gets, it
returns
SOME of the
value; if it is not defined on the input it gets, it returns
NONE. A good
example is a
table lookup function:
lookup : (int * string) list -> int -> string option
That is, we pass it a list of
int, string pairs, and an
int. If the
int is in the list, it returns the
associated string (well, really
SOME (s)) and if not, it returns
NONE.
This is particularly important when we're handling a value returned by a partial function. By the very nature of sum types, we can't do anything with the option itself besides case on whether it's a SOME or a NONE. Thus, we are forced to handle the case where the element is not found in the list, or malloc can't give us the memory we asked for.
In C, for example, instead of returning NONE, we just return a special value that indicates that we shouldn't use the value we got and that we need some special error handling. Of course, it is still a value of the type we were expecting, so there's nothing forcing us to handle that special case. This is what gets us into trouble most of the time -- trying to dereference a NULL pointer, for example. If malloc just returned NONE instead of NULL and SOME(p) instead of just the pointer, we would have no choice but to case on NONE or SOME and handle each appropriately, since that's literally all we can do with an option, or any sum type, for that matter.
This distinction (or lack thereof) gets us into trouble in the real world, too. People vie to get the vanity plate that says "NONE", since an officer taking down their plate number would write "NONE", when they really mean SOME("NONE") (of type string option), not NONE, as they're likely to confuse it to mean later.