Generic enums in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of generic enum pattern matching

What is the output of this Rust program using a generic enum and pattern matching?

Rust

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

fn main() {
    let x: OptionValue<i32> = OptionValue::Some(10);
    match x {
        OptionValue::Some(val) if val > 5 => println!("Greater than 5: {}", val),
        OptionValue::Some(val) => println!("Value: {}", val),
        OptionValue::None => println!("No value"),
    }
}

A Greater than 5: 10

B Value: 10

C Compilation error due to missing trait bound

D No value

💡 Hint

Look at the pattern guard `if val > 5` and the value inside Some.

The enum holds Some(10). The match arm with guard `if val > 5` matches because 10 > 5, so it prints "Greater than 5: 10".

❓ Predict Output

intermediate

Result of generic enum with different types

What will this Rust code print when run?

Rust

enum Container<T> {
    Item(T),
    Empty,
}

fn main() {
    let a: Container<&str> = Container::Item("hello");
    let b: Container<i32> = Container::Empty;

    match a {
        Container::Item(s) => println!("String: {}", s),
        Container::Empty => println!("Empty container"),
    }

    match b {
        Container::Item(n) => println!("Number: {}", n),
        Container::Empty => println!("Empty container"),
    }
}

A

Empty container
Empty container

B

String: hello
Number: 0

C

String: hello
Empty container

D Compilation error due to mismatched types

💡 Hint

Check the variant used for each variable and the match arms.

Variable `a` holds `Item("hello")`, so it prints "String: hello". Variable `b` holds `Empty`, so it prints "Empty container".

🔧 Debug

advanced

Why does this generic enum code fail to compile?

This Rust code tries to implement a method for a generic enum but fails. What is the cause of the compilation error?

Rust

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

impl<T> Wrapper<T> {
    fn unwrap(self) -> T {
        match self {
            Wrapper::Value(val) => val,
            Wrapper::None => panic!("No value"),
        }
    }
}

fn main() {
    let w: Wrapper<i32> = Wrapper::None;
    println!("{}", w.unwrap());
}

A No compilation error; program panics at runtime

B Compilation error because panic! macro is used incorrectly

C Compilation error because method unwrap returns T but None variant has no value

D Compilation error because enum variant None conflicts with std::option::Option::None

💡 Hint

Check if the method unwrap handles all variants and what happens at runtime.

The code compiles fine. The unwrap method returns the value for Value variant or panics for None variant. The program panics at runtime when unwrap is called on None.

📝 Syntax

advanced

Identify the syntax error in this generic enum definition

Which option correctly identifies the syntax error in this Rust code?

Rust

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

fn main() {
    let r: Result<i32, &str> = Result::Ok(5);
}

A Missing type annotations for generic parameters

B Missing semicolon after Err(E) variant

C Incorrect enum variant syntax; variants must be functions

D Missing closing brace '}' for enum Result

💡 Hint

Check the braces that open and close the enum block.

The enum block is missing the closing brace '}' after the variants, causing a syntax error.

🚀 Application

expert

How many items are in this generic enum vector?

Given this Rust code, what number does the program print?

Rust

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

fn main() {
    let items = vec![
        Data::Single(1),
        Data::Multiple(vec![2, 3]),
        Data::Single(4),
    ];

    let count = items.iter().fold(0, |acc, item| {
        match item {
            Data::Single(_) => acc + 1,
            Data::Multiple(v) => acc + v.len(),
        }
    });

    println!("Count: {}", count);
}

A 5

B 4

C 3

D 6

💡 Hint

Count single items as 1 and multiple items by their vector length.

The vector has 3 elements: Single(1) counts as 1, Multiple(vec![2,3]) counts as 2, Single(4) counts as 1. Total is 1 + 2 + 1 = 4.

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