Using unwrap and expect in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of unwrap on Some value

What is the output of this Rust code?

Rust

fn main() {
    let value = Some(42);
    println!("{}", value.unwrap());
}

A 42

B Some(42)

C None

D panic at unwrap on None

💡 Hint

unwrap() extracts the value inside Some or panics if None.

unwrap() returns the inner value if the Option is Some. Here, value is Some(42), so unwrap() returns 42.

❓ Predict Output

intermediate

Using expect with a custom panic message

What will this Rust program print or do?

Rust

fn main() {
    let value: Option<i32> = None;
    println!("{}", value.expect("Value was None!"));
}

A panic with message: Value was None!

B prints None

C prints 0

D Value was None!

💡 Hint

expect() panics with the given message if the Option is None.

Since value is None, calling expect() causes a panic with the message 'Value was None!'.

🔧 Debug

advanced

Identify the error when unwrapping a Result

What error does this Rust code produce when run?

Rust

fn main() {
    let result: Result<i32, &str> = Err("error occurred");
    println!("{}", result.unwrap());
}

A compiles but prints 0

B prints error occurred

C panic with message: called `Result::unwrap()` on an Err value: "error occurred"

D syntax error

💡 Hint

unwrap() on Err causes a panic with the error inside.

Calling unwrap() on an Err variant causes a panic with the error message inside Err.

❓ Predict Output

advanced

Difference between unwrap and expect output

What is the output of this Rust code?

Rust

fn main() {
    let opt: Option<&str> = None;
    opt.expect("Custom panic message");
}

A panic with message: called `Option::unwrap()` on a None value

B compiles but does nothing

C prints None

D panic with message: Custom panic message

💡 Hint

expect() panics with the custom message if Option is None.

expect() panics with the provided message when called on None, unlike unwrap() which uses a default message.

🧠 Conceptual

expert

Why prefer expect over unwrap in production code?

Which is the best reason to prefer using expect() instead of unwrap() in Rust production code?

A unwrap() is slower than expect()

B expect() allows providing a clear panic message, making debugging easier

C unwrap() cannot be used on Result types

D expect() automatically recovers from errors

💡 Hint

Think about error messages and debugging.

Using expect() lets you add a custom message that helps identify the cause of a panic, which is very useful in production debugging.

Practice

1. What does the unwrap() method do when called on an Option in Rust?

easy

A. Always returns Some without checking the value.

B. Returns None if the value is missing without panicking.

C. Returns the value inside if Some, or panics if None.

D. Converts the Option into a Result type.

Solution

1. Step 1: Understand unwrap behavior on Option

   The unwrap() method extracts the value inside an Option if it is Some.

2. Step 2: What happens if Option is None

   If the Option is None, unwrap() causes the program to panic and stop.

3. Final Answer:

   Returns the value inside if Some, or panics if None. -> Option C

4. Quick Check:

   unwrap() panics on None = C [OK]

Hint: unwrap() panics on None, returns value on Some [OK]

Common Mistakes:

• Thinking unwrap returns None instead of panicking
• Confusing unwrap with expect
• Assuming unwrap converts Option to Result

2. Which of the following is the correct syntax to use expect on an Option with a custom error message?

easy

A. option.unwrap("Custom error message")

B. option.expect("Custom error message")

C. option.expect_error("Custom error message")

D. option.unwrap_or("Custom error message")

Solution

1. Step 1: Recall expect syntax

   The expect method is called on an Option or Result with a string argument for the error message.

2. Step 2: Identify correct method and argument

   The correct syntax is option.expect("Custom error message"). Other options are invalid method names or wrong usage.

3. Final Answer:

   option.expect("Custom error message") -> Option B

4. Quick Check:

   expect() takes a string message = A [OK]

Hint: expect() needs a string message inside parentheses [OK]

Common Mistakes:

• Using unwrap with a message argument
• Using non-existent methods like expect_error
• Confusing unwrap_or with expect

3. What will be the output of this Rust code?

let value: Option<i32> = Some(10);
println!("{}", value.unwrap());

medium

A. None

B. Compilation error

C. panic at unwrap called on None

D. 10

Solution

1. Step 1: Check Option value

   The variable value is Some(10), so it contains the integer 10.

2. Step 2: unwrap() extracts the value

   Calling unwrap() on Some(10) returns 10 without panicking.

3. Final Answer:

   10 -> Option D

4. Quick Check:

   unwrap() on Some(10) = 10 [OK]

Hint: unwrap() returns inner value if Some, else panics [OK]

Common Mistakes:

• Expecting None as output
• Thinking unwrap returns Option again
• Assuming code panics on Some

4. Identify the error in this Rust code snippet:

let value: Option<i32> = None;
println!("{}", value.unwrap());

medium

A. Runtime panic because unwrap called on None

B. Compilation error due to unwrap on None

C. unwrap returns 0 by default

D. No error, prints None

Solution

1. Step 1: Analyze Option value

   The variable value is None, meaning it has no value inside.

2. Step 2: unwrap() behavior on None

   Calling unwrap() on None causes a runtime panic and stops the program.

3. Final Answer:

   Runtime panic because unwrap called on None -> Option A

4. Quick Check:

   unwrap() panics on None = D [OK]

Hint: unwrap() panics at runtime if Option is None [OK]

Common Mistakes:

• Thinking unwrap returns None safely
• Expecting compilation error instead of panic
• Assuming unwrap returns default value

5. You want to safely get a value from an Option<String> but provide a clear error message if it's None. Which code snippet correctly uses expect for this?

hard

A. let name = option_name.expect("Name was missing!");

B. let name = option_name.unwrap_or("Name was missing!");

C. let name = option_name.unwrap("Name was missing!");

D. let name = option_name.expect_error("Name was missing!");

Solution

1. Step 1: Understand expect usage

   The expect method extracts the value or panics with the provided custom message if None.

2. Step 2: Check each option

   let name = option_name.expect("Name was missing!"); correctly uses expect with a string message. let name = option_name.unwrap_or("Name was missing!"); uses unwrap_or which returns a default value, not an error. The remaining options use invalid syntax.

3. Final Answer:

   let name = option_name.expect("Name was missing!"); -> Option A

4. Quick Check:

   expect() with message = A [OK]

Hint: Use expect("message") to add custom panic messages [OK]

Common Mistakes:

• Using unwrap_or instead of expect for error message
• Passing message to unwrap (not allowed)
• Using non-existent expect_error method