Result enum in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using Result?

Consider this Rust code snippet using the Result enum. What will it print?

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() {
    match divide(10, 2) {
        Ok(val) => println!("Result is {}", val),
        Err(e) => println!("Error: {}", e),
    }
}

A Compilation error

B Error: division by zero

C Result is 0

D Result is 5

💡 Hint

Check what happens when dividing 10 by 2 and how the match handles Ok and Err.

The function divides 10 by 2, which is valid, so it returns Ok(5). The match prints the value inside Ok, so it prints 'Result is 5'.

❓ Predict Output

intermediate

What error message does this code produce?

Look at this Rust code using Result. What error message will it print?

Rust

fn parse_number(s: &str) -> Result<i32, String> {
    s.parse::<i32>().map_err(|_| String::from("parse error"))
}

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

A Number: 0

B Error: parse error

C Compilation error

D Error: invalid digit found in string

💡 Hint

The string "abc" cannot be parsed as a number, so the error branch runs.

The parse fails and map_err converts the parse error to the string "parse error". So the error message printed is 'Error: parse error'.

🔧 Debug

advanced

Why does this Rust code cause a compilation error?

This Rust code tries to unwrap a Result but causes a compilation error. Why?

Rust

fn get_value(flag: bool) -> Result<i32, String> {
    if flag {
        Ok(42)
    } else {
        Err("no value".to_string())
    }
}

fn main() {
    let val = get_value(true).unwrap_or("default");
    println!("Value: {}", val);
}

A The error string "no value" is not valid syntax

B unwrap_or cannot be used on Result, only on Option

C unwrap_or expects the same type as Ok, but "default" is a string, causing a type mismatch

D The function get_value returns a Result but unwrap_or is missing parentheses

💡 Hint

Check the type expected by unwrap_or and the type of the argument passed.

unwrap_or expects a value of the Ok type (i32), but "default" is a string, so the compiler reports a type mismatch error.

❓ Predict Output

advanced

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

Analyze this Rust code that uses the ? operator with Result. What will it print?

Rust

fn try_divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    let result = try_divide(10, 0).unwrap_or_else(|e| {
        println!("Error handled: {}", e);
        -1
    });
    println!("Result: {}", result);
}

A

Error handled: division by zero
Result: -1

B Result: 0

C Error handled: division by zero

D Compilation error

💡 Hint

The ? operator is not used here, but unwrap_or_else handles the error case.

try_divide returns Err for division by zero. unwrap_or_else runs the closure printing the error and returns -1. Then main prints 'Result: -1'.

🧠 Conceptual

expert

How many times is the closure executed in this Rust code using Result and map_err?

Consider this Rust code snippet. How many times will the closure inside map_err be executed?

Rust

fn main() {
    let res: Result<i32, &str> = Err("fail");
    let new_res = res.map_err(|e| {
        println!("Handling error: {}", e);
        "handled"
    });
    let final_res = new_res.map_err(|e| {
        println!("Second handler: {}", e);
        "final"
    });
}

A 2 times

B 1 time

C 0 times

D 3 times

💡 Hint

Each map_err runs only if the Result is Err. The Result stays Err after the first map_err.

The original Result is Err, so the first map_err closure runs once, printing 'Handling error: fail'. It returns a new Err, so the second map_err closure also runs once, printing 'Second handler: handled'. Total 2 times.