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§
source§impl<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));
source§impl<'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§
source§impl<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>
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere Self: Sized,
source§impl<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>
source§impl<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>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moreimpl<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 Twhere
T: 'a,
impl<'a, T> AsTaggedExplicit<'a> for Twhere T: 'a,
§impl<'a, T> AsTaggedImplicit<'a> for Twhere
T: 'a,
impl<'a, T> AsTaggedImplicit<'a> for Twhere T: 'a,
source§impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.