Custom errors

Real programs fail in their own ways. You can make your own error type so callers know exactly what went wrong.

Error enums

An enum lists every way an operation can fail. The caller can match on it.

1#[derive(Debug)]2enum PinError {3    TooShort,4    NotDigits,5}67fn check(pin: &str) -> Result<(), PinError> {8    if pin.len() < 4 {9        return Err(PinError::TooShort);10    }11    Ok(())12}

Display for errors

#[derive(Debug)] gives a message for developers, like TooShort. For a readable message, implement Display. Then {} prints your text. Inside fmt, use write!(f, ...), not println!.

1use std::fmt;23impl fmt::Display for PinError {4    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {5        match self {6            PinError::TooShort => write!(f, "PIN is too short"),7            PinError::NotDigits => write!(f, "PIN must be digits"),8        }9    }10}

From and ?

? can change one error type into another. It does this with From. If you write impl From<ParseIntError> for AppError, then ? on a parse result works in a function that returns Result<_, AppError>. Without it, s.parse::<i32>()? fails with E0277. With let n: i32 = s.parse()?; the code is E0271 instead, but it is the same problem.

1use std::num::ParseIntError;23impl From<ParseIntError> for AppError {4    fn from(_: ParseIntError) -> Self {5        AppError::BadNumber6    }7}

Box<dyn Error>

Box<dyn std::error::Error> can hold any error type. It is handy when a function can fail in several ways and you do not need a custom enum.

1use std::error::Error;23fn main() -> Result<(), Box<dyn Error>> {4    let n: i32 = "7".parse()?;5    let x: f64 = "0.5".parse()?;6    println!("{}", n as f64 + x);7    Ok(())8}

Remember

• An error enum names each way to fail.
• Display gives an error a readable message.
• impl From lets ? convert errors for you.
• Box<dyn Error> holds any error, so ? works on many kinds.