use eyre::{Report, Result};

  use eyre::{WrapErr, Result};

use crate::{Report, DefaultContext, ErrReport, StdError, EyreContext};
use core::convert::Infallible;

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

    pub trait StdError {
        fn ext_report<D>(self, msg: D) -> ErrReport<DefaultContext>

    pub trait StdError<C>
    where
        C: EyreContext,
    {
        fn ext_report<D>(self, msg: D) -> ErrReport<C>

    impl<E> StdError for E

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

        C: EyreContext,

        fn ext_report<D>(self, msg: D) -> ErrReport<DefaultContext>

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

    impl StdError for ErrReport<DefaultContext> {
        fn ext_report<D>(self, msg: D) -> ErrReport<DefaultContext>

    impl<C> StdError<C> for ErrReport<C>
    where
        C: EyreContext,
    {
        fn ext_report<D>(self, msg: D) -> ErrReport<C>

impl<T, E> Report<T, E> for Result<T, E>

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

    E: ext::StdError + Send + Sync + 'static,

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

    fn wrap_err<D>(self, msg: D) -> Result<T, ErrReport<DefaultContext>>

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

    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, ErrReport<DefaultContext>>

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

/// ```
/// # type T = ();
/// #
/// use eyre::{Report, Result};
///
/// fn maybe_get() -> Option<T> {
///     # const IGNORE: &str = stringify! {
///     ...
///     # };
///     # unimplemented!()
/// }
///
/// fn demo() -> Result<()> {
///     let t = maybe_get().wrap_err("there is no T")?;
///     # const IGNORE: &str = stringify! {
///     ...
///     # };
///     # unimplemented!()
/// }
/// ```
impl<T> Report<T, Infallible> for Option<T> {
    fn wrap_err<D>(self, msg: D) -> Result<T, ErrReport<DefaultContext>>
    where
        D: Display + Send + Sync + 'static,
    {
        self.ok_or_else(|| ErrReport::from_display(msg))
    }
    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, ErrReport<DefaultContext>>
    where
        D: Display + Send + Sync + 'static,
        F: FnOnce() -> D,
    {
        self.ok_or_else(|| ErrReport::from_display(msg()))
    }
}

    pub trait Sealed {}

    pub trait Sealed<C: EyreContext> {}

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

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

    pub(crate) fn from_display<M>(message: M) -> Self
    where
        M: Display + Send + Sync + 'static,
    {
        use crate::wrapper::DisplayError;
        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.
        unsafe { ErrReport::construct(error, vtable) }
    }

    /// [`Report`][crate::Report] extension trait may be more convenient than

    /// [`WrapErr`][crate::WrapErr] extension trait may be more convenient than

    /// `result.context(...)` via the `Report` trait would be if the context

    /// `result.context(...)` via the `WrapErr` trait would be if the context

    /// [see here]: trait.Report.html#effect-on-downcasting

    /// [see here]: trait.WrapErr.html#effect-on-downcasting

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

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

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

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

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

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

/// This is a reasonable return type to use throughout your application but also
/// for `fn main`; if you do, failures will be printed along with any
/// [context][Report] and a backtrace if one was captured.

/// This is a reasonable return type to use throughout your application but also for `fn main`; if
/// you do, failures will be printed along with a backtrace if one was captured.

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

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

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

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

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

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

pub trait Report<T, E>: context::private::Sealed {

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

    fn wrap_err<D>(self, msg: D) -> Result<T, ErrReport<DefaultContext>>

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

    fn wrap_err_with<D, F>(self, f: F) -> Result<T, ErrReport<DefaultContext>>

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

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

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

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

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