Enum EarlyReturn 

pub enum EarlyReturn<Return, Expr = ()> {
    Expr(Expr),
    Return(Return),
}

EarlyReturn

an enum that shows a value returned from a function should be returned early or not.

Variants

Expr(Expr)

Treat the value as an expression.

Return(Return)

Treat the value as a return value.

Implementations

impl<R, E> EarlyReturn<R, E>

pub fn expr(e: E) -> Self

Create an EarlyReturn::Expr

pub fn ret(r: R) -> Self

Create an EarlyReturn::Return

pub fn swap(self) -> EarlyReturn<E, R>

Swap the return and expression value.

pub fn or_return<Expr2>( self, res: EarlyReturn<R, Expr2>, ) -> EarlyReturn<R, Expr2>

get the second value if the first value is EarlyReturn::Expr, otherwise return the first value.

pub fn or_expr<Return2>( self, res: EarlyReturn<Return2, E>, ) -> EarlyReturn<Return2, E>

get the second value if the first value is EarlyReturn::Return, otherwise return the first value.

pub fn map<F: FnOnce(E) -> E2, E2>(self, f: F) -> EarlyReturn<R, E2>

Map the expression value.

pub async fn process_map<P: Processor<E>>( self, processor: &P, ) -> EarlyReturn<R, Result<P::Output, P::Error>>

where E: Send,

Map the expression value with an async function.

pub fn map_return<F: FnOnce(R) -> R2, R2>(self, f: F) -> EarlyReturn<R2, E>

Map the return value.

pub fn flat_map<F: FnOnce(E) -> EarlyReturn<R, E2>, E2>( self, f: F, ) -> EarlyReturn<R, E2>

Bind function of the monad.

pub async fn process_flat_map<P: Processor<E, Output = EarlyReturn<R, E2>>, E2>( self, processor: &P, ) -> EarlyReturn<R, Result<E2, P::Error>>

where E: Send,

Bind function of the monad with an async function.

pub fn from_result<Ok>(res: Result<E, R>) -> EarlyReturn<Result<Ok, R>, E>

Create an early return from a result. The error is treated as the return value.

impl<R, E> EarlyReturn<R, EarlyReturn<R, E>>

pub fn flatten(self) -> EarlyReturn<R, E>

Flatten the early return.

impl<R, E> EarlyReturn<R, &E>

pub fn copied_expr(self) -> EarlyReturn<R, E>

where E: Copy,

Copy the expression value.

pub fn cloned_expr(self) -> EarlyReturn<R, E>

where E: Clone,

Clone the expression value.

pub fn owned_expr<Owned>(self) -> EarlyReturn<R, Owned>

where E: ToOwned<Owned = Owned>,

Convert the expression value to an owned value.

impl<Succ, Err, Expr> EarlyReturn<Result<Succ, Err>, Expr>

pub fn try_map<F: FnOnce(Expr) -> Result<Expr2, Err2>, Expr2, Err2: Into<Err>>( self, f: F, ) -> EarlyReturn<Result<Succ, Err>, Expr2>

Map the expression value with a fallible function. Return the error if the function returns an error.

pub async fn try_process_map<P: Processor<Expr, Output = Expr2, Error = Err>, Expr2>( self, processor: &P, ) -> EarlyReturn<Result<Succ, Err>, Expr2>

where Expr: Send,

Map the expression value with an async fallible function. Return the error if the function returns an error.

impl<T> EarlyReturn<T, T>

pub fn safe_unwrap(self) -> T

Unwrap the early return.