In programming languages (especially 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 (e.g. Maybe (Maybe String) ≠ Maybe String), while nullable types do not (e.g. String?? = String?).
In type theory, it may be written as:
A?=A+1
A
A
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.
The option type is also a monad where:[2]
Nothing >>= f = Nothing -- Fails if the previous monad fails(Just x) >>= f = f x -- Succeeds when both monads succeed
The monadic nature of the option type is useful for efficiently tracking failure and errors.[3]
In Agda, the option type is named with variants and .
Since C++17, the option type is defined in the standard library as .
In Coq, the option type is defined as .
In Elm, the option type is defined as .[4]
let full = Some 42let empty = None
showValue full |> printfn "showValue full -> %s"showValue empty |> printfn "showValue empty -> %s"
In Haskell, the option type is defined as .[5]
main :: IO main = do let full = Just 42 let empty = Nothing
putStrLn $ "showValue full -> " ++ showValue full putStrLn $ "showValue empty -> " ++ showValue empty
In Idris, the option type is defined as .
main : IO main = do let full = Just 42 let empty = Nothing
putStrLn $ "showValue full -> " ++ showValue full putStrLn $ "showValue empty -> " ++ showValue empty
proc showValue(opt: Option[int]): string = opt.map(proc (x: int): string = "The value is: " & $x).get("No value")
let full = some(42) empty = none(int)
echo "showValue(full) -> ", showValue(full)echo "showValue(empty) -> ", showValue(empty)
In OCaml, the option type is defined as .[6]
let = let full = Some 42 in let empty = None in
print_endline ("show_value full -> " ^ show_value full); print_endline ("show_value empty -> " ^ show_value empty)
In Rust, the option type is defined as .[7]
fn main
In Scala, the option type is defined as, a type extended by and .
def main(args: Array[String]): Unit = val full = Some(42) val empty = None
println(s"showValue(full) -> $") println(s"showValue(empty) -> $")
In Standard ML, the option type is defined as .
In Swift, the option type is defined as but is generally written as .[8]
let full = 42let empty: Int? = nil
print("showValue(full) -> \(showValue(full))")print("showValue(empty) -> \(showValue(empty))")
In Zig, add ? before the type name like ?i32 to make it an optional type.
Payload n can be captured in an if or while statement, such as, and an else clause is evaluated if it is null.
fn showValue(allocator: std.mem.Allocator, opt: ?i32) ![]u8
pub fn main !void