Propagating errors with ? in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to propagate the error using the ? operator.

Rust

fn read_file() -> Result<String, std::io::Error> {
    let content = std::fs::read_to_string("file.txt")[1];
    Ok(content)
}

Drag options to blanks, or click blank then click option'

A?

B;

C!

D.

Attempts:

3 left

💡 Hint

Common Mistakes

Using ; instead of ? causes the error to be ignored and code to not compile.

Using ! is for macros, not error propagation.

The ? operator propagates the error if read_to_string fails, otherwise returns the content.

2fill in blank

medium

Complete the code to propagate the error from parsing an integer using the ? operator.

Rust

fn parse_number(s: &str) -> Result<i32, std::num::ParseIntError> {
    let num = s.parse::<i32>()[1];
    Ok(num)
}

Drag options to blanks, or click blank then click option'

A!

B.

C?

D;

Attempts:

3 left

💡 Hint

Common Mistakes

Using ; ignores the error and causes a type mismatch.

Using ! is incorrect here.

The ? operator propagates the parse error if parsing fails.

3fill in blank

hard

Fix the error in the code by correctly propagating the error with the ? operator.

Rust

fn open_and_read() -> Result<String, std::io::Error> {
    let mut file = std::fs::File::open("data.txt")[1];
    let mut buf = String::new();
    std::io::Read::read_to_string(&mut file, &mut buf)?;
    Ok(buf)
}

Drag options to blanks, or click blank then click option'

A?

B;

C!

D.

Attempts:

3 left

💡 Hint

Common Mistakes

Using ; causes a type mismatch error.

Using ! is invalid here.

The ? operator propagates the error from File::open if it fails.

4fill in blank

hard

Fill both blanks to propagate errors correctly when opening and reading a file.

Rust

fn read_file_contents() -> Result<String, std::io::Error> {
    let mut file = std::fs::File::open("input.txt")[1];
    let mut contents = String::new();
    file.read_to_string(&mut contents)[2];
    Ok(contents)
}

Drag options to blanks, or click blank then click option'

A?

B;

C!

D.

Attempts:

3 left

💡 Hint

Common Mistakes

Using ; ignores errors and causes compile errors.

Using ! is incorrect for error propagation.

Both File::open and read_to_string can fail, so both need ? to propagate errors.

5fill in blank

hard

Fill all three blanks to propagate errors correctly when opening, reading, and parsing a file.

Rust

fn read_and_parse() -> Result<i32, Box<dyn std::error::Error>> {
    let mut file = std::fs::File::open("number.txt")[1];
    let mut contents = String::new();
    file.read_to_string(&mut contents)[2];
    let number = contents.trim().parse::<i32>()[3];
    Ok(number)
}

Drag options to blanks, or click blank then click option'

A?

B;

C!

D.

Attempts:

3 left

💡 Hint

Common Mistakes

Using ; causes errors to be ignored and compilation to fail.

Using ! is not for error propagation.

All three operations can fail, so each needs ? to propagate errors properly.

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