Rust Option列挙型

Rustのstd::option::Optionのメモ。

概要

Option列挙型は、値が存在しない場合があることを表す列挙型。
Option列挙型はstd::preludeに含まれているので、useしなくても使える。

Optionインスタンスを作るには、値がある場合はSomeを使い、値が無い場合はNoneを使う。

    // 値を保持
    let opt = Some(123);
    println!("{:?} {}", opt, opt.is_some()); // →true

    // 値が無い
    let opt: Option<i32> = None;
    println!("{:?} {}", opt, opt.is_some()); // →false

Optionの実装のされ方

RustのOptionは列挙型で実装されている。
JavaのOptionalはひとつのクラスのみで定義され、ScalaのOptionは抽象クラスでSomeとNoneはそれを継承した別々のクラスになっている。
各言語がそれぞれの機能を駆使して実装しているのが面白い。

※以下のコードは、元のソースから分かりやすいように切り出したり変更したりしたもの

pub enum Option<T> {
    None,
    Some(T),
}

public final class Optional<T> {

    private static final Optional<?> EMPTY = new Optional<>(null);

    public static<T> Optional<T> empty() {
        return (Optional<T>) EMPTY;
    }

    public static <T> Optional<T> of(T value) {
        return new Optional<>(Objects.requireNonNull(value));
    }

    private final T value;

    private Optional(T value) {	// コンストラクター
        this.value = value;
    }
〜
}

sealed abstract class Option[+A]  {
  〜
}

final case class Some[+A](value: A) extends Option[A] {
  〜
}

case object None extends Option[Nothing] {
  〜
}

let s = Some(123);

var s = Optional.of(123);

val s = Some(123)

let s1: Option<i32> = None;
let s2 = None as Option<i32>;

Optional<Integer> s1 = Optional.empty();
var s2 = Optional.<Integer>empty();

val s1: Option[Int] = None
val s2 = None: Option[Int]

pub const fn is_some(&self) -> bool {
    matches!(*self, Some(_))
}

pub const fn is_none(&self) -> bool {
    !self.is_some()
}

public boolean isPresent() {
    return this.value != null;
}

public boolean isEmpty() {
    return this.value == null;
}

final def isDefined: Boolean = !isEmpty

final def isEmpty: Boolean = this eq None

pub const fn is_some(&self) -> bool {
    match *self {
        Some(_) => true,
        _ => false
    }
}

pub const fn unwrap(self) -> T {
    match self {
        Some(val) => val,
        None => unwrap_failed(),
    }
}

public T get() {
    if (this.value == null) {
        throw new NoSuchElementException("No value present");
    }
    return this.value;
}

// class Some
  def get: A = value

// object None
  def get: Nothing = throw new NoSuchElementException("None.get")

Optionのメソッド

Option<T>のメソッド（抜粋）。[2024-10-03]

その他に、Option<T>のTが特定の条件の場合だけ使用できるメソッドもある。

TがCloneトレイトを実装している場合

TがCloneトレイトを実装していると、Optionでcloneメソッドが使用できる。

clone(&self) -> Self

「Some(t)」に対して「Some(tのクローン)」が欲しい時に便利。

use std::rc::Rc;	// RcはCloneを実装している

struct MyStruct;

    let rc = Rc::new(MyStruct {});
    let opt: Option<Rc<MyStruct>> = Some(rc);
    let clo: Option<Rc<MyStruct>> = opt.clone();

クローン（複製）したので、cloはoptとは別の所有権になる。

Tが参照でCloneトレイトを実装している場合は、clonedメソッドが使用できる。[2025-08-21]
clonedメソッドは、Option<&U>に対してOption<U>を返す。（UがCloneトレイトを実装している必要がある）

Option<Result<T, E>>の場合

Option<Result<T, E>>だと、Optionでtransposeメソッドが使用でき、Result<Option<T>, E>に変換できる。

transpose(self) -> Result<Option<T>, E>

    let opt: Option<Result<i32, String>> = Some(Ok(123));
    let r:   Result<Option<i32>, String> = opt.transpose();

Option<Option<T>>の場合

Option<Option<T>>だと、Optionでflattenメソッドが使用できる。

flatten(self) -> Option<T>

    let opt = Some(Some(123));
    let flat = opt.flatten();
    assert_eq!(Some(123), flat);

TがPartialOrdやPartialEqトレイトを実装している場合

Tが演算子用のPartialOrdやPartialEqトレイト等を実装していると、Optionのまま大小比較や等値比較が出来る。
この場合、Noneが最小の値として扱われる。

    let some = Some(123);
    let s100 = Some(100);
    let none: Option<i32> = None;
    assert_eq!(true, s100 < some);
    assert_eq!(true, none < s100);

Optionと ?演算子

Resultで「?演算子」が使えるのと同様に、Optionでも?演算子を使うことが出来る。

Optionの?演算子は、Someのときはそれが保持している値を返し、NoneのときはNoneをreturnする（関数からNoneを返す）。

fn func1() -> Option<i32> {
    let n = func2()?;
    Some(n + 1)
}

fn func2() -> Option<i32> {
    None
}

Optionから値を取得する例

Optionから値を取得する例。[2025-08-22]

fn func(o: Option<i32>) {
  let n = o.unwrap(); // n: i32
  println!("{}", n);
}

fn func(o: Option<i32>) -> Option<String> {
  let n = o?;         // n: i32
  println!("{}", n);
  〜
}

struct MyStruct {
  value: Option<String>,
}

impl MyStruct {
  fn test(&mut self) {
    println!("before {:?}", self.value);

    let t = self.value.take(); // t: Option<String>
    println!("take   {:?}", t);

    println!("after  {:?}", self.value); // None
  }
}

fn func(o: Option<i32>) {
  match o {
    Some(n) => println!("{}", n),
    None => println!("none"),
  }
}

fn func(o: Option<i32>) {
  if let Some(n) = o {
    println!("{}", n);
  }
}

fn func(o: Option<String>) {
  match &o {
    Some(s) => println!("{}", s), // s: &String
    None => println!("none"),
  }
  println!("{:?}", o); // 2つめのprintln
}

fn func(o: Option<String>) {
  match o.as_ref() {
    Some(s) => println!("{}", s), // s: &String
    None => println!("none"),
  }
  println!("{:?}", o); // 2つめのprintln
}

fn func(o: Option<String>) {
  match o {
    Some(ref s) => println!("{}", s), // s: &String
    None => println!("none"),
  }
  println!("{:?}", o); // 2つめのprintln
}

構造体のOptionフィールドを取得する例

構造体のOptionフィールドを取得する例。[2024-10-03]

Option<T>のTが参照でない場合

struct MyCommon {}

struct MyOpt {
    field: Option<MyCommon>
}

    let mut opt = MyOpt { field: None };
    opt.field = Some(MyCommon {});

impl MyOpt {
    pub fn field(&self) -> Result<&MyCommon, &str> {
        self.field.as_ref().ok_or("field is None")
    }

    pub fn field_mut(&mut self) -> Result<&mut MyCommon, &str> {
        self.field.as_mut().ok_or("field is None")
    }
}

Option<T>のTが不変参照の場合

struct MyOpt<'a> {
    field: Option<&'a MyCommon>,
}

    let mut opt = MyOpt { field: None };
    opt.field = Some(&MyCommon {});

impl<'a> MyOpt<'a> {
    pub fn field(&self) -> Result<&MyCommon, &str> {
        self.field.ok_or("field is None")
    }
}

Option<T>のTが可変参照の場合

struct MyOpt<'a> {
    field: Option<&'a mut MyCommon>,
}

    let mut opt = MyOpt { field: None };
    let mut common = MyCommon {};
    opt.field = Some(&mut common);	// 可変参照の場合、直接「&mut MyCommon{}」とは書けない

impl<'a> MyOpt<'a> {
    pub fn field(&self) -> Result<&MyCommon, &str> {
        self.field.as_deref().ok_or("field is None")
    }

    pub fn field_mut(&mut self) -> Result<&mut MyCommon, &str> {
        self.field.as_deref_mut().ok_or("field is None")
    }
}

Option<T>のTがCloneを実装している場合

Cloneトレイトを実装しているRcの例。

use std::rc::Rc;

struct MyOpt {
    field: Option<Rc<MyCommon>>,
}

    let mut opt = MyOpt { field: None };
    opt.field = Some(Rc::new(MyCommon {}));

impl MyOpt {
    pub fn field(&self) -> Result<Rc<MyCommon>, &str> {
        self.field.clone().ok_or("field is None")
    }
}