How to convert between error types

You convert between error types in Rust by implementing the From trait for your custom error type or by using the ? operator with the Into trait to propagate errors. Define a custom error enum and implement From for the types you want to convert into it, then use ? to automatically convert and propagate errors in functions returning Result.

use std::io;

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

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

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

fn read_and_parse() -> Result<i32, AppError> {
    let input = io::stdin().read_line()?; // Converts io::Error to AppError
    let value: i32 = input.trim().parse()?; // Converts ParseIntError to AppError
    Ok(value)
}

Converting error types lets your program handle different kinds of failures using a single, unified error type. Think of it like a universal adapter that plugs different power cords into one outlet, so your code doesn't need to handle each specific failure separately. You use this when you want to simplify error handling across your application by grouping various errors into one custom type.