2.13 Error Handling: Result and Option

Rust primarily handles errors using two special enumeration types provided by the standard library, eschewing exceptions found in languages like C++ or Java.

2.13.1 Recoverable Errors: Result<T, E>

Result is used for operations that might fail in a recoverable way (e.g., file I/O, network requests, parsing). It has two variants:

  • Ok(T): Contains the success value of type T.
  • Err(E): Contains the error value of type E.
fn parse_number(s: &str) -> Result<i32, std::num::ParseIntError> {
    // `trim()` and `parse()` are methods called on the string slice `s`.
    // `parse()` returns a Result.
    s.trim().parse()
}

fn main() {
    let strings_to_parse = ["123", "abc", "-45"]; // Array of strings to attempt parsing

    for s in strings_to_parse { // Iterate over the array
        println!("Attempting to parse '{}':", s);
        match parse_number(s) {
            Ok(num) => println!("  Success: Parsed number: {}", num),
            Err(e) => println!("  Error: {}", e), // Display the specific parse error
        }
    }
}

The match statement is commonly used to handle both variants of a Result.

2.13.2 Absence of Value: Option<T>

Option is used when a value might be present or absent (similar to handling null pointers, but safer). It has two variants:

  • Some(T): Contains a value of type T.
  • None: Indicates the absence of a value.
fn find_character(text: &str, ch: char) -> Option<usize> {
    // `find()` is a method on string slices that returns Option<usize>.
    text.find(ch)
}

fn main() {
    let text = "Hello Rust";
    let chars_to_find = ['R', 'l', 'z']; // Array of characters to search for

    println!("Searching in text: \"{}\"", text);
    for ch in chars_to_find { // Iterate over the array
        println!("Searching for '{}':", ch);
        match find_character(text, ch) {
            Some(index) => println!("  Found at index: {}", index),
            None => println!("  Not found"),
        }
    }
}

2.13.3 Comparison with C

C traditionally handles errors using return codes (e.g., -1, NULL) combined with a global errno variable, or by passing pointers for output values and returning a status code. These approaches require careful manual checking and can be ambiguous or easily forgotten. Rust’s Result and Option force the programmer to explicitly acknowledge and handle potential failures or absence at compile time, leading to more robust code.