Generic enums in Rust - Step-by-Step Execution

Concept Flow - Generic enums

Define generic enum with type parameter T

↓

Create enum instance with specific type

↓

Match on enum variant

↓

Variant A

↓

Use value of type T

↓

End of match

This flow shows defining a generic enum, creating instances with specific types, and matching on variants to use the contained values.

Execution Sample

Rust

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

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

Defines a generic enum Option with type T, creates an instance with i32, and matches to print the value.

Execution Table

Step	Action	Evaluation	Result
1	Define enum Option<T>	Generic enum with variants Some(T) and None	Enum ready for use
2	Create x = Option::Some(5)	x is Option<i32> with Some(5)	x holds Some(5)
3	Match on x	x is Some(5)	Go to Some branch
4	Print value	val = 5	Output: Value: 5
5	End match	No more variants	Match complete

💡 Match ends after handling Some variant with value 5

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
x	uninitialized	Some(5)	Some(5)	Some(5)
val	N/A	N/A	5	5

Key Moments - 3 Insights

Why do we write Option<T> instead of just Option?

Option<T> means the enum can hold any type T. This is shown in step 1 of the execution_table where the enum is defined with a generic type parameter T.

How does Rust know what type T is when we create x?

In step 2, we create x as Option<i32> by specifying the type. This tells Rust that T is i32 for this instance.

What happens if x is Option::None?

In the match (step 3), if x was None, the code would go to the None branch and print 'No value' instead of 'Value: 5'.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of x after step 2?

A Some(5)

B None

C Uninitialized

D 5

💡 Hint

Check the 'After Step 2' column for variable x in variable_tracker.

At which step does the program print the output?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table for printing.

If we changed x to Option::None, which step's result would change?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Consider the match branches in step 3 and what is printed in step 4.

Concept Snapshot

Generic enums allow defining enums with a type parameter T.
You create instances by specifying the concrete type, e.g., Option<i32>.
Match on enum variants to access the contained value of type T.
This enables flexible, reusable enum definitions.

Full Transcript

This example shows how to define a generic enum Option with a type parameter T. We create an instance x of type Option<i32> holding the value Some(5). Then we match on x to check which variant it is. Since x is Some(5), we print the value 5. The execution table traces each step: defining the enum, creating x, matching on x, printing the value, and ending the match. The variable tracker shows how x and val change during execution. Key moments clarify why we use generics, how Rust infers types, and what happens if the enum is None. The quiz tests understanding of variable values and match behavior. This helps beginners see how generic enums work step-by-step in Rust.