Handling errors with match in Rust - Step-by-Step Execution

Concept Flow - Handling errors with match

Start

↓

Call function that may error

↓

match on Result

↓

Use value

↓

End

This flow shows calling a function that returns a Result, then using match to handle success (Ok) or error (Err) cases.

Execution Sample

Rust

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Cannot divide by zero"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10, 0) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

This code tries to divide 10 by 0 and uses match to print the result or error message.

Execution Table

Step	Action	Evaluation	Result
1	Call divide(10, 0)	b == 0 is true	Returns Err("Cannot divide by zero")
2	match on Result	Result is Err	Go to Err branch
3	Print error message	Prints "Error: Cannot divide by zero"	Output to console
4	End	No more code	Program ends

💡 Error branch taken because divisor is zero, so program prints error and ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
a	10	10	10	10	10
b	0	0	0	0	0
result	N/A	Err("Cannot divide by zero")	Err("Cannot divide by zero")	Err("Cannot divide by zero")	Err("Cannot divide by zero")
e	N/A	N/A	"Cannot divide by zero"	"Cannot divide by zero"	"Cannot divide by zero"

Key Moments - 2 Insights

Why does the program go to the Err branch instead of Ok?

Because the divisor b is zero, the divide function returns Err. The match statement checks the Result and takes the Err branch as shown in execution_table step 2.

What happens if the divisor is not zero?

If b is not zero, divide returns Ok with the division result. Then the match takes the Ok branch and prints the result instead of an error.

Visual Quiz - 3 Questions

Look at the execution table, what is the Result after Step 1?

A Err("Cannot divide by zero")

B Ok(10)

C Ok(0)

D None

💡 Hint

Check the 'Result' column in Step 1 of the execution_table.

At which step does the program print the error message?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look for the step where 'Print error message' happens in the execution_table.

If divide(10, 2) was called instead, which branch would match take?

A Neither branch

B Err branch

C Ok branch

D Both branches

💡 Hint

Recall that divide returns Ok when divisor is not zero, so match takes Ok branch.

Concept Snapshot

Handling errors with match in Rust:
- Use functions returning Result<T, E>
- Use match to check Result:
  match result {
    Ok(val) => handle success,
    Err(e) => handle error,
  }
- This cleanly separates success and error handling.

Full Transcript

This example shows how Rust uses the match statement to handle errors returned as Result types. The divide function returns Ok if division is possible, or Err if dividing by zero. The main function calls divide and uses match to check if the result is Ok or Err. If Ok, it prints the result; if Err, it prints the error message. The execution table traces each step: calling divide, matching on the result, printing the error, and ending. Variables like a, b, result, and e are tracked through the steps. Key moments clarify why the Err branch is taken when dividing by zero and what happens if the divisor is not zero. The visual quiz tests understanding of the result after calling divide, when the error prints, and which branch match takes for a non-zero divisor.

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