Handling errors with match in Rust - Time & Space Complexity

Time Complexity: Handling errors with match

O(n)

Understanding Time Complexity

When we handle errors using match in Rust, we want to know how the time to run the code changes as input grows.

We ask: How much work does the program do when matching on results?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn process_numbers(nums: &[i32]) {
    for &num in nums {
        match num.checked_mul(2) {
            Some(val) => println!("Double: {}", val),
            None => println!("Overflow for {}", num),
        }
    }
}

This code doubles each number if possible, or prints an overflow message if not.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each number in the input slice.
• How many times: Once for every number in the input list.

How Execution Grows With Input

Each number causes one check and one print. More numbers mean more work.

Input Size (n)	Approx. Operations
10	About 10 checks and prints
100	About 100 checks and prints
1000	About 1000 checks and prints

Pattern observation: The work grows directly with the number of items.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line as the input list gets bigger.

Common Mistake

[X] Wrong: "Matching on errors makes the code slower in a way that depends on the error type."

[OK] Correct: Matching just checks the result once per item, so it grows only with the number of items, not the error details.

Interview Connect

Understanding how error handling affects performance helps you write clear and efficient Rust code, a skill useful in many real projects.

Self-Check

"What if we replaced the loop with recursion? How would the time complexity change?"

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