Enum RespResult

pub enum RespResult<T, E> {
    Success(T),
    Err(E),
}

resp result for more flexible control the response body

• Result will become 500 using as web framework response type when Err(_), the action usually not I expect
• using non-Result type as web framework response type cannot using ?, the code will fill with if let or match

that why I need a RespResult which can

• control respond code or other message when it become RespResult::Err, not always 500
• impl the Try thus can using friendly ? to simplify code

note: because the Try not stable yet, this crate need Nightly rust

Variants

Success(T)

the respond is success with response body T

Err(E)

the respond is failure with response error E

Implementations

impl<T, E> RespResult<T, E>

pub fn flag_ok( data: T, flags: impl Into<ExtraFlags>, ) -> RespResult<FlagWrap<T>, E>

create a RespResult::Success with flags

pub fn with_flags( self, flags: impl Into<ExtraFlags>, ) -> RespResult<FlagWrap<T>, E>

covert a RespResult::<T, E> into RespResult<FlagWrap<T>, E> with provide flags

impl<T, E> RespResult<T, E>

pub fn map<N, F>(self, f: F) -> RespResult<N, E>

where F: FnOnce(T) -> N,

map currently T into N,

this method is similar to the same name method of Result

pub fn map_err<N, F>(self, f: F) -> RespResult<T, N>

where F: FnOnce(E) -> N,

map currently E into N,

this method is similar to the same name method of Result

pub fn and_then<N, F>(self, f: F) -> RespResult<N, E>

where F: FnOnce(T) -> RespResult<N, E>,

this method is similar to the same name method of Result

pub fn or_else<N, F>(self, f: F) -> RespResult<T, N>

where F: FnOnce(E) -> RespResult<T, N>,

this method is similar to the same name method of Result

impl<T, E> RespResult<T, E>

pub fn ok(data: T) -> Self

create an success RespResult

pub fn err(err: E) -> Self

where E: RespError,

create an error RespResult

Trait Implementations

impl<T: Debug, E: RespError> Debug for RespResult<T, E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Display, E: RespError> Display for RespResult<T, E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, R> Fallible for RespResult<T, R>

type Success = T

type Failure = R

fn to_result(self) -> Result<<Self as Fallible>::Success, Self::Failure>

impl<T, E> From<RespResult<T, E>> for RespResult<FlagWrap<T>, E>

fn from(inner: RespResult<T, E>) -> Self

Converts to this type from the input type.

impl<T, E> From<Result<T, E>> for RespResult<T, E>

where E: RespError,

fn from(r: Result<T, E>) -> Self

Converts to this type from the input type.

impl<T, E, F> FromResidual<RespResult<Infallible, E>> for Result<T, F>

where F: From<E>,

fn from_residual(residual: RespResult<Infallible, E>) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2)

Constructs the type from a compatible Residual type.

impl<T, E, Ei> FromResidual<RespResult<Infallible, Ei>> for RespResult<T, E>

where E: From<Ei>,

fn from_residual(residual: RespResult<Infallible, Ei>) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2)

Constructs the type from a compatible Residual type.

impl<T, E, F> FromResidual<Result<Infallible, E>> for RespResult<T, F>

where F: From<E>,

fn from_residual(residual: Result<Infallible, E>) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2)

Constructs the type from a compatible Residual type.

impl<E, T> IntoRespResult<T, E> for RespResult<T, E>

where E: RespError,

fn into_rresult(self) -> RespResult<T, E>

impl<T, E> IntoResponse for RespResult<T, E>

where T: RespBody, E: RespError,

fn into_response(self) -> Response

Create a response.

impl<T, E: RespError> Try for RespResult<T, E>

type Output = T

🔬This is a nightly-only experimental API. (try_trait_v2)

The type of the value produced by ? when not short-circuiting.

type Residual = RespResult<Infallible, E>

🔬This is a nightly-only experimental API. (try_trait_v2)

The type of the value passed to FromResidual::from_residual as part of ? when short-circuiting.

fn from_output(output: Self::Output) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2)

Constructs the type from its Output type.

fn branch(self) -> ControlFlow<Self::Residual, Self::Output>

🔬This is a nightly-only experimental API. (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).