Handling errors with match in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to match on the Result and print "Success" if Ok.

Rust

let result: Result<i32, &str> = Ok(10);
match result {
    [1] => println!("Success"),
    Err(e) => println!("Error: {}", e),
}

Drag options to blanks, or click blank then click option'

AOk(10)

BOk

COk(value)

DOk(_)

Attempts:

3 left

💡 Hint

Common Mistakes

Using Ok without parentheses causes a syntax error.

Using Ok(10) only matches if the value is exactly 10.

Using Ok(_) matches any successful result regardless of the value inside.

2fill in blank

medium

Complete the code to extract the error message from Err variant.

Rust

let result: Result<i32, &str> = Err("Failed");
match result {
    Ok(val) => println!("Value: {}", val),
    [1] => println!("Error: {}", err),
}

Drag options to blanks, or click blank then click option'

AErr(err)

BErr(e)

CErr(msg)

DErr(error)

Attempts:

3 left

💡 Hint

Common Mistakes

Binding to a variable name different from the one used in println! causes errors.

Using Err without a variable name causes a syntax error.

Binding the error to 'err' allows printing it in the println! macro.

3fill in blank

hard

Fix the error in the match arms to handle both Ok and Err correctly.

Rust

let result: Result<i32, &str> = Ok(5);
match result {
    Ok(value) => println!("Value is {}", value),
    [1] => println!("Error occurred"),
}

Drag options to blanks, or click blank then click option'

AErr(_)

BErr

CErr(e)

DErr()

Attempts:

3 left

💡 Hint

Common Mistakes

Using Err without parentheses causes syntax errors.

Using Err(e) without using 'e' causes warnings.

Err(_) matches any error value without binding it, avoiding unused variable warnings.

4fill in blank

hard

Fill both blanks to match on Result and print the value or error message.

Rust

let result: Result<&str, &str> = Err("Not found");
match result {
    [1] => println!("Found: {}", val),
    [2] => println!("Error: {}", err),
}

Drag options to blanks, or click blank then click option'

AOk(val)

BOk(value)

CErr(err)

DErr(e)

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names in match arms and println! causes errors.

Not binding variables causes inability to print values.

Ok(val) binds the success value to val; Err(err) binds the error to err for printing.

5fill in blank

hard

Fill all three blanks to create a match that handles Ok with a number, Err with a message, and a default case.

Rust

let result: Result<i32, &str> = Ok(42);
match result {
    [1] => println!("Number: {}", num),
    [2] => println!("Error: {}", msg),
    [3] => println!("Unknown result"),
}

Drag options to blanks, or click blank then click option'

AOk(num)

BErr(msg)

C_

DErr(e)

Attempts:

3 left

💡 Hint

Common Mistakes

Using Err(e) instead of Err(msg) when msg is used in println! causes errors.

Omitting the default case causes match to be non-exhaustive.

Ok(num) binds the number; Err(msg) binds the error message; _ matches any other case as default.

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