Lesson 17 of 20

6 mins read

Error Handling with Result<T, E> & the ? Operator

In Plain English

Rust separates errors into unrecoverable panics (panic!) and recoverable errors represented by Result<T, E> with variants Ok(T) and Err(E). The ? operator propagates errors up the call stack cleanly without nested match blocks.

The Mental Model

"Result<T, E> is like a certified courier package: you open it and either find the ordered merchandise (Ok) or a return receipt with the reason for failure (Err). The ? operator says: "If this package has an error, hand it immediately to my manager and exit.""

Deep Dive: How It Works

The Result<T, E> Enum: enum Result<T, E> { Ok(T), Err(E) }.

The ? Operator: If Result is Ok(v), unwraps v. If Result is Err(e), returns Err(e) from the enclosing function immediately.

expect() vs unwrap(): expect("custom msg") provides a descriptive crash message if the Result was Err.

Syntax Blueprint

fn parse_num(s: &str) -> Result<i32, ParseIntError> { let n = s.parse::<i32>()?; Ok(n) }

The ? operator replaces verbose match blocks for error propagation.

Core Rules to Remember

Explicit Failure: Functions that can fail must declare Result<T, E> in their signature.

? Operator: Propagates errors up the call stack in a single character.

No Hidden Exceptions: Every potential failure point is visible in the type system.

Common Beginner Traps & How to Fix Them

Mistake:Using ? in a function that does not return Result.

Why it happens: The ? operator returns early with Err(e), so the enclosing function signature must return Result.

How to fix: Ensure functions using ? return Result<T, E> or Option<T>.

Pro Tip: Use Result<(), Box<dyn std::error::Error>> in main() to allow using ? directly in your entry point!

Live Interactive Example

Hit Run Code to see it live

Result Propagation and Parsing

Rust 1.78 / rustc

Output Console

Click "Run Code" to view the rendered output.

How it works: Demonstrates handling Ok and Err variants with structured error diagnostics.

Your Turn: Micro Challenge

No pressure! Edit the starter code below and test your solution with instant feedback.

Micro Exercise

Safe division with Result

Write fn divide(a: i32, b: i32) -> Result<i32, &'static str> { if b == 0 { Err("Cannot divide by zero") } else { Ok(a / b) } }
In main(), match divide(100, 4) and print "Division Result: 25".

Sandbox Output

Click "Run & Check" to test your solution.

Finished reading and practicing?

Mark this lesson as completed to update your course progress.