yaahc/eyre - Change OFA7R4NFSICEFZE2SLDK7IP3ZZH4MFWN2YIT756ZJ42W2QJHTOWQC

Rename EyreContext to EyreHandler (#26) * Rename EyreContext to EyreHandler * bump version for new release * use pub use for aliases

Created by Jane Lusby on June 2, 2020

OFA7R4NFSICEFZE2SLDK7IP3ZZH4MFWN2YIT756ZJ42W2QJHTOWQC

Dependencies

In channels

main

Change contents

Replacement in Cargo.toml at line 3 [9.13]

B:BD[7.14] → [8.905:958]

version = "0.4.2" # remember to update html_root_url

[7.14]

[10.53]

version = "0.4.3" # remember to update html_root_url

Replacement in Cargo.toml at line 7 [9.13]

B:BD[9.161] → [4.0:120]

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

[9.161]

[10.231]

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

Insertion in README.md at line 7 [12.12]

[7.449]

[11.0]


[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

Replacement in README.md at line 17 [12.12]
B:BD[13.197] → [8.979:1002]
```
[`eyre::EyreContext`].
```
[13.197]
[8.1002]
```
[`eyre::EyreHandler`].
```
Replacement in README.md at line 19 [12.12]
B:BD[8.1003] → [8.1003:1022]
```
## Custom Contexts
```
[8.1003]
[8.1022]
```
```toml
[dependencies]
eyre = "0.4"
```
```

Replacement in README.md at line 24 [12.12]

B:BD[8.1023] → [5.0:78]

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

[8.1023]

[8.1102]

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

Replacement in README.md at line 29 [12.12]

B:BD[8.1247] → [8.1247:1369]

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

[8.1247]

[8.1369]

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

Replacement in README.md at line 34 [12.12]
B:BD[8.1524] → [8.1524:1560]
```
  `DefaultContext`'s report format.
```
[8.1524]
[8.1560]
```
  `DefaultHandler`'s report format.
```

Replacement in README.md at line 40 [12.12]

B:BD[8.1926] → [8.1926:1997]

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

[8.1926]

[8.1997]

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

Replacement in README.md at line 42 [12.12]

B:BD[8.2074] → [8.2074:2187]

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

[8.2074]

[14.3091]

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

Replacement in README.md at line 207 [12.12]

B:BD[15.486] → [15.486:564]

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

[15.486]

[15.564]

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

Replacement in README.md at line 254 [12.12]

∅:D[16.1057] → [17.303:377]

B:BD[18.119] → [17.303:377]

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

[16.1057]

[18.189]

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

Deletion in README.md at line 265 [12.12]
∅:D[19.98] → [15.955:1146]
∅:D[18.425] → [15.955:1146]
∅:D[13.819] → [15.955:1146]
∅:D[8.2524] → [15.955:1146]
B:BD[15.955] → [15.955:1146]
```
[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
```

Replacement in src/context.rs at line 2 [22.642]

B:BD[20.32] → [21.2343:2411]

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

[20.32]

[23.31]

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

Replacement in src/context.rs at line 11 [22.642]
B:BD[24.29] → [25.89:115]
```
    pub trait StdError<C>
```
[24.29]
[25.115]
```
    pub trait StdError<H>
```
Replacement in src/context.rs at line 13 [22.642]
B:BD[25.125] → [25.125:149]
```
        C: EyreContext,
```
[25.125]
[25.149]
```
        H: EyreHandler,
```

Replacement in src/context.rs at line 15 [22.642]

B:BD[25.155] → [16.1112:1164]

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

[25.155]

[24.107]

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

Replacement in src/context.rs at line 21 [22.642]
B:BD[26.483] → [25.211:244]
```
    impl<E, C> StdError<C> for E
```
[26.483]
[27.174]
```
    impl<E, H> StdError<H> for E
```
Replacement in src/context.rs at line 23 [22.642]
B:BD[27.184] → [25.245:269]
```
        C: EyreContext,
```
[27.184]
[24.198]
```
        H: EyreHandler,
```

Replacement in src/context.rs at line 26 [22.642]

B:BD[22.1587] → [16.1165:1217]

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

[22.1587]

[24.306]

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

Replacement in src/context.rs at line 34 [22.642]
B:BD[24.451] → [16.1259:1297]
```
    impl<C> StdError<C> for Report<C>
```
[24.451]
[25.367]
```
    impl<H> StdError<H> for Report<H>
```
Replacement in src/context.rs at line 36 [22.642]
B:BD[25.377] → [25.377:401]
```
        C: EyreContext,
```
[25.377]
[25.401]
```
        H: EyreHandler,
```

Replacement in src/context.rs at line 38 [22.642]

B:BD[25.407] → [16.1298:1350]

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

[25.407]

[24.534]

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

Replacement in src/context.rs at line 47 [22.642]
B:BD[22.1686] → [25.463:511]
```
impl<T, E, C> WrapErr<T, E, C> for Result<T, E>
```
[22.1686]
[24.693]
```
impl<T, E, H> WrapErr<T, E, H> for Result<T, E>
```

Replacement in src/context.rs at line 49 [22.642]

B:BD[24.699] → [25.512:581]

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

[24.699]

[24.745]

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

Replacement in src/context.rs at line 52 [22.642]

B:BD[24.747] → [16.1351:1408]

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

[24.747]

[28.447]

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

Replacement in src/context.rs at line 59 [22.642]

B:BD[22.1924] → [16.1409:1474]

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

[22.1924]

[27.436]

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

Replacement in src/context.rs at line 67 [22.642]

B:BD[13.827] → [13.827:883]

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

[13.827]

[13.883]

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

Replacement in src/context.rs at line 74 [22.642]

B:BD[13.972] → [13.972:1036]

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

[13.972]

[13.1036]

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

Replacement in src/context.rs at line 83 [22.642]
B:BD[21.2421] → [21.2421:2466]
```
impl<T, C> ContextCompat<T, C> for Option<T>
```
[21.2421]
[21.2466]
```
impl<T, H> ContextCompat<T, H> for Option<T>
```
Replacement in src/context.rs at line 85 [22.642]
B:BD[21.2472] → [21.2472:2492]
```
    C: EyreContext,
```
[21.2472]
[21.2492]
```
    H: EyreHandler,
```

Replacement in src/context.rs at line 87 [22.642]

B:BD[21.2494] → [21.2494:2551]

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

[21.2494]

[21.2551]

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

Replacement in src/context.rs at line 94 [22.642]

B:BD[21.2644] → [21.2644:2709]

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

[21.2644]

[21.2709]

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

Replacement in src/context.rs at line 102 [22.642]

B:BD[21.2833] → [21.2833:2889]

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

[21.2833]

[21.2889]

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

Replacement in src/context.rs at line 109 [22.642]

B:BD[21.3010] → [21.3010:3074]

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

[21.3010]

[21.3074]

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

Replacement in src/context.rs at line 155 [22.642]

B:BD[22.2904] → [16.1475:1526]

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

[22.2904]

[28.793]

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

Replacement in src/context.rs at line 157 [22.642]
B:BD[28.799] → [29.1660:1680]
```
    C: EyreContext,
```
[28.799]
[29.1680]
```
    H: EyreHandler,
```
Replacement in src/context.rs at line 188 [22.642]
B:BD[30.214] → [25.712:752]
```
    pub trait Sealed<C: EyreContext> {}
```
[30.214]
[30.238]
```
    pub trait Sealed<H: EyreHandler> {}
```

Replacement in src/context.rs at line 190 [22.642]

B:BD[30.239] → [25.753:840]

B:BD[25.840] → [21.3417:3472]

    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> {}

[30.239]

[22.3220]

    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> {}

Replacement in src/error.rs at line 3 [22.3238]
B:BD[26.573] → [31.280:304]
```
use crate::EyreContext;
```
[26.573]
[16.1527]
```
use crate::EyreHandler;
```
Replacement in src/error.rs at line 13 [22.3238]
B:BD[22.3932] → [16.1559:1577]
```
impl<C> Report<C>
```
[22.3932]
[29.1831]
```
impl<H> Report<H>
```
Replacement in src/error.rs at line 15 [22.3238]
B:BD[29.1837] → [29.1837:1857]
```
    C: EyreContext,
```
[29.1837]
[29.1857]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 83 [22.3238]

B:BD[32.36] → [29.1985:2075]

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

[32.36]

[26.722]

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

Replacement in src/error.rs at line 86 [22.3238]

B:BD[26.758] → [29.2076:2279]

            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>,

[26.758]

[32.300]

            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>,

Replacement in src/error.rs at line 93 [22.3238]

B:BD[32.381] → [33.54:102]

B:BD[33.102] → [16.1958:2019]

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

[32.381]

[22.4396]

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

Replacement in src/error.rs at line 104 [22.3238]

B:BD[32.480] → [29.2389:2507]

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

[32.480]

[26.802]

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

Replacement in src/error.rs at line 107 [22.3238]

B:BD[26.838] → [29.2508:2739]

            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>,

[26.838]

[32.814]

            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>,

Replacement in src/error.rs at line 115 [22.3238]

B:BD[32.962] → [33.167:215]

B:BD[33.215] → [21.3473:3534]

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

[32.962]

[21.3534]

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

Replacement in src/error.rs at line 126 [22.3238]

B:BD[21.3806] → [21.3806:3924]

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

[21.3806]

[21.3924]

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

Replacement in src/error.rs at line 129 [22.3238]

B:BD[21.3960] → [21.3960:4191]

            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>,

[21.3960]

[21.4191]

            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>,

Replacement in src/error.rs at line 137 [22.3238]

B:BD[21.4339] → [21.4339:4391]

∅:D[21.4391] → [16.2020:2081]

B:BD[33.215] → [16.2020:2081]

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

[21.4339]

[34.1044]

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

Replacement in src/error.rs at line 150 [22.3238]

B:BD[35.323] → [29.3437:3561]

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

[35.323]

[26.948]

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

Replacement in src/error.rs at line 153 [22.3238]

B:BD[26.984] → [29.3562:3806]

            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>,

[26.984]

[35.689]

            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>,

Replacement in src/error.rs at line 160 [22.3238]

B:BD[35.768] → [33.280:328]

B:BD[33.328] → [16.2082:2143]

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

[35.768]

[22.4605]

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

Replacement in src/error.rs at line 168 [22.3238]

B:BD[36.234] → [33.393:441]

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

[36.234]

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

Replacement in src/error.rs at line 170 [22.3238]

B:BD[36.270] → [29.3863:3971]

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

[36.270]

[26.1055]

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

Replacement in src/error.rs at line 173 [22.3238]

B:BD[26.1091] → [29.3972:4253]

            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>,

[26.1091]

[36.641]

            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>,

Replacement in src/error.rs at line 181 [22.3238]

B:BD[36.797] → [16.2144:2205]

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

[36.797]

[36.859]

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

Replacement in src/error.rs at line 189 [22.3238]

B:BD[32.1710] → [33.507:605]

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

[32.1710]

[27.910]

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

Replacement in src/error.rs at line 195 [22.3238]
B:BD[37.897] → [29.4395:4416]
```
            context,
```
[37.897]
[38.0]
```
            handler,
```

Replacement in src/error.rs at line 204 [22.3238]

B:BD[39.458] → [29.4417:4508]

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

[39.458]

[40.212]

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

Replacement in src/error.rs at line 266 [22.3238]

B:BD[41.559] → [33.656:705]

B:BD[33.705] → [16.2292:2375]

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

[41.559]

[42.47]

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

Replacement in src/error.rs at line 270 [22.3238]

B:BD[42.84] → [16.2376:2516]

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

[42.84]

[26.1092]

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

Replacement in src/error.rs at line 273 [22.3238]

B:BD[26.1128] → [16.2517:2659]

∅:D[16.2659] → [29.4978:5102]

B:BD[29.4978] → [29.4978:5102]

            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>,

[26.1128]

[42.474]

            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>,

Replacement in src/error.rs at line 280 [22.3238]

B:BD[42.662] → [16.2660:2721]

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

[42.662]

[22.5336]

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

Replacement in src/error.rs at line 434 [22.3238]

B:BD[31.632] → [43.128:184]

∅:D[43.184] → [44.229:263]

B:BD[44.229] → [44.229:263]

B:BD[44.263] → [33.771:816]

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

[31.632]

[44.291]

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

Replacement in src/error.rs at line 439 [22.3238]

B:BD[44.298] → [43.185:249]

∅:D[43.249] → [44.298:344]

B:BD[44.298] → [44.298:344]

B:BD[44.344] → [33.817:862]

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

[44.298]

[22.7472]

    /// 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()

Insertion in src/error.rs at line 449 [22.3238]

[22.7478]


    /// 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()
    }

Replacement in src/error.rs at line 458 [22.3238]
B:BD[26.1211] → [16.3138:3171]
```
impl<E, C> From<E> for Report<C>
```
[26.1211]
[28.1305]
```
impl<E, H> From<E> for Report<H>
```
Replacement in src/error.rs at line 460 [22.3238]
B:BD[28.1311] → [29.5359:5379]
```
    C: EyreContext,
```
[28.1311]
[28.1311]
```
    H: EyreHandler,
```
Replacement in src/error.rs at line 469 [22.3238]
B:BD[26.1236] → [16.3205:3248]
```
impl<C: EyreContext> Deref for Report<C> {
```
[26.1236]
[45.1503]
```
impl<H: EyreHandler> Deref for Report<H> {
```
Replacement in src/error.rs at line 478 [22.3238]
B:BD[26.1261] → [16.3249:3295]
```
impl<C: EyreContext> DerefMut for Report<C> {
```
[26.1261]
[22.7805]
```
impl<H: EyreHandler> DerefMut for Report<H> {
```
Replacement in src/error.rs at line 484 [22.3238]
B:BD[22.7896] → [16.3296:3341]
```
impl<C: EyreContext> Display for Report<C> {
```
[22.7896]
[21.4432]
```
impl<H: EyreHandler> Display for Report<H> {
```
Replacement in src/error.rs at line 490 [22.3238]
B:BD[22.8843] → [16.3342:3385]
```
impl<C: EyreContext> Debug for Report<C> {
```
[22.8843]
[21.4504]
```
impl<H: EyreHandler> Debug for Report<H> {
```
Replacement in src/error.rs at line 496 [22.3238]
B:BD[22.8984] → [16.3386:3413]
```
impl<C> Drop for Report<C>
```
[22.8984]
[29.5639]
```
impl<H> Drop for Report<H>
```
Replacement in src/error.rs at line 498 [22.3238]
B:BD[29.5645] → [29.5645:5665]
```
    C: EyreContext,
```
[29.5645]
[29.5665]
```
    H: EyreHandler,
```
Replacement in src/error.rs at line 512 [22.3238]
B:BD[46.174] → [29.5668:5690]
```
struct ErrorVTable<C>
```
[46.174]
[29.5690]
```
struct ErrorVTable<H>
```
Replacement in src/error.rs at line 514 [22.3238]
B:BD[29.5696] → [31.712:732]
```
    C: EyreContext,
```
[29.5696]
[29.5720]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 516 [22.3238]

B:BD[29.5722] → [29.5722:5862]

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

[29.5722]

[26.1262]

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

Replacement in src/error.rs at line 519 [22.3238]

B:BD[26.1290] → [29.5863:5960]

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

[26.1290]

[3.0]

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

Replacement in src/error.rs at line 521 [22.3238]

∅:D[3.38] → [29.5960:6203]

B:BD[29.5960] → [29.5960:6203]

    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),

[3.38]

[40.520]

    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),

Replacement in src/error.rs at line 527 [22.3238]

B:BD[39.1435] → [29.6204:6258]

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

[39.1435]

[29.6258]

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

Replacement in src/error.rs at line 529 [22.3238]
B:BD[29.6264] → [29.6264:6284]
```
    C: EyreContext,
```
[29.6264]
[29.6284]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 533 [22.3238]

B:BD[40.695] → [29.6287:6372]

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

[40.695]

[47.448]

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

Replacement in src/error.rs at line 538 [22.3238]

B:BD[39.1492] → [29.6373:6449]

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

[39.1492]

[29.6449]

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

Replacement in src/error.rs at line 540 [22.3238]
B:BD[29.6455] → [29.6455:6475]
```
    C: EyreContext,
```
[29.6455]
[29.6475]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 546 [22.3238]

B:BD[48.615] → [29.6478:6577]

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

[48.615]

[40.774]

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

Replacement in src/error.rs at line 551 [22.3238]

B:BD[39.1549] → [29.6578:6670]

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

[39.1549]

[46.451]

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

Replacement in src/error.rs at line 553 [22.3238]
B:BD[46.457] → [29.6671:6691]
```
    C: EyreContext,
```
[46.457]
[46.457]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 557 [22.3238]

B:BD[39.1623] → [29.6692:6765]

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

[39.1623]

[22.9174]

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

Replacement in src/error.rs at line 562 [22.3238]

B:BD[26.1315] → [29.6766:6866]

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

[26.1315]

[46.606]

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

Replacement in src/error.rs at line 564 [22.3238]
B:BD[46.612] → [29.6867:6887]
```
    C: EyreContext,
```
[46.612]
[46.612]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 568 [22.3238]

B:BD[39.1754] → [29.6888:6961]

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

[39.1754]

[49.305]

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

Replacement in src/error.rs at line 572 [22.3238]

B:BD[39.1811] → [29.6962:7062]

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

[39.1811]

[49.402]

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

Replacement in src/error.rs at line 574 [22.3238]
B:BD[49.408] → [29.7063:7083]
```
    C: EyreContext,
```
[49.408]
[49.408]
```
    H: EyreHandler,
```
Replacement in src/error.rs at line 576 [22.3238]
B:BD[49.449] → [29.7084:7114]
```
    C: Send + Sync + 'static,
```
[49.449]
[49.449]
```
    H: Send + Sync + 'static,
```

Replacement in src/error.rs at line 579 [22.3238]

B:BD[39.1893] → [29.7115:7184]

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

[39.1893]

[50.1375]

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

Replacement in src/error.rs at line 583 [22.3238]

B:BD[39.1950] → [29.7185:7278]

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

[39.1950]

[32.2035]

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

Replacement in src/error.rs at line 585 [22.3238]
B:BD[32.2041] → [29.7279:7299]
```
    C: EyreContext,
```
[32.2041]
[50.1466]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 591 [22.3238]

B:BD[39.2062] → [29.7300:7379]

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

[39.2062]

[38.165]

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

Replacement in src/error.rs at line 601 [22.3238]

B:BD[26.1340] → [29.7454:7551]

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

[26.1340]

[48.865]

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

Replacement in src/error.rs at line 603 [22.3238]
B:BD[48.871] → [29.7552:7572]
```
    C: EyreContext,
```
[48.871]
[29.7572]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 608 [22.3238]

B:BD[29.7626] → [29.7626:7722]

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

[29.7626]

[29.7722]

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

Replacement in src/error.rs at line 612 [22.3238]

B:BD[48.1190] → [29.7791:7887]

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

[48.1190]

[38.303]

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

Replacement in src/error.rs at line 622 [22.3238]

B:BD[26.1365] → [29.7962:8041]

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

[26.1365]

[48.1500]

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

Replacement in src/error.rs at line 624 [22.3238]
B:BD[48.1506] → [29.8042:8062]
```
    C: EyreContext,
```
[48.1506]
[29.8062]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 632 [22.3238]

B:BD[48.1746] → [29.8196:8296]

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

[48.1746]

[48.1840]

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

Replacement in src/error.rs at line 638 [22.3238]

B:BD[48.1932] → [29.8297:8397]

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

[48.1932]

[51.465]

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

Replacement in src/error.rs at line 646 [22.3238]

∅:D[16.3492] → [29.8479:8579]

B:BD[29.8479] → [29.8479:8579]

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

[16.3492]

[51.980]

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

Replacement in src/error.rs at line 648 [22.3238]
B:BD[51.986] → [29.8580:8600]
```
    C: EyreContext,
```
[51.986]
[29.8600]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 653 [22.3238]

B:BD[31.756] → [16.3493:3586]

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

[31.756]

[29.8761]

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

Replacement in src/error.rs at line 659 [22.3238]

B:BD[31.876] → [16.3587:3680]

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

[31.876]

[38.497]

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

Replacement in src/error.rs at line 666 [22.3238]

∅:D[16.3759] → [29.9019:9101]

B:BD[29.9019] → [29.9019:9101]

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

[16.3759]

[51.1558]

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

Replacement in src/error.rs at line 668 [22.3238]
B:BD[51.1564] → [29.9102:9122]
```
    C: EyreContext,
```
[51.1564]
[29.9122]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 675 [22.3238]

B:BD[51.1800] → [29.9256:9291]

B:BD[29.9291] → [16.3760:3833]

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

[51.1800]

[48.2026]

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

Replacement in src/error.rs at line 682 [22.3238]

B:BD[51.1953] → [29.9368:9403]

B:BD[29.9403] → [16.3916:3989]

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

[51.1953]

[51.2051]

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

Replacement in src/error.rs at line 696 [22.3238]
B:BD[22.9247] → [29.9480:9514]
```
pub(crate) struct ErrorImpl<E, C>
```
[22.9247]
[29.9514]
```
pub(crate) struct ErrorImpl<E, H>
```
Replacement in src/error.rs at line 698 [22.3238]
B:BD[29.9520] → [29.9520:9540]
```
    C: EyreContext,
```
[29.9520]
[29.9540]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 700 [22.3238]

B:BD[29.9542] → [29.9542:9579]

B:BD[29.9579] → [33.863:898]

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

[29.9542]

[48.2132]

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

Replacement in src/error.rs at line 715 [22.3238]
B:BD[22.9886] → [29.9794:9821]
```
impl<E, C> ErrorImpl<E, C>
```
[22.9886]
[29.9821]
```
impl<E, H> ErrorImpl<E, H>
```
Replacement in src/error.rs at line 717 [22.3238]
B:BD[29.9827] → [29.9827:9847]
```
    C: EyreContext,
```
[29.9827]
[29.9847]
```
    H: EyreHandler,
```
Replacement in src/error.rs at line 719 [22.3238]
B:BD[29.9849] → [29.9849:9892]
```
    fn erase(&self) -> &ErrorImpl<(), C> {
```
[29.9849]
[39.2672]
```
    fn erase(&self) -> &ErrorImpl<(), H> {
```

Replacement in src/error.rs at line 723 [22.3238]

B:BD[39.2859] → [29.9893:9974]

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

[39.2859]

[52.139]

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

Replacement in src/error.rs at line 727 [22.3238]
B:BD[34.1798] → [29.9975:10000]
```
impl<C> ErrorImpl<(), C>
```
[34.1798]
[29.10000]
```
impl<H> ErrorImpl<(), H>
```
Replacement in src/error.rs at line 729 [22.3238]
B:BD[29.10006] → [29.10006:10026]
```
    C: EyreContext,
```
[29.10006]
[29.10026]
```
    H: EyreHandler,
```
Replacement in src/error.rs at line 749 [22.3238]
B:BD[49.2159] → [29.10185:10225]
```
impl<E, C> StdError for ErrorImpl<E, C>
```
[49.2159]
[52.182]
```
impl<E, H> StdError for ErrorImpl<E, H>
```
Replacement in src/error.rs at line 751 [22.3238]
B:BD[52.188] → [29.10226:10246]
```
    C: EyreContext,
```
[52.188]
[52.188]
```
    H: EyreHandler,
```
Replacement in src/error.rs at line 759 [22.3238]
B:BD[49.2215] → [29.10247:10284]
```
impl<E, C> Debug for ErrorImpl<E, C>
```
[49.2215]
[49.2246]
```
impl<E, H> Debug for ErrorImpl<E, H>
```
Replacement in src/error.rs at line 761 [22.3238]
B:BD[49.2252] → [29.10285:10305]
```
    C: EyreContext,
```
[49.2252]
[49.2252]
```
    H: EyreHandler,
```
Replacement in src/error.rs at line 769 [22.3238]
B:BD[49.2465] → [29.10306:10345]
```
impl<E, C> Display for ErrorImpl<E, C>
```
[49.2465]
[49.2498]
```
impl<E, H> Display for ErrorImpl<E, H>
```
Replacement in src/error.rs at line 771 [22.3238]
B:BD[49.2504] → [29.10346:10366]
```
    C: EyreContext,
```
[49.2504]
[49.2504]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 779 [22.3238]

B:BD[49.2643] → [16.3990:4115]

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

[49.2643]

[49.2744]

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

Replacement in src/error.rs at line 795 [22.3238]

B:BD[53.9] → [16.4181:4292]

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

[53.9]

[53.96]

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

Replacement in src/error.rs at line 802 [22.3238]

B:BD[26.1419] → [16.4293:4364]

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

[26.1419]

[54.60]

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

Replacement in src/error.rs at line 809 [22.3238]

B:BD[26.1444] → [16.4365:4422]

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

[26.1444]

[54.188]

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

Replacement in src/fmt.rs at line 2 [56.270]
∅:D[55.2447] → [29.10753:10777]
B:BD[57.37] → [29.10753:10777]
```
use crate::EyreContext;
```
[56.300]
[44.670]
```
use crate::EyreHandler;
```
Replacement in src/fmt.rs at line 5 [56.270]
B:BD[56.330] → [29.10778:10803]
```
impl<C> ErrorImpl<(), C>
```
[56.330]
[29.10803]
```
impl<H> ErrorImpl<(), H>
```
Replacement in src/fmt.rs at line 7 [56.270]
B:BD[29.10809] → [29.10809:10829]
```
    C: EyreContext,
```
[29.10809]
[29.10829]
```
    H: EyreHandler,
```
Replacement in src/fmt.rs at line 10 [56.270]
∅:D[21.4894] → [33.989:1010]
B:BD[58.74] → [33.989:1010]
```
        self.context
```
[21.4894]
[33.1010]
```
        self.handler
```

Replacement in src/fmt.rs at line 12 [56.270]

B:BD[33.1032] → [33.1032:1093]

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

[33.1032]

[6.0]

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

Replacement in src/fmt.rs at line 17 [56.270]
∅:D[21.4971] → [33.1166:1187]
B:BD[56.1175] → [33.1166:1187]
```
        self.context
```
[21.4971]
[33.1187]
```
        self.handler
```

Replacement in src/fmt.rs at line 19 [56.270]

B:BD[33.1209] → [33.1209:1268]

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

[33.1209]

[6.74]

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

Replacement in src/kind.rs at line 48 [60.10]
B:BD[59.1632] → [16.4697:4731]
```
use crate::{EyreContext, Report};
```
[59.1632]
[23.275]
```
use crate::{EyreHandler, Report};
```

Replacement in src/kind.rs at line 69 [60.10]

B:BD[60.369] → [16.4732:4797]

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

[60.369]

[60.414]

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

Replacement in src/kind.rs at line 113 [60.10]

B:BD[36.1095] → [16.4956:5048]

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

[36.1095]

[16.5048]

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

Replacement in src/lib.rs at line 1 [22.11888]

B:BD[22.11888] → [16.5083:5162]

∅:D[16.5162] → [61.79:144]

∅:D[7.6214] → [61.79:144]

B:BD[61.79] → [61.79:144]

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

[22.11888]

[62.558]

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

Replacement in src/lib.rs at line 7 [22.11888]
B:BD[8.2676] → [8.2676:2703]
```
//! [`eyre::EyreContext`].
```
[8.2676]
[62.2534]
```
//! [`eyre::EyreHandler`].
```
Replacement in src/lib.rs at line 9 [22.11888]
B:BD[62.2538] → [62.2538:2569]
B:BD[62.2569] → [43.250:267]
∅:D[43.267] → [62.6040:6048]
B:BD[62.6040] → [62.6040:6048]
```
//! ```toml
//! [dependencies]
//! eyre = "0.4"
//! ```
```
[62.2538]
[8.2704]
```
//! ## Custom Report Handlers
```

Replacement in src/lib.rs at line 11 [22.11888]

B:BD[8.2708] → [8.2708:2818]

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

[8.2708]

[8.2818]

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

Replacement in src/lib.rs at line 14 [22.11888]

B:BD[8.2971] → [8.2971:3101]

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

[8.2971]

[8.3101]

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

Replacement in src/lib.rs at line 19 [22.11888]
B:BD[8.3267] → [8.3267:3307]
```
//!   `DefaultContext`'s report format.
```
[8.3267]
[8.3307]
```
//!   `DefaultHandler`'s report format.
```

Replacement in src/lib.rs at line 25 [22.11888]

B:BD[8.3693] → [8.3693:3768]

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

[8.3693]

[8.3768]

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

Replacement in src/lib.rs at line 27 [22.11888]

B:BD[8.3849] → [8.3849:3970]

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

[8.3849]

[8.3970]

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

Replacement in src/lib.rs at line 32 [22.11888]

B:BD[61.179] → [16.5682:5757]

∅:D[16.5757] → [61.257:305]

∅:D[7.6293] → [61.257:305]

B:BD[61.257] → [61.257:305]

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

[61.179]

[61.305]

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

Replacement in src/lib.rs at line 35 [22.11888]

B:BD[61.309] → [61.309:390]

B:BD[61.390] → [16.5758:5796]

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

[61.309]

[61.427]

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

Replacement in src/lib.rs at line 38 [22.11888]
B:BD[61.431] → [61.431:441]
```
//!   ```
```
[61.431]
[63.0]
```
//!   ```rust
```

Replacement in src/lib.rs at line 65 [22.11888]

B:BD[61.692] → [64.860:1137]

//! - 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.

[61.692]

[61.976]

//! - 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.

Replacement in src/lib.rs at line 71 [22.11888]
B:BD[61.980] → [61.980:990]
```
//!   ```
```
[61.980]
[63.392]
```
//!   ```rust
```
Replacement in src/lib.rs at line 115 [22.11888]
B:BD[61.1598] → [61.1598:1608]
```
//!   ```
```
[61.1598]
[16.5797]
```
//!   ```rust
```

Replacement in src/lib.rs at line 149 [22.11888]

B:BD[65.1620] → [65.1620:1823]

//!   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`]:

[65.1620]

[61.1897]

//!   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`]:

Replacement in src/lib.rs at line 165 [22.11888]

∅:D[66.1672] → [67.710:869]

B:BD[67.710] → [67.710:869]

//!   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

[66.1672]

[68.69]

//!   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

Deletion in src/lib.rs at line 168 [22.11888]
∅:D[68.88] → [67.889:893]
B:BD[67.889] → [67.889:893]
B:BD[67.893] → [68.89:145]
```
//!
//!   [thiserror]: https://github.com/dtolnay/thiserror
```
Replacement in src/lib.rs at line 169 [22.11888]
B:BD[67.953] → [67.953:963]
```
//!   ```
```
[67.953]
[69.180]
```
//!   ```rust
```
Replacement in src/lib.rs at line 187 [22.11888]
B:BD[61.2130] → [70.374:384]
```
//!   ```
```
[61.2130]
[7.6608]
```
//!   ```rust
```

Replacement in src/lib.rs at line 199 [22.11888]

B:BD[71.638] → [71.638:719]

B:BD[71.719] → [66.1673:1745]

∅:D[66.1745] → [71.793:852]

B:BD[71.793] → [71.793:852]

//! 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.

[71.638]

[71.852]

//! **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.

Replacement in src/lib.rs at line 213 [22.11888]

B:BD[71.1027] → [16.5944:6097]

∅:D[16.6097] → [66.1746:1820]

B:BD[7.6920] → [66.1746:1820]

//! `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.

[71.1027]

[13.1500]

//! `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

Replacement in src/lib.rs at line 261 [22.11888]

B:BD[13.2157] → [13.2157:2239]

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

[13.2157]

[13.2239]

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

Replacement in src/lib.rs at line 309 [22.11888]

∅:D[16.6159] → [72.487:565]

B:BD[72.487] → [72.487:565]

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

[16.6159]

[72.565]

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

Replacement in src/lib.rs at line 320 [22.11888]

B:BD[8.4340] → [8.4340:4394]

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

[8.4340]

[21.7071]

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

Insertion in src/lib.rs at line 402 [22.11888]
[13.2752]
[16.6215]
```
#[doc(hidden)]
pub use DefaultHandler as DefaultContext;
```
Insertion in src/lib.rs at line 405 [22.11888]
[16.6230]
[16.6230]
```
pub use EyreHandler as EyreContext;
#[doc(hidden)]
```

Replacement in src/lib.rs at line 456 [22.11888]

B:BD[73.1283] → [25.1099:1197]

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

[73.1283]

[7.7727]

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

Replacement in src/lib.rs at line 502 [22.11888]
B:BD[73.2560] → [16.6738:6776]
```
pub struct Report<C = DefaultContext>
```
[73.2560]
[29.11355]
```
pub struct Report<H = DefaultHandler>
```
Replacement in src/lib.rs at line 504 [22.11888]
B:BD[29.11361] → [29.11361:11381]
```
    C: EyreContext,
```
[29.11361]
[29.11381]
```
    H: EyreHandler,
```

Replacement in src/lib.rs at line 506 [22.11888]

B:BD[29.11383] → [29.11383:11431]

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

[29.11383]

[29.11431]

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

Replacement in src/lib.rs at line 509 [22.11888]

B:BD[29.11434] → [13.2942:2991]

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

[29.11434]

[13.2991]

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

Replacement in src/lib.rs at line 513 [22.11888]

B:BD[13.3020] → [13.3020:3132]

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

[13.3020]

[13.3132]

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

Replacement in src/lib.rs at line 516 [22.11888]

B:BD[13.3136] → [13.3136:3213]

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

[13.3136]

[13.3213]

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

Replacement in src/lib.rs at line 521 [22.11888]
B:BD[74.407] → [74.407:434]
```
/// use eyre::EyreContext;
```
[74.407]
[74.434]
```
/// use eyre::EyreHandler;
```
Replacement in src/lib.rs at line 526 [22.11888]
B:BD[74.490] → [74.490:515]
```
/// pub struct Context {
```
[74.490]
[74.515]
```
/// pub struct Handler {
```
Replacement in src/lib.rs at line 530 [22.11888]
B:BD[74.555] → [74.555:590]
```
/// impl EyreContext for Context {
```
[74.555]
[74.590]
```
/// impl EyreHandler for Handler {
```

Replacement in src/lib.rs at line 565 [22.11888]

B:BD[13.3331] → [74.1857:1974]

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

[13.3331]

[13.3434]

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

Replacement in src/lib.rs at line 568 [22.11888]

∅:D[13.3442] → [29.11434:11489]

B:BD[29.11434] → [29.11434:11489]

B:BD[29.11489] → [13.3443:3511]

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

[13.3442]

[13.3511]

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

Replacement in src/lib.rs at line 579 [22.11888]
B:BD[74.2025] → [74.2025:2056]
```
    /// use eyre::EyreContext;
```
[74.2025]
[74.2056]
```
    /// use eyre::EyreHandler;
```
Replacement in src/lib.rs at line 583 [22.11888]
B:BD[13.3859] → [13.3859:3888]
```
    /// pub struct Context {
```
[13.3834]
[74.2115]
```
    /// pub struct Handler {
```
Replacement in src/lib.rs at line 587 [22.11888]
B:BD[13.3948] → [13.3948:3987]
```
    /// impl EyreContext for Context {
```
[13.3948]
[74.2150]
```
    /// impl EyreHandler for Handler {
```
Replacement in src/lib.rs at line 634 [22.11888]
B:BD[74.3451] → [74.3451:3482]
```
    /// use eyre::EyreContext;
```
[74.3451]
[74.3482]
```
    /// use eyre::EyreHandler;
```
Replacement in src/lib.rs at line 639 [22.11888]
B:BD[74.3546] → [74.3546:3575]
```
    /// pub struct Context {
```
[74.3546]
[74.3575]
```
    /// pub struct Handler {
```
Replacement in src/lib.rs at line 643 [22.11888]
∅:D[74.3627] → [13.4552:4591]
B:BD[13.4552] → [13.4552:4591]
```
    /// impl EyreContext for Context {
```
[74.3627]
[74.3628]
```
    /// impl EyreHandler for Handler {
```

Replacement in src/lib.rs at line 709 [22.11888]

B:BD[29.11621] → [74.3850:3903]

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

[29.11621]

[74.3903]

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

Replacement in src/lib.rs at line 714 [22.11888]
∅:D[43.444] → [29.11621:11649]
∅:D[74.4043] → [29.11621:11649]
B:BD[29.11621] → [29.11621:11649]
```
pub struct DefaultContext {
```
[43.444]
[31.1752]
```
pub struct DefaultHandler {
```
Replacement in src/lib.rs at line 718 [22.11888]
B:BD[21.8250] → [21.8250:8293]
```
impl core::fmt::Debug for DefaultContext {
```
[21.8250]
[21.8293]
```
impl core::fmt::Debug for DefaultHandler {
```
Replacement in src/lib.rs at line 720 [22.11888]
B:BD[21.8368] → [21.8368:8409]
```
        f.debug_struct("DefaultContext")
```
[21.8368]
[21.8409]
```
        f.debug_struct("DefaultHandler")
```
Replacement in src/lib.rs at line 732 [22.11888]
B:BD[29.11686] → [29.11686:11724]
```
impl EyreContext for DefaultContext {
```
[29.11686]
[2.0]
```
impl EyreHandler for DefaultHandler {
```

Replacement in src/lib.rs at line 858 [22.11888]

B:BD[75.667] → [16.6942:7019]

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

[75.667]

[76.83]

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

Replacement in src/lib.rs at line 1025 [22.11888]

B:BD[77.3492] → [25.1523:1579]

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

[77.3492]

[25.1579]

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

Replacement in src/lib.rs at line 1027 [22.11888]
B:BD[25.1585] → [25.1585:1605]
```
    C: EyreContext,
```
[25.1585]
[25.1605]
```
    H: EyreHandler,
```

Replacement in src/lib.rs at line 1030 [22.11888]

B:BD[66.2572] → [16.7020:7077]

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

[66.2572]

[76.1425]

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

Replacement in src/lib.rs at line 1036 [22.11888]

B:BD[76.1597] → [16.7078:7141]

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

[76.1597]

[13.6537]

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

Replacement in src/lib.rs at line 1042 [22.11888]

B:BD[13.6689] → [13.6689:6745]

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

[13.6689]

[76.1655]

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

Replacement in src/lib.rs at line 1047 [22.11888]

B:BD[13.6867] → [21.9910:9972]

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

[13.6867]

[21.9972]

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

Replacement in src/lib.rs at line 1096 [22.11888]

B:BD[21.11613] → [21.11613:11672]

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

[21.11613]

[21.11672]

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

Replacement in src/lib.rs at line 1098 [22.11888]
B:BD[21.11678] → [21.11678:11698]
```
    C: EyreContext,
```
[21.11678]
[21.11698]
```
    H: EyreHandler,
```

Replacement in src/lib.rs at line 1102 [22.11888]

B:BD[21.11831] → [21.11831:11887]

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

[21.11831]

[21.11887]

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

Replacement in src/lib.rs at line 1108 [22.11888]
∅:D[21.12078] → [13.6867:6929]
B:BD[13.6867] → [13.6867:6929]
```
    fn with_context<D, F>(self, f: F) -> Result<T, Report<C>>
```
[21.12078]
[21.12079]
```
    fn with_context<D, F>(self, f: F) -> Result<T, Report<H>>
```

Replacement in src/lib.rs at line 1114 [22.11888]

B:BD[21.12241] → [21.12241:12298]

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

[21.12241]

[13.6929]

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

Replacement in src/lib.rs at line 1119 [22.11888]

B:BD[21.12430] → [21.12430:12493]

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

[21.12430]

[21.12493]

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

Replacement in src/lib.rs at line 1128 [22.11888]
B:BD[78.210] → [16.7142:7180]
```
    use crate::{EyreContext, Report};
```
[78.210]
[23.424]
```
    use crate::{EyreHandler, Report};
```

Replacement in src/lib.rs at line 1144 [22.11888]

B:BD[60.1152] → [16.7181:7233]

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

[60.1152]

[78.314]

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

Replacement in src/lib.rs at line 1146 [22.11888]
B:BD[78.324] → [29.12523:12547]
```
        C: EyreContext,
```
[78.324]
[78.324]
```
        H: EyreHandler,
```
Insertion in tests/test_macros.rs at line 1 [79.123]
[79.123]
[80.775]
```
#![allow(clippy::eq_op)]
```

Rename EyreContext to EyreHandler (#26) * Rename EyreContext to EyreHandler * bump version for new release * use pub use for aliases

Dependencies

In channels

Change contents

Replacement in Cargo.toml at line 3 [9.13]

Replacement in Cargo.toml at line 7 [9.13]

Insertion in README.md at line 7 [12.12]

Replacement in README.md at line 17 [12.12]

Replacement in README.md at line 19 [12.12]

Replacement in README.md at line 24 [12.12]

Replacement in README.md at line 29 [12.12]

Replacement in README.md at line 34 [12.12]

Replacement in README.md at line 40 [12.12]

Replacement in README.md at line 42 [12.12]

Replacement in README.md at line 207 [12.12]

Replacement in README.md at line 254 [12.12]

Deletion in README.md at line 265 [12.12]

Replacement in src/context.rs at line 2 [22.642]

Replacement in src/context.rs at line 11 [22.642]

Replacement in src/context.rs at line 13 [22.642]

Replacement in src/context.rs at line 15 [22.642]

Replacement in src/context.rs at line 21 [22.642]

Replacement in src/context.rs at line 23 [22.642]

Replacement in src/context.rs at line 26 [22.642]

Replacement in src/context.rs at line 34 [22.642]

Replacement in src/context.rs at line 36 [22.642]

Replacement in src/context.rs at line 38 [22.642]

Replacement in src/context.rs at line 47 [22.642]

Replacement in src/context.rs at line 49 [22.642]

Replacement in src/context.rs at line 52 [22.642]

Replacement in src/context.rs at line 59 [22.642]

Replacement in src/context.rs at line 67 [22.642]

Replacement in src/context.rs at line 74 [22.642]

Replacement in src/context.rs at line 83 [22.642]

Replacement in src/context.rs at line 85 [22.642]

Replacement in src/context.rs at line 87 [22.642]

Replacement in src/context.rs at line 94 [22.642]

Replacement in src/context.rs at line 102 [22.642]

Replacement in src/context.rs at line 109 [22.642]

Replacement in src/context.rs at line 155 [22.642]

Replacement in src/context.rs at line 157 [22.642]

Replacement in src/context.rs at line 188 [22.642]

Replacement in src/context.rs at line 190 [22.642]

Replacement in src/error.rs at line 3 [22.3238]

Replacement in src/error.rs at line 13 [22.3238]

Replacement in src/error.rs at line 15 [22.3238]