Rust中的map_err方法是Result类型的一个方法，用于转换错误类型。它允许你在保持Ok值不变的情况下，修改Err值。这在错误处理和类型转换中非常有用。

以下是map_err的详细用法和一些例子：

基本用法

fn main() -> Result<(), String> {
    let result: Result<i32, &str> = Err("原始错误");
    let mapped = result.map_err(|e| e.to_string());
    mapped
}

在这个例子中，我们将&str类型的错误转换为String类型。

链式调用

use std::num::ParseIntError;

fn parse_and_multiply(s: &str) -> Result<i32, String> {
    s.parse::<i32>()
        .map_err(|e: ParseIntError| e.to_string())
        .map(|n| n * 2)
}

fn main() {
    match parse_and_multiply("10") {
        Ok(n) => println!("结果: {}", n),
        Err(e) => println!("错误: {}", e),
    }
    
    match parse_and_multiply("abc") {
        Ok(n) => println!("结果: {}", n),
        Err(e) => println!("错误: {}", e),
    }
}

这个例子展示了如何在解析字符串并进行计算的过程中使用map_err转换错误类型。

自定义错误类型

#[derive(Debug)]
enum MyError {
    ParseError(std::num::ParseIntError),
    OtherError(String),
}

fn process(s: &str) -> Result<i32, MyError> {
    s.parse::<i32>()
        .map_err(MyError::ParseError)
        .map(|n| n * 2)
}

fn main() {
    match process("10") {
        Ok(n) => println!("结果: {}", n),
        Err(e) => println!("错误: {:?}", e),
    }
    
    match process("abc") {
        Ok(n) => println!("结果: {}", n),
        Err(e) => println!("错误: {:?}", e),
    }
}

这个例子展示了如何使用map_err将标准库的错误类型转换为自定义错误类型。

在?运算符中使用

use std::fs::File;
use std::io::{self, Read};

fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path).map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() {
    match read_file("nonexistent.txt") {
        Ok(contents) => println!("文件内容: {}", contents),
        Err(e) => println!("错误: {}", e),
    }
}

这个例子展示了如何在使用?运算符的同时使用map_err来转换错误类型。

与and_then结合使用

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("除数不能为零".to_string())
    } else {
        Ok(a / b)
    }
}

fn process_numbers(a: &str, b: &str) -> Result<i32, String> {
    a.parse::<i32>()
        .map_err(|e| format!("解析 a 失败: {}", e))
        .and_then(|a_num| {
            b.parse::<i32>()
                .map_err(|e| format!("解析 b 失败: {}", e))
                .and_then(|b_num| divide(a_num, b_num))
        })
}

fn main() {
    println!("{:?}", process_numbers("10", "2"));
    println!("{:?}", process_numbers("10", "0"));
    println!("{:?}", process_numbers("a", "2"));
}

这个例子展示了如何将map_err与and_then结合使用，以处理多个可能的错误情况。

通过这些例子，你可以看到map_err在错误处理和类型转换中的灵活性和强大功能。它允许你以一种清晰和类型安全的方式处理和转换错误。

参考