Option type

This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these messages) This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Option type" – news · newspapers · books · scholar · JSTOR (July 2019) (Learn how and when to remove this message) This article possibly contains original research. Please improve it by verifying the claims made and adding inline citations. Statements consisting only of original research should be removed. (July 2019) (Learn how and when to remove this message) (Learn how and when to remove this message)

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?).

This section has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these messages) This section may contain information not important or relevant to the article's subject. Please help improve this section. (July 2019) (Learn how and when to remove this message) This section possibly contains original research. Please improve it by verifying the claims made and adding inline citations. Statements consisting only of original research should be removed. (August 2019) (Learn how and when to remove this message) (Learn how and when to remove this message)

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

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

An option type can also be seen as a collection containing either one or zero elements.^{[original research?]}

The option type is also a monad where:^[2]

return = Just -- Wraps the value into a maybe  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]

This section needs expansion with: example usage. You can help by adding to it. (July 2022)

In Agda, the option type is named Maybe with variants nothing and just a.

In ATS, the option type is defined as

datatype option_t0ype_bool_type (a: t@ype+, bool) =  	| Some(a, true) of a  	| None(a, false) stadef option = option_t0ype_bool_type typedef Option(a: t@ype) = [b:bool] option(a, b) 

#include "share/atspre_staload.hats"  fn show_value (opt: Option int): string = 	case+ opt of 	| None() => "No value" 	| Some(s) => tostring_int s  implement main0 (): void = let 	val full = Some 42 	and empty = None in 	println!("show_value full → ", show_value full); 	println!("show_value empty → ", show_value empty); end 

show_value full → 42 show_value empty → No value 

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

This section needs expansion with: example usage. You can help by adding to it. (July 2022)

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

This section needs expansion with: example usage. You can help by adding to it. (July 2022)

In Elm, the option type is defined as type Maybe a = Just a | Nothing.^[4]

In F#, the option type is defined as type 'a option = None | Some of 'a.^[5]

let showValue =     Option.fold (fun _ x -> sprintf "The value is: %d" x) "No value"  let full = Some 42 let empty = None  showValue full |> printfn "showValue full -> %s" showValue empty |> printfn "showValue empty -> %s" 

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

In Haskell, the option type is defined as data Maybe a = Nothing | Just a.^[6]

showValue :: Maybe Int -> String showValue = foldl (\_ x -> "The value is: " ++ show x) "No value"  main :: IO () main = do     let full = Just 42     let empty = Nothing      putStrLn $ "showValue full -> " ++ showValue full     putStrLn $ "showValue empty -> " ++ showValue empty 

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

In Idris, the option type is defined as data Maybe a = Nothing | Just a.

showValue : Maybe Int -> String showValue = foldl (\_, x => "The value is " ++ show x) "No value"  main : IO () main = do     let full = Just 42     let empty = Nothing      putStrLn $ "showValue full -> " ++ showValue full     putStrLn $ "showValue empty -> " ++ showValue empty 

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

This section needs expansion with: the definition. You can help by adding to it. (July 2022)

import std/options  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) 

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

In OCaml, the option type is defined as type 'a option = None | Some of 'a.^[7]

let show_value =   Option.fold ~none:"No value" ~some:(fun x -> "The value is: " ^ string_of_int x)  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) 

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

In Rust, the option type is defined as enum Option<T> { None, Some(T) }.^[8]

fn show_value(opt: Option<i32>) -> String {     opt.map_or("No value".to_owned(), |x| format!("The value is: {}", x)) }  fn main() {     let full = Some(42);     let empty = 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 

In Scala, the option type is defined as sealed abstract class Option[+A], a type extended by final case class Some[+A](value: A) and case object None.

object Main:   def showValue(opt: Option[Int]): String =     opt.fold("No value")(x => s"The value is: $x")    def main(args: Array[String]): Unit =     val full = Some(42)     val empty = None      println(s"showValue(full) -> ${showValue(full)}")     println(s"showValue(empty) -> ${showValue(empty)}") 

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

This section needs expansion with: example usage. You can help by adding to it. (July 2022)

In Standard ML, the option type is defined as datatype 'a option = NONE | SOME of 'a.

In Swift, the option type is defined as enum Optional<T> { case none, some(T) } but is generally written as T?.^[9]

func showValue(_ opt: Int?) -> String {     return opt.map { "The value is: \($0)" } ?? "No value" }  let full = 42 let empty: Int? = nil  print("showValue(full) -> \(showValue(full))") print("showValue(empty) -> \(showValue(empty))") 

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

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 if (opt) |n| { ... } else { ... }, and an else clause is evaluated if it is null.

const std = @import("std");  fn showValue(allocator: std.mem.Allocator, opt: ?i32) ![]u8 {     return if (opt) |n|         std.fmt.allocPrint(allocator, "The value is: {}", .{n})     else         allocator.dupe(u8, "No value"); }  pub fn main() !void {     // Set up an allocator, and warn if we forget to free any memory.     var gpa = std.heap.GeneralPurposeAllocator(.{}){};     defer std.debug.assert(gpa.deinit() == .ok);     const allocator = gpa.allocator();      // Prepare the standard output stream.     const stdout = std.io.getStdOut().writer();      // Perform our example.     const full = 42;     const empty = null;      const full_msg = try showValue(allocator, full);     defer allocator.free(full_msg);     try stdout.print("showValue(allocator, full) -> {s}\n", .{full_msg});      const empty_msg = try showValue(allocator, empty);     defer allocator.free(empty_msg);     try stdout.print("showValue(allocator, empty) -> {s}\n", .{empty_msg}); } 

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

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