Option type

In programming languages (more so functional programming languages) and type theory, an option type or maybe type is a polymorphic type that represents encapsulation of an optional value; e.g., it is used as the return type of functions which may or may not return a meaningful value when they are applied. It consists of a constructor which either is empty (often named None or Nothing), or which encapsulates the original data type A (often written Just A or Some A).

A distinct, but related concept outside of functional programming, which is popular in object-oriented programming, is called nullable types (often expressed as A?). The core difference between option types and nullable types is that option types support nesting (Maybe (Maybe A) ≠ Maybe A), while nullable types do not (String?? = String?).

Option types as monads[edit]

The option type is a monad, which means it follows the algebraic laws associated with monads:

{\text{return}}\colon A\to A^{?}=a\mapsto {\text{Just}}\,a

{\text{bind}}\colon A^{?}\to (A\to B^{?})\to B^{?}=a\mapsto f\mapsto {\begin{cases}{\text{Nothing}}&{\text{if}}\ a={\text{Nothing}}\\f\,a'&{\text{if}}\ a={\text{Just}}\,a'\end{cases}}

The option monad can also be described in terms of functions return, fmap and join, where the latter two are given by:

{\text{fmap}}\colon (A\to B)\to A^{?}\to B^{?}=f\mapsto a\mapsto {\begin{cases}{\text{Nothing}}&{\text{if}}\ a={\text{Nothing}}\\{\text{Just}}\,f\,a'&{\text{if}}\ a={\text{Just}}\,a'\end{cases}}

{\text{join}}\colon {A^{?}}^{?}\to A^{?}=a\mapsto {\begin{cases}{\text{Nothing}}&{\text{if}}\ a={\text{Nothing}}\\{\text{Nothing}}&{\text{if}}\ a={\text{Just}}\,{\text{Nothing}}\\{\text{Just}}\,a'&{\text{if}}\ a={\text{Just}}\,{\text{Just}}\,a'\end{cases}}

The option monad is an additive monad: it has Nothing as a zero constructor and the following function as a monadic sum:

{\text{mplus}}\colon A^{?}\to A^{?}\to A^{?}=a_{1}\mapsto a_{2}\mapsto {\begin{cases}{\text{Nothing}}&{\text{if}}\ a_{1}={\text{Nothing}}\land a_{2}={\text{Nothing}}\\{\text{Just}}\,a'_{2}&{\text{if}}\ a_{1}={\text{Nothing}}\land a_{2}={\text{Just}}\,a'_{2}\\{\text{Just}}\,a'_{1}&{\text{if}}\ a_{1}={\text{Just}}\,a'_{1}\end{cases}}

The resulting structure is an idempotent monoid.

Names and definitions[edit]

In different programming languages, the option type has various names and definitions.

In Agda, it is named Maybe with variants nothing and just a.
In Coq, it is defined as Inductive option (A:Type) : Type := | Some : A -> option A | None : option A..
In Haskell, it is named Maybe, and defined as data Maybe a = Nothing | Just a.
In Idris, it is defined as data Maybe a = Nothing | Just a.
In OCaml, it is defined as type 'a option = None | Some of 'a.
In Rust, it is defined as enum Option<T> { None, Some(T) }.
In Scala, it is defined as parameterized abstract class '.. Option[A] = if (x == null) None else Some(x)...
In Standard ML, it is defined as datatype 'a option = NONE | SOME of 'a.
In Swift, it is defined as enum Optional<T> { case none, some(T) } but is generally written as T?.

In type theory, it may be written as: $A^{?}=A+1$ . This expresses the fact that for a given set of values in $A$ , an option types adds exactly on additional value (the empty value) to the set of valid values for $A$ .

In languages having tagged unions, as in most functional programming languages, option types can be expressed as the tagged union of a unit type plus the encapsulated type.

In the Curry–Howard correspondence, option types are related to the annihilation law for ∨: x∨1=1.

An option type can also be seen as a collection containing either one or zero elements.

Examples[edit]

Scala[edit]

Scala implements Option as a parameterized type, so a variable can be an Option, accessed as follows:^[1]

// Defining variables that are Options of type Int
val res1: Option[Int] = Some(42)
val res2: Option[Int] = None

// sample 1 :  This function uses pattern matching to deconstruct Options
def compute(opt: Option[Int]) = opt match {
  case None => "No value"
  case Some(x) => "The value is: " + x
}

// sample 2 :  This function uses monad method
def compute(opt: Option[Int]) = opt.fold("No Value")(v => "The value is:" + v )

println(compute(res1))  // The value is: 42
println(compute(res2))  // No value

Two main ways to use an Option value exist. The first, not the best, is the pattern matching, as in the first example. The second, the best practice is a monadic approach, as in the second example. In this way, a program is safe, as it can generate no exception or error (e.g., by trying to obtain the value of an Option variable that is equal to None). Thus, it essentially works as a type-safe alternative to the null value.

OCaml[edit]

OCaml implements Option as a parameterized variant type. Options are constructed and deconstructed as follows:

(* Deconstructing options *)
let compute opt = match opt with
  | None -> "No value"
  | Some x -> "The value is: " ^ string_of_int x

print_endline (compute None) (* "No value" *)
print_endline (compute (Some 42)) (* "The value is: 42" *)

F#[edit]

(* This function uses pattern matching to deconstruct Options *)
let compute = function
  | None   -> "No value"
  | Some x -> sprintf "The value is: %d" x

printfn "%s" (compute <| Some 42)(* The value is: 42 *)
printfn "%s" (compute None)      (* No value         *)

Haskell[edit]

-- This function uses pattern matching to deconstruct Maybes
compute :: Maybe Int -> String
compute Nothing  = "No value"
compute (Just x) = "The value is: " ++ show x

main :: IO ()
main = do
    print $ compute (Just 42) -- The value is: 42
    print $ compute Nothing -- No value

Swift[edit]

func compute(_ x: Int?) -> String {
  // This function uses optional binding to deconstruct optionals
  if let y = x {
    // y is now the non-optional `Int` content of `x`, if it has any
    return "The value is: \(y)"
  } else {
    return "No value"
  }
}

print(compute(42)) // The value is: 42
print(compute(nil)) // No value

func compute(_ x: Int?) -> String {
  // This function uses `map` to transform the optional if it has a value,
  // or pass along the nil if it doesn't. If `map` results in nil,
  // the nil coalescing operator `??` sets a fall-back value of "No value"
  return x.map { unwrappedX in "The value is: \(unwrappedX)" } ?? "No value"
}

print(compute(42)) // The value is: 42
print(compute(nil)) // No value

func compute(_ x: Int?) -> String {
  // This function uses pattern matching to deconstruct optionals
  switch x {
  case .none: 
    return "No value"
  case .some(let y): 
    return "The value is: \(y)"
  }
}

print(compute(42)) // The value is: 42
print(compute(nil)) // No value

func compute(_ x: Int?) -> String {
  // This function asserts that x has a value, forcefully unwraps x
  // and CRASHES if nil is encountered!
  return "The value is: \(x!)"
}

print(compute(42)) // The value is: 42
print(compute(nil)) // Crash!

Rust[edit]

Rust allows using either pattern matching or optional binding to deconstruct the Option type:

fn main() {
    // This function uses pattern matching to deconstruct optionals
    fn compute(x: Option<i32>) -> String {
        match x {
            Some(a) => format!("The value is: {}", a),
            None    => format!("No value")
        }
    }

    println!("{}", compute(Some(42))); // The value is: 42
    println!("{}", compute(None)); // No value
}

fn main() {
    // This function uses optional binding to deconstruct optionals
    fn compute(x: Option<i32>) -> String {
        if let Some(a) = x {
            format!("The value is: {}", a)
        } else {
            format!("No value")
        }
    }

    println!("{}", compute(Some(42))); // The value is: 42
    println!("{}", compute(None)); // No value
}

References[edit]

^ Martin Odersky; Lex Spoon; Bill Venners (2008). Programming in Scala. Artima Inc. pp. 282–284. ISBN 978-0-9815316-0-1. Retrieved 6 September 2011.

[OderskySpoon2008-1] Martin Odersky; Lex Spoon; Bill Venners (2008). Programming in Scala. Artima Inc. pp. 282–284. ISBN 978-0-9815316-0-1. Retrieved 6 September 2011.

[1]

v t e Data types
Uninterpreted	Bit Byte Trit Tryte Word Bit array
Numeric	Arbitrary-precision or bignum Complex Decimal Fixed point Floating point Double precision Extended precision Long double Octuple precision Quadruple precision Single precision Reduced precision Minifloat Half precision bfloat16 Integer signedness Interval Rational
Pointer	Address physical virtual Reference
Text	Character String null-terminated
Composite	Algebraic data type generalized Array Associative array Class Dependent Equality Inductive List Object metaobject Option type Product Record Refinement Set Union tagged
Other	Boolean Bottom type Collection Enumerated type Exception Function type Opaque data type Recursive data type Semaphore Stream Top type Type class Unit type Void
Related topics	Abstract data type Data structure Generic Kind metaclass Parametric polymorphism Primitive data type Protocol interface Subtyping Type constructor Type conversion Type system Type theory
See also platform-dependent and independent units of information

Option type

Contents

Option types as monads[edit]

Names and definitions[edit]

Examples[edit]

Scala[edit]

OCaml[edit]

F#[edit]

Haskell[edit]

Swift[edit]

Rust[edit]

See also[edit]

References[edit]

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Navigation

Interaction

Tools

Print/export

Languages