Enum Fail 

pub enum Fail<D, L: LaneProfile = AllLanes> {
    Rejected(D),
    Denied(L::Denied),
    Transient(L::Transient),
    Fatal(L::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::Denied)

Transient(L::Transient)

Fatal(L::Fatal)

Implementations

impl<D, L: LaneProfile<Denied = Denied>> Fail<D, L>

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

impl<D, L: LaneProfile<Transient = Transient>> Fail<D, L>

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: LaneProfile<Fatal = Fatal>> Fail<D, L>

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

impl<D, L: LaneProfile> Fail<D, L>

pub fn lane(&self) -> Lane

pub fn widen<P: Lift<D>, M: LaneProfile>(self) -> Fail<P, M>

where L::Denied: Into<M::Denied>, L::Transient: Into<M::Transient>, L::Fatal: Into<M::Fatal>, P::Unmapped: UnmappedInto<M::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: LaneProfile<Fatal = Fatal>>( self, f: impl FnOnce(D) -> Result<P, Fatal>, ) -> Fail<P, M>

where L::Denied: Into<M::Denied>, L::Transient: Into<M::Transient>, L::Fatal: Into<M::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, WithoutTransient<L>>

where L::Transient: NarrowTransient<L::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, WithoutDenied<L>>

where L::Denied: NarrowDenied<L::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: Clone, L: Clone + LaneProfile> Clone for Fail<D, L>

where L::Denied: Clone, L::Transient: Clone, L::Fatal: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D: Debug, L: Debug + LaneProfile> Debug for Fail<D, L>

where L::Denied: Debug, L::Transient: Debug, L::Fatal: Debug,

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl<D: Error + 'static, L: LaneProfile> Error for Fail<D, L>

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: Rejection, L: LaneProfile> Failure for Fail<D, L>

type Rejection = D

type Lanes = L

fn into_fail(self) -> Fail<Self::Rejection, Self::Lanes>

fn from_fail(f: Fail<Self::Rejection, Self::Lanes>) -> Self

fn as_fail(&self) -> &Fail<Self::Rejection, Self::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) -> Self

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) -> Self

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) -> Self

Converts to this type from the input type.

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

where S::Denied: Into<L::Denied>, S::Transient: Into<L::Transient>, S::Fatal: Into<L::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>) -> Self

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) -> Self

Converts to this type from the input type.

impl<W: Classify, D: Lift<W::Rejected, Unmapped = Infallible>, M: LaneProfile> From<W> for Fail<D, M>

where <W::Lanes as LaneProfile>::Denied: Into<M::Denied>, <W::Lanes as LaneProfile>::Transient: Into<M::Transient>, <W::Lanes as LaneProfile>::Fatal: Into<M::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) -> Self

Converts to this type from the input type.