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,

pub fn lanes(&self) -> LaneRef<'_, D>

A borrowed view of the current lane.

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 crate::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 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<W, D, M> From<W> for Fail<D, M>

where W: IntoLanes, D: Lift<<W as IntoLanes>::Rejected, Unmapped = !>, M: LaneProfile, <W as IntoLanes>::Shape: IntoFail, <<W as IntoLanes>::Lanes as LaneProfile>::Denied: Into<<M as LaneProfile>::Denied>, <<W as IntoLanes>::Lanes as LaneProfile>::Transient: Into<<M as LaneProfile>::Transient>, <<W as IntoLanes>::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 source’s lanes must fit the destination’s profile.

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

Converts to this type from the input type.

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

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

Note the NarrowTransient bound: a profile that admits Transient but not Fatal is not Laned, so retry cannot be handed one. Retrying an operation that claims it can never fail permanently is exactly the contradiction the bound rules out.

type WithoutTransient = Fail<D, <L as LaneProfile>::WithoutTransient>

fn lane(&self) -> Lane

fn level(&self) -> Level

The operator level of this failure: the lane’s default (Lane::level), overridden only by a Rejected outcome’s Rejection::level.

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

fn message(&self) -> String

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

fn is_transient(&self) -> bool

fn is_fatal(&self) -> bool

fn is_denied(&self) -> bool

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

where L: LaneProfile,

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

where L: LaneProfile,

type WithDenied = Fail<D, <L as LaneProfile>::WithDenied>

type WithoutDenied = Fail<D, <L as LaneProfile>::WithoutDenied>

type WithTransient = Fail<D, <L as LaneProfile>::WithTransient>

type WithoutTransient = Fail<D, <L as LaneProfile>::WithoutTransient>

type WithFatal = Fail<D, <L as LaneProfile>::WithFatal>