Any solution for failure (Error, ErrorKind) pattern? about anyhow

[dtolnay]

Our "context" works a bit differently than failure's to support the interactions with downcasting, but you could accomplish exactly the same ErrorKind pattern using this extension trait:

// put this somewhere that's shared across all your error types

pub struct WithKind<K> {
    pub kind: K,
    pub source: anyhow::Error,
}

pub trait Kind {
    type Ok;
    fn kind<K>(self, kind: K) -> Result<Self::Ok, WithKind<K>>;
}

impl<T, E> Kind for Result<T, E>
where
    E: Into<anyhow::Error>,
{
    type Ok = T;
    fn kind<K>(self, kind: K) -> Result<T, WithKind<K>> {
        self.map_err(|e| WithKind {
            kind,
            source: e.into(),
        })
    }
}

Then do everything in the link:

use thiserror::Error;

#[derive(Error, Debug)]
#[error("{kind}")]
pub struct Error {
    kind: ErrorKind,
    source: anyhow::Error,
}

#[derive(Error, Debug, Copy, Clone, Eq, PartialEq)]
pub enum ErrorKind {
    #[error("network failure")]
    NetworkFailure,
}

impl Error {
    pub fn kind(&self) -> ErrorKind {
        self.kind
    }
}

impl From<WithKind<ErrorKind>> for Error {
    fn from(w: WithKind<ErrorKind>) -> Self {
        Error {
            kind: w.kind,
            source: w.source,
        }
    }
}

and it gets used as:

use std::io;

fn inner() -> Result<(), io::Error> {
    Err(io::Error::new(io::ErrorKind::Other, "inner did not work"))
}

fn outer() -> Result<(), crate::Error> {
    inner().kind(ErrorKind::NetworkFailure)?;
    Ok(())
}

fn main() -> Result<(), anyhow::Error> {
    outer()?;
    Ok(())
}

[vimmerru]

Thanks! It works for me. One question why not just implement ResultExt::kind that will translate directly to Result<T, Error> like without WithKind proxy?

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

pub trait ResultExt<T, E> {
    fn kind(self, kind: ErrorKind) -> Result<T>;
}

impl<T, E> ResultExt<T, E> for std::result::Result<T, E>
where
    E: std::error::Error + Send + Sync + 'static,
{
    fn kind(self, kind: ErrorKind) -> Result<T> {
        self.map_err(|e| Error {
            kind,
            source: e.into(),
        })
    }
}

[dtolnay]

Your trait requires a different extension trait for every error type in your program. If your program only always uses one error type then maybe that's fine. But with my trait, downstream code is able to always import the same trait.