Propagating errors with ? in Rust - Step-by-Step Execution

Concept Flow - Propagating errors with ?

Call function that returns Result

↓

Check if Result is Ok or Err

↓

Extract value

↓

Continue with value

The ? operator checks if a Result is Ok or Err. If Ok, it extracts the value. If Err, it returns the error early from the function.

Execution Sample

Rust

fn read_number() -> Result<i32, String> {
    let s = "42";
    let num: i32 = s.parse().map_err(|e| e.to_string())?;
    Ok(num)
}

This function tries to parse a string to a number and uses ? to propagate any parsing error.

Execution Table

Step	Action	Expression	Result	Next Step
1	Assign string	s = "42"	s = "42"	Parse string to number
2	Parse string	s.parse()?	Ok(42)	Extract 42 and continue
3	Return value	Ok(num)	Ok(42)	Function ends successfully

💡 Function ends after returning Ok(42) because no error occurred.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
s	uninitialized	"42"	"42"	"42"
num	uninitialized	uninitialized	42	42

Key Moments - 3 Insights

What happens if s.parse() returns an Err?

If s.parse() returns Err, the ? operator immediately returns that Err from read_number(), skipping the rest of the function (see execution_table step 2).

Does the code continue after the ? operator if there is an error?

No, the ? operator stops execution and returns the error early, so code after it does not run if an error occurs (see execution_table step 2).

What type must the function return to use the ? operator?

The function must return a Result type compatible with the error type returned by the expression using ?, so the error can be propagated correctly.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of num after step 2?

A Err

B 42

C "42"

D uninitialized

💡 Hint

Check the 'Result' column in step 2 and the variable_tracker for num after step 2.

At which step does the function return early if s.parse() fails?

A Step 2

B Step 1

C Step 3

D Never returns early

💡 Hint

Look at the key_moments and execution_table step 2 about error propagation with ?.

If the function's return type was not Result, what would happen when using ? on s.parse()?

A Code would compile and run normally

B Runtime error when ? is used

C Compilation error because ? requires compatible Result return type

D The ? operator would be ignored

💡 Hint

Refer to key_moments about function return type requirements for using ?.

Concept Snapshot

Use ? to propagate errors in functions returning Result.
If expression is Ok(value), ? extracts value.
If Err(error), ? returns error early.
Function must return compatible Result type.
Simplifies error handling by avoiding match blocks.

Full Transcript

This visual trace shows how the ? operator works in Rust to propagate errors. The function read_number tries to parse a string to an integer. When s.parse()? is called, if parsing succeeds, the value 42 is extracted and assigned to num. If parsing fails, the ? operator returns the error immediately from read_number, skipping the rest of the code. The execution table shows each step: assigning the string, parsing with ?, and returning the Ok result. The variable tracker shows how s and num change. Key moments clarify that ? stops execution on error and requires the function to return a Result type. The quiz tests understanding of variable values, early returns, and type requirements. The snapshot summarizes the ? operator usage for easy reference.

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