Enum Fault 

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

Fail minus the Rejected lane: what an operation that cannot reject (nothing about it is the caller’s to correct) returns. Reads return Fault<L>; writes return Fail<{Entity}ConstraintViolation, L> — the type itself says whether a call can ever hand back a domain outcome.

Variants

Denied(<L as LaneProfile>::Denied)

Transient(<L as LaneProfile>::Transient)

Fatal(<L as LaneProfile>::Fatal)

Implementations

impl<L> Fault<L>

where L: LaneProfile,

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

A borrowed view of the current lane.

impl Fault

pub fn classify(e: &(dyn Error + 'static)) -> Fault

Classify an erased error at a boundary that only has &(dyn Error + 'static) — e.g. &*boxed for a Box<dyn Error> that is not Send/Sync and so cannot become a lane payload’s source (Fatal’s and Transient’s sources are Arc<dyn Error + Send + Sync>, by design — see the crate README). No Send/Sync bound is needed here: every step only ever borrows e. Call before the next .await — the chain being walked may not be Send.

1. A lane payload anywhere in the chain wins, carried through intact — kind, context, and (now Send/Sync, having been cloned out) its own original source.
2. Else, for each blessed foreign type whose classify-* feature is enabled (sqlx::Error, serde_json::Error, reqwest::Error, in that order), the first one found anywhere in the chain is classified exactly as that feature’s impl Classify would — with the error’s message as context in place of the source this function cannot move out of a shared reference.
3. Else Fatal(FatalKind::Dependency), with message_chain (private) as context.

Rule 3 is a safety default, not a shrug: an error this function cannot otherwise classify must still surface as something a boundary pages on, never silently as nothing. A lane payload found by this rule may itself be a Denied — narrowing it away, if the boundary has no subject, is the caller’s explicit next step (see Fault::narrow_denied).

impl<L> Fault<L>

where L: LaneProfile,

pub fn lane(&self) -> Lane

pub fn is_transient(&self) -> bool

pub fn is_fatal(&self) -> bool

pub fn is_denied(&self) -> bool

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

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

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

Consumes the Transient lane, yielding the same profile with its transient slot disabled. attempts is what the retry loop counted; an exhausted transient becomes Fatal(Exhausted) with the last transient as its source.

pub fn narrow_denied(self) -> Fault<<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.

impl<L> Fault<L>

where L: LaneProfile<Denied = Denied>,

Borrowed lane accessors. min_exhaustive_patterns lets a by-value match name only the lanes a profile enables, but a borrowed match still demands an arm for every variant. These accessors are the borrowed form, so no caller ever has to write a match *never {} arm. Each is available only when the profile enables that lane, so e.as_denied() on a no-denial profile is a compile error rather than a permanent None.

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

impl<L> Fault<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<L> Fault<L>

where L: LaneProfile<Fatal = Fatal>,

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

impl<L> Fault<L>

where L: LaneProfile,

pub fn widen<M>(self) -> Fault<M>

where 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>,

Trait Implementations

impl<L> Clone for Fault<L>

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

fn clone(&self) -> Fault<L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L> Debug for Fault<L>

where 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<L> Display for Fault<L>

where L: LaneProfile,

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

Formats the value using the given formatter.

impl<L> Error for Fault<L>

where 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, M> From<W> for Fault<M>

where W: IntoLanes<Rejected = !>, M: LaneProfile, <W as IntoLanes>::Shape: IntoFault, <<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 Fault: only for a source that never rejects, and only into a profile that holds all of the source’s lanes. A rejection, or a mixed wrapper, entering a Fault function stays an explicit narrowing (narrow_rejected), never a silent ?.

Why this is coherent with the reflexive From<T> for T: Fault<M>’s own Shape is kind::Fault, which is not [kind::IntoFault], and every type and marker involved is local to errlanes. Do not replace the marker bound with associated-type equality across several impls on a generic W: two such impls overlap (rust-lang/rust#20400).

fn from(w: W) -> Fault<M>

Converts to this type from the input type.

impl<L> Laned for Fault<L>

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

type WithoutTransient = Fault<<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, ) -> <Fault<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<L> Repr for Fault<L>

where L: LaneProfile,

impl<L> Reshape for Fault<L>

where L: LaneProfile,

type WithDenied = Fault<<L as LaneProfile>::WithDenied>

type WithoutDenied = Fault<<L as LaneProfile>::WithoutDenied>

type WithTransient = Fault<<L as LaneProfile>::WithTransient>

type WithoutTransient = Fault<<L as LaneProfile>::WithoutTransient>

type WithFatal = Fault<<L as LaneProfile>::WithFatal>