# 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