错误处理的三种风格：我的实践经验

// Result 的定义很简单
enum Result<T, E> {
    Ok(T),
    Err(E),
}

// 一个简单的文件读取函数
use std::fs;
use std::io;

fn read_config(filename: &str) -> Result<String, io::Error> {
    fs::read_to_string(filename)
}

// 使用的时候必须处理错误
fn main() {
    match read_config("config.txt") {
        Ok(content) => println!("Config: {}", content),
        Err(e) => eprintln!("Error reading config: {}", e),
    }
}

// 使用 ? 操作符进行错误传播
fn process_config() -> Result<ProcessedConfig, Box<dyn std::error::Error>> {
    let content = fs::read_to_string("config.txt")?;
    let parsed: RawConfig = serde_json::from_str(&content)?;
    let processed = validate_and_transform(parsed)?;
    Ok(processed)
}

// 或者使用更具体的错误类型
#[derive(Debug)]
enum ConfigError {
    IoError(io::Error),
    ParseError(serde_json::Error),
    ValidationError(String),
}

impl From<io::Error> for ConfigError {
    fn from(err: io::Error) -> Self {
        ConfigError::IoError(err)
    }
}

impl From<serde_json::Error> for ConfigError {
    fn from(err: serde_json::Error) -> Self {
        ConfigError::ParseError(err)
    }
}

fn process_config_v2() -> Result<ProcessedConfig, ConfigError> {
    let content = fs::read_to_string("config.txt")?;
    let parsed: RawConfig = serde_json::from_str(&content)?;
    let processed = validate_and_transform(parsed)
        .map_err(|e| ConfigError::ValidationError(e.to_string()))?;
    Ok(processed)
}

use anyhow::{Context, Result};

fn read_user_data(user_id: u64) -> Result<UserData> {
    let db_url = std::env::var("DATABASE_URL")
        .context("DATABASE_URL environment variable not set")?;

    let connection = establish_connection(&db_url)
        .context("Failed to connect to database")?;

    let user = fetch_user(&connection, user_id)
        .with_context(|| format!("Failed to fetch user with ID {}", user_id))?;

    let profile = fetch_user_profile(&connection, user_id)
        .context("Failed to fetch user profile")?;

    Ok(UserData { user, profile })
}

// 错误信息会自动串联，非常有用
fn main() {
    if let Err(e) = read_user_data(123) {
        eprintln!("Error: {:?}", e);
        // 输出类似：
        // Error: Failed to fetch user with ID 123
        // Caused by:
        //     0: Database query failed
        //     1: Connection timeout
    }
}

use thiserror::Error;

#[derive(Error, Debug)]
pub enum DataStoreError {
    #[error("Connection failed")]
    ConnectionFailed(#[from] io::Error),

    #[error("Invalid query: {query}")]
    InvalidQuery { query: String },

    #[error("User {user_id} not found")]
    UserNotFound { user_id: u64 },

    #[error("Permission denied for user {user_id}")]
    PermissionDenied { user_id: u64 },
}

// 使用起来很自然
fn get_user(user_id: u64) -> Result<User, DataStoreError> {
    if user_id == 0 {
        return Err(DataStoreError::InvalidQuery {
            query: "user_id cannot be 0".to_string(),
        });
    }

    // ... 其他逻辑

    Ok(user)
}

use reqwest;
use serde_json::Value;

// 链式操作处理 HTTP 请求
fn fetch_and_process_data(url: &str) -> Result<ProcessedData, Box<dyn std::error::Error>> {
    reqwest::blocking::get(url)?
        .json::<Value>()?                           // 解析 JSON
        .get("data")                                // 获取 data 字段
        .and_then(|v| v.as_array())                // 转换为数组
        .ok_or("Invalid data format")?             // 处理 None 情况
        .iter()                                     // 迭代
        .map(|item| parse_item(item))              // 解析每个元素
        .collect::<Result<Vec<_>, _>>()?           // 收集结果
        .into_iter()                               // 再次迭代
        .fold(Ok(ProcessedData::new()), |acc, item| {  // 累积处理
            acc.and_then(|mut data| {
                data.add_item(item)?;
                Ok(data)
            })
        })
}

// 并行处理多个请求
fn fetch_multiple_users(user_ids: &[u64]) -> Result<Vec<User>, DataStoreError> {
    user_ids
        .iter()
        .map(|&id| get_user(id))
        .collect()  // 这会在第一个错误时停止
}

// 如果想要收集所有结果（包括错误）
fn fetch_multiple_users_tolerant(user_ids: &[u64]) -> (Vec<User>, Vec<DataStoreError>) {
    user_ids
        .iter()
        .map(|&id| get_user(id))
        .fold((Vec::new(), Vec::new()), |(mut users, mut errors), result| {
            match result {
                Ok(user) => users.push(user),
                Err(e) => errors.push(e),
            }
            (users, errors)
        })
}

use thiserror::Error;
use anyhow::Context;

#[derive(Error, Debug)]
pub enum AuthError {
    #[error("Invalid input: {message}")]
    InvalidInput { message: String },

    #[error("User not found: {username}")]
    UserNotFound { username: String },

    #[error("Invalid credentials")]
    InvalidCredentials,

    #[error("Account disabled")]
    AccountDisabled,

    #[error("Database error")]
    DatabaseError(#[from] DatabaseError),

    #[error("Token generation failed")]
    TokenError(#[from] TokenError),

    #[error("System error")]
    SystemError(#[from] anyhow::Error),
}

#[derive(Debug)]
pub struct AuthResult {
    pub user: User,
    pub token: String,
}

impl AuthService {
    pub async fn authenticate(&self, username: &str, password: &str)
        -> Result<AuthResult, AuthError> {

        // 1. 验证输入
        if username.trim().is_empty() {
            return Err(AuthError::InvalidInput {
                message: "Username cannot be empty".to_string(),
            });
        }

        // 2. 查找用户
        let user = self.user_repository
            .find_by_username(username)
            .await?
            .ok_or_else(|| AuthError::UserNotFound {
                username: username.to_string(),
            })?;

        // 3. 验证密码
        if !self.password_service.verify(password, &user.password_hash)? {
            // 异步记录失败登录，不影响主流程
            let username = username.to_string();
            tokio::spawn(async move {
                if let Err(e) = audit_service.log_failed_login(&username).await {
                    tracing::warn!("Failed to log failed login: {}", e);
                }
            });

            return Err(AuthError::InvalidCredentials);
        }

        // 4. 检查用户状态
        if !user.is_active {
            return Err(AuthError::AccountDisabled);
        }

        // 5. 生成令牌
        let token = self.token_service.generate_token(&user)?;

        // 6. 记录成功登录（异步，不阻塞返回）
        let username = username.to_string();
        let audit_service = self.audit_service.clone();
        tokio::spawn(async move {
            if let Err(e) = audit_service.log_successful_login(&username).await {
                tracing::warn!("Failed to log successful login: {}", e);
            }
        });

        Ok(AuthResult { user, token })
    }

    // 批量认证用户
    pub async fn authenticate_batch(&self, credentials: &[(String, String)])
        -> Vec<Result<AuthResult, AuthError>> {

        // 并发处理，但保持错误信息
        futures::future::join_all(
            credentials.iter().map(|(username, password)| {
                self.authenticate(username, password)
            })
        ).await
    }

    // 容错的批量认证
    pub async fn authenticate_batch_tolerant(&self, credentials: &[(String, String)])
        -> (Vec<AuthResult>, Vec<(String, AuthError)>) {

        let results = self.authenticate_batch(credentials).await;

        results.into_iter()
            .zip(credentials.iter())
            .fold(
                (Vec::new(), Vec::new()),
                |(mut successes, mut failures), (result, (username, _))| {
                    match result {
                        Ok(auth_result) => successes.push(auth_result),
                        Err(error) => failures.push((username.clone(), error)),
                    }
                    (successes, failures)
                }
            )
    }
}

// 复杂的业务逻辑处理
async fn process_order(order_request: OrderRequest) -> Result<Order, OrderError> {
    let validated_request = validate_order_request(order_request)?;
    let inventory_check = check_inventory(&validated_request.items).await?;
    let payment_result = process_payment(&validated_request.payment).await?;
    let order = create_order(validated_request, inventory_check, payment_result)?;

    // 后续处理可以优雅地组合
    notify_customer(&order).await
        .map_err(|e| tracing::warn!("Failed to notify customer: {}", e))
        .ok(); // 通知失败不影响订单创建

    Ok(order)
}