Enum rocket::Outcome
[−]
[src]
#[must_use]pub enum Outcome<S, E, F> { Success(S), Failure(E), Forward(F), }
An enum representing success (Success
), failure (Failure
), or
forwarding (Forward
).
See the top level documentation for detailed information.
Variants
Success(S)
Contains the success value.
Failure(E)
Contains the failure error value.
Forward(F)
Contains the value to forward on.
Methods
impl<S, E, F> Outcome<S, E, F>
[src]
fn unwrap(self) -> S
Unwraps the Outcome, yielding the contents of a Success.
Panics
Panics if the value is not Success
.
Examples
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.unwrap(), 10);
fn expect(self, message: &str) -> S
Unwraps the Outcome, yielding the contents of a Success.
Panics
If the value is not Success
, panics with the given message
.
Examples
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.expect("success value"), 10);
fn is_success(&self) -> bool
Return true if this Outcome
is a Success
.
Examples
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.is_success(), true); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.is_success(), false); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.is_success(), false);
fn is_failure(&self) -> bool
Return true if this Outcome
is a Failure
.
Examples
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.is_failure(), false); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.is_failure(), true); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.is_failure(), false);
fn is_forward(&self) -> bool
Return true if this Outcome
is a Forward
.
Examples
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.is_forward(), false); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.is_forward(), false); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.is_forward(), true);
fn succeeded(self) -> Option<S>
Converts from Outcome<S, E, F>
to Option<S>
.
Returns the Some
of the Success
if this is a Success
, otherwise
returns None
. self
is consumed, and all other values are discarded.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.succeeded(), Some(10)); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.succeeded(), None); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.succeeded(), None);
fn failed(self) -> Option<E>
Converts from Outcome<S, E, F>
to Option<E>
.
Returns the Some
of the Failure
if this is a Failure
, otherwise
returns None
. self
is consumed, and all other values are discarded.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.failed(), None); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.failed(), Some("Hi! I'm an error.")); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.failed(), None);
fn forwarded(self) -> Option<F>
Converts from Outcome<S, E, F>
to Option<F>
.
Returns the Some
of the Forward
if this is a Forward
, otherwise
returns None
. self
is consumed, and all other values are discarded.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.forwarded(), None); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.forwarded(), None); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.forwarded(), Some(25));
fn as_ref(&self) -> Outcome<&S, &E, &F>
Converts from Outcome<S, E, F>
to Outcome<&S, &E, &F>
.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.as_ref(), Success(&10)); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.as_ref(), Failure(&"Hi! I'm an error."));
fn map<T, M: FnOnce(S) -> T>(self, f: M) -> Outcome<T, E, F>
Maps an Outcome<S, E, F>
to an Outcome<T, E, F>
by applying the
function f
to the value of type S
in self
if self
is an
Outcome::Success
.
let x: Outcome<i32, &str, usize> = Success(10); let mapped = x.map(|v| if v == 10 { "10" } else { "not 10" }); assert_eq!(mapped, Success("10"));
fn map_failure<T, M: FnOnce(E) -> T>(self, f: M) -> Outcome<S, T, F>
Maps an Outcome<S, E, F>
to an Outcome<S, T, F>
by applying the
function f
to the value of type E
in self
if self
is an
Outcome::Failure
.
let x: Outcome<i32, &str, usize> = Failure("hi"); let mapped = x.map_failure(|v| if v == "hi" { 10 } else { 0 }); assert_eq!(mapped, Failure(10));
fn map_forward<T, M: FnOnce(F) -> T>(self, f: M) -> Outcome<S, E, T>
Maps an Outcome<S, E, F>
to an Outcome<S, E, T>
by applying the
function f
to the value of type F
in self
if self
is an
Outcome::Forward
.
let x: Outcome<i32, &str, usize> = Forward(5); let mapped = x.map_forward(|v| if v == 5 { "a" } else { "b" }); assert_eq!(mapped, Forward("a"));
fn as_mut(&mut self) -> Outcome<&mut S, &mut E, &mut F>
Converts from Outcome<S, E, F>
to Outcome<&mut S, &mut E, &mut F>
.
let mut x: Outcome<i32, &str, usize> = Success(10); if let Success(val) = x.as_mut() { *val = 20; } assert_eq!(x.unwrap(), 20);
Trait Implementations
impl<S: Clone, E: Clone, F: Clone> Clone for Outcome<S, E, F>
[src]
fn clone(&self) -> Outcome<S, E, F>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl<S: Copy, E: Copy, F: Copy> Copy for Outcome<S, E, F>
[src]
impl<S: PartialEq, E: PartialEq, F: PartialEq> PartialEq for Outcome<S, E, F>
[src]
fn eq(&self, __arg_0: &Outcome<S, E, F>) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &Outcome<S, E, F>) -> bool
This method tests for !=
.
impl<S: PartialOrd, E: PartialOrd, F: PartialOrd> PartialOrd for Outcome<S, E, F>
[src]
fn partial_cmp(&self, __arg_0: &Outcome<S, E, F>) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, __arg_0: &Outcome<S, E, F>) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, __arg_0: &Outcome<S, E, F>) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, __arg_0: &Outcome<S, E, F>) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, __arg_0: &Outcome<S, E, F>) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl<S: Eq, E: Eq, F: Eq> Eq for Outcome<S, E, F>
[src]
impl<S: Ord, E: Ord, F: Ord> Ord for Outcome<S, E, F>
[src]
fn cmp(&self, __arg_0: &Outcome<S, E, F>) -> Ordering
This method returns an Ordering
between self
and other
. Read more
fn max(self, other: Self) -> Self
ord_max_min
)Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
ord_max_min
)Compares and returns the minimum of two values. Read more
impl<S: Hash, E: Hash, F: Hash> Hash for Outcome<S, E, F>
[src]
fn hash<__HSEF: Hasher>(&self, __arg_0: &mut __HSEF)
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<S, E, F> Try for Outcome<S, E, F>
[src]
type Ok = S
try_trait
)The type of this value when viewed as successful.
type Error = Result<F, E>
try_trait
)The type of this value when viewed as failed.
fn into_result(self) -> Result<Self::Ok, Self::Error>
try_trait
)Applies the "?" operator. A return of Ok(t)
means that the execution should continue normally, and the result of ?
is the value t
. A return of Err(e)
means that execution should branch to the innermost enclosing catch
, or return from the function. Read more
fn from_error(val: Self::Error) -> Self
try_trait
)Wrap an error value to construct the composite result. For example, Result::Err(x)
and Result::from_error(x)
are equivalent. Read more
fn from_ok(val: Self::Ok) -> Self
try_trait
)Wrap an OK value to construct the composite result. For example, Result::Ok(x)
and Result::from_ok(x)
are equivalent. Read more