Miette - How to specify errors that contain a generic that defaults to Box?

Question

While this question is about the miette library, it could probably be answered by every experienced Rustacean by looking at the miette sourcecode. It isn't that big, but I wasn't able to extract the answer from it, sadly.

All the following examples assume the dependencies:

miette = { version = "4.4", features = ["fancy"] }
thiserror = "1.0"

I currently have a custom error definition similar to the following in my library tokio-graceful-shutdown:

#[derive(Debug, thiserror::Error, miette::Diagnostic)]
pub enum MyError {
    #[error("Error containing another error")]
    AnError(#[source] Box<dyn Error + Send + Sync>),
}

I would like the source error type to be generic, with a default value of Box<dyn Error>.

My attempts

If I would leave out the miette::Diagnostic, the solution would look like this:

#[derive(Debug, thiserror::Error)]
pub enum MyError<ErrType = Box<dyn Error + Send + Sync>> {
    #[error("Error containing another error")]
    AnError(#[source] ErrType),
}

If I would leave out the Box<dyn Error> default value, the solution would look like this:

#[derive(Debug, thiserror::Error, miette::Diagnostic)]
pub enum MyError<ErrType: 'static + Error> {
    #[error("Error containing another error")]
    AnError(#[source] ErrType),
}

Sadly, combining the two, it turns out that Box<dyn Error> does NOT implement Error:

#[derive(Debug, thiserror::Error, miette::Diagnostic)]
pub enum MyError<ErrType: 'static + Error = Box<dyn Error + Send + Sync>> {
    #[error("Error containing another error")]
    AnError(#[source] ErrType),
}

|
| pub enum MyError<ErrType: 'static + Error = Box<dyn Error + Send + Sync>> {
|                                     ^^^^^ doesn't have a size known at compile-time
|
= help: the trait `Sized` is not implemented for `(dyn std::error::Error + Send + Sync + 'static)`
= note: required because of the requirements on the impl of `std::error::Error` for `Box<(dyn std::error::Error + Send + Sync + 'static)>`

I suspect, however, that this error message is a red herring and instead, the 'static + Error is incorrect and ErrType needs a different restriction.

The reason why I suspect this is that if I directly use Box<dyn Error> as the source type, it works, as in the first example. That makes me believe that it isn't actually Error that miette::Diagnostic requires to work.

Final question

(which is hopefully not susceptible to the XY problem)

What should be inserted at the <???> placeholder to make the following code compile?

#[derive(Debug, thiserror::Error, miette::Diagnostic)]
pub enum MyError<ErrType: <???> = Box<dyn Error + Send + Sync>> {
    #[error("Error containing another error")]
    AnError(#[source] ErrType),
}

score 3 · Accepted Answer · answered Apr 25 '22 at 23:16

3

For why this happens, see Why doesn't Box<dyn Error> implement Error? (by the way, this is not related to miette at all: the error is triggered even without it).

You can use a newtype wrapper to work around this problem:

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

impl fmt::Debug for BoxedError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(&self.0, f)
    }
}

impl fmt::Display for BoxedError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.0, f)
    }
}

impl Error for BoxedError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        self.0.source()
    }
    #[allow(deprecated)]
    fn description(&self) -> Option<&str> {
        self.0.description()
    }
    #[allow(deprecated)]
    fn cause(&self) -> Option<&dyn Error> {
        self.0.cause()
    }
}

#[derive(Debug, thiserror::Error, miette::Diagnostic)]
pub enum MyError<ErrType: 'static + Error = BoxedError> {
    #[error("Error containing another error")]
    AnError(#[source] ErrType),
}

answered Apr 25 '22 at 23:16

Chayim Friedman

47,971
5
48
77

Thanks :) The question though is, why did my original verison work? The one that used `Box` directly in the `#[source]` tag? As `Box` does not implement `Error` and, to my knowledge, template specialization is not a thing in Rust? – Finomnis Apr 26 '22 at 00:25
@Finomnis `thiserror` uses the same trick @Shepmaster talks about in his answer, in the linked question. – Chayim Friedman Apr 26 '22 at 00:31
Aaaaah, I see. That makes a lot of sense now, very smart of them. I will have to think about your code, but it might actually give me what I need. Thanks :) – Finomnis Apr 26 '22 at 00:39
Turns out you are right, the fact that `#[source]` accepted `Box` in the first place is in [this](https://github.com/dtolnay/thiserror/blob/master/src/aserror.rs) little piece of magic, it's not even part of miette at all. – Finomnis Apr 26 '22 at 01:37

Miette - How to specify errors that contain a generic that defaults to Box?

My attempts

Final question

1 Answers1