Propagating Errors with Question Mark

In this lesson, you will learn how to replace verbose error-handling boilerplate with the concise ? operator.

The Problem: Boilerplate Overload

Previously, when a function returns a Result, you likely used a match statement to handle errors. If an error occurred, you would return it immediately; otherwise, you would extract the inner value to continue. Writing this manually for every function call becomes tedious and clutters your logic:

fn read_data() -> Result<String, MyError> {
    let file_result = open_file();
    let file = match file_result {
        Ok(f) => f,
        Err(e) => return Err(e), // Manual propagation
    };
    
    // Continue processing...
}

The Solution: The Question Mark Operator

The ? operator acts as a shortcut for that entire match block. When you place a ? after a Result, Rust does two things automatically:

1. If the result is Ok(value), it unwraps the value and assigns it to your variable.
2. If the result is Err(e), it returns that error early from the function, exactly like the manual match block above.

With the ? operator, our example becomes much cleaner:

fn read_data() -> Result<String, MyError> {
    let file = open_file()?; // Error is propagated automatically if it fails
    
    // If we reach this line, we know 'file' contains the valid data
    process(file)
}

Why it works

The ? operator is designed specifically to streamline the "propagate or proceed" workflow. It reduces the "indentation staircase" caused by nested match statements and keeps your primary logic front and center. Because it forces an early return, it relies on your function return type being compatible with the error type being returned. This makes your code more readable while maintaining the strict safety and explicit error handling that Rust is known for.

Key Takeaway: The ? operator is a syntactic shortcut that handles the "return early on error" pattern automatically, turning multi-line match statements into a single, clean character.