std::option::Option - Rust (original) (raw)

Enum std::option::Option1.0.0 [−] [src]

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

No value

Some value T

`impl<T> [Option](../../std/option/enum.Option.html "enum std::option::Option")<T>`[src]

`pub fn [is_some](#method.is%5Fsome)(&self) -> [bool](../primitive.bool.html)`[src]

Returns true if the option is a Some value.

let x: Option = Some(2); assert_eq!(x.is_some(), true);

let x: Option = None; assert_eq!(x.is_some(), false);Run

`pub fn [is_none](#method.is%5Fnone)(&self) -> [bool](../primitive.bool.html)`[src]

Returns true if the option is a None value.

let x: Option = Some(2); assert_eq!(x.is_none(), false);

let x: Option = None; assert_eq!(x.is_none(), true);Run

`pub fn [as_ref](#method.as%5Fref)(&self) -> [Option](../../std/option/enum.Option.html "enum std::option::Option")<[&](../primitive.reference.html)T>`[src]

Converts from Option<T> to Option<&T>.

Convert an Option<String> into an Option<usize>, preserving the original. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an Option to a reference to the value inside the original.

let num_as_str: Option = Some("10".to_string());

let num_as_int: Option = num_as_str.as_ref().map(|n| n.len()); println!("still can print num_as_str: {:?}", num_as_str);Run

`pub fn [as_mut](#method.as%5Fmut)(&mut self) -> [Option](../../std/option/enum.Option.html "enum std::option::Option")<[&mut ](../primitive.reference.html)T>`[src]

Converts from Option<T> to Option<&mut T>.

let mut x = Some(2); match x.as_mut() { Some(v) => *v = 42, None => {}, } assert_eq!(x, Some(42));Run

`pub fn [expect](#method.expect)(self, msg: &[str](../primitive.str.html)) -> T`[src]

Unwraps an option, yielding the content of a Some.

Panics if the value is a None with a custom panic message provided bymsg.

let x = Some("value"); assert_eq!(x.expect("the world is ending"), "value");Run

let x: Option<&str> = None; x.expect("the world is ending"); Run

`pub fn [unwrap](#method.unwrap)(self) -> T`[src]

Moves the value v out of the Option<T> if it is Some(v).

In general, because this function may panic, its use is discouraged. Instead, prefer to use pattern matching and handle the Nonecase explicitly.

Panics if the self value equals None.

let x = Some("air"); assert_eq!(x.unwrap(), "air");Run

let x: Option<&str> = None; assert_eq!(x.unwrap(), "air"); Run

`pub fn [unwrap_or](#method.unwrap%5For)(self, def: T) -> T`[src]

Returns the contained value or a default.

Arguments passed to unwrap_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use unwrap_or_else, which is lazily evaluated.

assert_eq!(Some("car").unwrap_or("bike"), "car"); assert_eq!(None.unwrap_or("bike"), "bike");Run

`pub fn unwrap_or_else(self, f: F) -> T where

F: FnOnce() -> T, `[src]

Returns the contained value or computes it from a closure.

let k = 10; assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4); assert_eq!(None.unwrap_or_else(|| 2 * k), 20);Run

`pub fn map<U, F>(self, f: F) -> Option where

F: FnOnce(T) -> U, `[src]

Maps an Option<T> to Option<U> by applying a function to a contained value.

Convert an Option<String> into an Option<usize>, consuming the original:

let maybe_some_string = Some(String::from("Hello, World!"));

let maybe_some_len = maybe_some_string.map(|s| s.len());

assert_eq!(maybe_some_len, Some(13));Run

`pub fn map_or<U, F>(self, default: U, f: F) -> U where

F: FnOnce(T) -> U, `[src]

Applies a function to the contained value (if any), or returns the provided default (if not).

let x = Some("foo"); assert_eq!(x.map_or(42, |v| v.len()), 3);

let x: Option<&str> = None; assert_eq!(x.map_or(42, |v| v.len()), 42);Run

`pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U where

D: FnOnce() -> U,
F: FnOnce(T) -> U, `[src]

Applies a function to the contained value (if any), or computes a default (if not).

let k = 21;

let x = Some("foo"); assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 3);

let x: Option<&str> = None; assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 42);Run

`pub fn [ok_or](#method.ok%5For)<E>(self, err: E) -> [Result](../../std/result/enum.Result.html "enum std::result::Result")<T, E>`[src]

Transforms the Option<T> into a Result<T, E>, mapping Some(v) toOk(v) and None to Err(err).

Arguments passed to ok_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use ok_or_else, which is lazily evaluated.

let x = Some("foo"); assert_eq!(x.ok_or(0), Ok("foo"));

let x: Option<&str> = None; assert_eq!(x.ok_or(0), Err(0));Run

`pub fn ok_or_else<E, F>(self, err: F) -> Result<T, E> where

F: FnOnce() -> E, `[src]

Transforms the Option<T> into a Result<T, E>, mapping Some(v) toOk(v) and None to Err(err()).

let x = Some("foo"); assert_eq!(x.ok_or_else(|| 0), Ok("foo"));

let x: Option<&str> = None; assert_eq!(x.ok_or_else(|| 0), Err(0));Run

ⓘImportant traits for Iter<'a, A>

pub fn [iter](#method.iter)(&self) -> [Iter](../../std/option/struct.Iter.html "struct std::option::Iter")<T>[src]

Returns an iterator over the possibly contained value.

let x = Some(4); assert_eq!(x.iter().next(), Some(&4));

let x: Option = None; assert_eq!(x.iter().next(), None);Run

ⓘImportant traits for IterMut<'a, A>

pub fn [iter_mut](#method.iter%5Fmut)(&mut self) -> [IterMut](../../std/option/struct.IterMut.html "struct std::option::IterMut")<T>[src]

Returns a mutable iterator over the possibly contained value.

let mut x = Some(4); match x.iter_mut().next() { Some(v) => *v = 42, None => {}, } assert_eq!(x, Some(42));

let mut x: Option = None; assert_eq!(x.iter_mut().next(), None);Run

`pub fn [and](#method.and)<U>(self, optb: [Option](../../std/option/enum.Option.html "enum std::option::Option")<U>) -> [Option](../../std/option/enum.Option.html "enum std::option::Option")<U>`[src]

Returns None if the option is None, otherwise returns optb.

let x = Some(2); let y: Option<&str> = None; assert_eq!(x.and(y), None);

let x: Option = None; let y = Some("foo"); assert_eq!(x.and(y), None);

let x = Some(2); let y = Some("foo"); assert_eq!(x.and(y), Some("foo"));

let x: Option = None; let y: Option<&str> = None; assert_eq!(x.and(y), None);Run

`pub fn and_then<U, F>(self, f: F) -> Option where

F: FnOnce(T) -> Option, `[src]

Returns None if the option is None, otherwise calls f with the wrapped value and returns the result.

Some languages call this operation flatmap.

fn sq(x: u32) -> Option { Some(x * x) } fn nope(_: u32) -> Option { None }

assert_eq!(Some(2).and_then(sq).and_then(sq), Some(16)); assert_eq!(Some(2).and_then(sq).and_then(nope), None); assert_eq!(Some(2).and_then(nope).and_then(sq), None); assert_eq!(None.and_then(sq).and_then(sq), None);Run

`pub fn filter
(self, predicate: P) -> Option where

P: FnOnce(&T) -> bool, `[src]

🔬 This is a nightly-only experimental API. (option_filter #45860)

Returns None if the option is None, otherwise calls predicatewith the wrapped value and returns:

Some(t) if predicate returns true (where t is the wrapped value), and
None if predicate returns false.

This function works similar to Iterator::filter(). You can imagine the Option<T> being an iterator over one or zero elements. filter()lets you decide which elements to keep.

#![feature(option_filter)]

fn is_even(n: &i32) -> bool { n % 2 == 0 }

assert_eq!(None.filter(is_even), None); assert_eq!(Some(3).filter(is_even), None); assert_eq!(Some(4).filter(is_even), Some(4));Run

`pub fn [or](#method.or)(self, optb: [Option](../../std/option/enum.Option.html "enum std::option::Option")<T>) -> [Option](../../std/option/enum.Option.html "enum std::option::Option")<T>`[src]

Returns the option if it contains a value, otherwise returns optb.

Arguments passed to or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use or_else, which is lazily evaluated.

let x = Some(2); let y = None; assert_eq!(x.or(y), Some(2));

let x = None; let y = Some(100); assert_eq!(x.or(y), Some(100));

let x = Some(2); let y = Some(100); assert_eq!(x.or(y), Some(2));

let x: Option = None; let y = None; assert_eq!(x.or(y), None);Run

`pub fn or_else(self, f: F) -> Option where

F: FnOnce() -> Option, `[src]

Returns the option if it contains a value, otherwise calls f and returns the result.

fn nobody() -> Option<&'static str> { None } fn vikings() -> Option<&'static str> { Some("vikings") }

assert_eq!(Some("barbarians").or_else(vikings), Some("barbarians")); assert_eq!(None.or_else(vikings), Some("vikings")); assert_eq!(None.or_else(nobody), None);Run

`pub fn [get_or_insert](#method.get%5For%5Finsert)(&mut self, v: T) -> [&mut ](../primitive.reference.html)T`

1.20.0

[src]

Inserts v into the option if it is None, then returns a mutable reference to the contained value.

let mut x = None;

{ let y: &mut u32 = x.get_or_insert(5); assert_eq!(y, &5);

*y = 7;

}

assert_eq!(x, Some(7));Run

`pub fn get_or_insert_with(&mut self, f: F) -> &mut T where

F: FnOnce() -> T, `

1.20.0

[src]

Inserts a value computed from f into the option if it is None, then returns a mutable reference to the contained value.

let mut x = None;

{ let y: &mut u32 = x.get_or_insert_with(|| 5); assert_eq!(y, &5);

*y = 7;

}

assert_eq!(x, Some(7));Run

`pub fn [take](#method.take)(&mut self) -> [Option](../../std/option/enum.Option.html "enum std::option::Option")<T>`[src]

Takes the value out of the option, leaving a None in its place.

let mut x = Some(2); x.take(); assert_eq!(x, None);

let mut x: Option = None; x.take(); assert_eq!(x, None);Run

`impl<'a, T> Option<&'a T> where

T: Clone, `[src]

`pub fn [cloned](#method.cloned)(self) -> [Option](../../std/option/enum.Option.html "enum std::option::Option")<T>`[src]

Maps an Option<&T> to an Option<T> by cloning the contents of the option.

let x = 12; let opt_x = Some(&x); assert_eq!(opt_x, Some(&12)); let cloned = opt_x.cloned(); assert_eq!(cloned, Some(12));Run

`impl<'a, T> Option<&'a mut T> where

T: Clone, `[src]

`pub fn [cloned](#method.cloned-1)(self) -> [Option](../../std/option/enum.Option.html "enum std::option::Option")<T>`[src]

🔬 This is a nightly-only experimental API. (option_ref_mut_cloned #43738)

Maps an Option<&mut T> to an Option<T> by cloning the contents of the option.

#![feature(option_ref_mut_cloned)] let mut x = 12; let opt_x = Some(&mut x); assert_eq!(opt_x, Some(&mut 12)); let cloned = opt_x.cloned(); assert_eq!(cloned, Some(12));Run

`impl Option where

T: Default, `[src]

`pub fn [unwrap_or_default](#method.unwrap%5For%5Fdefault)(self) -> T`[src]

Returns the contained value or a default

Consumes the self argument then, if Some, returns the contained value, otherwise if None, returns the default value for that type.

Convert a string to an integer, turning poorly-formed strings into 0 (the default value for integers). parse converts a string to any other type that implements FromStr, returningNone on error.

let good_year_from_input = "1909"; let bad_year_from_input = "190blarg"; let good_year = good_year_from_input.parse().ok().unwrap_or_default(); let bad_year = bad_year_from_input.parse().ok().unwrap_or_default();

assert_eq!(1909, good_year); assert_eq!(0, bad_year);Run

`impl<T, E> [Option](../../std/option/enum.Option.html "enum std::option::Option")<[Result](../../std/result/enum.Result.html "enum std::result::Result")<T, E>>`[src]

`pub fn [transpose](#method.transpose)(self) -> [Result](../../std/result/enum.Result.html "enum std::result::Result")<[Option](../../std/option/enum.Option.html "enum std::option::Option")<T>, E>`[src]

🔬 This is a nightly-only experimental API. (transpose_result #47338)

Transposes an Option of a Result into a Result of an Option.

None will be mapped to Ok(None).Some(Ok(_)) and Some(Err(_)) will be mapped to Ok(Some(_)) and Err(_).

#![feature(transpose_result)]

#[derive(Debug, Eq, PartialEq)] struct SomeErr;

let x: Result<Option, SomeErr> = Ok(Some(5)); let y: Option<Result<i32, SomeErr>> = Some(Ok(5)); assert_eq!(x, y.transpose());Run

`impl Debug for Option where

T: Debug, `[src]

`impl<'a, T> [IntoIterator](../../std/iter/trait.IntoIterator.html "trait std::iter::IntoIterator") for &'a mut [Option](../../std/option/enum.Option.html "enum std::option::Option")<T>`

1.4.0

[src]

`impl<T> [IntoIterator](../../std/iter/trait.IntoIterator.html "trait std::iter::IntoIterator") for [Option](../../std/option/enum.Option.html "enum std::option::Option")<T>`[src]

`type [Item](../../std/iter/trait.IntoIterator.html#associatedtype.Item) = T`

The type of the elements being iterated over.

`type [IntoIter](../../std/iter/trait.IntoIterator.html#associatedtype.IntoIter) = [IntoIter](../../std/option/struct.IntoIter.html "struct std::option::IntoIter")<T>`

Which kind of iterator are we turning this into?

`fn [into_iter](../../std/iter/trait.IntoIterator.html#tymethod.into%5Fiter)(self) -> [IntoIter](../../std/option/struct.IntoIter.html "struct std::option::IntoIter")<T>`[src]

Returns a consuming iterator over the possibly contained value.

let x = Some("string"); let v: Vec<&str> = x.into_iter().collect(); assert_eq!(v, ["string"]);

let x = None; let v: Vec<&str> = x.into_iter().collect(); assert!(v.is_empty());Run

`impl<'a, T> [IntoIterator](../../std/iter/trait.IntoIterator.html "trait std::iter::IntoIterator") for &'a [Option](../../std/option/enum.Option.html "enum std::option::Option")<T>`

1.4.0

[src]

`type [Item](../../std/iter/trait.IntoIterator.html#associatedtype.Item) = [&'a ](../primitive.reference.html)T`

The type of the elements being iterated over.

`type [IntoIter](../../std/iter/trait.IntoIterator.html#associatedtype.IntoIter) = [Iter](../../std/option/struct.Iter.html "struct std::option::Iter")<'a, T>`

Which kind of iterator are we turning this into?

ⓘImportant traits for Iter<'a, A>

fn [into_iter](../../std/iter/trait.IntoIterator.html#tymethod.into%5Fiter)(self) -> [Iter](../../std/option/struct.Iter.html "struct std::option::Iter")<'a, T>[src]

Creates an iterator from a value. Read more

`impl<A, V> FromIterator<Option > for Option where

V: FromIterator , `[src]

`fn from_iter(iter: I) -> Option where

I: IntoIterator<Item = Option >, `[src]

Takes each element in the Iterator: if it is None, no further elements are taken, and the None is returned. Should no None occur, a container with the values of each Option is returned.

Here is an example which increments every integer in a vector, checking for overflow:

use std::u16;

let v = vec![1, 2]; let res: Option<Vec> = v.iter().map(|&x: &u16| if x == u16::MAX { None } else { Some(x + 1) } ).collect(); assert!(res == Some(vec![2, 3]));Run

`impl Hash for Option where

T: Hash, `[src]