对 Rust 错误处理的思考和 anyerr

#[derive(Error, Debug)]
#[error("inner error")]
pub struct InnerError;

#[derive(Error, Debug)]
pub enum OuterError {
    #[error("{source} with {var1} and {var2}")]
    Inner {
        source: InnerError,
        var1: u32,
        var2: u32,
    }
}

fn inner_func() -> Result<(), InnerError> {
    Err(InnerError)
}

fn outer_func() -> Result<(), OuterError> {
    let var1 = 1;
    let var2 = 2;
    // Too verbose
    inner_func().map_err(|source| OuterError::Inner { source, var1, var2 })?;
    Ok(())
}

#[derive(Debug, Snafu)]
#[snafu(display("inner error"))]
pub struct InnerError;

#[derive(Debug, Snafu)]
pub enum OuterError {
    #[snafu(display("{source} with {var1} and {var2}"))]
    Inner {
        source: InnerError,
        var1: u32,
        var2: u32,
    }
}

fn inner_func() -> Result<(), InnerError> {
    Err(InnerError)
}

fn outer_func() -> Result<(), OuterError> {
    let var1 = 1;
    let var2 = 2;
    inner_func().context(InnerSnafu { var1, var2 })?;
    Ok(())
}

#[derive(Debug, Snafu)]
pub struct Error(ErrorImpl);

// Variants are no longer accessible from outside.
#[derive(Debug, Snafu)]
enum ErrorImpl {
    Cause1,
    Cause2,
    // ...
}

pub struct Whatever {
    source: Option<Box<dyn std::error::Error>>,
    message: String,
    backtrace: Backtrace,
}

// Customize your own error type.
mod err {
    use anyerr::context::LiteralKeyStringMapContext;
    use anyerr::AnyError as AnyErrorTemplate;

    pub use anyerr::kind::NoErrorKind as ErrKind;
    pub use anyerr::Report;
    pub use anyerr::{Intermediate, Overlay};

    pub type AnyError = AnyErrorTemplate<LiteralKeyStringMapContext, ErrKind>;
    pub type AnyResult<T> = Result<T, AnyError>;
}

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::process::Termination;
use std::thread;
use std::time::Duration;

use err::*;

const SERVER_IP: &str = "127.0.0.1";
const SERVER_PORT: &str = "8080";

fn main() -> impl Termination {
    // Captures the result and prints the error if failed.
    Report::capture(|| {
        let listener = TcpListener::bind(format!("{SERVER_IP}:{SERVER_PORT}"))
            .map_err(AnyError::wrap) // Wraps an existing error.
            .overlay("could not bind the listener to the endpoint") // Adds an error message.
            .context("ip", SERVER_IP) // Attaches a key-value pair as context information
            .context("port", SERVER_PORT)?;

        eprintln!("Started listening on {SERVER_IP}:{SERVER_PORT}");

        for connection in listener.incoming() {
            let Ok(stream) = connection else {
                continue;
            };

            thread::spawn(move || {
                handle_connection(stream).unwrap_or_else(|err| {
                    let report = Report::wrap(err).kind(false);
                    eprintln!("{report}"); // Formats the error with a backtrace and contextual data.
                });
            });
        }

        Ok(())
    })
    .kind(false)
}

fn handle_connection(mut stream: TcpStream) -> AnyResult<()> {
    let client_addr = stream
        .peer_addr()
        .map_or("<UNKNOWN>".into(), |addr| addr.to_string());
    let mut buffer = [0u8; 256];
    let mut total_read = 0;

    eprintln!("{client_addr} started the connection");
    thread::sleep(Duration::from_secs(3));

    loop {
        let size_read = stream
            .read(&mut buffer)
            .map_err(AnyError::wrap)
            .overlay("could not read bytes from the client")
            .context("client_addr", &client_addr)
            .context("total_read", total_read)?;
        total_read += size_read;

        if size_read == 0 {
            eprintln!("{client_addr} closed the connection");
            return Ok(());
        }

        thread::sleep(Duration::from_secs(3));

        let mut cursor = 0;
        while cursor < size_read {
            let size_written = stream
                .write(&buffer[cursor..size_read])
                .map_err(AnyError::wrap)
                .overlay("could not write bytes to the client")
                .context("client_addr", &client_addr)
                .context("total_read", total_read)
                .context("cursor", cursor)?;
            cursor += size_written;
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ContextKey {
    ErrorCode,
    Timeout,
    Other(&'static str),
}

impl Display for ContextKey {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        match self {
            Self::ErrorCode => write!(f, "error-code"),
            Self::Timeout => write!(f, "timeout"),
            Self::Other(key) => write!(f, "{key}"),
        }
    }
}

mod err {
    use std::fmt::{Display, Formatter, Result as FmtResult};

    use anyerr::context::map::AnyMapContext;
    use anyerr::AnyError as AnyErrorTemplate;

    pub use anyerr::kind::NoErrorKind as ErrKind;

    // ...

    // Our custom context storage.
    type CustomKeyAnyMapContext = AnyMapContext<ContextKey, ContextKey>;

    pub type AnyError = AnyErrorTemplate<CustomKeyAnyMapContext, ErrKind>;
    pub type AnyResult<T> = Result<T, AnyError>;
}

use err::*;

fn fails() -> AnyResult<()> {
    let err = AnyError::builder()
        .message("an unknown error occurred")
        .context(ContextKey::ErrorCode, 42u32)
        .context(ContextKey::Timeout, false)
        .context(ContextKey::Other("function"), "fails()")
        .build();
    Err(err)
}

fn main() {
    let err = fails().unwrap_err();

    let error_code: &u32 = err.value_as(&ContextKey::ErrorCode).unwrap();
    let is_timeout: &bool = err.value_as(&ContextKey::Timeout).unwrap();
    let function_name: &&str = err.value_as(&ContextKey::Other("function")).unwrap();

    eprintln!("The error code is {error_code}");
    eprintln!("Whether the function failed due to timeout: {is_timeout}");
    eprintln!("The name of the failed function: {function_name}");
}