Enum std::option::OptionStable
[-] [+]
[src]
pub enum Option<T> {
None,
Some(T),
}The Option type. See the module level documentation for more.
Variants
None | No value |
Some | Some value |
Methods
impl<T> Option<T>
fn is_some(&self) -> bool
Returns true if the option is a Some value
Example
fn main() { let x: Option<u32> = Some(2); assert_eq!(x.is_some(), true); let x: Option<u32> = None; assert_eq!(x.is_some(), false); }let x: Option<u32> = Some(2); assert_eq!(x.is_some(), true); let x: Option<u32> = None; assert_eq!(x.is_some(), false);
fn is_none(&self) -> bool
Returns true if the option is a None value
Example
fn main() { let x: Option<u32> = Some(2); assert_eq!(x.is_none(), false); let x: Option<u32> = None; assert_eq!(x.is_none(), true); }let x: Option<u32> = Some(2); assert_eq!(x.is_none(), false); let x: Option<u32> = None; assert_eq!(x.is_none(), true);
fn as_ref(&'r self) -> Option<&'r T>
Convert from Option<T> to Option<&T>
Example
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<String> = Some("10".to_string()); // First, cast `Option<String>` to `Option<&String>` with `as_ref`, // then consume *that* with `map`, leaving `num_as_str` on the stack. let num_as_int: Option<usize> = num_as_str.as_ref().map(|n| n.len()); println!("still can print num_as_str: {:?}", num_as_str);
fn as_mut(&'r mut self) -> Option<&'r mut T>
Convert from Option<T> to Option<&mut T>
Example
fn main() { let mut x = Some(2); match x.as_mut() { Some(v) => *v = 42, None => {}, } assert_eq!(x, Some(42)); }let mut x = Some(2); match x.as_mut() { Some(v) => *v = 42, None => {}, } assert_eq!(x, Some(42));
fn as_mut_slice(&'r mut self) -> &'r mut [T]
Convert from Option<T> to &mut [T] (without copying)
Example
fn main() { let mut x = Some("Diamonds"); { let v = x.as_mut_slice(); assert!(v == ["Diamonds"]); v[0] = "Dirt"; assert!(v == ["Dirt"]); } assert_eq!(x, Some("Dirt")); }let mut x = Some("Diamonds"); { let v = x.as_mut_slice(); assert!(v == ["Diamonds"]); v[0] = "Dirt"; assert!(v == ["Dirt"]); } assert_eq!(x, Some("Dirt"));
fn expect(self, msg: &str) -> T
Unwraps an option, yielding the content of a Some
Panics
Panics if the value is a None with a custom panic message provided by
msg.
Example
fn main() { let x = Some("value"); assert_eq!(x.expect("the world is ending"), "value"); }let x = Some("value"); assert_eq!(x.expect("the world is ending"), "value");fn main() { let x: Option<&str> = None; x.expect("the world is ending"); // panics with `world is ending` }
let x: Option<&str> = None; x.expect("the world is ending"); // panics with `world is ending`
fn unwrap(self) -> T
Returns the inner T of a Some(T).
Panics
Panics if the self value equals None.
Safety note
In general, because this function may panic, its use is discouraged.
Instead, prefer to use pattern matching and handle the None
case explicitly.
Example
fn main() { let x = Some("air"); assert_eq!(x.unwrap(), "air"); }let x = Some("air"); assert_eq!(x.unwrap(), "air");fn main() { let x: Option<&str> = None; assert_eq!(x.unwrap(), "air"); // fails }
let x: Option<&str> = None; assert_eq!(x.unwrap(), "air"); // fails
fn unwrap_or(self, def: T) -> T
Returns the contained value or a default.
Example
fn main() { assert_eq!(Some("car").unwrap_or("bike"), "car"); assert_eq!(None.unwrap_or("bike"), "bike"); }assert_eq!(Some("car").unwrap_or("bike"), "car"); assert_eq!(None.unwrap_or("bike"), "bike");
fn unwrap_or_else<F>(self, f: F) -> T where F: FnOnce(), <F as FnOnce()>::Output == T
Returns the contained value or computes it from a closure.
Example
fn main() { let k = 10i32; assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4); assert_eq!(None.unwrap_or_else(|| 2 * k), 20); }let k = 10i32; assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4); assert_eq!(None.unwrap_or_else(|| 2 * k), 20);
fn map<U, F>(self, f: F) -> Option<U> where F: FnOnce(T), <F as FnOnce(T)>::Output == U
Maps an Option<T> to Option<U> by applying a function to a contained value
Example
Convert an Option<String> into an Option<usize>, consuming the original:
let num_as_str: Option<String> = Some("10".to_string()); // `Option::map` takes self *by value*, consuming `num_as_str` let num_as_int: Option<usize> = num_as_str.map(|n| n.len());
fn map_or<U, F>(self, def: U, f: F) -> U where F: FnOnce(T), <F as FnOnce(T)>::Output == U
Applies a function to the contained value or returns a default.
Example
fn main() { 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); }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);
fn map_or_else<U, D, F>(self, def: D, f: F) -> U where D: FnOnce(), <D as FnOnce()>::Output == U, F: FnOnce(T), <F as FnOnce(T)>::Output == U
Applies a function to the contained value or computes a default.
Example
fn main() { 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); }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);
fn ok_or<E>(self, err: E) -> Result<T, E>
Transforms the Option<T> into a Result<T, E>, mapping Some(v) to
Ok(v) and None to Err(err).
Example
fn main() { 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)); }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));
fn ok_or_else<E, F>(self, err: F) -> Result<T, E> where F: FnOnce(), <F as FnOnce()>::Output == E
Transforms the Option<T> into a Result<T, E>, mapping Some(v) to
Ok(v) and None to Err(err()).
Example
fn main() { 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)); }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));
fn iter(&self) -> Iter<T>
Returns an iterator over the possibly contained value.
Example
fn main() { let x = Some(4); assert_eq!(x.iter().next(), Some(&4)); let x: Option<u32> = None; assert_eq!(x.iter().next(), None); }let x = Some(4); assert_eq!(x.iter().next(), Some(&4)); let x: Option<u32> = None; assert_eq!(x.iter().next(), None);
fn iter_mut(&mut self) -> IterMut<T>
Returns a mutable iterator over the possibly contained value.
Example
fn main() { let mut x = Some(4); match x.iter_mut().next() { Some(&mut ref mut v) => *v = 42, None => {}, } assert_eq!(x, Some(42)); let mut x: Option<u32> = None; assert_eq!(x.iter_mut().next(), None); }let mut x = Some(4); match x.iter_mut().next() { Some(&mut ref mut v) => *v = 42, None => {}, } assert_eq!(x, Some(42)); let mut x: Option<u32> = None; assert_eq!(x.iter_mut().next(), None);
fn into_iter(self) -> IntoIter<T>
Returns a consuming iterator over the possibly contained value.
Example
fn main() { let x = Some("string"); let v: Vec<&str> = x.into_iter().collect(); assert_eq!(v, vec!["string"]); let x = None; let v: Vec<&str> = x.into_iter().collect(); assert!(v.is_empty()); }let x = Some("string"); let v: Vec<&str> = x.into_iter().collect(); assert_eq!(v, vec!["string"]); let x = None; let v: Vec<&str> = x.into_iter().collect(); assert!(v.is_empty());
fn and<U>(self, optb: Option<U>) -> Option<U>
Returns None if the option is None, otherwise returns optb.
Example
fn main() { let x = Some(2); let y: Option<&str> = None; assert_eq!(x.and(y), None); let x: Option<u32> = 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<u32> = None; let y: Option<&str> = None; assert_eq!(x.and(y), None); }let x = Some(2); let y: Option<&str> = None; assert_eq!(x.and(y), None); let x: Option<u32> = 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<u32> = None; let y: Option<&str> = None; assert_eq!(x.and(y), None);
fn and_then<U, F>(self, f: F) -> Option<U> where F: FnOnce(T), <F as FnOnce(T)>::Output == Option<U>
Returns None if the option is None, otherwise calls f with the
wrapped value and returns the result.
Some languages call this operation flatmap.
Example
fn main() { fn sq(x: u32) -> Option<u32> { Some(x * x) } fn nope(_: u32) -> Option<u32> { 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); }fn sq(x: u32) -> Option<u32> { Some(x * x) } fn nope(_: u32) -> Option<u32> { 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);
fn or(self, optb: Option<T>) -> Option<T>
Returns the option if it contains a value, otherwise returns optb.
Example
fn main() { 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<u32> = None; let y = None; assert_eq!(x.or(y), None); }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<u32> = None; let y = None; assert_eq!(x.or(y), None);
fn or_else<F>(self, f: F) -> Option<T> where F: FnOnce(), <F as FnOnce()>::Output == Option<T>
Returns the option if it contains a value, otherwise calls f and
returns the result.
Example
fn main() { 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); }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);
fn take(&mut self) -> Option<T>
Takes the value out of the option, leaving a None in its place.
Example
fn main() { let mut x = Some(2); x.take(); assert_eq!(x, None); let mut x: Option<u32> = None; x.take(); assert_eq!(x, None); }let mut x = Some(2); x.take(); assert_eq!(x, None); let mut x: Option<u32> = None; x.take(); assert_eq!(x, None);
impl<'a, T, D> Option<D> where T: Clone, D: Deref, <D as Deref>::Target == T
fn cloned(self) -> Option<T>
Maps an Option
impl<T> Option<T> where T: Default
fn unwrap_or_default(self) -> T
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.
Example
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, returning
None 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);
Trait Implementations
impl<T> AsSlice<T> for Option<T>
impl<T> Default for Option<T>
impl<A, V> FromIterator<Option<A>> for Option<V> where V: FromIterator<A>
fn from_iter<I>(iter: I) -> Option<V> where I: IntoIterator, <I as IntoIterator>::Item == Option<A>
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:
fn main() { use std::u16; let v = vec!(1, 2); let res: Option<Vec<u16>> = v.iter().map(|&x: &u16| if x == u16::MAX { None } else { Some(x + 1) } ).collect(); assert!(res == Some(vec!(2, 3))); }use std::u16; let v = vec!(1, 2); let res: Option<Vec<u16>> = v.iter().map(|&x: &u16| if x == u16::MAX { None } else { Some(x + 1) } ).collect(); assert!(res == Some(vec!(2, 3)));