Rust 错误处理的黄金搭档(thiserror和anyhow)

import "fmt"

type NotFoundError struct {
    Resource string
}

func (e NotFoundError) Error() string {
    return fmt.Sprintf("%s not found", e.Resource)
}

use std::error::Error;
use std::{fmt, io, num::ParseIntError};

#[derive(Debug)]
enum MyError {
    Io(io::Error),
    Parse(ParseIntError),
    Custom(String),
}

// 实现 Display 特征
impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            MyError::Io(e) => write!(f, "IO 错误: {}", e),
            MyError::Parse(e) => write!(f, "解析错误: {}", e),
            MyError::Custom(s) => write!(f, "自定义错误: {}", s),
        }
    }
}

// 实现 Error 特征，标记该类型为错误类型
impl Error for MyError {}

// 实现 From 特征，支持错误自动转换
impl From<io::Error> for MyError {
    fn from(e: io::Error) -> Self {
        MyError::Io(e)
    }
}

impl From<ParseIntError> for MyError {
    fn from(e: ParseIntError) -> Self {
        MyError::Parse(e)
    }
}

use std::{io, num::ParseIntError};
use thiserror::Error;

#[derive(Error, Debug)] 
enum MyError {
    // 定义 Display 输出格式，{0} 引用变体第一个字段
    #[error("IO 错误: {0}")]
    // #[from] 自动实现 From 特征
    Io(#[from] io::Error),

    #[error("解析错误: {0}")]
    Parse(#[from] ParseIntError),

    #[error("自定义错误: {0}")]
    Custom(String),
}

use std::error::Error;
use std::fs;

fn read_and_parse(path: &str) -> Result<i32, Box<dyn Error>> {
    let content = fs::read_to_string(path)?;
    let num: i32 = content.trim().parse()?;
    Ok(num)
}

impl<E: Error + 'static> From<E> for Box<dyn Error> {
    fn from(err: E) -> Self {
        Box::new(err)
    }
}

Box<dyn Error + Send + Sync + 'static>

use anyhow::Result;

fn main() -> Result<()> {
    Ok(())
}

use anyhow::{Context, Result};
use std::fs;

fn read_and_parse(path: &str) -> Result<i32> {
    let content = fs::read_to_string(path)?;
    let num: i32 = content.trim().parse()?;
    Ok(num)
}

fn main() -> anyhow::Result<()> {
    let content = fs::read_to_string("config.json")
        .context("读取配置文件失败")?;
    
    println!("{}", content);
    
    Ok(())
}

// Output:
// Error: 读取配置文件失败

// Caused by:
//     No such file or directory (os error 2)

use std::thread;

fn do_work() -> anyhow::Result<()> {
    Err(anyhow::anyhow!("something wrong"))
}

fn main() {
    let handle = thread::spawn(|| do_work());

    let result = handle.join().unwrap();

    match result {
        Ok(_) => println!("success"),
        Err(e) => println!("error: {:#}", e),
    }
}

// Output:
// error: something wrong