15.2 The Result Type

While some errors are drastic enough to require an immediate panic, most can be foreseen and addressed. Rust’s primary tool for handling these routine failures is the Result type, ensuring you account for both success and error conditions at compile time.

15.2.1 Understanding the Result Enum

The Result enum in Rust looks like this:

enum Result<T, E> {
    Ok(T),
    Err(E),
}
  • Ok(T): Stores the “happy path” result of type T.
  • Err(E): Stores the error of type E.

Comparing this to C-style error returns, Result elegantly bundles both success and failure possibilities in a single type, preventing you from ignoring the error path.

15.2.2 Option vs. Result

Rust also provides an Option<T> type:

enum Option<T> {
    Some(T),
    None,
}
  • Option<T> is for when a value may or may not exist, but no error message is necessary (e.g., searching for an item in a collection).
  • Result<T, E> is for when an operation can fail and you need to convey specific error information.

15.2.3 Basic Usage of Result

Here is a simple example that parses two string slices into integers and then multiplies them:

use std::num::ParseIntError;

fn multiply(first_str: &str, second_str: &str) -> Result<i32, ParseIntError> {
    match first_str.parse::<i32>() {
        Ok(first_number) => match second_str.parse::<i32>() {
            Ok(second_number) => Ok(first_number * second_number),
            Err(e) => Err(e),
        },
        Err(e) => Err(e),
    }
}

fn main() {
    println!("{:?}", multiply("10", "2")); // Ok(20)
    println!("{:?}", multiply("x", "y"));  // Err(ParseIntError(...))
}

This explicit matching ensures each potential error is handled. To avoid deep nesting, you can leverage map and and_then:

use std::num::ParseIntError;

fn multiply(first_str: &str, second_str: &str) -> Result<i32, ParseIntError> {
    first_str
        .parse::<i32>()
        .and_then(|first_number| {
            second_str
                .parse::<i32>()
                .map(|second_number| first_number * second_number)
        })
}

fn main() {
    println!("{:?}", multiply("10", "2")); // Ok(20)
    println!("{:?}", multiply("x", "y"));  // Err(ParseIntError(...))
}

15.2.4 Returning Result from main()

In Rust, the main() function ordinarily has a return type of (), but it can return Result instead:

use std::num::ParseIntError;

fn main() -> Result<(), ParseIntError> {
    let number_str = "10";
    let number = number_str.parse::<i32>()?;
    println!("{}", number);
    Ok(())
}

If an error occurs, Rust will exit with a non-zero status code. If everything succeeds, Rust exits with status 0.