Enum std::option::Option [] [src]

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

The Option`Option` type. See the module level documentation for more.

Variants

None

No value

Some

Some value T`T`

Methods

impl<T> Option<T>

fn is_some(&self) -> bool

Returns true`trueif the option is a` if the option is a Some`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`trueif the option is a` if the option is a None`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(&'r self) -> Option<&'r T>

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

Examples

Convert an Option<String>`Optioninto an` into an Option<usize>`Option, preserving the original. The`, preserving the original. The map`mapmethod takes the` method takes the self`selfargument by value, consuming the original, so this technique uses` argument by value, consuming the original, so this technique uses as_ref`as_refto first take an` to first take an Option`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(&'r mut self) -> Option<&'r mut T>

Converts from Option<T>`Optionto` to Option<&mut T>`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(&'r mut self) -> &'r mut [T]

Unstable

: waiting for mut conventions

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

Examples

#![feature(core)] 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`Some`

Panics

Panics if the value is a None`Nonewith a custom panic message provided by` with a custom panic message provided by msg`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 `world is ending` }
let x: Option<&str> = None;
x.expect("the world is ending"); // panics with `world is ending`

fn unwrap(self) -> T

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

Panics

Panics if the self value equals None`None`.

Safety note

In general, because this function may panic, its use is discouraged. Instead, prefer to use pattern matching and handle the None`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>`Optionto` to Option<U>`Option` by applying a function to a contained value

Examples

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

fn main() { 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()); }
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) -> U

Applies a function to the contained value or returns a default.

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

Applies a function to the contained value or computes a default.

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>`Optioninto a` into a Result<T, E>`Result, mapping`, mapping Some(v)`Some(v)to` to Ok(v)`Ok(v)and` and None`Noneto` to Err(err)`Err(err)`.

Examples

#![feature(core)] 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>`Optioninto a` into a Result<T, E>`Result, mapping`, mapping Some(v)`Some(v)to` to Ok(v)`Ok(v)and` and None`Noneto` to Err(err())`Err(err())`.

Examples

#![feature(core)] 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

#![feature(core)] 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 and<U>(self, optb: Option<U>) -> Option<U>

Returns None`Noneif the option is` if the option is None`None, otherwise returns`, otherwise returns optb`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`Noneif the option is` if the option is None`None, otherwise calls`, otherwise calls f`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`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`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`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(&'a self) -> &'a [T]

Unstable

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

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

fn cloned(self) -> Option<T>

Maps an Option<&T> to an Option 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`selfargument then, if` argument then, if Some`Some, returns the contained value, otherwise if`, returns the contained value, otherwise if None`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`parseconverts a string to any other type that implements` converts a string to any other type that implements FromStr`FromStr, returning`, returning None`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, 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>>

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

fn rand<R>(rng: &mut R) -> Option<T> where R: Rng

Derived Implementations

impl<T> Hash for Option<T> where T: Hash + 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 + Debug

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

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

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

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

impl<T> PartialOrd<Option<T>> for Option<T> where T: PartialOrd<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> + 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 + Copy

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

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

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