Enum tokio_jsonrpc::macro_exports::Option

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

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

Variants

None

No value

Some(T)

Some value T

Methods

impl<T> Option<T>

fn is_some(&self) -> bool

Returns true if the option is a Some value.

Examples

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

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.

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

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

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

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

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

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

Panics

Panics if the self value equals None.

Examples

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

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

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

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:

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

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

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

Examples

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

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

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

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

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

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

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 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 get_or_insert(&mut self, v: T) -> &mut T

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

Examples

let mut x = None;

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

    *y = 7;
}

assert_eq!(x, Some(7));

fn get_or_insert_with<F>(&mut self, f: F) -> &mut T where
    F: FnOnce() -> T, 

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

Examples

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

fn take(&mut self) -> Option<T>

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

Examples

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

Examples

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

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

fn cloned(self) -> Option<T>

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

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

Examples

#![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));

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.

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 Buf for Option<[u8; 1]>

fn remaining(&self) -> usize

fn bytes(&self) -> &[u8]

fn advance(&mut self, cnt: usize)

impl<T> Value for Option<T> where
    T: Value, 

fn serialize(
    &self,
    record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl<F, T, E> Future for Option<F> where
    F: Future<Item = T, Error = E>, 

type Item = Option<T>

The type of value that this future will resolved with if it is successful.

type Error = E

The type of error that this future will resolve with if it fails in a normal fashion.

fn poll(&mut self) -> Result<Async<Option<T>>, E>

Query this future to see if its value has become available, registering interest if it is not.

fn wait(self) -> Result<Self::Item, Self::Error>

Block the current thread until this future is resolved.

fn map<F, U>(self, f: F) -> Map<Self, F> where
    F: FnOnce(Self::Item) -> U, 

Map this future's result to a different type, returning a new future of the resulting type.

fn map_err<F, E>(self, f: F) -> MapErr<Self, F> where
    F: FnOnce(Self::Error) -> E, 

Map this future's error to a different error, returning a new future.

fn from_err<E>(self) -> FromErr<Self, E> where
    E: From<Self::Error>, 

Map this future's error to any error implementing From for this future's Error, returning a new future.

fn then<F, B>(self, f: F) -> Then<Self, B, F> where
    B: IntoFuture,
    F: FnOnce(Result<Self::Item, Self::Error>) -> B, 

Chain on a computation for when a future finished, passing the result of the future to the provided closure f.

fn and_then<F, B>(self, f: F) -> AndThen<Self, B, F> where
    B: IntoFuture<Error = Self::Error>,
    F: FnOnce(Self::Item) -> B, 

Execute another future after this one has resolved successfully.

fn or_else<F, B>(self, f: F) -> OrElse<Self, B, F> where
    B: IntoFuture<Item = Self::Item>,
    F: FnOnce(Self::Error) -> B, 

Execute another future if this one resolves with an error.

fn select<B>(self, other: B) -> Select<Self, <B as IntoFuture>::Future> where
    B: IntoFuture<Item = Self::Item, Error = Self::Error>, 

Waits for either one of two futures to complete.

fn select2<B>(self, other: B) -> Select2<Self, <B as IntoFuture>::Future> where
    B: IntoFuture, 

Waits for either one of two differently-typed futures to complete.

fn join<B>(self, other: B) -> Join<Self, <B as IntoFuture>::Future> where
    B: IntoFuture<Error = Self::Error>, 

Joins the result of two futures, waiting for them both to complete.

fn join3<B, C>(
    self,
    b: B,
    c: C
) -> Join3<Self, <B as IntoFuture>::Future, <C as IntoFuture>::Future> where
    B: IntoFuture<Error = Self::Error>,
    C: IntoFuture<Error = Self::Error>, 

Same as join, but with more futures.

fn join4<B, C, D>(
    self,
    b: B,
    c: C,
    d: D
) -> Join4<Self, <B as IntoFuture>::Future, <C as IntoFuture>::Future, <D as IntoFuture>::Future> where
    B: IntoFuture<Error = Self::Error>,
    C: IntoFuture<Error = Self::Error>,
    D: IntoFuture<Error = Self::Error>, 

Same as join, but with more futures.

fn join5<B, C, D, E>(
    self,
    b: B,
    c: C,
    d: D,
    e: E
) -> Join5<Self, <B as IntoFuture>::Future, <C as IntoFuture>::Future, <D as IntoFuture>::Future, <E as IntoFuture>::Future> where
    B: IntoFuture<Error = Self::Error>,
    C: IntoFuture<Error = Self::Error>,
    D: IntoFuture<Error = Self::Error>,
    E: IntoFuture<Error = Self::Error>, 

Same as join, but with more futures.

fn into_stream(self) -> IntoStream<Self>

Convert this future into a single element stream.

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoFuture,
    <Self::Item as IntoFuture>::Error: From<Self::Error>, 

Flatten the execution of this future when the successful result of this future is itself another future.

fn flatten_stream(self) -> FlattenStream<Self> where
    Self::Item: Stream,
    <Self::Item as Stream>::Error == Self::Error, 

Flatten the execution of this future when the successful result of this future is a stream.

fn fuse(self) -> Fuse<Self>

Fuse a future such that poll will never again be called once it has completed.

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    F: FnOnce(&Self::Item) -> (), 

Do something with the item of a future, passing it on.

fn catch_unwind(self) -> CatchUnwind<Self> where
    Self: UnwindSafe, 

Catches unwinding panics while polling the future.

fn shared(self) -> Shared<Self>

Create a cloneable handle to this future where all handles will resolve to the same result.

impl<T> From<T> for Option<T>

fn from(val: T) -> Option<T>

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

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

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

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

Formats the value using the given formatter.

impl<T> Default for Option<T>

fn default() -> Option<T>

Returns None.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

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

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>>, 

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<u16>> = v.iter().map(|&x: &u16|
    if x == u16::MAX { None }
    else { Some(x + 1) }
).collect();
assert!(res == Some(vec![2, 3]));

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

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

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

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<T> IntoIterator for Option<T>

type Item = T

type IntoIter = IntoIter<T>

fn into_iter(self) -> IntoIter<T>

Returns a consuming iterator over the possibly contained value.

Examples

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

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<T> PartialEq<Option<T>> for Option<T> where
    T: PartialEq<T>, 

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

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

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

impl<'de, T> Deserialize<'de> for Option<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Option<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for Option<T> where
    T: Serialize, 

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.