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>
Returns a Success
value as Ok()
or value
in Err
. 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>
Returns a Success
value as Ok()
or f()
in Err
. 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 as_mut(&mut self) -> Outcome<&mut S, &mut E, &mut F>
pub 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);
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 the Success
value using 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 the Failure
value using 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 the Forward
value using f
. 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>
Converts from Outcome<S, E, F>
to Outcome<T, E, F>
using f
to map
Success(S)
to Success(T)
.
If self
is not Success
, self
is returned.
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>
Converts from Outcome<S, E, F>
to Outcome<S, T, F>
using f
to map
Failure(E)
to Failure(T)
.
If self
is not Failure
, self
is returned.
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>
Converts from Outcome<S, E, F>
to Outcome<S, E, T>
using f
to map
Forward(F)
to Forward(T)
.
If self
is not Forward
, self
is returned.
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));
sourcepub fn ok_map_forward<M>(self, f: M) -> Result<S, E> where
M: FnOnce(F) -> Result<S, E>,
pub fn ok_map_forward<M>(self, f: M) -> Result<S, E> where
M: FnOnce(F) -> Result<S, E>,
Converts Outcome<S, E, F>
to Result<S, E>
by identity mapping
Success(S)
and Failure(E)
to Result<T, E>
and mapping Forward(F)
to Result<T, E>
using f
.
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.ok_map_forward(|x| Ok(x as i32 + 1)), Ok(10));
let x: Outcome<i32, &str, usize> = Failure("hello");
assert_eq!(x.ok_map_forward(|x| Ok(x as i32 + 1)), Err("hello"));
let x: Outcome<i32, &str, usize> = Forward(0);
assert_eq!(x.ok_map_forward(|x| Ok(x as i32 + 1)), Ok(1));
sourcepub fn ok_map_failure<M>(self, f: M) -> Result<S, F> where
M: FnOnce(E) -> Result<S, F>,
pub fn ok_map_failure<M>(self, f: M) -> Result<S, F> where
M: FnOnce(E) -> Result<S, F>,
Converts Outcome<S, E, F>
to Result<S, E>
by identity mapping
Success(S)
and Forward(F)
to Result<T, F>
and mapping Failure(E)
to Result<T, F>
using f
.
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.ok_map_failure(|s| Ok(123)), Ok(10));
let x: Outcome<i32, &str, usize> = Failure("hello");
assert_eq!(x.ok_map_failure(|s| Ok(123)), Ok(123));
let x: Outcome<i32, &str, usize> = Forward(0);
assert_eq!(x.ok_map_failure(|s| Ok(123)), Err(0));
sourceimpl<'r, 'o: 'r> Outcome<Response<'r>, Status, Data<'r>>
impl<'r, 'o: 'r> Outcome<Response<'r>, Status, Data<'r>>
sourcepub fn from<R: Responder<'r, 'o>>(
req: &'r Request<'_>,
responder: R
) -> Outcome<'r>
pub fn from<R: Responder<'r, 'o>>(
req: &'r Request<'_>,
responder: R
) -> 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, route};
fn str_responder<'r>(req: &'r Request, _: Data<'r>) -> route::Outcome<'r> {
route::Outcome::from(req, "Hello, world!")
}
sourcepub fn try_from<R, E>(req: &'r Request<'_>, result: Result<R, E>) -> Outcome<'r> where
R: Responder<'r, 'o>,
E: Debug,
pub fn try_from<R, E>(req: &'r Request<'_>, result: Result<R, E>) -> Outcome<'r> where
R: Responder<'r, 'o>,
E: Debug,
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, route};
fn str_responder<'r>(req: &'r Request, _: Data<'r>) -> route::Outcome<'r> {
route::Outcome::from(req, "Hello, world!")
}
sourcepub fn from_or_forward<R>(
req: &'r Request<'_>,
data: Data<'r>,
responder: R
) -> Outcome<'r> where
R: Responder<'r, 'o>,
pub fn from_or_forward<R>(
req: &'r Request<'_>,
data: Data<'r>,
responder: R
) -> Outcome<'r> where
R: Responder<'r, 'o>,
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, route};
fn str_responder<'r>(req: &'r Request, data: Data<'r>) -> route::Outcome<'r> {
route::Outcome::from_or_forward(req, data, "Hello, world!")
}
sourcepub fn failure(code: Status) -> Outcome<'r>
pub fn failure(code: Status) -> Outcome<'r>
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.
Example
use rocket::{Request, Data, route};
use rocket::http::Status;
fn bad_req_route<'r>(_: &'r Request, _: Data<'r>) -> route::Outcome<'r> {
route::Outcome::failure(Status::BadRequest)
}
sourcepub fn forward(data: Data<'r>) -> Outcome<'r>
pub fn forward(data: Data<'r>) -> Outcome<'r>
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.
Example
use rocket::{Request, Data, route};
fn always_forward<'r>(_: &'r Request, data: Data<'r>) -> route::Outcome<'r> {
route::Outcome::forward(data)
}
Trait Implementations
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
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
impl<'a, T> AsTaggedExplicit<'a> for T where
T: 'a,
impl<'a, T> AsTaggedExplicit<'a> for T where
T: 'a,
fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self>
impl<'a, T> AsTaggedImplicit<'a> for T where
T: 'a,
impl<'a, T> AsTaggedImplicit<'a> for T where
T: 'a,
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> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
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
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more