anyhow = "1.0.28"

indenter = "0.1.3"

indenter = "0.2.0"

Eyre

eyre

There are two main incompatibilities that you might encounter when porting a
codebase from `anyhow` to `eyre`:
- type inference errors when using `eyre!`
- `.context` not being implemented for `Option`

It is not 100% compatible because there are some cases where `eyre` encounters
type inference errors but it should mostly work as a drop in replacement.
Specifically, the following works in anyhow:

#### Type Inference Errors
The type inference issue is caused by the generic parameter, which isn't
present in `anyhow::Error`. Specifically, the following works in anyhow:

use anyhow::anyhow;

let val = get_optional_val.ok_or_else(|| anyhow!("failed to get value")).unwrap();

let val = get_optional_val().ok_or_else(|| anyhow!("failed to get value")).unwrap_err();

```rust

```rust,compile_fail
use eyre::eyre;

let val = get_optional_val.ok_or_else(|| eyre!("failed to get value")).unwrap();

let val = get_optional_val().ok_or_else(|| eyre!("failed to get value")).unwrap();

let val: Report = get_optional_val.ok_or_else(|| eyre!("failed to get value")).unwrap();

let val: Report = get_optional_val().ok_or_else(|| eyre!("failed to get value")).unwrap();
```
#### `Context` and `Option`
As part of renaming `Context` to `WrapErr` we also intentionally do not
implement `WrapErr` for `Option`. This decision was made because `wrap_err`
implies that you're creating a new error that saves the old error as its
`source`. With `Option` there is no source error to wrap, so `wrap_err` ends up
being somewhat meaningless.
Instead `eyre` intends for users to use the combinator functions provided by
`std` for converting `Option`s to `Result`s. So where you would write this with
anyhow:
```rust
use anyhow::Context;
let opt: Option<()> = None;
let result = opt.context("new error message");

With `eyre` we want users to write:
```rust
use eyre::{eyre, Result};
let opt: Option<()> = None;
let result: Result<()> = opt.ok_or_else(|| eyre!("new error message"));
```
However, to help with porting we do provide a `ContextCompat` trait which
implements `context` for options which you can import to make existing
`.context` calls compile.

    /// Construct an iterator over a chain of errors via the `source` method
    ///
    /// # Example
    ///
    /// ```rust
    /// use std::error::Error;
    /// use std::fmt::{self, Write};
    /// use eyre::Chain;
    /// use indenter::indented;
    ///
    /// fn report(error: &(dyn Error + 'static), f: &mut fmt::Formatter<'_>) -> fmt::Result {
    ///     let mut errors = Chain::new(error).enumerate();
    ///     for (i, error) in errors {
    ///         writeln!(f)?;
    ///         write!(indented(f).ind(i), "{}", error)?;
    ///     }
    ///
    ///     Ok(())
    /// }
    /// ```

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

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

    }
}
impl<T, C> ContextCompat<T, C> for Option<T>
where
    C: EyreContext,
{
    fn wrap_err<D>(self, msg: D) -> Result<T, Report<C>>
    where
        D: Display + Send + Sync + 'static,
    {
        self.context(msg)
    }
    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, Report<C>>
    where
        D: Display + Send + Sync + 'static,
        F: FnOnce() -> D,
    {
        self.with_context(msg)
    }
    fn context<D>(self, msg: D) -> Result<T, Report<C>>
    where
        D: Display + Send + Sync + 'static,
    {
        self.ok_or_else(|| Report::from_display(msg))
    }
    fn with_context<D, F>(self, msg: F) -> Result<T, Report<C>>
    where
        D: Display + Send + Sync + 'static,
        F: FnOnce() -> D,
    {
        self.ok_or_else(|| Report::from_display(msg()))

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

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

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

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

    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

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

    impl<T, C: EyreContext> Sealed<C> for Option<T> {}

        unsafe { Report::construct(error, vtable, context) }
    }
    pub(crate) fn from_display<M>(message: M) -> Self
    where
        M: Display + Send + Sync + 'static,
    {
        use crate::wrapper::{DisplayError, NoneError};
        let error: DisplayError<M> = DisplayError(message);
        let vtable = &ErrorVTable {
            object_drop: object_drop::<DisplayError<M>, C>,
            object_ref: object_ref::<DisplayError<M>, C>,
            #[cfg(feature = "std")]
            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>,
        };
        // Safety: DisplayError is repr(transparent) so it is okay for the
        // vtable to allow casting the DisplayError<M> to M.
        let context = Some(C::default(&NoneError));

    pub fn chain(&self) -> Chain {

    pub fn chain(&self) -> Chain<'_> {

    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

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

    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

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

    pub msg: D,
    pub error: E,

    pub(crate) msg: D,
    pub(crate) error: E,

    pub(crate) fn chain(&self) -> Chain {

    pub(crate) fn chain(&self) -> Chain<'_> {

    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

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

    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

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

    pub(crate) fn display(&self, f: &mut fmt::Formatter) -> fmt::Result {

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

    pub(crate) fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {

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

#![allow(missing_debug_implementations, missing_docs)]

//! # Details

//! ## Details

//! # No-std support

//! ## No-std support

//! # Compatibility with `anyhow`

//! ## Compatibility with `anyhow`

//! It is not 100% compatible because there are some cases where `eyre` encounters
//! type inference errors but it should mostly work as a drop in replacement.
//! Specifically, the following works in anyhow:

//! There are two main incompatibilities that you might encounter when porting a
//! codebase from `anyhow` to `eyre`:
//!
//! - type inference errors when using `eyre!`
//! - `.context` not being implemented for `Option`
//!
//! #### Type Inference Errors
//!
//! The type inference issue is caused by the generic parameter, which isn't
//! present in `anyhow::Error`. Specifically, the following works in anyhow:

//! ```rust,compile_fail

//! ```rust
//! # fn get_optional_val() -> Option<()> { None };
//! use anyhow::anyhow;
//!

//! let val = get_optional_val.ok_or_else(|| anyhow!("failed to get value")).unwrap();

//! let val = get_optional_val().ok_or_else(|| anyhow!("failed to get value")).unwrap_err();

//! use eyre::eyre;
//!
//! # fn get_optional_val() -> Option<()> { None };

//! let val = get_optional_val.ok_or_else(|| eyre!("failed to get value")).unwrap();

//! let val = get_optional_val().ok_or_else(|| eyre!("failed to get value")).unwrap();

//! let val: Report = get_optional_val.ok_or_else(|| eyre!("failed to get value")).unwrap();

//! let val: Report = get_optional_val().ok_or_else(|| eyre!("failed to get value")).unwrap();
//! ```
//!
//! #### `Context` and `Option`
//!
//! As part of renaming `Context` to `WrapErr` we also intentionally do not
//! implement `WrapErr` for `Option`. This decision was made because `wrap_err`
//! implies that you're creating a new error that saves the old error as its
//! `source`. With `Option` there is no source error to wrap, so `wrap_err` ends up
//! being somewhat meaningless.
//!
//! Instead `eyre` intends for users to use the combinator functions provided by
//! `std` for converting `Option`s to `Result`s. So where you would write this with
//! anyhow:
//!
//! ```rust
//! use anyhow::Context;
//!
//! let opt: Option<()> = None;
//! let result = opt.context("new error message");
//! ```
//!
//! With `eyre` we want users to write:
//!
//! ```rust
//! use eyre::{eyre, Result};
//!
//! let opt: Option<()> = None;
//! let result: Result<()> = opt.ok_or_else(|| eyre!("new error message"));

//!
//! However, to help with porting we do provide a `ContextCompat` trait which
//! implements `context` for options which you can import to make existing
//! `.context` calls compile.

#![warn(
    missing_debug_implementations,
    missing_docs,
    missing_doc_code_examples,
    rust_2018_idioms,
    unreachable_pub,
    bad_style,
    const_err,
    dead_code,
    improper_ctypes,
    non_shorthand_field_patterns,
    no_mangle_generic_items,
    overflowing_literals,
    path_statements,
    patterns_in_fns_without_body,
    private_in_public,
    unconditional_recursion,
    unused,
    unused_allocation,
    unused_comparisons,
    unused_parens,
    while_true
)]

    pub use alloc::boxed::Box;

    pub(crate) use alloc::boxed::Box;

    pub use std::boxed::Box;

    pub(crate) use std::boxed::Box;

    pub use alloc::string::String;

    pub(crate) use alloc::string::String;

    #[cfg(feature = "std")]
    pub use std::string::String;

    // #[cfg(feature = "std")]
    // pub(crate) use std::string::String;

/// use indenter::indented;

/// #                     write!(indenter::Indented::numbered(f, n), "{}", error)?;

/// #                     write!(indented(f).ind(n), "{}", error)?;

/// #                     write!(indenter::Indented::new(f), "{}", error)?;

/// #                     write!(indented(f), "{}", error)?;

    /// #                     write!(indenter::Indented::numbered(f, n), "{}", error)?;

    /// #                     write!(indenter::indented(f).ind(n), "{}", error)?;

    /// #                     write!(indenter::Indented::new(f), "{}", error)?;

    /// #                     write!(indenter::indented(f), "{}", error)?;

    /// use indenter::indented;

    ///                     write!(indenter::Indented::numbered(f, n), "{}", error)?;

    ///                     write!(indented(f).ind(n), "{}", error)?;

    ///                     write!(indenter::Indented::new(f), "{}", error)?;

    ///                     write!(indented(f), "{}", error)?;

}
impl core::fmt::Debug for DefaultContext {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("DefaultContext")
            .field(
                "backtrace",
                match &self.backtrace {
                    Some(_) => &"Some(Backtrace { ... })",
                    None => &"None",
                },
            )
            .finish()
    }

                    write!(indenter::Indented::numbered(f, n), "{}", error)?;

                    write!(indenter::indented(f).ind(n), "{}", error)?;

                    write!(indenter::Indented::new(f), "{}", error)?;

                    write!(indenter::indented(f), "{}", error)?;

#[allow(missing_debug_implementations)]

/// ```
///
/// # Wrapping Types That Don't impl `Error` (e.g. `&str` and `Box<dyn Error>`)
///
/// Due to restrictions for coherence `Report` cannot impl `From` for types that don't impl
/// `Error`. Attempts to do so will give "this type might implement Error in the future" as an
/// error. As such, `wrap_err`, which uses `From` under the hood, cannot be used to wrap these
/// types. Instead we encourage you to use the combinators provided for `Result` in `std`/`core`.
///
/// For example, instead of this:
///
/// ```rust,compile_fail
/// use std::error::Error;
/// use eyre::{WrapErr, Report};
///
/// fn wrap_example(err: Result<(), Box<dyn Error + Send + Sync + 'static>>) -> Result<(), Report> {
///     err.wrap_err("saw a downstream error")
/// }

///
/// We encourage you to write this:

/// ```rust
/// use std::error::Error;
/// use eyre::{WrapErr, Report, eyre};
///
/// fn wrap_example(err: Result<(), Box<dyn Error + Send + Sync + 'static>>) -> Result<(), Report> {
///     err.map_err(|e| eyre!(e)).wrap_err("saw a downstream error")
/// }
/// ```
///

    fn with_context<D, F>(self, f: F) -> Result<T, Report<C>>
    where
        D: Display + Send + Sync + 'static,
        F: FnOnce() -> D;
}
/// Provides the `context` method for `Option` when porting from `anyhow`
///
/// This trait is sealed and cannot be implemented for types outside of
/// `eyre`.
///
/// ## Why Doesn't `Eyre` impl `WrapErr` for `Option`?
///
/// `eyre` doesn't impl `WrapErr` for `Option` because `wrap_err` implies that you're creating a
/// new error that saves the previous error as its `source`. Calling `wrap_err` on an `Option` is
/// meaningless because there is no source error. `anyhow` avoids this issue by using a different
/// mental model where you're adding "context" to an error, though this not a mental model for
/// error handling that `eyre` agrees with.
///
/// Instead, `eyre` encourages users to think of each error as distinct, where the previous error
/// is the context being saved by the new error, which is backwards compared to anyhow's model. In
/// this model you're encouraged to use combinators provided by `std` for `Option` to convert an
/// option to a `Result`
///
/// # Example
///
/// Instead of:
///
/// ```rust
/// use eyre::ContextCompat;
///
/// fn get_thing(mut things: impl Iterator<Item = u32>) -> eyre::Result<u32> {
///     things
///         .find(|&thing| thing == 42)
///         .context("the thing wasnt in the list")
/// }
/// ```
///
/// We encourage you to use this:
///
/// ```rust
/// use eyre::eyre;
///
/// fn get_thing(mut things: impl Iterator<Item = u32>) -> eyre::Result<u32> {
///     things
///         .find(|&thing| thing == 42)
///         .ok_or_else(|| eyre!("the thing wasnt in the list"))
/// }
/// ```
pub trait ContextCompat<T, C>: context::private::Sealed<C>
where
    C: EyreContext,
{
    /// Compatibility version of `wrap_err` for creating new errors with new source on `Option`
    /// when porting from `anyhow`
    fn context<D>(self, msg: D) -> Result<T, Report<C>>
    where
        D: Display + Send + Sync + 'static;
    /// Compatibility version of `wrap_err_with` for creating new errors with new source on `Option`
    /// when porting from `anyhow`

    where
        D: Display + Send + Sync + 'static,
        F: FnOnce() -> D;
    /// Compatibility re-export of `context` for porting from `anyhow` to `eyre`
    fn wrap_err<D>(self, msg: D) -> Result<T, Report<C>>

        D: Display + Send + Sync + 'static;
    /// Compatibility re-export of `with_context` for porting from `anyhow` to `eyre`
    fn wrap_err_with<D, F>(self, f: F) -> Result<T, Report<C>>
    where

#[repr(transparent)]
pub(crate) struct DisplayError<M>(pub(crate) M);

pub struct MessageError<M>(pub M);

pub(crate) struct MessageError<M>(pub(crate) M);
pub(crate) struct NoneError;
impl<M> Debug for DisplayError<M>
where
    M: Display,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Display::fmt(&self.0, f)
    }
}

impl<M> Display for DisplayError<M>
where
    M: Display,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Display::fmt(&self.0, f)
    }
}
impl<M> StdError for DisplayError<M> where M: Display + 'static {}

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

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

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

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

#[repr(transparent)]
pub struct DisplayError<M>(pub M);

impl<M> Debug for DisplayError<M>
where
    M: Display,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        Display::fmt(&self.0, f)

impl Debug for NoneError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Debug::fmt("Option was None", f)

impl<M> Display for DisplayError<M>
where
    M: Display,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        Display::fmt(&self.0, f)

impl Display for NoneError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Display::fmt("Option was None", f)

impl<M> StdError for DisplayError<M> where M: Display + 'static {}

impl StdError for NoneError {}

pub struct BoxedError(pub Box<dyn StdError + Send + Sync>);

pub(crate) struct BoxedError(pub(crate) Box<dyn StdError + Send + Sync>);

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

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

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

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