Propagating errors with ? in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using the ? operator?

Consider this Rust function that reads a number from a string and doubles it. What will be printed when calling main()?

Rust

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

fn main() {
    match double_number("10") {
        Ok(val) => println!("Result: {}", val),
        Err(e) => println!("Error: {}", e),
    }
}

A Result: 20

B Result: 10

C Error: invalid digit found in string

D Compilation error due to missing match

💡 Hint

Remember that ? returns the error early if parsing fails, otherwise continues.

The string "10" parses successfully to 10, then doubled to 20, so the output is Result: 20.

❓ Predict Output

intermediate

What error does this Rust code raise when using the ? operator?

What happens when running this Rust code?

Rust

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

fn main() {
    match parse_and_double("abc") {
        Ok(val) => println!("Result: {}", val),
        Err(e) => println!("Error: {}", e),
    }
}

A Panic at runtime due to unwrap on Err

B Error: invalid digit found in string

C Compilation error: cannot use ? outside function returning Result

D Result: 0

💡 Hint

What happens if parsing fails with ? inside a function returning Result?

The string "abc" cannot be parsed to an integer, so s.parse()? returns an error which is propagated. The error message is "invalid digit found in string".

🔧 Debug

advanced

Why does this Rust code fail to compile when using the ? operator?

Examine this Rust code snippet. Why does it fail to compile?

Rust

fn try_parse(s: &str) {
    let n: i32 = s.parse()?;
    println!("Number: {}", n);
}

fn main() {
    try_parse("42");
}

A parse() returns Option, not Result

B Missing semicolon after parse() call

C Cannot use ? operator inside main function

D Function try_parse must return Result to use ? operator

💡 Hint

The ? operator can only be used in functions that return Result or Option.

The function try_parse returns nothing (()), but uses ?. This is invalid because ? needs the function to return a compatible Result or Option type.

📝 Syntax

advanced

Which option correctly propagates errors using the ? operator in Rust?

Choose the code snippet that correctly uses the ? operator to propagate errors.

A

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

B

fn read_number(s: &str) -> i32 {
    let n = s.parse()?;
    n
}

C

fn read_number(s: &str) -> Result<i32, std::num::ParseIntError> {
    let n = s.parse().unwrap();
    Ok(n)
}

D

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

💡 Hint

Remember that ? can only be used on a Result or Option value directly.

Option A correctly uses ? on the Result from parse() and returns Ok(n). Option A returns i32 but uses ? which requires a Result return type. Option A misuses unwrap() before ?. Option A tries to use ? inside Ok() which is invalid syntax.

🚀 Application

expert

How many times is the error propagated in this Rust code using multiple ? operators?

Given this Rust code, how many times will the error be propagated if the input string is invalid?

Rust

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

fn step2(s: &str) -> Result<i32, std::num::ParseIntError> {
    let n = step1(s)?;
    Ok(n * 2)
}

fn main() {
    match step2("not_a_number") {
        Ok(val) => println!("Value: {}", val),
        Err(e) => println!("Error: {}", e),
    }
}

A The error is propagated twice inside step1 before returning

B The error is caught and handled inside step1, so no propagation

C The error is propagated once from step1 to step2, then to main

D The error causes a panic and does not propagate

💡 Hint

Think about how the ? operator passes errors up the call stack.

The error from s.parse() in step1 is propagated up by ? to step2, which also uses ? to propagate it further to main. So the error is propagated once per function call up the chain.