version = "0.3.9" # remember to update html_root_url

version = "0.3.10" # remember to update html_root_url

backtrace = "0.3.46"

use eyre::{eyre, Report, WrapErr};
fn main() -> Result<(), Report> {
    let e: Report = eyre!("oh no this program is just bad!");
    Err(e).wrap_err("usage example successfully experienced a failure")
}

//! <br>
//!

//! <br>
//!

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

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

/// <br>
///

/// ```rust,compile_fail
/// type Report = eyre::Report<MyContext>;

/// ```rust
/// use backtrace::Backtrace;
/// use eyre::EyreContext;
/// # use eyre::Chain;
/// # use std::error::Error;
///
/// pub struct Context {
///     backtrace: Backtrace,
/// }
///
/// impl EyreContext for Context {
///     // ...
/// #     #[allow(unused_variables)]
/// #     fn default(error: &(dyn Error + 'static)) -> Self {
/// #         let backtrace = Backtrace::new();
/// #         Self { backtrace }
/// #     }
/// #     fn debug(
/// #         &self,
/// #         error: &(dyn Error + 'static),
/// #         f: &mut core::fmt::Formatter<'_>,
/// #     ) -> core::fmt::Result {
/// #         use core::fmt::Write as _;
/// #         if f.alternate() {
/// #             return core::fmt::Debug::fmt(error, f);
/// #         }
/// #         write!(f, "{}", error)?;
/// #         if let Some(cause) = error.source() {
/// #             write!(f, "\n\nCaused by:")?;
/// #             let multiple = cause.source().is_some();
/// #             for (n, error) in Chain::new(cause).enumerate() {
/// #                 writeln!(f)?;
/// #                 if multiple {
/// #                     write!(indenter::Indented::numbered(f, n), "{}", error)?;
/// #                 } else {
/// #                     write!(indenter::Indented::new(f), "{}", error)?;
/// #                 }
/// #             }
/// #         }
/// #         let backtrace = &self.backtrace;
/// #         write!(f, "\n\nStack backtrace:\n{:?}", backtrace)?;
/// #         Ok(())
/// #     }
/// }

/// // And optionally...
/// type Result<T, E = eyre::Report<MyContext>> = core::result::Result<T, E>;

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

    /// ```rust,compile_fail
    /// use std::backtrace::Backtrace;

    /// ```rust
    /// use backtrace::Backtrace;
    /// use eyre::EyreContext;
    /// # use eyre::Chain;
    /// use std::error::Error;

    /// #[derive(Debug)]

    ///     backtrace: Option<Backtrace>,

    ///     backtrace: Backtrace,

    ///     #[allow(unused_variables)]

    /// #     #[allow(unused_variables)]

    ///         let backtrace = if error.backtrace().is_some() {
    ///             None
    ///         } else {
    ///             Some(Backtrace::capture())
    ///         };

    ///         let backtrace = Backtrace::new();

    /// #     fn debug(
    /// #         &self,
    /// #         error: &(dyn Error + 'static),
    /// #         f: &mut core::fmt::Formatter<'_>,
    /// #     ) -> core::fmt::Result {
    /// #         use core::fmt::Write as _;
    /// #         if f.alternate() {
    /// #             return core::fmt::Debug::fmt(error, f);
    /// #         }
    /// #         write!(f, "{}", error)?;
    /// #         if let Some(cause) = error.source() {
    /// #             write!(f, "\n\nCaused by:")?;
    /// #             let multiple = cause.source().is_some();
    /// #             for (n, error) in Chain::new(cause).enumerate() {
    /// #                 writeln!(f)?;
    /// #                 if multiple {
    /// #                     write!(indenter::Indented::numbered(f, n), "{}", error)?;
    /// #                 } else {
    /// #                     write!(indenter::Indented::new(f), "{}", error)?;
    /// #                 }
    /// #             }
    /// #         }
    /// #         let backtrace = &self.backtrace;
    /// #         write!(f, "\n\nStack backtrace:\n{:?}", backtrace)?;
    /// #         Ok(())
    /// #     }

    ///

    /// ```rust,compile_fail

    /// ```rust
    /// use backtrace::Backtrace;
    /// use eyre::EyreContext;
    /// use eyre::Chain;
    /// use std::error::Error;
    ///
    /// pub struct Context {
    ///     backtrace: Backtrace,
    /// }
    ///

    /// #     #[allow(unused_variables)]
    /// #     fn default(error: &(dyn Error + 'static)) -> Self {
    /// #         let backtrace = Backtrace::new();
    /// #         Self { backtrace }
    /// #     }

    ///

    /// ```rust,compile_fail
    /// fn member_ref(&self, typeid: TypeId) -> Option<&dyn Any> {
    ///     if typeid == TypeId::of::<Backtrace>() {
    ///         self.backtrace.as_ref().map(|b| b as &dyn Any)
    ///     } else {
    ///         None
    ///     }
    /// }
    /// ```

/// The default provided context for `eyre::Report`.
///
/// On nightly this supports conditionally capturing a `std::backtrace::Backtrace` if the source
/// error did not already capture one.

                let mut backtrace = backtrace.to_string();
                if backtrace.starts_with("stack backtrace:") {
                    // Capitalize to match "Caused by:"
                    backtrace.replace_range(0..1, "S");
                }
                backtrace.truncate(backtrace.trim_end().len());
                write!(f, "\n\n{}", backtrace)?;

                write!(f, "\n\nStack backtrace:\n{}", backtrace)?;

/// <br>
///

///
/// <br>