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.