Struct std::prelude::Option

Optional value

Optional values can either contain a value or they can be empty.

See also module-level documentation.

Example

let a = Option::some(1);
let b: Option<i32> = Option::none();

assert_eq!(a.is_some(), true);
assert_eq!(b.is_some(), false);
Run this example

Methods

• fn some(inner: T) -> Option<T>

  source

  Create a populated Option value

  Example

  let opt = Option::some(42);
  
  assert!(opt.is_some());
  assert_eq!(opt.unwrap(), 42);
  Run this example

• fn none() -> Option<T>

  source

  Create an empty Option value

  Example

  let opt: Option<i32> = Option::none();
  
  assert!(opt.is_none());
  Run this example

• fn is_some(self: &Option<T>) -> bool

  source

  Returns true if the option is populated, false otherwise.

• fn is_none(self: &Option<T>) -> bool

  source

  Returns true if the option is empty, false otherwise.

• fn unwrap(self: Option<T>) -> T

  source

  Returns a value, if present, panics otherwise.

  Examples

  assert_eq!(Option::some(42).unwrap(), 42);
  Run this example

  let opt: Option<i32> = Option::none();
  
  opt.unwrap(); // panics
  Run this example

• fn ok_or<E>(self: Option<T>, err: E) -> Result<T, E>

  source

  Convert the option into a Result.

  If the option is empty, the err value will be used for the error variant.

• fn ok_or_else<E, F>(self: Option<T>, f: F) -> Result<T, E>

  F: Fn() -> E

  source

  Convert the option into a Result.

  If the option is empty, the callback will be called to get the the error variant.

• fn unwrap_or(self: Option<T>, val: T) -> T

  source

  Returns a value, if present, otherwise return a default value.

  Example

  assert_eq!(Option::some(42).unwrap_or(1337), 42);
  assert_eq!(Option::none::<i32>().unwrap_or(1337), 1337);
  Run this example

• fn unwrap_or_else<F>(self: Option<T>, func: F) -> T

  F: Fn() -> T

  source

  Returns a value, if present, otherwise invoke func to get the default.

  Example

  let a = Option::some(42);
  let b: Option<i32> = Option::none();
  
  fn default() -> i32 {
      1337
  }
  
  assert_eq!(a.unwrap_or_else(default), 42);
  assert_eq!(b.unwrap_or_else(default), 1337);
  Run this example

• fn map<Tm, F>(self: Option<T>, func: F) -> Option<Tm>

  F: Fn(T) -> Tm

  source

  Transform the value inside the Option by calling the provided function.

  If the value is none, function is not called.

  Example

  let a = Option::some(42).map(|v: i32| -> i32 { v + 1 });
  let b = Option::none::<i32>().map(|v: i32| -> i32 { v + 1 });
  
  assert_eq!(a, Option::some(43));
  assert_eq!(b, Option::none());
  Run this example

• fn and<Tm>(self: Option<T>, other: Option<Tm>) -> Option<Tm>

  source

  If self is none, return none, otherwise return other

  Example

  let a = Option::some(42);
  let b = Option::some(true);
  let c = Option::none::<i32>();
  
  assert_eq!(a.and(b), Option::some(true));
  assert_eq!(a.and(c), Option::none());
  assert_eq!(c.and(a), Option::none());
  Run this example

• fn and_then<Tm, F>(self: Option<T>, func: F) -> Option<Tm>

  F: Fn(T) -> Option<Tm>

  source

  If self is none, return none, otherwise return the result of calling func.

  Example

  let a = Option::some(42)
      .and_then(|v: i32| -> Option<i32> {
          if v == 0 {
              Option::none()
          } else {
              Option::some(v + 1)
          }
      });
  
  assert_eq!(a, Option::some(43));
  Run this example

• fn or(self: Option<T>, other: Option<T>) -> Option<T>

  source

  Return self if it is populated, otherwise return other.

  Example

  let a = Option::some(42);
  let b = Option::none::<i32>();
  
  assert_eq!(a.or(b), Option::some(42));
  assert_eq!(b.or(a), Option::some(42));
  Run this example

• fn or_else<F>(self: Option<T>, func: F) -> Option<T>

  F: Fn() -> Option<T>

  source

  Return self if it is populated, otherwise return the result of calling func.

  Example

  let a = Option::some(42);
  let b = Option::none::<i32>();
  
  assert_eq!(
      a.or_else(|| -> Option<i32> { Option::none() }),
      Option::some(42)
  );
  assert_eq!(
      b.or_else(|| -> Option<i32> { Option::some(42) }),
      Option::some(42)
  );
  Run this example

• fn replace(self: &mut Option<T>, val: T) -> Option<T>

  source

  Replaces the value in the option by the value given in parameter, returning the old value if present.

  Example

  let a = Option::some(42);
  let b = Option::none::<i32>();
  
  assert_eq!(a.replace(1337), Option::some(42));
  assert_eq!(b.replace(1337), Option::none());
  
  assert_eq!(a, Option::some(1337));
  assert_eq!(b, Option::some(1337));
  Run this example

• fn as_nullable_ptr(self: &Option<T>) -> &T

  source

  Returns pointer to inner or a null pointer if not present.

  Example

  let a = Option::some(42);
  let b = Option::none::<i32>();
  
  assert_eq!(*a.as_nullable_ptr(), 42);
  assert_eq!(b.as_nullable_ptr(), null);
  Run this example

• fn as_ptr(self: &Option<T>) -> Option<&T>

  source

  Transform a pointer to Option to an Option of pointer.

  Example

  let a = Option::some(42);
  
  let b = a.as_ptr();
  assert_eq!(*b.unwrap(), 42);
  
  a = Option::some(1337);
  assert_eq!(*b.unwrap(), 1337);
  Run this example

• fn as_mut_ptr(self: &mut Option<T>) -> Option<&mut T>

  source

  Transform a mutable pointer to Option to an Option of mutable pointer.

  Example

  let a = Option::some(42);
  
  *a.as_mut_ptr().unwrap() = 1337;
  
  assert_eq!(a, Option::some(1337));
  Run this example

• fn flatten(self: Option<Option<T>>) -> Option<T>

  source

  Flattens a nested Option into a single Option.

  Example

  assert_eq!(Option::some(Option::some(42)).flatten(), Option::some(42));
  assert_eq!(Option::some(Option::none::<i32>()).flatten(), Option::none());
  assert_eq!(Option::none::<Option<i32>>().flatten(), Option::none());
  Run this example

• fn zip<O>(self: Option<T>, other: Option<O>) -> Option<(T, O)>

  source

  Merges two Options into an Option of a tuple.

  If either self or other is none, the result is none.

  Example

  let a = Option::some(42);
  let b = Option::some(1337);
  
  assert_eq!(a.zip(b), Option::some((42, 1337)));
  Run this example

• fn debug_fmt<F>(self: &Option<T>, formatter: &mut F) -> Result

  F: Formatter<F>

  source

  Write the debug representation object into a given formatter.

  See Formattable for details.

• fn iter(self: &Option<T>) -> OnceIterator<T>

  source

  Returns an iterator over the elements of this iterable.

  See Iterable for details.

• fn move(self: &mut Option<T>) -> Option<T>

  source

  Creates a copy of the object, leaving an inert object behind.

  See Movable for details.

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

  source

  Convert Option<Result<T, E>> to Result<Option<T>, E>

  See also transpose for the reverse operation.

  Example

  assert_eq!(
      Option::some(Result::ok::<i32, ()>(42)).transpose(),
      Result::ok(Option::some(42))
  );
  assert_eq!(
      Option::some(Result::err::<i32, ()>(())).transpose(),
      Result::err(())
  );
  assert_eq!(
      Option::none::<Result<i32, ()>>().transpose(),
      Result::ok(Option::none())
  );
  Run this example

• fn hash<T, H>(self: &Option<T>, hasher: &mut H)

  T: Hashable<T, H>

  H: Hasher<H>

  source

  Update hasher state with the contents of this object.

  See Hashable for details.

• fn equals<T>(lhs: &Option<T>, rhs: &Option<T>) -> bool

  T: Equatable<T>

  source

  Returns true if arguments are equal, false otherwise

  See Equatable for details.

• fn compare<T>(lhs: &Option<T>, rhs: &Option<T>) -> Ordering

  T: Comparable<T>

  source

  Compare the value

  See Comparable for details.

• fn fmt<T, F>(self: &Option<T>, formatter: &mut F) -> Result

  T: Formattable<T, F>

  F: Formatter<F>

  source

  Write the object into a given formatter.

  See Formattable for details.

• fn free<T>(self: &mut Option<T>)

  T: Freeable<T>

  source

  Frees the memory backing the object.

Protocols

Macros

Mixins

• mixin<T> Equatable<Option<T>>

  T: Equatable<T>

• fn not_equals(lhs: &Self, rhs: &Self) -> bool

  source

  Returns false if arguments are equal, true otherwise

• mixin<T> Comparable<Option<T>>

  T: Comparable<T>

• fn less_than(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs is strictly less than rhs, false otherwise

• fn less_than_or_equal(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs is less or equal to rhs, false otherwise

• fn greater_than(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs strictly greater than rhs, false otherwise

• fn greater_than_or_equal(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs greater than or equal rhs, false otherwise