Generic enums in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a generic enum in Rust?

A generic enum in Rust is an enum that can hold different types specified by a generic parameter. It allows the enum to be flexible and work with various data types.

beginner

How do you define a generic enum with one type parameter in Rust?

You add a type parameter inside angle brackets after the enum name, like <T>. For example:

enum Option<T> {
    Some(T),
    None,
}

intermediate

Why use generic enums instead of fixed-type enums?

Generic enums let you write one enum that works with many types, reducing code duplication and increasing flexibility. For example, Option<T> can hold any type T, not just one fixed type.

intermediate

Can generic enums have multiple type parameters? Give an example.

Yes, generic enums can have multiple type parameters. Example:

enum Result {
    Ok(T),
    Err(E),
}

This enum can hold a success value of type T or an error value of type E.

beginner

How do you create an instance of a generic enum with a specific type?

You specify the type when you use the enum. For example:<br><pre>let x: Option<i32> = Option::Some(5);</pre> Here, Option is used with i32 as the type parameter.

What does the <T> mean in enum Option<T>?

A It declares a generic type parameter T for the enum.

B It is a syntax error in Rust.

C It means the enum only works with type T fixed as integer.

D It is a lifetime parameter.

The declares a generic type parameter, allowing the enum to hold any type specified when used.

Which of these is a valid generic enum definition?

A enum Result { Ok<T>, Err<E> }

B enum Result<T, E> { Ok(T), Err(E) }

C enum Result<T> { Ok, Err }

D enum Result<T, E> { Ok, Err }

Option B correctly defines a generic enum with two type parameters and variants holding those types.

How do you create an Option holding a string "hello"?

A Option::Some("hello")

B Option::Some(hello)

C Option::None("hello")

D Option::Some<String>

Option::Some("hello") creates an Option holding a string slice. The type is inferred or can be specified explicitly.

What is the benefit of using generic enums?

A They restrict enums to only one data type.

B They make enums slower.

C They allow enums to work with multiple data types without rewriting code.

D They are only used for error handling.

Generic enums increase flexibility by allowing the same enum to hold different types.

Can you use a generic enum without specifying the type parameter?

A Only if the enum has no variants.

B Yes, Rust assumes a default type.

C Yes, generic enums do not require type parameters.

D No, you must specify or let Rust infer the type.

You must specify the type parameter or let Rust infer it from context.

Explain what a generic enum is and why it is useful in Rust.

Think about how enums can hold different types using generics.

Write a simple generic enum with two variants and explain how to create an instance of it.

Use something like Result<T, E> or Option<T>.

Practice

1. What is the main benefit of using generic enums in Rust?

easy

A. They allow enums to hold different types of data without rewriting code.

B. They make enums run faster by using less memory.

C. They automatically generate functions for enums.

D. They restrict enums to only one data type.

Solution

1. Step 1: Understand what generic enums do

   Generic enums let you define an enum that can hold different types of data by using type parameters.

2. Step 2: Identify the benefit

   This means you can reuse the same enum for many data types without rewriting it for each type.

3. Final Answer:

   They allow enums to hold different types of data without rewriting code. -> Option A

4. Quick Check:

   Generic enums = flexible data types [OK]

Hint: Generic enums = one enum, many data types [OK]

Common Mistakes:

• Thinking generic enums improve speed
• Believing they auto-generate functions
• Assuming they limit data types

2. Which of the following is the correct syntax to define a generic enum named Option with a type parameter T?

easy

A. enum Option<T> { Some(T), None }

B. enum Option { Some<T>(T), None }

C. enum Option<T> { Some, None(T) }

D. enum Option { Some(T), None }

Solution

1. Step 1: Recall generic enum syntax

   Generic enums declare the type parameter after the enum name, like enum Name<T>.

2. Step 2: Check variant definitions

   Variants can use the generic type T directly, e.g., Some(T). The None variant has no data.

3. Final Answer:

   enum Option<T> { Some(T), None } -> Option A

4. Quick Check:

   Generic param after enum name = enum Option<T> { Some(T), None } [OK]

Hint: Generic param goes after enum name, not variant [OK]

Common Mistakes:

• Putting <T> after variant name
• Adding data to None variant
• Omitting generic parameter after enum name

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

enum Result {
    Ok(T),
    Err(E),
}

fn main() {
    let value: Result = Result::Ok(10);
    match value {
        Result::Ok(v) => println!("Value: {}", v),
        Result::Err(e) => println!("Error: {}", e),
    }
}

medium

A. Compilation error

B. Error: 10

C. Value: Err

D. Value: 10

Solution

1. Step 1: Understand the enum and value

   The enum Result has two variants: Ok with type T and Err with type E. The variable value is Result::Ok(10).

2. Step 2: Match arms and output

   The match checks if value is Ok or Err. Since it is Ok(10), it prints Value: 10.

3. Final Answer:

   Value: 10 -> Option D

4. Quick Check:

   Match Ok(10) prints Value: 10 [OK]

Hint: Match enum variant to print correct value [OK]

Common Mistakes:

• Confusing Ok and Err variants
• Expecting error output for Ok variant
• Thinking code won't compile

4. Identify the error in this generic enum usage:

enum Wrapper<T> {
    Value(T),
}

fn main() {
    let w: Wrapper = Wrapper::Value(5);
}

medium

A. Cannot use Wrapper::Value to create a value.

B. Enum variants cannot hold generic types.

C. Missing type parameter <i32> when declaring w.

D. The enum must have a lifetime parameter.

Solution

1. Step 1: Check enum declaration and usage

   The enum Wrapper is generic over T. When creating w, the type parameter is missing.

2. Step 2: Understand Rust's type inference rules

   Rust requires specifying the type parameter explicitly or letting it infer from context. Here, w is declared without <i32>, so it causes an error.

3. Final Answer:

   Missing type parameter <i32> when declaring w. -> Option C

4. Quick Check:

   Generic enum needs type parameter specified [OK]

Hint: Always specify generic type when declaring variables [OK]

Common Mistakes:

• Omitting generic type parameter
• Thinking enum variants can't hold generics
• Adding unnecessary lifetime parameters

5. Given this generic enum:

enum Container<T> {
    Single(T),
    Multiple(Vec<T>),
}

Which code correctly creates a Container holding multiple String values and prints each string?

hard

A. let c: Container = Container::Multiple(vec!["a", "b"]);
match c {
Container::Multiple(v) => for s in v { println!("{}", s); },
_ => (),
}

B. let c = Container::Multiple(vec!["a".to_string(), "b".to_string()]);
if let Container::Multiple(v) = c {
for s in v { println!("{}", s); }
}

C. let c = Container::Single(vec!["a".to_string(), "b".to_string()]);
match c {
Container::Multiple(v) => for s in v { println!("{}", s); },
_ => (),
}

D. let c = Container::Multiple(vec!["a", "b"]);
if let Container::Multiple(v) = c {
for s in v { println!("{}", s); }
}

Solution

1. Step 1: Check type correctness in creation

   The enum Container expects Vec<T> for Multiple. Using vec!["a".to_string(), "b".to_string()] creates a Vec<String>, matching Container<String>.

2. Step 2: Verify pattern matching and printing

   The if let correctly matches Container::Multiple(v) and iterates over v to print each string.

3. Final Answer:

   Code correctly creates and prints the strings. -> Option B

4. Quick Check:

   Correct generic type and pattern matching = let c = Container::Multiple(vec!["a".to_string(), "b".to_string()]); if let Container::Multiple(v) = c { for s in v { println!("{}", s); } } [OK]

Hint: Use to_string() for String vectors and match variants properly [OK]

Common Mistakes:

• Missing generic type annotation
• Using wrong variant for multiple values
• Using string slices instead of String objects