pub enum Outcome<S, E, F> {
Success(S),
Failure(E),
Forward(F),
}
Expand description
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.
Implementations
sourceimpl<S, E, F> Outcome<S, E, F>
impl<S, E, F> Outcome<S, E, F>
sourcepub fn is_success(&self) -> bool
pub 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);
sourcepub fn is_failure(&self) -> bool
pub 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);
sourcepub fn is_forward(&self) -> bool
pub 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);
sourcepub fn succeeded(self) -> Option<S>
pub 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);
sourcepub fn failed(self) -> Option<E>
pub 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);
sourcepub fn forwarded(self) -> Option<F>
pub 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));
sourcepub fn success_or<T>(self, value: T) -> Result<S, T>
pub fn success_or<T>(self, value: T) -> Result<S, T>
Converts from Outcome<S, E, F>
to Result<S, T>
for a given T
.
Returns Ok
with the Success
value if this is a Success
, otherwise
returns an Err
with the provided value. self
is consumed, and all
other values are discarded.
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.success_or(false), Ok(10));
let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error.");
assert_eq!(x.success_or(false), Err(false));
let x: Outcome<i32, &str, usize> = Forward(25);
assert_eq!(x.success_or("whoops"), Err("whoops"));
sourcepub fn success_or_else<T, V: FnOnce() -> T>(self, f: V) -> Result<S, T>
pub fn success_or_else<T, V: FnOnce() -> T>(self, f: V) -> Result<S, T>
Converts from Outcome<S, E, F>
to Result<S, T>
for a given T
produced from a supplied function or closure.
Returns Ok
with the Success
value if this is a Success
, otherwise
returns an Err
with the result of calling f
. self
is consumed, and
all other values are discarded.
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.success_or_else(|| false), Ok(10));
let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error.");
assert_eq!(x.success_or_else(|| false), Err(false));
let x: Outcome<i32, &str, usize> = Forward(25);
assert_eq!(x.success_or_else(|| "whoops"), Err("whoops"));
sourcepub fn as_ref(&self) -> Outcome<&S, &E, &F>
pub 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."));
sourcepub fn map<T, M: FnOnce(S) -> T>(self, f: M) -> Outcome<T, E, F>
pub 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"));
sourcepub fn map_failure<T, M: FnOnce(E) -> T>(self, f: M) -> Outcome<S, T, F>
pub 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));
sourcepub fn map_forward<T, M: FnOnce(F) -> T>(self, f: M) -> Outcome<S, E, T>
pub 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"));
sourcepub fn and_then<T, M: FnOnce(S) -> Outcome<T, E, F>>(
self,
f: M
) -> Outcome<T, E, F>
pub fn and_then<T, M: FnOnce(S) -> Outcome<T, E, F>>(
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
.
Examples
let x: Outcome<i32, &str, bool> = Success(10);
let mapped = x.and_then(|v| match v {
10 => Success("10"),
1 => Forward(false),
_ => Failure("30")
});
assert_eq!(mapped, Success("10"));
sourcepub fn failure_then<T, M: FnOnce(E) -> Outcome<S, T, F>>(
self,
f: M
) -> Outcome<S, T, F>
pub fn failure_then<T, M: FnOnce(E) -> Outcome<S, T, F>>(
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
.
Examples
let x: Outcome<i32, &str, bool> = Failure("hi");
let mapped = x.failure_then(|v| match v {
"hi" => Failure(10),
"test" => Forward(false),
_ => Success(10)
});
assert_eq!(mapped, Failure(10));
sourcepub fn forward_then<T, M: FnOnce(F) -> Outcome<S, E, T>>(
self,
f: M
) -> Outcome<S, E, T>
pub fn forward_then<T, M: FnOnce(F) -> Outcome<S, E, 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
.
Examples
let x: Outcome<i32, &str, Option<bool>> = Forward(Some(false));
let mapped = x.forward_then(|v| match v {
Some(true) => Success(10),
Some(false) => Forward(20),
None => Failure("10")
});
assert_eq!(mapped, Forward(20));
sourceimpl<'r> Outcome<Response<'r>, Status, Data>
impl<'r> Outcome<Response<'r>, Status, Data>
sourcepub fn from<T: Responder<'r>>(req: &Request<'_>, responder: T) -> Outcome<'r>
pub fn from<T: Responder<'r>>(req: &Request<'_>, responder: T) -> Outcome<'r>
Return the Outcome
of response to req
from responder
.
If the responder returns Ok
, an outcome of Success
is
returned with the response. If the responder returns Err
, an
outcome of Failure
is returned with the status code.
Example
use rocket::{Request, Data};
use rocket::handler::Outcome;
fn str_responder(req: &Request, _: Data) -> Outcome<'static> {
Outcome::from(req, "Hello, world!")
}
sourcepub fn from_or_forward<T>(
req: &Request<'_>,
data: Data,
responder: T
) -> Outcome<'r> where
T: Responder<'r>,
pub fn from_or_forward<T>(
req: &Request<'_>,
data: Data,
responder: T
) -> Outcome<'r> where
T: Responder<'r>,
Return the Outcome
of response to req
from responder
.
If the responder returns Ok
, an outcome of Success
is
returned with the response. If the responder returns Err
, an
outcome of Forward
is returned.
Example
use rocket::{Request, Data};
use rocket::handler::Outcome;
fn str_responder(req: &Request, data: Data) -> Outcome<'static> {
Outcome::from_or_forward(req, data, "Hello, world!")
}
sourcepub fn failure(code: Status) -> Outcome<'static>
pub fn failure(code: Status) -> Outcome<'static>
Return an Outcome
of Failure
with the status code code
. This is
equivalent to Outcome::Failure(code)
.
This method exists to be used during manual routing where
rocket::handler::Outcome
is imported instead of rocket::Outcome
.
Example
use rocket::{Request, Data};
use rocket::handler::Outcome;
use rocket::http::Status;
fn bad_req_route(_: &Request, _: Data) -> Outcome<'static> {
Outcome::failure(Status::BadRequest)
}
sourcepub fn forward(data: Data) -> Outcome<'static>
pub fn forward(data: Data) -> Outcome<'static>
Return an Outcome
of Forward
with the data data
. This is
equivalent to Outcome::Forward(data)
.
This method exists to be used during manual routing where
rocket::handler::Outcome
is imported instead of rocket::Outcome
.
Example
use rocket::{Request, Data};
use rocket::handler::Outcome;
fn always_forward(_: &Request, data: Data) -> Outcome<'static> {
Outcome::forward(data)
}
Trait Implementations
sourceimpl<S, X, E: From<X>, Y, F: From<Y>> FromResidual<Outcome<!, X, Y>> for Outcome<S, E, F>
impl<S, X, E: From<X>, Y, F: From<Y>> FromResidual<Outcome<!, X, Y>> for Outcome<S, E, F>
sourcefn from_residual(r: Outcome<!, X, Y>) -> Self
fn from_residual(r: Outcome<!, X, Y>) -> Self
try_trait_v2
)Constructs the type from a compatible Residual
type. Read more
sourceimpl<Y, S, E: From<Y>, F> FromResidual<Result<Infallible, Y>> for Outcome<S, E, F>
impl<Y, S, E: From<Y>, F> FromResidual<Result<Infallible, Y>> for Outcome<S, E, F>
sourcefn from_residual(r: Result<Infallible, Y>) -> Self
fn from_residual(r: Result<Infallible, Y>) -> Self
try_trait_v2
)Constructs the type from a compatible Residual
type. Read more
sourceimpl<S: Ord, E: Ord, F: Ord> Ord for Outcome<S, E, F>
impl<S: Ord, E: Ord, F: Ord> Ord for Outcome<S, E, F>
sourceimpl<S: PartialEq, E: PartialEq, F: PartialEq> PartialEq<Outcome<S, E, F>> for Outcome<S, E, F>
impl<S: PartialEq, E: PartialEq, F: PartialEq> PartialEq<Outcome<S, E, F>> for Outcome<S, E, F>
sourceimpl<S: PartialOrd, E: PartialOrd, F: PartialOrd> PartialOrd<Outcome<S, E, F>> for Outcome<S, E, F>
impl<S: PartialOrd, E: PartialOrd, F: PartialOrd> PartialOrd<Outcome<S, E, F>> for Outcome<S, E, F>
sourcefn partial_cmp(&self, other: &Outcome<S, E, F>) -> Option<Ordering>
fn partial_cmp(&self, other: &Outcome<S, E, F>) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl<A, B, C> Try for Outcome<A, B, C>
impl<A, B, C> Try for Outcome<A, B, C>
type Output = A
type Output = A
try_trait_v2
)The type of the value produced by ?
when not short-circuiting.
type Residual = Outcome<!, B, C>
type Residual = Outcome<!, B, C>
try_trait_v2
)The type of the value passed to FromResidual::from_residual
as part of ?
when short-circuiting. Read more
sourcefn from_output(x: Self::Output) -> Self
fn from_output(x: Self::Output) -> Self
try_trait_v2
)Constructs the type from its Output
type. Read more
sourcefn branch(self) -> ControlFlow<Self::Residual, Self::Output>
fn branch(self) -> ControlFlow<Self::Residual, Self::Output>
try_trait_v2
)Used in ?
to decide whether the operator should produce a value
(because this returned ControlFlow::Continue
)
or propagate a value back to the caller
(because this returned ControlFlow::Break
). Read more
impl<S: Copy, E: Copy, F: Copy> Copy for Outcome<S, E, F>
impl<S: Eq, E: Eq, F: Eq> Eq for Outcome<S, E, F>
impl<S, E, F> StructuralEq for Outcome<S, E, F>
impl<S, E, F> StructuralPartialEq for Outcome<S, E, F>
Auto Trait Implementations
impl<S, E, F> RefUnwindSafe for Outcome<S, E, F> where
E: RefUnwindSafe,
F: RefUnwindSafe,
S: RefUnwindSafe,
impl<S, E, F> Send for Outcome<S, E, F> where
E: Send,
F: Send,
S: Send,
impl<S, E, F> Sync for Outcome<S, E, F> where
E: Sync,
F: Sync,
S: Sync,
impl<S, E, F> Unpin for Outcome<S, E, F> where
E: Unpin,
F: Unpin,
S: Unpin,
impl<S, E, F> UnwindSafe for Outcome<S, E, F> where
E: UnwindSafe,
F: UnwindSafe,
S: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
sourcefn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
Compare self to key
and return true
if they are equal.
sourceimpl<T> IntoCollection<T> for T
impl<T> IntoCollection<T> for T
sourcefn into_collection<A>(self) -> SmallVec<A> where
A: Array<Item = T>,
fn into_collection<A>(self) -> SmallVec<A> where
A: Array<Item = T>,
Converts self
into a collection.
fn mapped<U, F, A>(self, f: F) -> SmallVec<A> where
F: FnMut(T) -> U,
A: Array<Item = U>,
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more