Handling errors with match in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of match error handling with Result

What is the output of this Rust code when the input string is "42"?

Rust

fn parse_number(input: &str) -> Result<i32, String> {
    match input.parse::<i32>() {
        Ok(num) => Ok(num),
        Err(_) => Err(String::from("Failed to parse number")),
    }
}

fn main() {
    let result = parse_number("42");
    match result {
        Ok(n) => println!("Parsed number: {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

A Compilation error

B Error: Failed to parse number

C Parsed number: 0

D Parsed number: 42

💡 Hint

The input string "42" can be successfully converted to an integer.

The input "42" parses correctly to the integer 42, so the Ok branch is taken and prints "Parsed number: 42".

❓ Predict Output

intermediate

Output when parsing fails in match

What is the output of this Rust code when the input string is "abc"?

Rust

fn parse_number(input: &str) -> Result<i32, String> {
    match input.parse::<i32>() {
        Ok(num) => Ok(num),
        Err(_) => Err(String::from("Failed to parse number")),
    }
}

fn main() {
    let result = parse_number("abc");
    match result {
        Ok(n) => println!("Parsed number: {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

A Error: Failed to parse number

B Panic at runtime

C Compilation error

D Parsed number: 0

💡 Hint

The input string "abc" cannot be converted to an integer.

Parsing "abc" to i32 fails, so the Err branch is taken and prints the error message.

🔧 Debug

advanced

Identify the error in match arms handling Result

What error does this Rust code produce when compiled?

Rust

fn main() {
    let result: Result<i32, &str> = Err("error");
    match result {
        Ok(num) => println!("Number: {}", num),
        Err(e) => println!("Error: {}", e),
        _ => println!("Unknown case"),
    }
}

A Runtime panic: no matching pattern

B Compilation error: unreachable pattern

C Prints: Error: error

D Compilation error: missing match arm

💡 Hint

The match arms cover all possible variants of Result already.

The wildcard arm '_' is unreachable because Result only has Ok and Err variants, causing a compilation error.

❓ Predict Output

advanced

Output of nested match error handling

What is the output of this Rust code?

Rust

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Division by zero"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    let result = divide(10, 0);
    match result {
        Ok(val) => println!("Result: {}", val),
        Err(e) => match e.as_str() {
            "Division by zero" => println!("Cannot divide by zero!"),
            _ => println!("Other error: {}", e),
        },
    }
}

A Cannot divide by zero!

B Other error: Division by zero

C Result: 0

D Compilation error

💡 Hint

The error string matches "Division by zero" exactly.

The error string matches the first pattern in the nested match, so it prints the custom message.

🧠 Conceptual

expert

Why use match for error handling in Rust?

Which statement best explains why Rust uses match expressions for handling errors with Result types?

A Because match automatically retries failed operations without extra code.

B Because match converts all errors into panics by default.

C Because match forces exhaustive handling of all possible cases, preventing unhandled errors.

D Because match allows ignoring errors silently without warnings.

💡 Hint

Think about safety and explicit handling in Rust.

Rust's match requires handling all variants of Result, ensuring no error case is missed, which improves safety.