Enum Cause 

pub enum Cause<E> {
    Fail(E),
    Die(String),
    Interrupt(FiberId),
    Both(Box<Cause<E>>, Box<Cause<E>>),
    Then(Box<Cause<E>>, Box<Cause<E>>),
}

Effect failure algebra: typed errors, defects, fiber interrupts, and composite causes.

Variants

Fail(E)

Recoverable failure carrying the typed error E.

Die(String)

Defect (panic-style) message.

Interrupt(FiberId)

Fiber interrupted at fiber_id.

Both(Box<Cause<E>>, Box<Cause<E>>)

Parallel composition of two causes.

Then(Box<Cause<E>>, Box<Cause<E>>)

Sequential composition: left observed before right.

Implementations

impl<E> Cause<E>

pub fn fail(error: E) -> Self

Cause::Fail wrapping error.

pub fn die(message: impl Into<String>) -> Self

Cause::Die with message.

pub fn interrupt(fiber_id: FiberId) -> Self

Cause::Interrupt for fiber_id.

pub fn both(left: Cause<E>, right: Cause<E>) -> Self

Cause::Both combining left and right.

pub fn then(left: Cause<E>, right: Cause<E>) -> Self

Cause::Then sequencing left before right.

pub fn map_fail<E2, F>(self, map: F) -> Cause<E2>

where F: Fn(E) -> E2 + Copy,

Map Cause::Fail payloads with map; preserve other variants.

pub fn fail_option(self) -> Option<E>

Cause::Fail payload as Some, every other variant as None.

Uses crate::foundation::option_::option::from_predicate on the failure value.

pub fn contains<F>(&self, pred: &F) -> bool

where F: Fn(&Cause<E>) -> bool,

Return true if pred matches this cause or any sub-cause (depth-first).

pub fn pretty(&self) -> String

where E: Display + Clone + 'static,

Human-readable tree of this cause (for debugging and logs).

impl<E> Cause<Cause<E>>

pub fn flatten(self) -> Cause<E>

Flatten a Cause<Cause<E>> into Cause<E>.

Fail(inner) unwraps to inner; structural variants (Both, Then) are recursively flattened; Die and Interrupt are preserved.

Trait Implementations

impl<E: Clone> Clone for Cause<E>

fn clone(&self) -> Cause<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for Cause<E>

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

Formats the value using the given formatter.

impl<E: Hash + Eq + PartialEq> Hash for Cause<E>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<E: Hash + Eq + PartialEq> PartialEq for Cause<E>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: Clone + 'static> Semigroup for Cause<E>

Cause<E> with Cause::both forms a commutative semigroup.

Law: combine(combine(a, b), c) ≡ combine(a, combine(b, c)) (Both is associative).

fn combine(self, other: Self) -> Self

Combine two values associatively.

fn combine_ref(&self, other: &Self) -> Self

where Self: Clone,

Combine by reference, cloning as needed.

impl<E: Hash + Eq + PartialEq> Eq for Cause<E>