Option type

For families of option contracts in finance, seeOption style.

Inprogramming languages(especiallyfunctional programminglanguages) andtype theory,anoption typeormaybe typeis apolymorphic typethat 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 namedNoneorNothing), or which encapsulates the original data typeA(often writtenJust AorSome A).

A distinct, but related concept outside of functional programming, which is popular inobject-oriented programming,is callednullable types(often expressed asA?). 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?).

Theoretical aspects

Intype theory,it may be written as:$A^{?}=A+1$.This expresses the fact that for a given set of values in$A$,an option type adds exactly one additional value (the empty value) to the set of valid values for$A$.This is reflected in programming by the fact that in languages havingtagged unions,option types can be expressed as the tagged union of the encapsulated type plus aunit type.

In theCurry–Howard correspondence,option types are related to theannihilation lawfor ∨: x∨1=1.

An option type can also be seen as acollectioncontaining either one or zero elements.

The option type is also amonadwhere:

return=Just-- Wraps the value into a maybe

Nothing>>=f=Nothing-- Fails if the previous monad fails
(Justx)>>=f=fx-- Succeeds when both monads succeed

The monadic nature of the option type is useful for efficiently tracking failure and errors.

Examples

Agda

Further information:Agda (programming language)

In Agda, the option type is namedMaybewith variantsnothingandjusta.

C++

Since C++17, the option type is defined in the standard library astemplate<typenameT>std::optional<T>.

Coq

Further information:Coq (software)

In Coq, the option type is defined asInductiveoption(A:Type):Type:=|Some:A->optionA|None:optionA..

Elm

Further information:Elm (programming language)

In Elm, the option type is defined astypeMaybea=Justa|Nothing.

F#

Further information:F Sharp (programming language)

letshowValue=
Option.fold(fun_x->sprintf"The value is: %d"x)"No value"

letfull=Some42
letempty=None

showValuefull|>printfn"showValue full -> %s"
showValueempty|>printfn"showValue empty -> %s"

showValue full -> The value is: 42
showValue empty -> No value

Haskell

Further information:Haskell (programming language)

In Haskell, the option type is defined asdataMaybea=Nothing|Justa.

showValue::MaybeInt->String
showValue=foldl(\_x->"The value is:"++showx)"No value"

main::IO()
main=do
letfull=Just42
letempty=Nothing

putStrLn$"showValue full ->"++showValuefull
putStrLn$"showValue empty ->"++showValueempty

showValue full -> The value is: 42
showValue empty -> No value

Idris

Further information:Idris (programming language)

In Idris, the option type is defined asdataMaybea=Nothing|Justa.

showValue:MaybeInt->String
showValue=foldl(\_,x=>"The value is"++showx)"No value"

main:IO()
main=do
letfull=Just42
letempty=Nothing

putStrLn$"showValue full ->"++showValuefull
putStrLn$"showValue empty ->"++showValueempty

showValue full -> The value is: 42
showValue empty -> No value

Nim

Further information:Nim (programming language)

importstd/options

procshowValue(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)

showValue(full) -> The Value is: 42
showValue(empty) -> No value

OCaml

Further information:OCaml

In OCaml, the option type is defined astype'aoption=None|Someof'a.

letshow_value=
Option.fold~none:"No value"~some:(funx->"The value is:"^string_of_intx)

let()=
letfull=Some42in
letempty=Nonein

print_endline("show_value full ->"^show_valuefull);
print_endline("show_value empty ->"^show_valueempty)

show_value full -> The value is: 42
show_value empty -> No value

Rust

Further information:Rust (programming language)

In Rust, the option type is defined asenumOption<T>{None,Some(T)}.

fnshow_value(opt:Option<i32>)->String{
opt.map_or("No value".to_owned(),|x|format!("The value is: {}",x))
}

fnmain(){
letfull=Some(42);
letempty=None;

println!("show_value(full) -> {}",show_value(full));
println!("show_value(empty) -> {}",show_value(empty));
}

show_value(full) -> The value is: 42
show_value(empty) -> No value

Scala

Further information:Scala (programming language)

In Scala, the option type is defined assealedabstractclassOption[+A],a type extended byfinalcaseclassSome[+A](value:A)andcaseobjectNone.

objectMain:
defshowValue(opt:Option[Int]):String=
opt.fold("No value")(x=>s "The value is:$x")

defmain(args:Array[String]):Unit=
valfull=Some(42)
valempty=None

println(s "showValue(full) ->${showValue(full)}")
println(s "showValue(empty) ->${showValue(empty)}")

showValue(full) -> The value is: 42
showValue(empty) -> No value

Standard ML

Further information:Standard ML

In Standard ML, the option type is defined asdatatype'aoption=NONE|SOMEof'a.

Swift

Further information:Swift (programming language)

In Swift, the option type is defined asenumOptional<T>{casenone,some(T)}but is generally written asT?.

funcshowValue(_opt:Int?)->String{
returnopt.map{"The value is:\($0)"}??"No value"
}

letfull=42
letempty:Int?=nil

print("showValue(full) ->\(showValue(full))")
print("showValue(empty) ->\(showValue(empty))")

showValue(full) -> The value is: 42
showValue(empty) -> No value

Zig

Further information:Zig (programming language)

In Zig, add? before the type name like?i32to make it an optional type.

Payloadncan be captured in aniforwhilestatement, such asif(opt)|n|{...}else{...},and anelseclause is evaluated if it isnull.

conststd=@import("std");

fnshowValue(allocator:std.mem.Allocator,opt:?i32)![]u8{
returnif(opt)|n|
std.fmt.allocPrint(allocator,"The value is: {}",.{n})
else
allocator.dupe(u8,"No value");
}

pubfnmain()!void{
// Set up an allocator, and warn if we forget to free any memory.
vargpa=std.heap.GeneralPurposeAllocator(.{}){};
deferstd.debug.assert(gpa.deinit()==.ok);
constallocator=gpa.allocator();

// Prepare the standard output stream.
conststdout=std.io.getStdOut().writer();

// Perform our example.
constfull=42;
constempty=null;

constfull_msg=tryshowValue(allocator,full);
deferallocator.free(full_msg);
trystdout.print("showValue(allocator, full) -> {s}\n",.{full_msg});

constempty_msg=tryshowValue(allocator,empty);
deferallocator.free(empty_msg);
trystdout.print("showValue(allocator, empty) -> {s}\n",.{empty_msg});
}

showValue(allocator, full) -> The value is: 42
showValue(allocator, empty) -> No value

See also

• Result type
• Tagged union
• Nullable type
• Null object pattern
• Exception handling
• Pattern matching