Option型のソースを表示

{{翻訳直後|1={{revision|:en:Option type|1092448390|英語版 "Option type" 2022年6月10日 (金) 10:23 (UTC)}}|date=2022-06}}
{{複数の問題
| 出典の明記 = July 2019
| 独自研究 = July 2019
}}

[[プログラミング言語]]{{efn|特に[[関数型プログラミング]]言語において。}}と[[型理論]]において、'''Option型'''（{{lang-en|Option type}}）または'''Maybe型'''（{{lang-en|Maybe type}}）は存在しない可能性のある値をカプセル化して表す{{ill|パラメトリック多相|en|parametric polymorphism|label=多相型}}である。例えば、関数の戻り値が存在する場合と存在しない場合を表すためにこの型は使用される。この型は空{{efn|多くの場合、<code>None</code>または<code>Nothing</code>という名前。}}またはオリジナルのデータ型<code>A</code>をカプセルした{{efn|多くの場合、<code>Just A</code>または<code>Some A</code>と書かれる。}}コンストラクタから構成されている。

関数型プログラミング以外において、全く異なるが関連する概念として[[Nullable型]]{{efn|多くの場合、<code>A?</code>として表される。}}が[[オブジェクト指向プログラミング]]で一般的である。Option型とNullable型の主な違いは、Option型はネストすることができる{{efn|例えば、<code>Maybe (Maybe String)</code> ≠ <code>Maybe String</code>。}}のに対して、Nullable型はこれに対応していない{{efn|例えば、<code>String??</code> {{=}} <code>String?</code>。}}ことである。

== 理論的側面 ==
{{複数の問題
| section = 1
| 内容過剰 = July 2019
| 独自研究 = August 2019
}}

[[型理論]]において、Option型は<math>A^{?} = A + 1</math>のように記述することができる。これは与えられた値の組<math>A</math>に対して、Option型は<math>A</math>の有効な値の組に正確に1つの追加の値（空の値）を追加するという事実を表している。これは{{ill|タグ付き共用体|en|Tagged union}}を持つ言語において、Option型がカプセル化型と{{ill|Unit型|en|unit type}}のタグ付き共用体として表現できるという事実によってプログラミングに反映されている<ref>{{cite web|url=https://bartoszmilewski.com/2015/01/13/simple-algebraic-data-types/|title=Simple Algebraic Data Types|last=Milewski|first=Bartosz|date=2015-01-13|website=Bartosz Milewski's Programming Cafe|at=Sum types. "We could have encoded Maybe as: data Maybe a = Either () a"|language=en|archive-url=https://web.archive.org/web/20190818084741/https://bartoszmilewski.com/2015/01/13/simple-algebraic-data-types/|archive-date=2019-08-18|url-status=live|access-date=2019-08-18}}</ref>。

[[カリー＝ハワード同型対応]]において、Option型は∨: x∨1=1の[[吸収法則|消滅法則]]に関連している{{How|date=August 2019|title=It is unclear how this is the case, and there are no links to external references that explain this.}}。

{{Original research inline|Option型は1個または0個の要素を含む{{ill|コレクション (抽象データ型)|en|collection (abstract data type)|label=コレクション}}と見なすこともできる|date=July 2019}}。

Option型も[[モナド (プログラミング)#Maybeモナド|モナド]]であり、次のようになる<ref>{{cite web|url=http://www.learnyouahaskell.com/a-fistful-of-monads|title=A Fistful of Monads - Learn You a Haskell for Great Good!|website=www.learnyouahaskell.com|access-date=2019-08-18}}</ref>:

<syntaxhighlight lang="haskell">
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
</syntaxhighlight>

Option型のモナディックな性質は、失敗とエラーを効率的に追跡するのに役立つ<ref>{{cite web|url=https://www.youtube.com/watch?v=t1e8gqXLbsU |archive-url=https://ghostarchive.org/varchive/youtube/20211220/t1e8gqXLbsU |archive-date=2021-12-20 |url-status=live|title=What is a Monad?|last=Hutton|first=Graham|date=Nov 25, 2017|website=Computerphile Youtube|access-date=Aug 18, 2019}}{{cbignore}}</ref>。

== 型名と定義 ==
それぞれのプログラミング言語において、Option型は様々な名前と定義がある。

* [[Agda]]では、{{code|2=agda|nothing}}と{{code|2=agda|just a}}という要素を持ち、{{code|2=agda|Maybe}}という名前で定義されている。
* [[Coq]]では、{{code|2=coq|1=Inductive option (A:Type) : Type := {{!}} Some : A -> option A {{!}} None : option A. }}として定義されている。
* [[Elm (プログラミング言語)|Elm]]では、{{code|Maybe|elm}}という名前で{{code|2=elm|1=type Maybe a = Just a {{!}} Nothing}}として定義されている<ref>{{cite web |title=Maybe · An Introduction to Elm |url=https://guide.elm-lang.org/error_handling/maybe.html |website=guide.elm-lang.org|accessdate=2022-06-11}}</ref>。
* [[Haskell]]では、{{code|Maybe|haskell}}という名前で{{code|2=haskell|1=data Maybe a = Nothing {{!}} Just a}}として定義されている。
* {{ill|Idris|en|Idris (programming language)}}では、{{code|2=idris|1=data Maybe a = Nothing {{!}} Just a}}として定義されている。
* [[OCaml]]では、{{code|2=ocaml|1=type 'a option = None {{!}} Some of 'a}}として定義されている。
* [[Python]]では、3.10以降で{{code|2=python|1=typing.Optional[T]}}または{{code|2=python|1=T {{!}} None}}{{efn|[[wiktionary:type hinting|型ヒント]]を介して。}}として示される。
* [[Rust (プログラミング言語)|Rust]]では、{{code|2=rust|enum Option<T> { None, Some(T) } }}として定義されている。
* [[Scala]]では、{{code|2=scala|1=final case class Some[+A](value: A)}}と{{code|2=scala|1=case object None}}の型拡張によって、{{code|2=scala|1=sealed abstract class Option[+A]}}として定義されている。
* [[Standard ML]]では、{{code|2=sml|1=datatype 'a option = NONE {{!}} SOME of 'a}}として定義されている。
* [[Swift (プログラミング言語)|Swift]]では、{{code|2=swift|enum Optional<T> { case none, some(T) } }}として定義されているが、通常は{{code|2=swift|T?}}として記述される<ref>{{cite web|title=Apple Developer Documentation|url=https://developer.apple.com/documentation/swift/optional|access-date=2020-09-06|website=developer.apple.com}}</ref>。

== 例 ==
<!--
Gentle reminder to not add language examples that do not satisfy the laws.
If you do not know what this means, please refrain from adding examples.

List of things that are NOT option types and therefore do not need to be added:
- std::optional<T> in C++
- Nullable<T> (T?) in C#
- Null (T?) in Dart
- Optional<T> in Java
- Nullable{T} in Julia
- Nullable types (T?) in Kotlin
- Definiteness (:D) in Raku
-->

=== F# ===
;コード例:<syntaxhighlight lang="fsharp">
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"
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="output">
compute full -> The value is: 42
compute empty -> No value
</syntaxhighlight>

=== Haskell ===
;コード例:<syntaxhighlight lang="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
</syntaxhighlight>

;実行結果:<syntaxhighlight lang="output">
compute full -> The value is: 42
compute empty -> No value
</syntaxhighlight>

=== Nim ===
;コード例:<syntaxhighlight lang="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)
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="output">
compute(full) -> The Value is: 42
compute(empty) -> No value
</syntaxhighlight>

=== OCaml ===
[[OCaml]]は<code>Option</code>をパラメータ化された要素型として実装している。<code>Option</code>は次のように構築及び分解される:

;コード例:<syntaxhighlight lang="ocaml">
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)
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="output">
compute full -> The value is: 42
compute empty -> No value
</syntaxhighlight>

=== Rust ===
;コード例:<syntaxhighlight lang="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));
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="output">
compute(full) -> The value is: 42
compute(empty) -> No value
</syntaxhighlight>

=== Scala ===
[[Scala]]は<code>Option</code>をパラメータ化された型として実装しているので、変数は<code>Option</code>になることができ、次のようにアクセスできる<ref name="OderskySpoon2008">{{cite book|author1=Martin Odersky|author2=Lex Spoon|author3=Bill Venners|title=Programming in Scala|url=https://books.google.com/books?id=MFjNhTjeQKkC&pg=PA283|access-date=6 September 2011|year=2008|publisher=Artima Inc|isbn=978-0-9815316-0-1|pages=282–284}}</ref>:

;コード例:<syntaxhighlight lang="scala">
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)}")
  }
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="output">
compute(full) -> The value is: 42
compute(empty) -> No value
</syntaxhighlight>

<code>Option</code>の値を使用する方法は2つある。1つは、最良ではないが最初の例のように[[パターンマッチング]]による方法である。もう1つは、最良の方法である2番目の例のようなモナディックアプローチである。このように、プログラムは例外またはエラーを生成することができない{{efn|例えば<code>None</code>と等しい<code>Option</code>変数の値を取得しようとすることによって。}}ので安全である。従って、これは基本的にnull値の型安全な代替手段として機能する。

=== Swift ===
;コード例:<syntaxhighlight lang="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))")
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="output">
compute(full) -> The value is: 42
compute(empty) -> No value
</syntaxhighlight>

=== Zig ===
;コード例:<syntaxhighlight lang="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});
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="output">
full -> The value is: 42 
empty -> No value
</syntaxhighlight>
:Zigでは、<code>?i32</code> の様に型名の前に ? を追加するとOptional型となる。
:<code>if (opt) |n| {</code> の様に if 文、あるいは while文でペイロード n をキャプチャーすることができ、null の場合 else 節が評価される。

== 脚注 ==
=== 注釈 ===
{{Notelist}}

=== 出典 ===
{{Reflist}}

== 関連項目 ==
* [[Result型]]
* {{ill|タグ付き共用体|en|Tagged union}}
* [[Nullable型]]
* {{ill|Nullオブジェクトパターン|en|Null object pattern}}
* [[例外処理]]
* [[パターンマッチング]]

{{データ型}}

{{DEFAULTSORT:Optionかた}}
[[Category:関数型プログラミング]]
[[Category:データ型]]
[[Category:型理論]]