Option

Sometimes it’s desirable to catch the failure of some parts of a program
instead of calling panic!; this can be accomplished using the Option enum.

The Option<T> enum has two variants:

  • None, to indicate failure or lack of value, and
  • Some(value), a tuple struct that wraps a value with type T.
  1. // An integer division that doesn't `panic!`
  2. fn checked_division(dividend: i32, divisor: i32) -> Option<i32> {
  3.     if divisor == 0 {
  4.         // Failure is represented as the `None` variant
  5.         None
  6.     } else {
  7.         // Result is wrapped in a `Some` variant
  8.         Some(dividend / divisor)
  9.     }
  10. }
  12. // This function handles a division that may not succeed
  13. fn try_division(dividend: i32, divisor: i32) {
  14.     // `Option` values can be pattern matched, just like other enums
  15.     match checked_division(dividend, divisor) {
  16.         None => println!("{} / {} failed!", dividend, divisor),
  17.         Some(quotient) => {
  18.             println!("{} / {} = {}", dividend, divisor, quotient)
  19.         },
  20.     }
  21. }
  23. fn main() {
  24.     try_division(4, 2);
  25.     try_division(1, 0);
  27.     // Binding `None` to a variable needs to be type annotated
  28.     let none: Option<i32> = None;
  29.     let _equivalent_none = None::<i32>;
  31.     let optional_float = Some(0f32);
  33.     // Unwrapping a `Some` variant will extract the value wrapped.
  34.     println!("{:?} unwraps to {:?}", optional_float, optional_float.unwrap());
  36.     // Unwrapping a `None` variant will `panic!`
  37.     println!("{:?} unwraps to {:?}", none, none.unwrap());
  38. }