Result enum in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Result enum in Rust?

The Result enum is a type used for error handling. It has two variants: Ok for success and Err for failure.

beginner

What are the two variants of the Result enum?

Ok(T) which holds a success value of type T, and Err(E) which holds an error value of type E.

beginner

How do you handle a Result value in Rust?

You can use match to check if it is Ok or Err, then handle each case accordingly.

intermediate

What does the unwrap() method do on a Result?

It returns the success value if Ok, but causes the program to panic if it is Err.

intermediate

Why is using Result better than using panic! directly?

Because Result forces you to handle errors explicitly, making your program more reliable and preventing unexpected crashes.

What does Result<T, E> represent in Rust?

A A function that always returns an error

B A way to panic the program

C A type for storing multiple values

D A value that can be either success (<code>Ok</code>) or error (<code>Err</code>)

Result<T, E> is used to represent either success (Ok) or failure (Err) in Rust.

Which method on Result will cause a panic if the value is Err?

A is_ok()

B expect()

C unwrap()

D map()

unwrap() returns the success value or panics if it is an error.

How do you safely handle both Ok and Err variants of a Result?

A Using <code>unwrap()</code> always

B Using <code>match</code> to check each variant

C Ignoring the <code>Err</code> variant

D Using <code>panic!</code> directly

Using match lets you handle success and error cases explicitly.

What is the type of the value inside Ok in Result<T, E>?

A T

B E

C Result

D Option

The Ok variant holds a value of type T.

Why should you prefer Result over panicking in Rust?

A Because <code>Result</code> forces explicit error handling

B Because panics are faster

C Because <code>Result</code> hides errors

D Because panics never stop the program

Result encourages you to handle errors clearly, avoiding unexpected crashes.

Explain what the Result enum is and how it helps in error handling in Rust.

Think about how Rust uses Result to avoid crashes.

Describe how you would use match to handle a Result value in a Rust program.

Imagine you get a Result from a function and want to do different things for success or error.

Practice

1. What does the Result enum in Rust represent?

easy

A. A type for storing multiple values in a list

B. A way to loop over numbers

C. A value that can be either success (Ok) or failure (Err)

D. A function that always returns Ok

Solution

1. Step 1: Understand the purpose of Result

   Result is used to show if an operation succeeded or failed.

2. Step 2: Identify the two variants

   Ok means success, Err means failure or error.

3. Final Answer:

   A value that can be either success (Ok) or failure (Err) -> Option C

4. Quick Check:

   Result = success or failure [OK]

Hint: Remember: Result = Ok (success) or Err (failure) [OK]

Common Mistakes:

• Thinking Result is a list or collection
• Confusing Result with loops or arrays
• Assuming Result always means success

2. Which of the following is the correct way to create a Result with a success value of 10?

easy

A. let x: Result = Result::new(10);

B. let x: Result = Err(10);

C. let x: Result = Ok("10");

D. let x: Result = Ok(10);

Solution

1. Step 1: Check the correct variant for success

   Success uses Ok, so Ok(10) is correct.

2. Step 2: Verify the type matches

   The type is Result, so Ok(10) matches i32 for success.

3. Final Answer:

   let x: Result<i32, &str> = Ok(10); -> Option D

4. Quick Check:

   Success = Ok(value) [OK]

Hint: Use Ok(value) for success, Err(value) for error [OK]

Common Mistakes:

• Using Err for success value
• Mismatching types inside Ok or Err
• Trying to use Result::Ok instead of Ok directly

3. What will be printed by this Rust code?

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

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

medium

A. Result: 0

B. Result: 5

C. Error: Divide by zero

D. Compile error

Solution

1. Step 1: Check the divide function call

   Calling divide(10, 2) means b is 2, not zero, so it returns Ok(10 / 2) which is Ok(5).

2. Step 2: Match on the Result

   The match sees Ok(5), so it prints Result: 5.

3. Final Answer:

   Result: 5 -> Option B

4. Quick Check:

   Ok(5) prints Result: 5 [OK]

Hint: Match Ok prints result, Err prints error message [OK]

Common Mistakes:

• Assuming divide by 2 returns error
• Confusing Ok and Err branches
• Expecting compile error due to String

4. Identify the error in this Rust code using Result:

fn get_number(flag: bool) -> Result {
    if flag {
        Ok(42)
    } else {
        Err(42)
    }
}

medium

A. The Err variant has wrong type; should be a String

B. The Ok variant should return a String

C. Missing semicolon after Ok(42)

D. Function must return Option not Result

Solution

1. Step 1: Check the function return type

   The function returns Result<i32, String>, so Ok must hold i32 and Err must hold String.

2. Step 2: Identify the error in Err(42)

   42 is an integer, but Err expects a String. This causes a type mismatch.

3. Final Answer:

   The Err variant has wrong type; should be a String -> Option A

4. Quick Check:

   Err type must match declared error type [OK]

Hint: Err must match error type declared in Result [OK]

Common Mistakes:

• Using wrong type inside Err
• Thinking Ok needs String
• Ignoring type mismatch errors

5. Given a list of strings representing numbers, which Rust code correctly converts them to integers and collects only successful parses using Result handling?

let strings = vec!["10", "abc", "20", "xyz"];
// Fill in the blank:
let numbers: Vec<i32> = strings.iter()
    .map(|s| s.parse::<i32>())
    .__________;
println!("{:?}", numbers);

hard

A. filter_map(Result::ok).collect()

B. filter(|r| r.is_ok()).collect()

C. map(Result::unwrap).collect()

D. collect::()

Solution

1. Step 1: Understand parse returns Result

   Each s.parse::<i32>() returns Result<i32, _>, so we get an iterator of Results.

2. Step 2: Use filter_map(Result::ok) to keep only successes

   filter_map(Result::ok) extracts the Ok values and skips errors, then collect() gathers them into a vector.

3. Final Answer:

   filter_map(Result::ok).collect() -> Option A

4. Quick Check:

   filter_map(Result::ok) keeps only successful parses [OK]

Hint: Use filter_map(Result::ok) to keep only Ok values [OK]

Common Mistakes:

• Using filter without extracting Ok values
• Calling unwrap on all results causing panic
• Trying to collect without filtering errors