name = "anyhow"

name = "eyre"

repository = "https://github.com/dtolnay/anyhow"
documentation = "https://docs.rs/anyhow"

repository = "https://github.com/dtolnay/eyre"
documentation = "https://docs.rs/eyre"

travis-ci = { repository = "dtolnay/anyhow" }

travis-ci = { repository = "dtolnay/eyre" }

[![Build Status](https://api.travis-ci.com/dtolnay/anyhow.svg?branch=master)](https://travis-ci.com/dtolnay/anyhow)
[![Latest Version](https://img.shields.io/crates/v/anyhow.svg)](https://crates.io/crates/anyhow)
[![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/anyhow)

[![Build Status](https://api.travis-ci.com/dtolnay/eyre.svg?branch=master)](https://travis-ci.com/dtolnay/eyre)
[![Latest Version](https://img.shields.io/crates/v/eyre.svg)](https://crates.io/crates/eyre)
[![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/eyre)

This library provides [`anyhow::Error`][Error], a trait object based error type

This library provides [`eyre::Error`][Error], a trait object based error type

[Error]: https://docs.rs/anyhow/1.0/anyhow/struct.Error.html

[Error]: https://docs.rs/eyre/1.0/eyre/struct.Error.html

anyhow = "1.0"

eyre = "1.0"

- Use `Result<T, anyhow::Error>`, or equivalently `anyhow::Result<T>`, as the

- Use `Result<T, eyre::Error>`, or equivalently `eyre::Result<T>`, as the

  use anyhow::Result;

  use eyre::Result;

  use anyhow::{Context, Result};

  use eyre::{Context, Result};

- One-off error messages can be constructed using the `anyhow!` macro, which
  supports string interpolation and produces an `anyhow::Error`.

- One-off error messages can be constructed using the `eyre!` macro, which
  supports string interpolation and produces an `eyre::Error`.

  return Err(anyhow!("Missing attribute: {}", missing));

  return Err(eyre!("Missing attribute: {}", missing));

anyhow = { version = "1.0", default-features = false }

eyre = { version = "1.0", default-features = false }

The `anyhow::Error` type works something like `failure::Error`, but unlike

The `eyre::Error` type works something like `failure::Error`, but unlike

// backtrace in anyhow.

// backtrace in eyre.

        .arg("--crate-name=anyhow_build")

        .arg("--crate-name=eyre_build")

use crate::{Context, Error, StdError};

use crate::{Context, ErrReport, StdError};

        fn ext_context<C>(self, context: C) -> Error

        fn ext_context<C>(self, context: C) -> ErrReport

        fn ext_context<C>(self, context: C) -> Error

        fn ext_context<C>(self, context: C) -> ErrReport

            Error::from_context(context, self, backtrace)

            ErrReport::from_context(context, self, backtrace)

    impl StdError for Error {
        fn ext_context<C>(self, context: C) -> Error

    impl StdError for ErrReport {
        fn ext_context<C>(self, context: C) -> ErrReport

    fn context<C>(self, context: C) -> Result<T, Error>

    fn context<C>(self, context: C) -> Result<T, ErrReport>

    fn with_context<C, F>(self, context: F) -> Result<T, Error>

    fn with_context<C, F>(self, context: F) -> Result<T, ErrReport>

/// use anyhow::{Context, Result};

/// use eyre::{Context, Result};

    fn context<C>(self, context: C) -> Result<T, Error>

    fn context<C>(self, context: C) -> Result<T, ErrReport>

        self.ok_or_else(|| Error::from_display(context, backtrace!()))

        self.ok_or_else(|| ErrReport::from_display(context, backtrace!()))

    fn with_context<C, F>(self, context: F) -> Result<T, Error>

    fn with_context<C, F>(self, context: F) -> Result<T, ErrReport>

        self.ok_or_else(|| Error::from_display(context(), backtrace!()))

        self.ok_or_else(|| ErrReport::from_display(context(), backtrace!()))

impl<C> StdError for ContextError<C, Error>

impl<C> StdError for ContextError<C, ErrReport>

use crate::{Error, StdError};

use crate::{ErrReport, StdError};

impl Error {

impl ErrReport {

    /// The error type must be threadsafe and `'static`, so that the `Error`

    /// The error type must be threadsafe and `'static`, so that the `ErrReport`

        Error::from_std(error, backtrace)

        ErrReport::from_std(error, backtrace)

    /// If the argument implements std::error::Error, prefer `Error::new`

    /// If the argument implements std::error::Error, prefer `ErrReport::new`

    /// now or in the future, use `anyhow!(err)` which handles either way

    /// now or in the future, use `eyre!(err)` which handles either way

    /// `Error::msg("...")` is equivalent to `anyhow!("...")` but occasionally

    /// `ErrReport::msg("...")` is equivalent to `eyre!("...")` but occasionally

    /// use anyhow::{Error, Result};

    /// use eyre::{ErrReport, Result};

    ///         .map_err(Error::msg)

    ///         .map_err(ErrReport::msg)

        Error::from_adhoc(message, backtrace!())

        ErrReport::from_adhoc(message, backtrace!())

        unsafe { Error::construct(error, vtable, backtrace) }

        unsafe { ErrReport::construct(error, vtable, backtrace) }

        unsafe { Error::construct(error, vtable, backtrace) }

        unsafe { ErrReport::construct(error, vtable, backtrace) }

        unsafe { Error::construct(error, vtable, backtrace) }

        unsafe { ErrReport::construct(error, vtable, backtrace) }

        unsafe { Error::construct(error, vtable, backtrace) }

        unsafe { ErrReport::construct(error, vtable, backtrace) }

        unsafe { Error::construct(error, vtable, backtrace) }

        unsafe { ErrReport::construct(error, vtable, backtrace) }

        Error { inner }

        ErrReport { inner }

    /// use anyhow::Result;

    /// use eyre::Result;

    ///         anyhow::Error::new(error).context(context)

    ///         eyre::ErrReport::new(error).context(context)

        let error: ContextError<C, Error> = ContextError {

        let error: ContextError<C, ErrReport> = ContextError {

            object_drop: object_drop::<ContextError<C, Error>>,
            object_ref: object_ref::<ContextError<C, Error>>,

            object_drop: object_drop::<ContextError<C, ErrReport>>,
            object_ref: object_ref::<ContextError<C, ErrReport>>,

            object_mut: object_mut::<ContextError<C, Error>>,
            object_boxed: object_boxed::<ContextError<C, Error>>,

            object_mut: object_mut::<ContextError<C, ErrReport>>,
            object_boxed: object_boxed::<ContextError<C, ErrReport>>,

        // As the cause is anyhow::Error, we already have a backtrace for it.

        // As the cause is eyre::ErrReport, we already have a backtrace for it.

        unsafe { Error::construct(error, vtable, backtrace) }

        unsafe { ErrReport::construct(error, vtable, backtrace) }

    /// Get the backtrace for this Error.

    /// Get the backtrace for this ErrReport.

    /// An iterator of the chain of source errors contained by this Error.

    /// An iterator of the chain of source errors contained by this ErrReport.

    /// use anyhow::Error;

    /// use eyre::ErrReport;

    /// pub fn underlying_io_error_kind(error: &Error) -> Option<io::ErrorKind> {

    /// pub fn underlying_io_error_kind(error: &ErrReport) -> Option<io::ErrorKind> {

    /// [`chain()`][Error::chain].

    /// [`chain()`][ErrReport::chain].

            // Error has a Drop impl which we want to not run.

            // ErrReport has a Drop impl which we want to not run.

    /// # use anyhow::anyhow;

    /// # use eyre::eyre;

    /// # let error = anyhow!("...");

    /// # let error = eyre!("...");

impl<E> From<E> for Error

impl<E> From<E> for ErrReport

        Error::from_std(error, backtrace)

        ErrReport::from_std(error, backtrace)

impl Deref for Error {

impl Deref for ErrReport {

impl DerefMut for Error {

impl DerefMut for ErrReport {

impl Display for Error {

impl Display for ErrReport {

impl Debug for Error {

impl Debug for ErrReport {

impl Drop for Error {

impl Drop for ErrReport {

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, Error>>.

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, ErrReport>>.

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

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

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

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

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, Error>>.

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, ErrReport>>.

            Box<ErrorImpl<ContextError<ManuallyDrop<C>, Error>>>,

            Box<ErrorImpl<ContextError<ManuallyDrop<C>, ErrReport>>>,

        // Drop the entire rest of the data structure rooted in the next Error.

        // Drop the entire rest of the data structure rooted in the next ErrReport.

            Box<ErrorImpl<ContextError<C, ManuallyDrop<Error>>>>,

            Box<ErrorImpl<ContextError<C, ManuallyDrop<ErrReport>>>>,

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

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

            // Error has a Drop impl which we want to not run.

            // ErrReport has a Drop impl which we want to not run.

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

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

impl AsRef<dyn StdError + Send + Sync> for Error {

impl AsRef<dyn StdError + Send + Sync> for ErrReport {

impl AsRef<dyn StdError> for Error {

impl AsRef<dyn StdError> for ErrReport {

// Tagged dispatch mechanism for resolving the behavior of `anyhow!($expr)`.

// Tagged dispatch mechanism for resolving the behavior of `eyre!($expr)`.

// When anyhow! is given a single expr argument to turn into anyhow::Error, we
// want the resulting Error to pick up the input's implementation of source()

// When eyre! is given a single expr argument to turn into eyre::ErrReport, we
// want the resulting ErrReport to pick up the input's implementation of source()

//     trait AnyhowNew {
//         fn new(self) -> Error;

//     trait EyreNew {
//         fn new(self) -> ErrReport;

//     impl<T> AnyhowNew for T

//     impl<T> EyreNew for T

//         default fn new(self) -> Error {

//         default fn new(self) -> ErrReport {

//     impl<T> AnyhowNew for T

//     impl<T> EyreNew for T

//         fn new(self) -> Error {

//         fn new(self) -> ErrReport {

// AdhocKind and TraitKind that both have an anyhow_kind() method. AdhocKind is

// AdhocKind and TraitKind that both have an eyre_kind() method. AdhocKind is

// The anyhow! macro will set up the call in this form:

// The eyre! macro will set up the call in this form:

//     (&error).anyhow_kind().new(error)

//     (&error).eyre_kind().new(error)

use crate::Error;

use crate::ErrReport;

    fn anyhow_kind(&self) -> Adhoc {

    fn eyre_kind(&self) -> Adhoc {

    pub fn new<M>(self, message: M) -> Error

    pub fn new<M>(self, message: M) -> ErrReport

        Error::from_adhoc(message, backtrace!())

        ErrReport::from_adhoc(message, backtrace!())

    fn anyhow_kind(&self) -> Trait {

    fn eyre_kind(&self) -> Trait {

impl<E> TraitKind for E where E: Into<Error> {}

impl<E> TraitKind for E where E: Into<ErrReport> {}

    pub fn new<E>(self, error: E) -> Error

    pub fn new<E>(self, error: E) -> ErrReport

        E: Into<Error>,

        E: Into<ErrReport>,

    fn anyhow_kind(&self) -> Boxed {

    fn eyre_kind(&self) -> Boxed {

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

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

        Error::from_boxed(error, backtrace)

        ErrReport::from_boxed(error, backtrace)

//! This library provides [`anyhow::Error`][Error], a trait object based error

//! This library provides [`eyre::ErrReport`][ErrReport], a trait object based error

//! - Use `Result<T, anyhow::Error>`, or equivalently `anyhow::Result<T>`, as

//! - Use `Result<T, eyre::ErrReport>`, or equivalently `eyre::Result<T>`, as

//!   the `std::error::Error` trait.

//!   the `std::error::ErrReport` trait.

//!   use anyhow::Result;

//!   use eyre::Result;

//!   use anyhow::{Context, Result};

//!   use eyre::{Context, Result};

//!   # use anyhow::anyhow;

//!   # use eyre::eyre;

//!   # let error = anyhow!("...");

//!   # let error = eyre!("...");

//! - One-off error messages can be constructed using the `anyhow!` macro, which
//!   supports string interpolation and produces an `anyhow::Error`.

//! - One-off error messages can be constructed using the `eyre!` macro, which
//!   supports string interpolation and produces an `eyre::ErrReport`.

//!   # use anyhow::{anyhow, Result};

//!   # use eyre::{eyre, Result};

//!   return Err(anyhow!("Missing attribute: {}", missing));

//!   return Err(eyre!("Missing attribute: {}", missing));

//! anyhow = { version = "1.0", default-features = false }

//! eyre = { version = "1.0", default-features = false }

//! `std::error::Error` trait which is only available through std, no_std mode
//! will require an explicit `.map_err(Error::msg)` when working with a

//! `std::error::ErrReport` trait which is only available through std, no_std mode
//! will require an explicit `.map_err(ErrReport::msg)` when working with a

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

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

pub use anyhow as format_err;

pub use eyre as format_err;

/// The `Error` type, a wrapper around a dynamic error type.

/// The `ErrReport` type, a wrapper around a dynamic error type.

/// `Error` works a lot like `Box<dyn std::error::Error>`, but with these

/// `ErrReport` works a lot like `Box<dyn std::error::Error>`, but with these

/// - `Error` requires that the error is `Send`, `Sync`, and `'static`.
/// - `Error` guarantees that a backtrace is available, even if the underlying

/// - `ErrReport` requires that the error is `Send`, `Sync`, and `'static`.
/// - `ErrReport` guarantees that a backtrace is available, even if the underlying

/// - `Error` is represented as a narrow pointer — exactly one word in

/// - `ErrReport` is represented as a narrow pointer — exactly one word in

/// which you constructed your anyhow::Error.

/// which you constructed your eyre::ErrReport.

/// To print causes as well using anyhow's default formatting of causes, use the

/// To print causes as well using eyre's default formatting of causes, use the

///    0: <E as anyhow::context::ext::StdError>::ext_context
///              at /git/anyhow/src/backtrace.rs:26

///    0: <E as eyre::context::ext::StdError>::ext_context
///              at /git/eyre/src/backtrace.rs:26

///    2: anyhow::context::<impl anyhow::Context<T,E> for core::result::Result<T,E>>::with_context
///              at /git/anyhow/src/context.rs:58

///    2: eyre::context::<impl eyre::Context<T,E> for core::result::Result<T,E>>::with_context
///              at /git/eyre/src/context.rs:58

/// use anyhow::{Context, Result};

/// use eyre::{Context, Result};

pub struct Error {

pub struct ErrReport {

/// This type is the iterator returned by [`Error::chain`].

/// This type is the iterator returned by [`ErrReport::chain`].

/// use anyhow::Error;

/// use eyre::ErrReport;

/// pub fn underlying_io_error_kind(error: &Error) -> Option<io::ErrorKind> {

/// pub fn underlying_io_error_kind(error: &ErrReport) -> Option<io::ErrorKind> {

/// `anyhow::Result` may be used with one *or* two type parameters.

/// `eyre::Result` may be used with one *or* two type parameters.

/// use anyhow::Result;

/// use eyre::Result;

///            // ^ equivalent to std::result::Result<T, anyhow::Error>

///            // ^ equivalent to std::result::Result<T, eyre::Error>

/// use anyhow::Result;

/// use eyre::Result;

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

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

/// `anyhow`.

/// `eyre`.

/// use anyhow::{Context, Result};

/// use eyre::{Context, Result};

/// `anyhow::Error` may be downcast to `C` **or** to `E`.

/// `eyre::Error` may be downcast to `C` **or** to `E`.

///     # use anyhow::bail;

///     # use eyre::bail;

///     use anyhow::{Context, Result};

///     use eyre::{Context, Result};

///     # use anyhow::bail;

///     # use eyre::bail;

///     use anyhow::{Context, Result};

///     use eyre::{Context, Result};

    fn context<C>(self, context: C) -> Result<T, Error>

    fn context<C>(self, context: C) -> Result<T, ErrReport>

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

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

    use crate::Error;

    use crate::ErrReport;

    pub fn new_adhoc<M>(message: M) -> Error

    pub fn new_adhoc<M>(message: M) -> ErrReport

        Error::from_adhoc(message, backtrace!())

        ErrReport::from_adhoc(message, backtrace!())

/// # use anyhow::{bail, Result};

/// # use eyre::{bail, Result};

/// # use anyhow::{bail, Result};

/// # use eyre::{bail, Result};

        return $crate::private::Err($crate::anyhow!($msg));

        return $crate::private::Err($crate::eyre!($msg));

        return $crate::private::Err($crate::anyhow!($err));

        return $crate::private::Err($crate::eyre!($err));

        return $crate::private::Err($crate::anyhow!($fmt, $($arg)*));

        return $crate::private::Err($crate::eyre!($fmt, $($arg)*));

/// # use anyhow::{ensure, Result};

/// # use eyre::{ensure, Result};

/// # use anyhow::{ensure, Result};

/// # use eyre::{ensure, Result};

            return $crate::private::Err($crate::anyhow!($msg));

            return $crate::private::Err($crate::eyre!($msg));

            return $crate::private::Err($crate::anyhow!($err));

            return $crate::private::Err($crate::eyre!($err));

            return $crate::private::Err($crate::anyhow!($fmt, $($arg)*));

            return $crate::private::Err($crate::eyre!($fmt, $($arg)*));

/// use anyhow::{anyhow, Result};

/// use eyre::{eyre, Result};

///         return Err(anyhow!("key length must be 16 characters, got {:?}", key));

///         return Err(eyre!("key length must be 16 characters, got {:?}", key));

macro_rules! anyhow {

macro_rules! eyre {

        (&error).anyhow_kind().new(error)

        (&error).eyre_kind().new(error)

use anyhow::{bail, Result};

use eyre::{bail, Result};

use anyhow::Error;

use eyre::ErrReport;

    assert_send::<Error>();

    assert_send::<ErrReport>();

    assert_sync::<Error>();

    assert_sync::<ErrReport>();

    use anyhow::anyhow;

    use eyre::eyre;

    let error = anyhow!("oh no!");

    let error = eyre!("oh no!");

use anyhow::anyhow;

use eyre::eyre;

    let error = anyhow!(error);

    let error = eyre!(error);

    let error = anyhow!(error);

    let error = eyre!(error);

fn test_boxed_anyhow() {
    let error = anyhow!("oh no!").context("it failed");
    let error = anyhow!(error);

fn test_boxed_eyre() {
    let error = eyre!("oh no!").context("it failed");
    let error = eyre!(error);

use anyhow::{anyhow, Error};

use eyre::{eyre, ErrReport};

fn error() -> Error {
    anyhow!(0).context(1).context(2).context(3)

fn error() -> ErrReport {
    eyre!(0).context(1).context(2).context(3)

use anyhow::{Context, Error, Result};

use eyre::{Context, ErrReport, Result};

// https://github.com/dtolnay/anyhow/issues/18

// https://github.com/dtolnay/eyre/issues/18

fn make_chain() -> (Error, Dropped) {

fn make_chain() -> (ErrReport, Dropped) {

    let high = Err::<(), Error>(mid)

    let high = Err::<(), ErrReport>(mid)

use anyhow::{Error, Result};

use eyre::{ErrReport, Result};

    let error = Error::new(DetectDrop::new(&has_dropped));

    let error = ErrReport::new(DetectDrop::new(&has_dropped));

use anyhow::Error;

use eyre::ErrReport;

    let error = Error::new(DetectDrop::new(&has_dropped));

    let error = ErrReport::new(DetectDrop::new(&has_dropped));

    let error = Error::new(LargeAlignedError("oh no!"));

    let error = ErrReport::new(LargeAlignedError("oh no!"));

use anyhow::{bail, Context, Result};

use eyre::{bail, Context, Result};

use anyhow::ensure;

use eyre::ensure;

use anyhow::Error;

use eyre::ErrReport;

    assert_eq!(mem::size_of::<Error>(), mem::size_of::<usize>());

    assert_eq!(mem::size_of::<ErrReport>(), mem::size_of::<usize>());

    assert_eq!(mem::size_of::<Result<(), Error>>(), mem::size_of::<usize>());

    assert_eq!(mem::size_of::<Result<(), ErrReport>>(), mem::size_of::<usize>());

    assert::<Error>();

    assert::<ErrReport>();

    drop(Error::new(DetectDrop::new(&has_dropped)));

    drop(ErrReport::new(DetectDrop::new(&has_dropped)));

use anyhow::anyhow;

use eyre::eyre;

    let error = anyhow!("oh no!");

    let error = eyre!("oh no!");

    let error = anyhow!(msg);

    let error = eyre!(msg);

    let error = anyhow!(msg);

    let error = eyre!(msg);

    let error = anyhow!("{} {}!", "oh", "no");

    let error = eyre!("{} {}!", "oh", "no");

    let error = anyhow!(TestError::Io(io));

    let error = eyre!(TestError::Io(io));

fn test_anyhow_from_anyhow() {
    let error = anyhow!("oh no!").context("context");
    let error = anyhow!(error);

fn test_eyre_from_eyre() {
    let error = eyre!("oh no!").context("context");
    let error = eyre!(error);

use anyhow::anyhow;

use eyre::eyre;

    let _ = anyhow!(Error);

    let _ = eyre!(Error);

error[E0599]: no method named `anyhow_kind` found for reference `&Error` in the current scope

error[E0599]: no method named `eyre_kind` found for reference `&Error` in the current scope

7 |     let _ = anyhow!(Error);
  |             ^^^^^^^^^^^^^^ method not found in `&Error`

7 |     let _ = eyre!(Error);
  |             ^^^^^^^^^^^^ method not found in `&Error`

  = note: the method `anyhow_kind` exists but the following trait bounds were not satisfied:
          `&Error : anyhow::kind::AdhocKind`
          `&Error : anyhow::kind::TraitKind`
          `Error : anyhow::kind::TraitKind`

  = note: the method `eyre_kind` exists but the following trait bounds were not satisfied:
          `&Error : eyre::kind::AdhocKind`
          `&Error : eyre::kind::TraitKind`
          `Error : eyre::kind::TraitKind`

  = note: the following traits define an item `anyhow_kind`, perhaps you need to implement one of them:
          candidate #1: `anyhow::kind::AdhocKind`
          candidate #2: `anyhow::kind::TraitKind`
          candidate #3: `anyhow::kind::BoxedKind`

  = note: the following traits define an item `eyre_kind`, perhaps you need to implement one of them:
          candidate #1: `eyre::kind::AdhocKind`
          candidate #2: `eyre::kind::TraitKind`
          candidate #3: `eyre::kind::BoxedKind`