Handling errors with match in Rust - Mini Project: Build & Apply

Handling errors with match

📖 Scenario: You are writing a small Rust program that reads a number from a string and handles possible errors gracefully.

🎯 Goal: Build a Rust program that converts a string to a number using parse() and uses match to handle success and error cases.

📋 What You'll Learn

Create a string variable with a number value

Create a variable to hold the parsed result using parse()

Use match to handle Ok and Err cases

Print the parsed number if successful or an error message if parsing fails

💡 Why This Matters

🌍 Real World

Parsing user input or data from files often requires handling errors to avoid program crashes.

💼 Career

Understanding error handling with <code>match</code> is essential for writing safe and reliable Rust programs.

1

Create a string with a number

Create a variable called number_str and set it to the string "42".

Rust

# Your code here

Hint

Use let to create the variable and put the number inside quotes.

2

Parse the string to a number

Create a variable called parsed_number and set it to the result of calling number_str.parse::().

Rust

let number_str = "42";
# Your code here

Hint

Use parse::() to convert the string to a 32-bit integer.

3

Use match to handle parsing result

Use match parsed_number with arms for Ok(num) and Err(e). Inside Ok(num), create a variable number equal to num. Inside Err(e), create a variable error_message equal to e.to_string().

Rust

let number_str = "42";
let parsed_number = number_str.parse::();
# Your code here

Hint

Use match to check if parsing was successful or not.

4

Print the result or error message

Inside the Ok(num) arm, add println!("Parsed number: {}", num);. Inside the Err(e) arm, add println!("Failed to parse number: {}", e);.

Rust

let number_str = "42";
let parsed_number = number_str.parse::();

match parsed_number {
    Ok(num) => {
        let number = num;
        // Your code here
    },
    Err(e) => {
        let error_message = e.to_string();
        // Your code here
    }
}

Hint

Use println! to show the number or error message.

Practice

1. What does the match statement do when used with a Result type in Rust?

easy

A. It ignores errors and continues execution.

B. It automatically fixes errors in the code.

C. It converts the result into a string.

D. It checks if the result is Ok or Err and lets you handle each case.

Solution

1. Step 1: Understand the purpose of match with Result

   The match statement is used to check the two possible states of a Result: Ok for success and Err for failure.

2. Step 2: Recognize handling of both cases

   By matching on Ok and Err, you can write code to handle success and error separately, making the program safe and clear.

3. Final Answer:

   It checks if the result is Ok or Err and lets you handle each case. -> Option D

4. Quick Check:

   match with Result = handle Ok or Err [OK]

Hint: Remember: match splits Result into Ok or Err cases [OK]

Common Mistakes:

• Thinking match fixes errors automatically
• Assuming match converts Result to string
• Ignoring error cases in match

2. Which of the following is the correct syntax to match a Result<T, E> named res and print "Success" if Ok?

easy

A. match res { Ok => println!("Success"), Err => println!("Error") }

B. match res { Ok(_) => println!("Success"), Err(_) => println!("Error") }

C. match res { Ok(x) println!("Success"), Err(e) println!("Error") }

D. match res { Ok(_) => println!("Error"), Err(_) => println!("Success") }

Solution

1. Step 1: Check pattern matching syntax

   The correct syntax uses Ok(_) and Err(_) with arrows => to separate patterns from actions.

2. Step 2: Verify the printed messages

   match res { Ok(_) => println!("Success"), Err(_) => println!("Error") } prints "Success" on Ok and "Error" on Err, which matches the question requirement.

3. Final Answer:

   match res { Ok(_) => println!("Success"), Err(_) => println!("Error") } -> Option B

4. Quick Check:

   Correct match syntax = match res { Ok(_) => println!("Success"), Err(_) => println!("Error") } [OK]

Hint: Use arrows => after patterns and parentheses for Ok/Err [OK]

Common Mistakes:

• Omitting arrows => in match arms
• Not using parentheses for Ok(_) or Err(_)
• Swapping success and error messages

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

let res: Result<i32, &str> = Err("fail");
match res {
    Ok(val) => println!("Value: {}", val),
    Err(e) => println!("Error: {}", e),
}

medium

A. Error: fail

B. Value: 0

C. Value: fail

D. No output

Solution

1. Step 1: Identify the Result variant

   The variable res is assigned Err("fail"), so it represents an error.

2. Step 2: Match arms execution

   The match will go to the Err(e) arm and print "Error: fail".

3. Final Answer:

   Error: fail -> Option A

4. Quick Check:

   Err variant prints error message [OK]

Hint: Check if Result is Ok or Err to predict output [OK]

Common Mistakes:

• Confusing Err with Ok variant
• Expecting value instead of error message
• Ignoring the match arms

4. Find the error in this Rust code snippet:

let res: Result<i32, &str> = Ok(10);
match res {
    Ok(val) => println!("Value: {}", val),
    Err => println!("Error occurred"),
}

medium

A. Missing parentheses after Err in match arm

B. Missing semicolon after println! macro

C. Ok variant should be Err

D. Result type is incorrect

Solution

1. Step 1: Check match arm patterns

   In Rust, match arms for Result must pattern match with parentheses, so Err should be Err(_) or Err(e).

2. Step 2: Identify the syntax error

   The code uses Err without parentheses, which is invalid syntax and causes a compile error.

3. Final Answer:

   Missing parentheses after Err in match arm -> Option A

4. Quick Check:

   Err pattern needs parentheses () [OK]

Hint: Always use parentheses for Err(_) or Ok(_) in match [OK]

Common Mistakes:

• Writing Err without parentheses
• Confusing semicolon placement
• Changing Result type unnecessarily

5. You want to write a function that returns Result<i32, String>. Inside, you try to parse a string to an integer. Using match, how do you handle the parsing result to return Ok(number) if successful or Err with a custom message if it fails?

hard

A. match s.parse() { Ok(n) => Err(n), Err(e) => Ok(e.to_string()) }

B. if s.parse().is_ok() { Ok(s.parse().unwrap()) } else { Err("Parse failed") }

C. match s.parse() { Ok(n) => Ok(n), Err(_) => Err(String::from("Parse failed")) }

D. match s.parse() { Ok(n) => n, Err(_) => "Parse failed" }

Solution

1. Step 1: Understand parse returns Result

   The parse() method returns Result<T, E>, so matching on it lets us handle success and failure.

2. Step 2: Return matching Result from function

   On Ok(n), return Ok(n) to propagate success. On Err(_), return Err with a custom error message as a String.

3. Final Answer:

   match s.parse() { Ok(n) => Ok(n), Err(_) => Err(String::from("Parse failed")) } -> Option C

4. Quick Check:

   Match parse Result to return Ok or custom Err [OK]

Hint: Return Ok(n) on success, Err(custom message) on failure [OK]

Common Mistakes:

• Swapping Ok and Err returns
• Returning raw values instead of Result
• Using string literals instead of String in Err