How to Convert Between Error Types in Rust

You convert error types in Rust by implementing the From trait for your custom error type to define the conversion logic. This allows you to use the ? operator to automatically convert errors from one type to another within functions that return Result<T, YourErrorType>.

use std::fmt;

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

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            MyError::Io(e) => write!(f, "IO error: {}", e),
            MyError::Parse(e) => write!(f, "Parse error: {}", e),
        }
    }
}

impl std::error::Error for MyError {}

impl From<std::io::Error> for MyError {
    fn from(err: std::io::Error) -> Self {
        MyError::Io(err)
    }
}

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

fn process_data() -> Result<i32, MyError> {
    let input = std::fs::read_to_string("data.txt")?;
    let value: i32 = input.trim().parse()?;
    Ok(value)
}

Converting error types is like translating a message from one language to another so your program can understand it. You define a rulebook (the From trait) that tells Rust exactly how to turn a specific error, like a file read failure, into your custom error type. This lets your code handle different mistakes uniformly without writing repetitive checks for every single error.