Using unwrap and expect in Rust - Mini Project: Build & Apply

Using unwrap and expect

📖 Scenario: Imagine you are writing a small Rust program that reads a user's age from a string and wants to convert it to a number. Sometimes the string might not be a valid number, so you need to handle that carefully.

🎯 Goal: You will learn how to use unwrap and expect to handle the result of converting a string to a number in Rust. This will help you understand how to deal with possible errors in a simple way.

📋 What You'll Learn

Create a string variable with a number value

Create a string variable with a non-number value

Use unwrap to convert the number string to an integer

Use expect to convert the non-number string to an integer with a custom error message

Print both results

💡 Why This Matters

🌍 Real World

Parsing user input or data from files often requires converting strings to numbers. Using <code>unwrap</code> and <code>expect</code> helps quickly handle success or failure in simple programs.

💼 Career

Understanding error handling with <code>unwrap</code> and <code>expect</code> is essential for Rust developers to write safe and clear code, especially when dealing with input/output and data parsing.

1

Create string variables with number and non-number values

Create a string variable called number_str with the value "42" and another string variable called not_number_str with the value "abc".

Rust

# Your code here

Hint

Use let to create variables and assign string values with double quotes.

2

Parse the number string using unwrap

Create a variable called number and set it to the result of parsing number_str to an i32 using parse() and then call unwrap() on it.

Rust

let number_str = "42";
let not_number_str = "abc";
# Your code here

Hint

Use parse() to convert the string to a number and unwrap() to get the value or panic if it fails.

3

Parse the non-number string using expect with a message

Create a variable called not_number and set it to the result of parsing not_number_str to an i32 using parse() and then call expect("Failed to parse not_number_str") on it.

Rust

let number_str = "42";
let not_number_str = "abc";
let number: i32 = number_str.parse().unwrap();
# Your code here

Hint

Use expect() to provide a custom error message if parsing fails.

4

Print the parsed values

Use println! to print number and not_number variables on separate lines.

Rust

let number_str = "42";
let not_number_str = "abc";
let number: i32 = number_str.parse().unwrap();
println!("{}", number);
let not_number: i32 = not_number_str.parse().expect("Failed to parse not_number_str");
# Your code here

Hint

Use println!("{}", variable); to print variables. The program will panic on the second print because of the invalid parse.

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