Errors: Result and the ? operator

Your own error type, and ?

1use std::fmt;2use std::num::ParseIntError;3 4#[derive(Debug)]5enum ConfigError {6    Missing(&'static str),7    BadNumber(ParseIntError),8}9 10impl fmt::Display for ConfigError {11    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {12        match self {13            ConfigError::Missing(k) => write!(f, "missing key {k}"),14            ConfigError::BadNumber(e) => write!(f, "bad number: {e}"),15        }16    }17}18 19impl std::error::Error for ConfigError {}20 21impl From<ParseIntError> for ConfigError { // lets ? convert the error for us22    fn from(e: ParseIntError) -> Self {23        ConfigError::BadNumber(e)24    }25}26 27fn workers(raw: Option<&str>) -> Result<u32, ConfigError> {28    let text = raw.ok_or(ConfigError::Missing("workers"))?;29    let n: u32 = text.trim().parse()?; // ParseIntError -> ConfigError via From30    Ok(n)31}32 33fn main() -> Result<(), Box<dyn std::error::Error>> {34    println!("{:?}", workers(Some(" 8 ")));35    println!("{}", workers(None).unwrap_err());36    println!("{}", workers(Some("eight")).unwrap_err());37    let n = workers(Some("4"))?; // in main too, because main returns Result38    println!("running {n} workers");39    Ok(())40}

Output: Ok(8), missing key workers, bad number: invalid digit found in string, running 4 workers.

expr? means: if expr is Ok(v), the value is v; if it is Err(e), return Err(From::from(e)) from the enclosing function right now. The From impl is what lets one function call code with different error types and still return its own. ? also works on Option in a function returning Option. ok_or converts an Option into a Result.

main can return Result<(), E> for any E: Debug. Returning Err prints the error and exits with a non-zero status. Box<dyn std::error::Error> accepts any error type, through a blanket From impl.

Choosing error types

• Libraries usually return an enum like ConfigError, so callers can match on the cases. The thiserror crate derives the Display, Error and From boilerplate above.
• Applications often care more about a good message than about matching. Box<dyn Error> or the anyhow crate collect any error and let you add context (.context("reading config")).
• Implement Error::source() (or let thiserror do it) so a chain of causes can be printed, much like Go's wrapped errors.

Panics

panic!, unwrap(), expect(), array indexing out of bounds and integer overflow in debug builds all panic. By default a panic unwinds the current thread's stack, running Drop for every value as it goes, and ends the thread; in the main thread that ends the program. Setting panic = "abort" in a Cargo profile skips unwinding and makes binaries smaller. std::panic::catch_unwind exists for FFI boundaries and thread pools, not for ordinary error handling.

A useful habit: convert errors at boundaries. Inside a module, use a precise error type; at the edge of the program (an HTTP handler, main), turn it into a status code or a message for a human, and log the full chain of source() causes once.

Use expect("why this can't fail") rather than bare unwrap() when you do assert something: the message is the documentation.