version = "0.4.2" # remember to update html_root_url

version = "0.4.3" # remember to update html_root_url

description = "Flexible concrete Error Reporting type built on std::error::Error with customizable Context and Reports"

description = "Flexible concrete Error Reporting type built on std::error::Error with customizable Reports"

[actions-badge]: https://github.com/yaahc/eyre/workflows/Continuous%20integration/badge.svg
[actions-url]: https://github.com/yaahc/eyre/actions?query=workflow%3A%22Continuous+integration%22

[`eyre::EyreContext`].

[`eyre::EyreHandler`].

## Custom Contexts

```toml
[dependencies]
eyre = "0.4"
```

The heart of this crate is its ability to swap out the Context type to change

## Custom Report Handlers
The heart of this crate is its ability to swap out the Handler type to change

customize its behavior. Below is a list of known custom context crates and
short summaries of what features they provide.

customize its behavior. Below is a list of known crates that export report
handlers for eyre and short summaries of what features they provide.

  `DefaultContext`'s report format.

  `DefaultHandler`'s report format.

- [`simple-eyre`]: A minimal `EyreContext` that captures no additional

- [`simple-eyre`]: A minimal `EyreHandler` that captures no additional

- [`jane-eyre`]: A custom context type that exists purely for the pun.
  Currently just re-exports `color-eyre`.

- [`jane-eyre`]: A a report handler crate that exists purely for the pun.
Currently just re-exports `color-eyre`.

the Context parameter. The solution to this problem, should you encounter it,

the Handler parameter. The solution to this problem, should you encounter it,

[`eyre::EyreContext`]: https://docs.rs/eyre/*/eyre/trait.EyreContext.html

[`eyre::EyreHandler`]: https://docs.rs/eyre/*/eyre/trait.EyreHandler.html

[actions-badge]: https://github.com/yaahc/eyre/workflows/Continuous%20integration/badge.svg
[actions-url]: https://github.com/yaahc/eyre/actions?query=workflow%3A%22Continuous+integration%22

use crate::{ContextCompat, EyreContext, Report, StdError, WrapErr};

use crate::{ContextCompat, EyreHandler, Report, StdError, WrapErr};

    pub trait StdError<C>

    pub trait StdError<H>

        C: EyreContext,

        H: EyreHandler,

        fn ext_report<D>(self, msg: D) -> Report<C>

        fn ext_report<D>(self, msg: D) -> Report<H>

    impl<E, C> StdError<C> for E

    impl<E, H> StdError<H> for E

        C: EyreContext,

        H: EyreHandler,

        fn ext_report<D>(self, msg: D) -> Report<C>

        fn ext_report<D>(self, msg: D) -> Report<H>

    impl<C> StdError<C> for Report<C>

    impl<H> StdError<H> for Report<H>

        C: EyreContext,

        H: EyreHandler,

        fn ext_report<D>(self, msg: D) -> Report<C>

        fn ext_report<D>(self, msg: D) -> Report<H>

impl<T, E, C> WrapErr<T, E, C> for Result<T, E>

impl<T, E, H> WrapErr<T, E, H> for Result<T, E>

    C: EyreContext,
    E: ext::StdError<C> + Send + Sync + 'static,

    H: EyreHandler,
    E: ext::StdError<H> + Send + Sync + 'static,

    fn wrap_err<D>(self, msg: D) -> Result<T, Report<C>>

    fn wrap_err<D>(self, msg: D) -> Result<T, Report<H>>

    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, Report<C>>

    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, Report<H>>

    fn context<D>(self, msg: D) -> Result<T, Report<C>>

    fn context<D>(self, msg: D) -> Result<T, Report<H>>

    fn with_context<D, F>(self, msg: F) -> Result<T, Report<C>>

    fn with_context<D, F>(self, msg: F) -> Result<T, Report<H>>

impl<T, C> ContextCompat<T, C> for Option<T>

impl<T, H> ContextCompat<T, H> for Option<T>

    C: EyreContext,

    H: EyreHandler,

    fn wrap_err<D>(self, msg: D) -> Result<T, Report<C>>

    fn wrap_err<D>(self, msg: D) -> Result<T, Report<H>>

    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, Report<C>>

    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, Report<H>>

    fn context<D>(self, msg: D) -> Result<T, Report<C>>

    fn context<D>(self, msg: D) -> Result<T, Report<H>>

    fn with_context<D, F>(self, msg: F) -> Result<T, Report<C>>

    fn with_context<D, F>(self, msg: F) -> Result<T, Report<H>>

impl<D, C> StdError for ContextError<D, Report<C>>

impl<D, H> StdError for ContextError<D, Report<H>>

    C: EyreContext,

    H: EyreHandler,

    pub trait Sealed<C: EyreContext> {}

    pub trait Sealed<H: EyreHandler> {}

    impl<T, E, C: EyreContext> Sealed<C> for Result<T, E> where E: ext::StdError<C> {}
    impl<T, C: EyreContext> Sealed<C> for Option<T> {}

    impl<T, E, H: EyreHandler> Sealed<H> for Result<T, E> where E: ext::StdError<H> {}
    impl<T, H: EyreHandler> Sealed<H> for Option<T> {}

use crate::EyreContext;

use crate::EyreHandler;

impl<C> Report<C>

impl<H> Report<H>

    C: EyreContext,

    H: EyreHandler,

            object_drop: object_drop::<E, C>,
            object_ref: object_ref::<E, C>,

            object_drop: object_drop::<E, H>,
            object_ref: object_ref::<E, H>,

            object_mut: object_mut::<E, C>,
            object_boxed: object_boxed::<E, C>,
            object_downcast: object_downcast::<E, C>,
            object_drop_rest: object_drop_front::<E, C>,

            object_mut: object_mut::<E, H>,
            object_boxed: object_boxed::<E, H>,
            object_downcast: object_downcast::<E, H>,
            object_drop_rest: object_drop_front::<E, H>,

        let context = Some(C::default(&error));
        unsafe { Report::construct(error, vtable, context) }

        let handler = Some(H::default(&error));
        unsafe { Report::construct(error, vtable, handler) }

            object_drop: object_drop::<MessageError<M>, C>,
            object_ref: object_ref::<MessageError<M>, C>,

            object_drop: object_drop::<MessageError<M>, H>,
            object_ref: object_ref::<MessageError<M>, H>,

            object_mut: object_mut::<MessageError<M>, C>,
            object_boxed: object_boxed::<MessageError<M>, C>,
            object_downcast: object_downcast::<M, C>,
            object_drop_rest: object_drop_front::<M, C>,

            object_mut: object_mut::<MessageError<M>, H>,
            object_boxed: object_boxed::<MessageError<M>, H>,
            object_downcast: object_downcast::<M, H>,
            object_drop_rest: object_drop_front::<M, H>,

        let context = Some(C::default(&error));
        unsafe { Report::construct(error, vtable, context) }

        let handler = Some(H::default(&error));
        unsafe { Report::construct(error, vtable, handler) }

            object_drop: object_drop::<DisplayError<M>, C>,
            object_ref: object_ref::<DisplayError<M>, C>,

            object_drop: object_drop::<DisplayError<M>, H>,
            object_ref: object_ref::<DisplayError<M>, H>,

            object_mut: object_mut::<DisplayError<M>, C>,
            object_boxed: object_boxed::<DisplayError<M>, C>,
            object_downcast: object_downcast::<M, C>,
            object_drop_rest: object_drop_front::<M, C>,

            object_mut: object_mut::<DisplayError<M>, H>,
            object_boxed: object_boxed::<DisplayError<M>, H>,
            object_downcast: object_downcast::<M, H>,
            object_drop_rest: object_drop_front::<M, H>,

        let context = Some(C::default(&NoneError));
        unsafe { Report::construct(error, vtable, context) }

        let handler = Some(H::default(&NoneError));
        unsafe { Report::construct(error, vtable, handler) }

            object_drop: object_drop::<ContextError<D, E>, C>,
            object_ref: object_ref::<ContextError<D, E>, C>,

            object_drop: object_drop::<ContextError<D, E>, H>,
            object_ref: object_ref::<ContextError<D, E>, H>,

            object_mut: object_mut::<ContextError<D, E>, C>,
            object_boxed: object_boxed::<ContextError<D, E>, C>,
            object_downcast: context_downcast::<D, E, C>,
            object_drop_rest: context_drop_rest::<D, E, C>,

            object_mut: object_mut::<ContextError<D, E>, H>,
            object_boxed: object_boxed::<ContextError<D, E>, H>,
            object_downcast: context_downcast::<D, E, H>,
            object_drop_rest: context_drop_rest::<D, E, H>,

        let context = Some(C::default(&error));
        unsafe { Report::construct(error, vtable, context) }

        let handler = Some(H::default(&error));
        unsafe { Report::construct(error, vtable, handler) }

        let context = Some(C::default(&error));

        let handler = Some(H::default(&error));

            object_drop: object_drop::<BoxedError, C>,
            object_ref: object_ref::<BoxedError, C>,

            object_drop: object_drop::<BoxedError, H>,
            object_ref: object_ref::<BoxedError, H>,

            object_mut: object_mut::<BoxedError, C>,
            object_boxed: object_boxed::<BoxedError, C>,
            object_downcast: object_downcast::<Box<dyn StdError + Send + Sync>, C>,
            object_drop_rest: object_drop_front::<Box<dyn StdError + Send + Sync>, C>,

            object_mut: object_mut::<BoxedError, H>,
            object_boxed: object_boxed::<BoxedError, H>,
            object_downcast: object_downcast::<Box<dyn StdError + Send + Sync>, H>,
            object_drop_rest: object_drop_front::<Box<dyn StdError + Send + Sync>, H>,

        unsafe { Report::construct(error, vtable, context) }

        unsafe { Report::construct(error, vtable, handler) }

    unsafe fn construct<E>(error: E, vtable: &'static ErrorVTable<C>, context: Option<C>) -> Self

    unsafe fn construct<E>(error: E, vtable: &'static ErrorVTable<H>, handler: Option<H>) -> Self

            context,

            handler,

        let erased = mem::transmute::<Box<ErrorImpl<E, C>>, Box<ErrorImpl<(), C>>>(inner);

        let erased = mem::transmute::<Box<ErrorImpl<E, H>>, Box<ErrorImpl<(), H>>>(inner);

        let context = self.inner.context.take();
        let error: ContextError<D, Report<C>> = ContextError { msg, error: self };

        let handler = self.inner.handler.take();
        let error: ContextError<D, Report<H>> = ContextError { msg, error: self };

            object_drop: object_drop::<ContextError<D, Report<C>>, C>,
            object_ref: object_ref::<ContextError<D, Report<C>>, C>,

            object_drop: object_drop::<ContextError<D, Report<H>>, H>,
            object_ref: object_ref::<ContextError<D, Report<H>>, H>,

            object_mut: object_mut::<ContextError<D, Report<C>>, C>,
            object_boxed: object_boxed::<ContextError<D, Report<C>>, C>,
            object_downcast: context_chain_downcast::<D, C>,
            object_drop_rest: context_chain_drop_rest::<D, C>,

            object_mut: object_mut::<ContextError<D, Report<H>>, H>,
            object_boxed: object_boxed::<ContextError<D, Report<H>>, H>,
            object_downcast: context_chain_downcast::<D, H>,
            object_drop_rest: context_chain_drop_rest::<D, H>,

        unsafe { Report::construct(error, vtable, context) }

        unsafe { Report::construct(error, vtable, handler) }

    /// Get a reference to the Context for this Report.
    pub fn context(&self) -> &C {
        self.inner.context.as_ref().unwrap()

    /// Get a reference to the Handler for this Report.
    pub fn handler(&self) -> &H {
        self.inner.handler.as_ref().unwrap()

    /// Get a mutable reference to the Context for this Report.
    pub fn context_mut(&mut self) -> &mut C {
        self.inner.context.as_mut().unwrap()

    /// Get a mutable reference to the Handler for this Report.
    pub fn handler_mut(&mut self) -> &mut H {
        self.inner.handler.as_mut().unwrap()
    }
    /// Get a reference to the Handler for this Report.
    #[doc(hidden)]
    pub fn context(&self) -> &H {
        self.inner.handler.as_ref().unwrap()

    /// Get a mutable reference to the Handler for this Report.
    #[doc(hidden)]
    pub fn context_mut(&mut self) -> &mut H {
        self.inner.handler.as_mut().unwrap()
    }

impl<E, C> From<E> for Report<C>

impl<E, H> From<E> for Report<H>

    C: EyreContext,

    H: EyreHandler,

impl<C: EyreContext> Deref for Report<C> {

impl<H: EyreHandler> Deref for Report<H> {

impl<C: EyreContext> DerefMut for Report<C> {

impl<H: EyreHandler> DerefMut for Report<H> {

impl<C: EyreContext> Display for Report<C> {

impl<H: EyreHandler> Display for Report<H> {

impl<C: EyreContext> Debug for Report<C> {

impl<H: EyreHandler> Debug for Report<H> {

impl<C> Drop for Report<C>

impl<H> Drop for Report<H>

    C: EyreContext,

    H: EyreHandler,

struct ErrorVTable<C>

struct ErrorVTable<H>

    C: EyreContext,

    H: EyreHandler,

    object_drop: unsafe fn(Box<ErrorImpl<(), C>>),
    object_ref: unsafe fn(&ErrorImpl<(), C>) -> &(dyn StdError + Send + Sync + 'static),

    object_drop: unsafe fn(Box<ErrorImpl<(), H>>),
    object_ref: unsafe fn(&ErrorImpl<(), H>) -> &(dyn StdError + Send + Sync + 'static),

    object_mut: unsafe fn(&mut ErrorImpl<(), C>) -> &mut (dyn StdError + Send + Sync + 'static),

    object_mut: unsafe fn(&mut ErrorImpl<(), H>) -> &mut (dyn StdError + Send + Sync + 'static),

    object_boxed: unsafe fn(Box<ErrorImpl<(), C>>) -> Box<dyn StdError + Send + Sync + 'static>,
    object_downcast: unsafe fn(&ErrorImpl<(), C>, TypeId) -> Option<NonNull<()>>,
    object_drop_rest: unsafe fn(Box<ErrorImpl<(), C>>, TypeId),

    object_boxed: unsafe fn(Box<ErrorImpl<(), H>>) -> Box<dyn StdError + Send + Sync + 'static>,
    object_downcast: unsafe fn(&ErrorImpl<(), H>, TypeId) -> Option<NonNull<()>>,
    object_drop_rest: unsafe fn(Box<ErrorImpl<(), H>>, TypeId),

unsafe fn object_drop<E, C>(e: Box<ErrorImpl<(), C>>)

unsafe fn object_drop<E, H>(e: Box<ErrorImpl<(), H>>)

    C: EyreContext,

    H: EyreHandler,

    let unerased = mem::transmute::<Box<ErrorImpl<(), C>>, Box<ErrorImpl<E, C>>>(e);

    let unerased = mem::transmute::<Box<ErrorImpl<(), H>>, Box<ErrorImpl<E, H>>>(e);

unsafe fn object_drop_front<E, C>(e: Box<ErrorImpl<(), C>>, target: TypeId)

unsafe fn object_drop_front<E, H>(e: Box<ErrorImpl<(), H>>, target: TypeId)

    C: EyreContext,

    H: EyreHandler,

    let unerased = mem::transmute::<Box<ErrorImpl<(), C>>, Box<ErrorImpl<ManuallyDrop<E>, C>>>(e);

    let unerased = mem::transmute::<Box<ErrorImpl<(), H>>, Box<ErrorImpl<ManuallyDrop<E>, H>>>(e);

unsafe fn object_ref<E, C>(e: &ErrorImpl<(), C>) -> &(dyn StdError + Send + Sync + 'static)

unsafe fn object_ref<E, H>(e: &ErrorImpl<(), H>) -> &(dyn StdError + Send + Sync + 'static)

    C: EyreContext,

    H: EyreHandler,

    &(*(e as *const ErrorImpl<(), C> as *const ErrorImpl<E, C>))._object

    &(*(e as *const ErrorImpl<(), H> as *const ErrorImpl<E, H>))._object

unsafe fn object_mut<E, C>(e: &mut ErrorImpl<(), C>) -> &mut (dyn StdError + Send + Sync + 'static)

unsafe fn object_mut<E, H>(e: &mut ErrorImpl<(), H>) -> &mut (dyn StdError + Send + Sync + 'static)

    C: EyreContext,

    H: EyreHandler,

    &mut (*(e as *mut ErrorImpl<(), C> as *mut ErrorImpl<E, C>))._object

    &mut (*(e as *mut ErrorImpl<(), H> as *mut ErrorImpl<E, H>))._object

unsafe fn object_boxed<E, C>(e: Box<ErrorImpl<(), C>>) -> Box<dyn StdError + Send + Sync + 'static>

unsafe fn object_boxed<E, H>(e: Box<ErrorImpl<(), H>>) -> Box<dyn StdError + Send + Sync + 'static>

    C: EyreContext,

    H: EyreHandler,

    C: Send + Sync + 'static,

    H: Send + Sync + 'static,

    mem::transmute::<Box<ErrorImpl<(), C>>, Box<ErrorImpl<E, C>>>(e)

    mem::transmute::<Box<ErrorImpl<(), H>>, Box<ErrorImpl<E, H>>>(e)

unsafe fn object_downcast<E, C>(e: &ErrorImpl<(), C>, target: TypeId) -> Option<NonNull<()>>

unsafe fn object_downcast<E, H>(e: &ErrorImpl<(), H>, target: TypeId) -> Option<NonNull<()>>

    C: EyreContext,

    H: EyreHandler,

        let unerased = e as *const ErrorImpl<(), C> as *const ErrorImpl<E, C>;

        let unerased = e as *const ErrorImpl<(), H> as *const ErrorImpl<E, H>;

unsafe fn context_downcast<D, E, C>(e: &ErrorImpl<(), C>, target: TypeId) -> Option<NonNull<()>>

unsafe fn context_downcast<D, E, H>(e: &ErrorImpl<(), H>, target: TypeId) -> Option<NonNull<()>>

    C: EyreContext,

    H: EyreHandler,

        let unerased = e as *const ErrorImpl<(), C> as *const ErrorImpl<ContextError<D, E>, C>;

        let unerased = e as *const ErrorImpl<(), H> as *const ErrorImpl<ContextError<D, E>, H>;

        let unerased = e as *const ErrorImpl<(), C> as *const ErrorImpl<ContextError<D, E>, C>;

        let unerased = e as *const ErrorImpl<(), H> as *const ErrorImpl<ContextError<D, E>, H>;

unsafe fn context_drop_rest<D, E, C>(e: Box<ErrorImpl<(), C>>, target: TypeId)

unsafe fn context_drop_rest<D, E, H>(e: Box<ErrorImpl<(), H>>, target: TypeId)

    C: EyreContext,

    H: EyreHandler,

            Box<ErrorImpl<(), C>>,
            Box<ErrorImpl<ContextError<ManuallyDrop<D>, E>, C>>,

            Box<ErrorImpl<(), H>>,
            Box<ErrorImpl<ContextError<ManuallyDrop<D>, E>, H>>,

            Box<ErrorImpl<(), C>>,
            Box<ErrorImpl<ContextError<D, ManuallyDrop<E>>, C>>,

            Box<ErrorImpl<(), H>>,
            Box<ErrorImpl<ContextError<D, ManuallyDrop<E>>, H>>,

unsafe fn context_chain_downcast<D, C>(e: &ErrorImpl<(), C>, target: TypeId) -> Option<NonNull<()>>

unsafe fn context_chain_downcast<D, H>(e: &ErrorImpl<(), H>, target: TypeId) -> Option<NonNull<()>>

    C: EyreContext,

    H: EyreHandler,

            e as *const ErrorImpl<(), C> as *const ErrorImpl<ContextError<D, Report<C>>, C>;

            e as *const ErrorImpl<(), H> as *const ErrorImpl<ContextError<D, Report<H>>, H>;

            e as *const ErrorImpl<(), C> as *const ErrorImpl<ContextError<D, Report<C>>, C>;

            e as *const ErrorImpl<(), H> as *const ErrorImpl<ContextError<D, Report<H>>, H>;

unsafe fn context_chain_drop_rest<D, C>(e: Box<ErrorImpl<(), C>>, target: TypeId)

unsafe fn context_chain_drop_rest<D, H>(e: Box<ErrorImpl<(), H>>, target: TypeId)

    C: EyreContext,

    H: EyreHandler,

            Box<ErrorImpl<(), C>>,
            Box<ErrorImpl<ContextError<ManuallyDrop<D>, Report<C>>, C>>,

            Box<ErrorImpl<(), H>>,
            Box<ErrorImpl<ContextError<ManuallyDrop<D>, Report<H>>, H>>,

            Box<ErrorImpl<(), C>>,
            Box<ErrorImpl<ContextError<D, ManuallyDrop<Report<C>>>, C>>,

            Box<ErrorImpl<(), H>>,
            Box<ErrorImpl<ContextError<D, ManuallyDrop<Report<H>>>, H>>,

pub(crate) struct ErrorImpl<E, C>

pub(crate) struct ErrorImpl<E, H>

    C: EyreContext,

    H: EyreHandler,

    vtable: &'static ErrorVTable<C>,
    pub(crate) context: Option<C>,

    vtable: &'static ErrorVTable<H>,
    pub(crate) handler: Option<H>,

impl<E, C> ErrorImpl<E, C>

impl<E, H> ErrorImpl<E, H>

    C: EyreContext,

    H: EyreHandler,

    fn erase(&self) -> &ErrorImpl<(), C> {

    fn erase(&self) -> &ErrorImpl<(), H> {

        unsafe { &*(self as *const ErrorImpl<E, C> as *const ErrorImpl<(), C>) }

        unsafe { &*(self as *const ErrorImpl<E, H> as *const ErrorImpl<(), H>) }

impl<C> ErrorImpl<(), C>

impl<H> ErrorImpl<(), H>

    C: EyreContext,

    H: EyreHandler,

impl<E, C> StdError for ErrorImpl<E, C>

impl<E, H> StdError for ErrorImpl<E, H>

    C: EyreContext,

    H: EyreHandler,

impl<E, C> Debug for ErrorImpl<E, C>

impl<E, H> Debug for ErrorImpl<E, H>

    C: EyreContext,

    H: EyreHandler,

impl<E, C> Display for ErrorImpl<E, C>

impl<E, H> Display for ErrorImpl<E, H>

    C: EyreContext,

    H: EyreHandler,

impl<C: EyreContext> From<Report<C>> for Box<dyn StdError + Send + Sync + 'static> {
    fn from(error: Report<C>) -> Self {

impl<H: EyreHandler> From<Report<H>> for Box<dyn StdError + Send + Sync + 'static> {
    fn from(error: Report<H>) -> Self {

impl<C: EyreContext> From<Report<C>> for Box<dyn StdError + 'static> {
    fn from(error: Report<C>) -> Self {

impl<H: EyreHandler> From<Report<H>> for Box<dyn StdError + 'static> {
    fn from(error: Report<H>) -> Self {

impl<C: EyreContext> AsRef<dyn StdError + Send + Sync> for Report<C> {

impl<H: EyreHandler> AsRef<dyn StdError + Send + Sync> for Report<H> {

impl<C: EyreContext> AsRef<dyn StdError> for Report<C> {

impl<H: EyreHandler> AsRef<dyn StdError> for Report<H> {

use crate::EyreContext;

use crate::EyreHandler;

impl<C> ErrorImpl<(), C>

impl<H> ErrorImpl<(), H>

    C: EyreContext,

    H: EyreHandler,

        self.context

        self.handler

            .map(|context| context.display(self.error(), f))

            .map(|handler| handler.display(self.error(), f))

        self.context

        self.handler

            .map(|context| context.debug(self.error(), f))

            .map(|handler| handler.debug(self.error(), f))

use crate::{EyreContext, Report};

use crate::{EyreHandler, Report};

    pub fn new<M, C: EyreContext>(self, message: M) -> Report<C>

    pub fn new<M, H: EyreHandler>(self, message: M) -> Report<H>

    pub fn new<C: EyreContext>(self, error: Box<dyn StdError + Send + Sync>) -> Report<C> {

    pub fn new<H: EyreHandler>(self, error: Box<dyn StdError + Send + Sync>) -> Report<H> {

//! This library provides [`eyre::Report`][Report], a trait object based error
//! type for easy idiomatic error handling in Rust applications.

//! This library provides [`eyre::Report`][Report], a trait object based
//! error handling type for easy idiomatic error handling and reporting in Rust
//! applications.

//! [`eyre::EyreContext`].

//! [`eyre::EyreHandler`].

//! ```toml
//! [dependencies]
//! eyre = "0.4"
//! ```

//! ## Custom Report Handlers

//! ## Custom Contexts
//!
//! The heart of this crate is it's ability to swap out the Context type to change

//! The heart of this crate is its ability to swap out the Handler type to change

//! customize its behavior. Below is a list of known custom context crates and
//! short summaries of what features they provide.

//! customize its behavior. Below is a list of known crates that export report
//! handlers for eyre and short summaries of what features they provide.

//!   `DefaultContext`'s report format.

//!   `DefaultHandler`'s report format.

//! - [`simple-eyre`]: A minimal `EyreContext` that captures no additional

//! - [`simple-eyre`]: A minimal `EyreHandler` that captures no additional

//! - [`jane-eyre`]: A custom context type that exists purely for the pun.
//!   Currently just re-exports `color-eyre`.

//! - [`jane-eyre`]: A a report handler crate that exists purely for the pun.
//! Currently just re-exports `color-eyre`.

//! - Use `Result<T, eyre::Report>`, or equivalently `eyre::Result<T>`, as
//!   the return type of any fallible function.

//! - Use `Result<T, eyre::Report>`, or equivalently `eyre::Result<T>`, as the
//!   return type of any fallible function.

//!   Within the function, use `?` to easily propagate any error that implements
//!   the `std::error::Report` trait.

//!   Within the function, use `?` to easily propagate any error that implements the
//!   `std::error::Error` trait.

//!   ```

//!   ```rust

//! - Create new errors from messages to help the person troubleshooting the error understand where
//! things went wrong. A low-level error like "No such file or directory" can be annoying to
//! directly and often benefit from being wrapped with higher level error messages.

//! - Wrap a lower level error with a new error created from a message to help the
//!   person troubleshooting understand what the chain of failures that occured. A
//!   low-level error like "No such file or directory" can be annoying to debug
//!   without more information about what higher level step the application was in
//!   the middle of.

//!   ```

//!   ```rust

//!   ```

//!   ```rust

//!   error if the underlying error type does not already provide its own. In
//!   order to see backtraces, they must be enabled through the environment
//!   variables described in [`std::backtrace`]:

//!   error if the underlying error type does not already provide its own. In order
//!   to see backtraces, they must be enabled through the environment variables
//!   described in [`std::backtrace`]:

//!   including ones defined in your crate. We do not bundle a `derive(Error)`
//!   macro but you can write the impls yourself or use a standalone macro like

//!   including ones defined in your crate. We do not bundle a `derive(Error)` macro
//!   but you can write the impls yourself or use a standalone macro like

//!
//!   [thiserror]: https://github.com/dtolnay/thiserror

//!   ```

//!   ```rust

//!   ```

//!   ```rust

//! In no_std mode, the same API is almost all available and works the same way.
//! To depend on Eyre in no_std mode, disable our default enabled "std"
//! feature in Cargo.toml. A global allocator is required.

//! **NOTE**: tests are currently broken for `no_std` so I cannot guarantee that
//! everything works still. I'm waiting for upstream fixes to be merged rather than
//! fixing them myself, so bear with me.
//!
//! In no_std mode, the same API is almost all available and works the same way. To
//! depend on Eyre in no_std mode, disable our default enabled "std" feature in
//! Cargo.toml. A global allocator is required.

//! `std::error::Report` trait which is only available through std, no_std mode
//! will require an explicit `.map_err(Report::msg)` when working with a
//! non-Eyre error type inside a function that returns Eyre's error type.

//! `std::error::Error` trait which is only available through std, no_std mode will
//! require an explicit `.map_err(Report::msg)` when working with a non-Eyre error
//! type inside a function that returns Eyre's error type.
//!
//! ## Comparison to failure
//!
//! The `eyre::Report` type works something like `failure::Error`, but unlike
//! failure ours is built around the standard library's `std::error::Error` trait
//! rather than a separate trait `failure::Fail`. The standard library has adopted
//! the necessary improvements for this to be possible as part of [RFC 2504].
//!
//! [RFC 2504]: https://github.com/rust-lang/rfcs/blob/master/text/2504-fix-error.md
//!
//! ## Comparison to thiserror
//!
//! Use Eyre if you don't care what error type your functions return, you just
//! want it to be easy. This is common in application code. Use [thiserror] if you
//! are a library that wants to design your own dedicated error type(s) so that on
//! failures the caller gets exactly the information that you choose.
//!
//! [thiserror]: https://github.com/dtolnay/thiserror

//! the Context parameter. The solution to this problem, should you encounter it,

//! the Handler parameter. The solution to this problem, should you encounter it,

//! [`eyre::EyreContext`]: https://docs.rs/eyre/*/eyre/trait.EyreContext.html

//! [`eyre::EyreHandler`]: https://docs.rs/eyre/*/eyre/trait.EyreHandler.html

#![doc(html_root_url = "https://docs.rs/eyre/0.4.2")]

#![doc(html_root_url = "https://docs.rs/eyre/0.4.3")]

#[doc(hidden)]
pub use DefaultHandler as DefaultContext;

pub use EyreHandler as EyreContext;
#[doc(hidden)]

///    2: eyre::context::<impl eyre::WrapErr<T,E,C> for core::result::Result<T,E>>::wrap_err_with

///    2: eyre::context::<impl eyre::WrapErr<T,E,H> for core::result::Result<T,E>>::wrap_err_with

pub struct Report<C = DefaultContext>

pub struct Report<H = DefaultHandler>

    C: EyreContext,

    H: EyreHandler,

    inner: ManuallyDrop<Box<ErrorImpl<(), C>>>,

    inner: ManuallyDrop<Box<ErrorImpl<(), H>>>,

/// Context trait for customizing `eyre::Report`

/// Error Report Handler trait for customizing `eyre::Report`

/// In order to insert your own custom context type you must first implement the
/// `eyre::EyreContext` trait.

/// In order to insert your own custom context and report format you must first
/// implement the `eyre::EyreHandler` trait.

/// Once you've defined a custom Context type you can use it throughout your

/// Once you've defined a custom Handler type you can use it throughout your

/// use eyre::EyreContext;

/// use eyre::EyreHandler;

/// pub struct Context {

/// pub struct Handler {

/// impl EyreContext for Context {

/// impl EyreHandler for Handler {

/// type Report = eyre::Report<Context>;
/// type Result<T, E = eyre::Report<Context>> = core::result::Result<T, E>;

/// type Report = eyre::Report<Handler>;
/// type Result<T, E = eyre::Report<Handler>> = core::result::Result<T, E>;

pub trait EyreContext: Sized + Send + Sync + 'static {
    /// Default construct a `Context` when constructing a `Report`.

pub trait EyreHandler: Sized + Send + Sync + 'static {
    /// Default construct a `Handler` when constructing a `Report`.

    /// use eyre::EyreContext;

    /// use eyre::EyreHandler;

    /// pub struct Context {

    /// pub struct Handler {

    /// impl EyreContext for Context {

    /// impl EyreHandler for Handler {

    /// use eyre::EyreContext;

    /// use eyre::EyreHandler;

    /// pub struct Context {

    /// pub struct Handler {

    /// impl EyreContext for Context {

    /// impl EyreHandler for Handler {

/// The default provided context for `eyre::Report`.

/// The default provided error report handler for `eyre::Report`.

pub struct DefaultContext {

pub struct DefaultHandler {

impl core::fmt::Debug for DefaultContext {

impl core::fmt::Debug for DefaultHandler {

        f.debug_struct("DefaultContext")

        f.debug_struct("DefaultHandler")

impl EyreContext for DefaultContext {

impl EyreHandler for DefaultHandler {

pub type Result<T, E = Report<DefaultContext>> = core::result::Result<T, E>;

pub type Result<T, E = Report<DefaultHandler>> = core::result::Result<T, E>;

pub trait WrapErr<T, E, C>: context::private::Sealed<C>

pub trait WrapErr<T, E, H>: context::private::Sealed<H>

    C: EyreContext,

    H: EyreHandler,

    fn wrap_err<D>(self, msg: D) -> Result<T, Report<C>>

    fn wrap_err<D>(self, msg: D) -> Result<T, Report<H>>

    fn wrap_err_with<D, F>(self, f: F) -> Result<T, Report<C>>

    fn wrap_err_with<D, F>(self, f: F) -> Result<T, Report<H>>

    fn context<D>(self, msg: D) -> Result<T, Report<C>>

    fn context<D>(self, msg: D) -> Result<T, Report<H>>

    fn with_context<D, F>(self, f: F) -> Result<T, Report<C>>

    fn with_context<D, F>(self, f: F) -> Result<T, Report<H>>

pub trait ContextCompat<T, C>: context::private::Sealed<C>

pub trait ContextCompat<T, H>: context::private::Sealed<H>

    C: EyreContext,

    H: EyreHandler,

    fn context<D>(self, msg: D) -> Result<T, Report<C>>

    fn context<D>(self, msg: D) -> Result<T, Report<H>>

    fn with_context<D, F>(self, f: F) -> Result<T, Report<C>>

    fn with_context<D, F>(self, f: F) -> Result<T, Report<H>>

    fn wrap_err<D>(self, msg: D) -> Result<T, Report<C>>

    fn wrap_err<D>(self, msg: D) -> Result<T, Report<H>>

    fn wrap_err_with<D, F>(self, f: F) -> Result<T, Report<C>>

    fn wrap_err_with<D, F>(self, f: F) -> Result<T, Report<H>>

    use crate::{EyreContext, Report};

    use crate::{EyreHandler, Report};

    pub fn new_adhoc<M, C>(message: M) -> Report<C>

    pub fn new_adhoc<M, H>(message: M) -> Report<H>

        C: EyreContext,

        H: EyreHandler,

#![allow(clippy::eq_op)]