Enum Fail 

pub enum Fail<D, L = Profile<true, true, true>>
where
    L: LaneProfile,
{
    Rejected(D),
    Denied(<L as LaneProfile>::Denied),
    Transient(<L as LaneProfile>::Transient),
    Fatal(<L as LaneProfile>::Fatal),
}

The generic view over a domain rejection D, before retries have run.

Display discipline: Display’s Rejected arm keeps its rejected: {d} prefix for logs, but no boundary may build a user-facing message from to_string() — a rejection’s message may embed caller-supplied input. Use as_rejected and Rejection::code instead: record_fail keys error.code off the code, never the message, and a GraphQL boundary should do the same for its error extension.

Variants

Rejected(D)

Denied(<L as LaneProfile>::Denied)

Transient(<L as LaneProfile>::Transient)

Fatal(<L as LaneProfile>::Fatal)

Implementations

impl<D, L> Fail<D, L>

where L: LaneProfile<Denied = Denied>,

pub fn as_denied(&self) -> Option<&Denied>

impl<D, L> Fail<D, L>

where L: LaneProfile<Transient = Transient>,

pub fn as_transient(&self) -> Option<&Transient>

pub fn is_congestion(&self) -> bool

pub fn is_contention(&self) -> bool

See [TransientKind::is_contention].

impl<D, L> Fail<D, L>

where L: LaneProfile<Fatal = Fatal>,

pub fn as_fatal(&self) -> Option<&Fatal>

impl<D, L> Fail<D, L>

where L: LaneProfile,

pub fn lane(&self) -> Lane

pub fn widen<P, M>(self) -> Fail<P, M>

where P: Lift<D>, M: LaneProfile, <L as LaneProfile>::Denied: Into<<M as LaneProfile>::Denied>, <L as LaneProfile>::Transient: Into<<M as LaneProfile>::Transient>, <L as LaneProfile>::Fatal: Into<<M as LaneProfile>::Fatal>, <P as Lift<D>>::Unmapped: UnmappedInto<<M as LaneProfile>::Fatal>,

Widen the rejection and the lane profile without changing any classification. The value-level form of [WidenResult::widen], with the same single rule: P: Lift<D> is satisfied by a total From<D> (through errlanes’ blanket, Unmapped = Infallible) and by a partial #[lift(Source, unhandled = fatal)] mapping (Unmapped = Source), whose unmapped cases demote to Fatal(Invariant) with the rejection as their source — which is why a partial mapping requires the destination to admit Fatal. The strict/partial choice is declared once on the destination enum; the call site does not repeat it.

pub fn widen_with<P, M>( self, f: impl FnOnce(D) -> Result<P, Fatal>, ) -> Fail<P, M>

where M: LaneProfile<Fatal = Fatal>, <L as LaneProfile>::Denied: Into<<M as LaneProfile>::Denied>, <L as LaneProfile>::Transient: Into<<M as LaneProfile>::Transient>, <L as LaneProfile>::Fatal: Into<<M as LaneProfile>::Fatal>,

pub fn map_rejected<D2>(self, f: impl FnOnce(D) -> D2) -> Fail<D2, L>

pub fn rejected(self) -> Result<D, Fault<L>>

Narrows to the domain outcome, or the non-domain fault. let d = e.rejected()?; propagates the fault into any enclosing Fail<_, L> (or a Failure carrier) via the blanket From<Fault<L>>.

pub fn as_rejected(&self) -> Option<&D>

pub fn is_transient(&self) -> bool

pub fn is_fatal(&self) -> bool

pub fn is_denied(&self) -> bool

pub fn message(&self) -> String

where D: Rejection,

The operator-safe one-line text for this failure — exactly what record writes to exception.message, for a boundary that must persist it rather than (or as well as) record it. Transient/ Fatal: the whole source() chain joined with ": ". Denied: its Display. Rejected: the rejection’s code, never its message (display discipline — a rejection’s message may embed caller-supplied input).

pub fn narrow_transient( self, attempts: u32, ) -> Fail<D, <L as LaneProfile>::WithoutTransient>

where <L as LaneProfile>::Transient: NarrowTransient<<L as LaneProfile>::Fatal>,

Consumes the Transient lane, yielding the same rejection over L with its transient slot disabled. An exhausted transient becomes Fatal(Exhausted), carrying attempts and the last transient as its source.

pub fn narrow_denied(self) -> Fail<D, <L as LaneProfile>::WithoutDenied>

where <L as LaneProfile>::Denied: NarrowDenied<<L as LaneProfile>::Fatal>,

Narrows away the Denied lane: a denial at a boundary with no subject (code running as the system) becomes Fatal(Denied) with the Denied as its source.

pub fn narrow_rejected(self) -> Fault<L>

where D: Rejection, L: LaneProfile<Fatal = Fatal>,

Narrows away the Rejected lane: a rejection at a boundary with no caller to correct it is an invariant violation, and becomes Fatal(Invariant) with the rejection as its source — the same rule a partial #[lift(.., unhandled = fatal)] applies. Nothing is left to reject, so the result is a Fault. with_opaque_source: d’s Display may embed caller-supplied input (the same display discipline Rejection documents everywhere else), so source() still returns it for a handler or test to downcast_ref, but message_chain must not walk into it.

Trait Implementations

impl<D, L> Clone for Fail<D, L>

where D: Clone, L: Clone + LaneProfile, <L as LaneProfile>::Denied: Clone, <L as LaneProfile>::Transient: Clone, <L as LaneProfile>::Fatal: Clone,

fn clone(&self) -> Fail<D, L>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<D, L> Debug for Fail<D, L>

where D: Debug, L: Debug + LaneProfile, <L as LaneProfile>::Denied: Debug, <L as LaneProfile>::Transient: Debug, <L as LaneProfile>::Fatal: Debug,

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

Formats the value using the given formatter.

impl<D, L> Display for Fail<D, L>

where D: Display, L: LaneProfile,

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

Formats the value using the given formatter.

impl<D, L> Error for Fail<D, L>

where D: Error + 'static, L: LaneProfile,

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl<D, L> Failure for Fail<D, L>

where D: Rejection, L: LaneProfile,

type Rejection = D

type Lanes = L

fn into_fail( self, ) -> Fail<<Fail<D, L> as Failure>::Rejection, <Fail<D, L> as Failure>::Lanes>

fn from_fail( f: Fail<<Fail<D, L> as Failure>::Rejection, <Fail<D, L> as Failure>::Lanes>, ) -> Fail<D, L>

fn as_fail( &self, ) -> &Fail<<Fail<D, L> as Failure>::Rejection, <Fail<D, L> as Failure>::Lanes>

fn lane(&self) -> Lane

fn is_transient(&self) -> bool

impl<D, L> From<Denied> for Fail<D, L>

where L: LaneProfile<Denied = Denied> + LaneProfile,

fn from(d: Denied) -> Fail<D, L>

Converts to this type from the input type.

impl<D, L> From<Exhausted> for Fail<D, L>

where L: LaneProfile<Fatal = Fatal> + LaneProfile,

fn from(e: Exhausted) -> Fail<D, L>

Converts to this type from the input type.

impl<D, L> From<Fatal> for Fail<D, L>

where L: LaneProfile<Fatal = Fatal> + LaneProfile,

fn from(f: Fatal) -> Fail<D, L>

Converts to this type from the input type.

impl<D, S, L> From<Fault<S>> for Fail<D, L>

where S: LaneProfile, L: LaneProfile, <S as LaneProfile>::Denied: Into<<L as LaneProfile>::Denied>, <S as LaneProfile>::Transient: Into<<L as LaneProfile>::Transient>, <S as LaneProfile>::Fatal: Into<<L as LaneProfile>::Fatal>,

The real blanket the Infallible encoding could not have: Fault<L> is not Fail, so this does not overlap From<T> for T.

fn from(f: Fault<S>) -> Fail<D, L>

Converts to this type from the input type.

impl<D, L> From<Transient> for Fail<D, L>

where L: LaneProfile<Transient = Transient> + LaneProfile,

fn from(t: Transient) -> Fail<D, L>

Converts to this type from the input type.

impl<W, D, M> From<W> for Fail<D, M>

where W: Classify, D: Lift<<W as Classify>::Rejected, Unmapped = !>, M: LaneProfile, <<W as Classify>::Lanes as LaneProfile>::Denied: Into<<M as LaneProfile>::Denied>, <<W as Classify>::Lanes as LaneProfile>::Transient: Into<<M as LaneProfile>::Transient>, <<W as Classify>::Lanes as LaneProfile>::Fatal: Into<<M as LaneProfile>::Fatal>,

? into a Fail: the rejected part must be absorbed totally by D (no decision left for the call site to make with .widen()); the wrapper’s lanes must fit the destination’s profile. Replaces the narrower impl<C: Rejection, D: From<C>, L> From<C> for Fail<D, L> — a bare rejection is the W::Rejected = W, W::Lanes = NoLanes case of this.

fn from(w: W) -> Fail<D, M>

Converts to this type from the input type.