Trait StackableErr 

pub trait StackableErr {
    type Output;

    // Required methods
    fn stack(self) -> Self::Output;
    fn stack_locationless(self) -> Self::Output;
    fn stack_err<E: Display + Send + Sync + 'static>(self, e: E) -> Self::Output;
    fn stack_err_with<E: Display + Send + Sync + 'static, F: FnOnce() -> E>(
        self,
        f: F,
    ) -> Self::Output;
    fn stack_err_locationless<E: Display + Send + Sync + 'static>(
        self,
        e: E,
    ) -> Self::Output;
    fn stack_err_with_locationless<E: Display + Send + Sync + 'static, F: FnOnce() -> E>(
        self,
        f: F,
    ) -> Self::Output;
    fn wrap_err<D: Display + Send + Sync + 'static>(
        self,
        msg: D,
    ) -> Self::Output;
    fn wrap_err_with<D: Display + Send + Sync + 'static, F: FnOnce() -> D>(
        self,
        msg: F,
    ) -> Self::Output;
    fn context<D: Display + Send + Sync + 'static>(self, msg: D) -> Self::Output;
    fn with_context<D: Display + Send + Sync + 'static, F: FnOnce() -> D>(
        self,
        msg: F,
    ) -> Self::Output;
}

Conversion to and addition to the stack of a stackable_error::Error.

See the main crate documentation and implementation for examples.

Required Associated Types

type Output

Required Methods

fn stack(self) -> Self::Output

Pushes just location information to the error stack

fn stack_locationless(self) -> Self::Output

Only converts to Self::Output and pushes it on the error stack

fn stack_err<E: Display + Send + Sync + 'static>(self, e: E) -> Self::Output

Pushes the result of f and location information to the error stack

fn stack_err_with<E: Display + Send + Sync + 'static, F: FnOnce() -> E>( self, f: F, ) -> Self::Output

Pushes e and location information to the error stack

fn stack_err_locationless<E: Display + Send + Sync + 'static>( self, e: E, ) -> Self::Output

Pushes e without location information to the error stack

fn stack_err_with_locationless<E: Display + Send + Sync + 'static, F: FnOnce() -> E>( self, f: F, ) -> Self::Output

Pushes the result of f without location information to the error stack

fn wrap_err<D: Display + Send + Sync + 'static>(self, msg: D) -> Self::Output

Alternate for StackableErr::stack_err which can be used for easier translation to and from the eyre crate

fn wrap_err_with<D: Display + Send + Sync + 'static, F: FnOnce() -> D>( self, msg: F, ) -> Self::Output

Alternate for StackableErr::stack_err_with which can be used for easier translation to and from the eyre crate

fn context<D: Display + Send + Sync + 'static>(self, msg: D) -> Self::Output

Alternate for StackableErr::stack_err which can be used for easier translation to and from the anyhow crate

fn with_context<D: Display + Send + Sync + 'static, F: FnOnce() -> D>( self, msg: F, ) -> Self::Output

Alternate for StackableErr::stack_err_with which can be used for easier translation to and from the anyhow crate

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T> StackableErr for Option<T>

type Output = Result<T, StackedError>

fn stack(self) -> Self::Output

fn stack_locationless(self) -> Self::Output

fn stack_err<E1: Display + Send + Sync + 'static>(self, e: E1) -> Self::Output

fn stack_err_with<E1: Display + Send + Sync + 'static, F: FnOnce() -> E1>( self, f: F, ) -> Self::Output

fn stack_err_locationless<E1: Display + Send + Sync + 'static>( self, e: E1, ) -> Self::Output

fn stack_err_with_locationless<E1: Display + Send + Sync + 'static, F: FnOnce() -> E1>( self, f: F, ) -> Self::Output

fn wrap_err<D: Display + Send + Sync + 'static>(self, msg: D) -> Self::Output

fn wrap_err_with<D: Display + Send + Sync + 'static, F: FnOnce() -> D>( self, msg: F, ) -> Self::Output

fn context<D: Display + Send + Sync + 'static>(self, msg: D) -> Self::Output

fn with_context<D: Display + Send + Sync + 'static, F: FnOnce() -> D>( self, msg: F, ) -> Self::Output

impl<T, E: Display + Send + Sync + 'static> StackableErr for Result<T, E>

type Output = Result<T, StackedError>

fn stack(self) -> Self::Output

fn stack_locationless(self) -> Self::Output

fn stack_err<E1: Display + Send + Sync + 'static>(self, e: E1) -> Self::Output

fn stack_err_with<E1: Display + Send + Sync + 'static, F: FnOnce() -> E1>( self, f: F, ) -> Self::Output

fn stack_err_locationless<E1: Display + Send + Sync + 'static>( self, e: E1, ) -> Self::Output

fn stack_err_with_locationless<E1: Display + Send + Sync + 'static, F: FnOnce() -> E1>( self, f: F, ) -> Self::Output

fn wrap_err<D: Display + Send + Sync + 'static>(self, msg: D) -> Self::Output

fn wrap_err_with<D: Display + Send + Sync + 'static, F: FnOnce() -> D>( self, msg: F, ) -> Self::Output

fn context<D: Display + Send + Sync + 'static>(self, msg: D) -> Self::Output

fn with_context<D: Display + Send + Sync + 'static, F: FnOnce() -> D>( self, msg: F, ) -> Self::Output

Implementors

impl StackableErr for Error

type Output = Result<(), StackedError>