Enum tokio_jsonrpc::macro_exports::Option 1.0.0
[−]
[src]
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>
[src]
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
option_entry
)Inserts v
into the option if it is None
, then
returns a mutable reference to the contained value.
Examples
#![feature(option_entry)] 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
option_entry
)Inserts a value computed from f
into the option if it is None
, then
returns a mutable reference to the contained value.
Examples
#![feature(option_entry)] 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
[src]
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<T> Option<T> where T: Default
[src]
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<F, T, E> Future for Option<F> where F: Future<Item=T, Error=E>
[src]
type Item = Option<T>
The type of value that this future will resolved with if it is successful. Read more
type Error = E
The type of error that this future will resolve with if it fails in a normal fashion. Read more
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. Read more
fn wait(self) -> Result<Self::Item, Self::Error>
Block the current thread until this future is resolved. Read more
fn boxed(self)
-> Box<Future<Error=Self::Error, Item=Self::Item> + 'static + Send> where Self: Send + 'static
-> Box<Future<Error=Self::Error, Item=Self::Item> + 'static + Send> where Self: Send + 'static
Convenience function for turning this future into a trait object which is also Send
. Read more
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. Read more
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. Read more
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. Read more
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
. Read more
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. Read more
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. Read more
fn select<B>(self, other: B) -> Select<Self, B::Future> where B: IntoFuture<Item=Self::Item, Error=Self::Error>
Waits for either one of two futures to complete. Read more
fn select2<B>(self, other: B) -> Select2<Self, B::Future> where B: IntoFuture
Waits for either one of two differently-typed futures to complete. Read more
fn join<B>(self, other: B) -> Join<Self, B::Future> where B: IntoFuture<Error=Self::Error>
Joins the result of two futures, waiting for them both to complete. Read more
fn join3<B, C>(self, b: B, c: C) -> Join3<Self, B::Future, C::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::Future, C::Future, D::Future> where B: IntoFuture<Error=Self::Error>,
C: IntoFuture<Error=Self::Error>,
D: IntoFuture<Error=Self::Error>
b: B,
c: C,
d: D)
-> Join4<Self, B::Future, C::Future, D::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::Future, C::Future, D::Future, E::Future> where B: IntoFuture<Error=Self::Error>,
C: IntoFuture<Error=Self::Error>,
D: IntoFuture<Error=Self::Error>,
E: IntoFuture<Error=Self::Error>
b: B,
c: C,
d: D,
e: E)
-> Join5<Self, B::Future, C::Future, D::Future, E::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. Read more
fn flatten(self) -> Flatten<Self> where Self::Item: IntoFuture, Self::Item::Error: From<Self::Error>
Flatten the execution of this future when the successful result of this future is itself another future. Read more
fn flatten_stream(self) -> FlattenStream<Self> where Self::Item: Stream, Self::Item::Error == Self::Error
Flatten the execution of this future when the successful result of this future is a stream. Read more
fn fuse(self) -> Fuse<Self>
Fuse a future such that poll
will never again be called once it has completed. Read more
fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe
Catches unwinding panics while polling the future. Read more
Create a cloneable handle to this future where all handles will resolve to the same result. Read more
impl Buf for Option<[u8; 1]>
[src]
impl<T> Rand for Option<T> where T: Rand
[src]
impl<T> PartialEq<Option<T>> for Option<T> where T: PartialEq<T>
[src]
fn eq(&self, __arg_0: &Option<T>) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &Option<T>) -> bool
This method tests for !=
.
impl<T> Debug for Option<T> where T: Debug
[src]
fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl<T> IntoIterator for Option<T>
[src]
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>
1.4.0[src]
impl<'a, T> IntoIterator for &'a mut Option<T>
1.4.0[src]
impl<T> Eq for Option<T> where T: Eq
[src]
impl<T> Hash for Option<T> where T: Hash
[src]
fn hash<__HT>(&self, __arg_0: &mut __HT) where __HT: Hasher
Feeds this value into the state given, updating the hasher as necessary.
fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher
1.3.0
Feeds a slice of this type into the state provided.
impl<A, V> FromIterator<Option<A>> for Option<V> where V: FromIterator<A>
[src]
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> From<T> for Option<T>
1.12.0[src]
impl<T> Copy for Option<T> where T: Copy
[src]
impl<T> Ord for Option<T> where T: Ord
[src]
impl<T> Clone for Option<T> where T: Clone
[src]
fn clone(&self) -> Option<T>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl<T> Default for Option<T>
[src]
impl<T> PartialOrd<Option<T>> for Option<T> where T: PartialOrd<T>
[src]
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> Value for Option<T> where T: Value
fn serialize(&self,
record: &Record,
key: &'static str,
serializer: &mut Serializer)
-> Result<(), Error>
record: &Record,
key: &'static str,
serializer: &mut Serializer)
-> Result<(), Error>
impl<T> Serialize for Option<T> where T: Serialize
[src]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer
Serialize this value into the given Serde serializer. Read more
impl<T> Deserialize for Option<T> where T: Deserialize
[src]
fn deserialize<D>(deserializer: D) -> Result<Option<T>, D::Error> where D: Deserializer
Deserialize this value from the given Serde deserializer. Read more