Option型

プログラミング言語と型理論において、Option型（）またはMaybe型（）は存在しない可能性のある値をカプセル化して表すである。例えば、関数の戻り値が存在する場合と存在しない場合を表すためにこの型は使用される。この型は空またはオリジナルのデータ型codice_1をカプセルしたコンストラクタから構成されている。
関数型プログラミング以外において、全く異なるが関連する概念としてNullable型がオブジェクト指向プログラミングで一般的である。Option型とNullable型の主な違いは、Option型はネストすることができるのに対して、Nullable型はこれに対応していないことである。
理論的側面.
型理論において、Option型はformula_1のように記述することができる。これは与えられた値の組formula_2に対して、Option型はformula_2の有効な値の組に正確に1つの追加の値（空の値）を追加するという事実を表している。これはを持つ言語において、Option型がカプセル化型とのタグ付き共用体として表現できるという事実によってプログラミングに反映されている。
カリー＝ハワード同型対応において、Option型は∨: x∨1=1の消滅法則に関連している。
Option型もモナドであり、次のようになる:
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
Option型のモナディックな性質は、失敗とエラーを効率的に追跡するのに役立つ。
型名と定義.
それぞれのプログラミング言語において、Option型は様々な名前と定義がある。
例.
F#.
let compute =
 Option.fold (fun _ x -> sprintf "The value is: %d" x) "No value"
let full = Some 42
let empty = None
compute full |> printfn "compute full -> %s"
compute empty |> printfn "compute empty -> %s"
compute full -> The value is: 42
compute empty -> No value
Haskell.
compute :: Maybe Int -> String
compute = foldl (\_ x -> "The value is: " ++ show x) "No value"
main :: IO ()
main = do
 let full = Just 42
 let empty = Nothing
 putStrLn $ "compute full -> " ++ compute full
 putStrLn $ "compute empty -> " ++ compute empty
compute full -> The value is: 42
compute empty -> No value
Nim.
import std/options
proc compute(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 "compute(full) -> ", compute(full)
echo "compute(empty) -> ", compute(empty)
compute(full) -> The Value is: 42
compute(empty) -> No value
OCaml.
OCamlはcodice_2をパラメータ化された要素型として実装している。codice_2は次のように構築及び分解される:
let compute =
 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 ("compute full -> " ^ compute full);
 print_endline ("compute empty -> " ^ compute empty)
compute full -> The value is: 42
compute empty -> No value
Rust.
fn compute(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!("compute(full) -> {}", compute(full));
 println!("compute(empty) -> {}", compute(empty));
compute(full) -> The value is: 42
compute(empty) -> No value
Scala.
Scalaはcodice_2をパラメータ化された型として実装しているので、変数はcodice_2になることができ、次のようにアクセスできる:
object Main {
 def compute(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"compute(full) -> ${compute(full)}")
 println(s"compute(empty) -> ${compute(empty)}")
compute(full) -> The value is: 42
compute(empty) -> No value
codice_2の値を使用する方法は2つある。1つは、最良ではないが最初の例のようにパターンマッチングによる方法である。もう1つは、最良の方法である2番目の例のようなモナディックアプローチである。このように、プログラムは例外またはエラーを生成することができないので安全である。従って、これは基本的にnull値の型安全な代替手段として機能する。
Swift.
func compute(_ opt: Int?) -> String {
 return opt.map { "The value is: \($0)" } ?? "No value"
let full = 42
let empty: Int? = nil
print("compute(full) -> \(compute(full))")
print("compute(empty) -> \(compute(empty))")
compute(full) -> The value is: 42
compute(empty) -> No value
Zig.
const std = @import("std");
const print = std.io.getStdOut().writer().print;
const Compute = struct {
 value: ?i32,
 pub fn init(value: ?i32) Compute {
 return Compute{ .value = value };
 pub fn format(
 self: @This(),
 comptime fmt: []const u8,
 options: std.fmt.FormatOptions,
 out_stream: anytype,
 ) !void {
 _ = fmt;
 _ = options;
 if (self.value) |n| {
 return out_stream.print("The value is: {}", .{n});
 } else {
 return out_stream.print("No value", .{});
pub fn main() !void {
 const full = Compute.init(42);
 const empty = Compute.init(null);
 try print("full -> {}\n", .{full});
 try print("empty -> {}\n", .{empty});
full -> The value is: 42 
empty -> No value