pub type Outcome<S, E> = Outcome<S, (Status, E), Status>;
Expand description
Type alias for the Outcome
of a FromRequest
conversion.
Aliased Type§
enum Outcome<S, E> {
Success(S),
Failure((Status, E)),
Forward(Status),
}
Variants§
Success(S)
Contains the success value.
Failure((Status, E))
Contains the failure error value.
Forward(Status)
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));
Trait Implementations§
source§impl<'r, T: FromRequest<'r>> FromRequest<'r> for Outcome<T, T::Error>
impl<'r, T: FromRequest<'r>> FromRequest<'r> for Outcome<T, T::Error>
§type Error = Infallible
type Error = Infallible
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 more