Enum std::option::Option [] [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 T

Methods

impl<T> Option<T>

fn is_some(&self) -> bool

Returns true if the option is a Some value

Examples

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

Examples

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(&self) -> Option<&T>

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

Examples

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.

fn main() { 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); }
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(&mut self) -> Option<&mut T>

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

Examples

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(&mut self) -> &mut [T]

Deprecated since 1.4.0

: niche API, unclear of usefulness

Converts from Option<T> to &mut [T] (without copying)

Examples

#![feature(as_slice)] fn main() { #![allow(deprecated)] 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")); }
#![feature(as_slice)]

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.

Examples

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 `the world is ending` }
let x: Option<&str> = None;
x.expect("the world is ending"); // panics with `the world is ending`

fn unwrap(self) -> T

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

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.

Examples

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.

Examples

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() -> T

Returns the contained value or computes it from a closure.

Examples

fn main() { let k = 10; assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4); assert_eq!(None.unwrap_or_else(|| 2 * k), 20); }
let k = 10;
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) -> U

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

Examples

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

fn main() { let maybe_some_string = Some(String::from("Hello, World!")); // `Option::map` takes self *by value*, consuming `maybe_some_string` let maybe_some_len = maybe_some_string.map(|s| s.len()); assert_eq!(maybe_some_len, Some(13)); }
let maybe_some_string = Some(String::from("Hello, World!"));
// `Option::map` takes self *by value*, consuming `maybe_some_string`
let maybe_some_len = maybe_some_string.map(|s| s.len());

assert_eq!(maybe_some_len, Some(13));

fn map_or<U, F>(self, default: U, f: F) -> U where F: FnOnce(T) -> U

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

Examples

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, default: D, f: F) -> U where F: FnOnce(T) -> U, D: FnOnce() -> U

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

Examples

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).

Examples

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() -> E

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

Examples

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.

Examples

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.

Examples

fn main() { let mut x = Some(4); match x.iter_mut().next() { Some(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(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));

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

fn and<U>(self, optb: Option<U>) -> Option<U>

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

Examples

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) -> 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.

Examples

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.

Examples

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() -> Option<T>

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

Examples

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.

Examples

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);

fn as_slice(&self) -> &[T]

Deprecated since 1.4.0

: niche API, unclear of usefulness

Converts from Option<T> to &[T] (without copying)

impl<'a, T> Option<&'a T> where T: Clone

fn cloned(self) -> Option<T>

Maps an Option<&T> to an Option<T> by cloning the contents of the 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.

Examples

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.

fn main() { 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); }
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> Default for Option<T>

fn default() -> Option<T>

impl<T> IntoIterator for Option<T>

type Item = T

type IntoIter = IntoIter<T>

fn into_iter(self) -> IntoIter<T>

impl<'a, T> IntoIterator for &'a Option<T>

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut Option<T>

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, 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<Item=Option<A>>

Derived Implementations

impl<T> Hash for Option<T> where T: Hash

fn hash<__H>(&self, __arg_0: &mut __H) where __H: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

impl<T> Debug for Option<T> where T: Debug

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Ord for Option<T> where T: Ord

fn cmp(&self, __arg_0: &Option<T>) -> Ordering

impl<T> Eq for Option<T> where T: Eq

impl<T> PartialOrd<Option<T>> for Option<T> where T: PartialOrd<T>

fn partial_cmp(&self, __arg_0: &Option<T>) -> Option<Ordering>

fn lt(&self, __arg_0: &Option<T>) -> bool

fn le(&self, __arg_0: &Option<T>) -> bool

fn gt(&self, __arg_0: &Option<T>) -> bool

fn ge(&self, __arg_0: &Option<T>) -> bool

impl<T> PartialEq<Option<T>> for Option<T> where T: PartialEq<T>

fn eq(&self, __arg_0: &Option<T>) -> bool

fn ne(&self, __arg_0: &Option<T>) -> bool

impl<T> Copy for Option<T> where T: Copy

impl<T> Clone for Option<T> where T: Clone

fn clone(&self) -> Option<T>

fn clone_from(&mut self, source: &Self)