Why Propagating errors with ? in Rust? - Purpose & Use Cases

The Big Idea

What if you could stop writing bulky error checks and still catch every problem perfectly?

The Scenario

Imagine you are writing a program that reads a file, processes its content, and then saves the result. Without a simple way to handle errors, you have to check after every step if something went wrong and write extra code to handle each case.

The Problem

This manual error checking makes your code long, hard to read, and easy to mess up. You might forget to check an error or write repetitive code that clutters your main logic.

The Solution

The ? operator lets you quickly pass errors up the chain without writing extra code. It stops the current function and returns the error if something goes wrong, keeping your code clean and easy to follow.

Before vs After

✗ Before

let file = File::open("data.txt");
if file.is_err() {
    return Err(file.unwrap_err());
}
let file = file.unwrap();

✓ After

let file = File::open("data.txt")?;

What It Enables

You can write clear, concise functions that automatically handle errors and focus on the main task.

Real Life Example

When building a web server, you often read configuration files and database connections. Using ? helps you quickly stop and report errors without messy code everywhere.

Key Takeaways

Manual error checks clutter code and cause mistakes.

? operator simplifies error handling by propagating errors automatically.

Cleaner code means easier maintenance and fewer bugs.

Practice

1. What does the ? operator do in Rust when used with a Result type?

easy

A. It ignores any error and always returns the success value.

B. It converts the Result into an Option.

C. It returns the error immediately if there is one, otherwise unwraps the value.

D. It retries the operation until it succeeds.

Solution

1. Step 1: Understand the ? operator behavior

   The ? operator checks if the Result is an Err. If yes, it returns the error from the current function immediately.

2. Step 2: What happens if Result is Ok?

   If the Result is Ok, it unwraps the value inside and continues execution.

3. Final Answer:

   It returns the error immediately if there is one, otherwise unwraps the value. -> Option C

4. Quick Check:

   ? returns error or unwraps value [OK]

Hint: Remember: ? returns error early or unwraps success [OK]

Common Mistakes:

• Thinking ? converts Result to Option
• Assuming ? ignores errors
• Believing ? retries operations

2. Which of the following function signatures correctly allows using the ? operator inside the function to propagate std::io::Error?

easy

A. fn read_file() -> String

B. fn read_file() -> Result

C. fn read_file() -> ()

D. fn read_file() -> Option<String>

Solution

1. Step 1: Identify return types compatible with ?

   The ? operator works only in functions returning Result or Option.

2. Step 2: Check each signature

   fn read_file() -> String returns String directly, no error type, so ? can't be used. fn read_file() -> Result returns Result, which supports ?. fn read_file() -> () returns unit (), no error handling. fn read_file() -> Option<String> returns Option, which supports ? for absence but cannot propagate std::io::Error.

3. Final Answer:

   fn read_file() -> Result -> Option B

4. Quick Check:

   Function must return Result or Option for ? [OK]

Hint: Use Result or Option return type to use ? [OK]

Common Mistakes:

• Using ? in functions returning plain types
• Forgetting to specify error type in Result
• Confusing Option and Result return types

3. What is the output of the following Rust code?

fn parse_number(s: &str) -> Result {
    let num = s.parse::<i32>()?;
    Ok(num * 2)
}

fn main() {
    match parse_number("10") {
        Ok(n) => println!("{}", n),
        Err(e) => println!("Error: {}", e),
    }
}

medium

A. 20

B. Error: invalid digit found in string

C. 10

D. Compilation error

Solution

1. Step 1: Understand parse_number function

   The function tries to parse the string "10" to an integer using s.parse::<i32>()?. Since "10" is valid, it unwraps to 10.

2. Step 2: Calculate the returned value

   It multiplies the parsed number by 2, so 10 * 2 = 20, then returns Ok(20).

3. Step 3: Check main output

   The match prints the number 20 because parsing succeeded.

4. Final Answer:

   20 -> Option A

5. Quick Check:

   Valid parse returns doubled number [OK]

Hint: Valid parse with ? returns doubled value [OK]

Common Mistakes:

• Assuming parse fails and prints error
• Confusing output with input string
• Thinking code won't compile due to ?

4. Identify the error in this Rust function using ? and fix it:

fn get_first_char(s: &str) -> Result {
    let first = s.chars().next()?;
    Ok(first)
}

medium

A. Change next() to next().ok_or("Empty string".to_string())?

B. Change return type to Option<char>

C. Replace ? with .unwrap()

D. No error, code is correct

Solution

1. Step 1: Analyze next() return type

   next() returns an Option<char>, but ? requires Result or Option compatible with function return.

2. Step 2: Fix error propagation

   Since function returns Result, convert Option to Result using next().ok_or("Empty string".to_string())? to propagate error properly.

3. Final Answer:

   Change next() to next().ok_or("Empty string".to_string())? -> Option A

4. Quick Check:

   Convert Option to Result for ? in Result function [OK]

Hint: Convert Option to Result with ok_or before ? [OK]

Common Mistakes:

• Using ? directly on Option in Result function
• Ignoring error conversion from Option to Result
• Replacing ? with .unwrap() causing panic

5. You want to write a function that reads a file and returns the number of lines. It should propagate any IO errors using ?. Which of the following implementations correctly uses ? to propagate errors?

hard

A. fn count_lines(path: &str) -> Option<usize> {
let content = std::fs::read_to_string(path)?;
Some(content.lines().count())
}

B. fn count_lines(path: &str) -> usize {
let content = std::fs::read_to_string(path)?;
content.lines().count()
}

C. fn count_lines(path: &str) -> Result {
let content = std::fs::read_to_string(path).unwrap();
Ok(content.lines().count())
}

D. fn count_lines(path: &str) -> Result {
let content = std::fs::read_to_string(path)?;
Ok(content.lines().count())
}

Solution

1. Step 1: Check function return type compatibility

   The function returns Result, so it can use ? to propagate IO errors.

2. Step 2: Analyze each option

   fn count_lines(path: &str) -> Result { let content = std::fs::read_to_string(path)?; Ok(content.lines().count()) } uses ? correctly and returns Ok with line count. fn count_lines(path: &str) -> usize { let content = std::fs::read_to_string(path)?; content.lines().count() } returns usize directly but uses ? which is invalid here. fn count_lines(path: &str) -> Result { let content = std::fs::read_to_string(path).unwrap(); Ok(content.lines().count()) } uses unwrap() which panics on error, not propagates. fn count_lines(path: &str) -> Option<usize> { let content = std::fs::read_to_string(path)?; Some(content.lines().count()) } returns Option but read_to_string returns Result, so ? cannot be used directly.

3. Final Answer:

   fn count_lines(path: &str) -> Result<usize, std::io::Error> { let content = std::fs::read_to_string(path)?; Ok(content.lines().count()) } -> Option D

4. Quick Check:

   Return Result and use ? to propagate errors [OK]

Hint: Match function return type with ? usage for error propagation [OK]

Common Mistakes:

• Using ? in functions without Result or Option return
• Using unwrap() instead of propagating errors
• Mismatching return types and error handling