Generic structs in Rust - Step-by-Step Execution

Concept Flow - Generic structs

Define struct with <T>

↓

Create instance with specific type

↓

Use fields of instance

↓

Generic type allows flexibility

This flow shows how a struct is defined with a generic type, then created with a specific type, and finally used.

Execution Sample

Rust

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let p = Point { x: 5, y: 10 };
}

Defines a generic struct Point and creates an instance with integers.

Execution Table

Step	Action	Code Line	State Change	Notes
1	Define generic struct Point<T>	struct Point<T> { x: T, y: T }	Point<T> type created	Generic placeholder T introduced
2	Create instance p with T = i32	let p = Point { x: 5, y: 10 };	p.x = 5, p.y = 10	T replaced by i32 for this instance
3	Access p.x	p.x	Value = 5	Using field of generic struct instance
4	Access p.y	p.y	Value = 10	Using field of generic struct instance
5	End	-	-	Program ends after instance creation and access

💡 All steps complete; generic struct used with concrete type i32

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
p.x	-	5	5	5	5
p.y	-	10	10	10	10

Key Moments - 3 Insights

Why do we write <T> after struct name?

The <T> tells Rust this struct uses a generic type placeholder. In the execution_table step 1, this placeholder is defined but not yet a real type.

When does T become a real type like i32?

In step 2 of the execution_table, when we create the instance p with x=5 and y=10, Rust infers T as i32 for this instance.

Can p.x and p.y have different types?

No, because the struct uses the same generic T for both fields. So p.x and p.y must be the same type, shown in step 2.

Visual Quiz - 3 Questions

Look at the execution_table step 2, what type does T become for instance p?

A i32

B f64

C String

D bool

💡 Hint

Check the values assigned to p.x and p.y in step 2; they are integers.

At which step do we first use the fields of the generic struct?

A Step 1

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the Action column in execution_table; step 3 accesses p.x.

If we changed p.y to a string, what would happen in the execution_table?

A p.x would convert to String automatically

B T would be inferred as String

C Compilation error because x and y types differ

D No change, code runs fine

💡 Hint

Recall key_moments answer about both fields sharing the same generic type T.

Concept Snapshot

Generic structs allow defining structs with placeholder types <T>.
When creating an instance, T is replaced by a real type (e.g., i32).
All fields using T share the same type.
This enables flexible and reusable data structures.

Full Transcript

This example shows how to define a generic struct Point with a type placeholder T. When we create an instance p with x=5 and y=10, Rust infers T as i32. We then access p.x and p.y fields which hold integer values. The generic struct allows us to reuse the same structure with different types by replacing T with the desired type during instance creation.

Practice

1. What does the <T> mean in the definition of a generic struct in Rust?

easy

A. It specifies a fixed type that the struct must always use.

B. It declares a placeholder type that can be replaced with any type when used.

C. It is used to define a function inside the struct.

D. It marks the struct as unsafe to use.

Solution

1. Step 1: Understand generic type parameters

   The <T> syntax declares a generic type parameter named T, which acts as a placeholder for any type.

2. Step 2: Recognize its purpose in structs

   This allows the struct to be flexible and work with any data type specified when creating an instance.

3. Final Answer:

   It declares a placeholder type that can be replaced with any type when used. -> Option B

4. Quick Check:

   Generic type parameter = placeholder type [OK]

Hint: Generic <T> means flexible type placeholder [OK]

Common Mistakes:

• Thinking <T> fixes the type permanently
• Confusing <T> with function syntax
• Assuming <T> makes the struct unsafe

2. Which of the following is the correct syntax to define a generic struct named Container with one generic type parameter T?

easy

A. struct Container<T> { value: T }

B. struct Container { T value }

C. struct Container<T> (value: T);

D. struct Container<T> = { value: T };

Solution

1. Step 1: Recall Rust struct syntax with generics

   Generic structs use struct Name<T> { field: T } syntax.

2. Step 2: Check each option

   struct Container<T> { value: T } matches the correct syntax with curly braces and generic parameter T. Options A, B, and D have syntax errors or wrong struct declaration styles.

3. Final Answer:

   struct Container<T> { value: T } -> Option A

4. Quick Check:

   Correct generic struct syntax = struct Container<T> { value: T } [OK]

Hint: Use struct Name<T> { field: T } for generic structs [OK]

Common Mistakes:

• Omitting angle brackets around T
• Using parentheses instead of braces
• Trying to assign struct with '='

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

struct Pair<T> {
    first: T,
    second: T,
}

fn main() {
    let pair = Pair { first: 5, second: 10 };
    println!("{} and {}", pair.first, pair.second);
}

medium

A. 5 and 10

B. Pair { first: 5, second: 10 }

C. Compilation error due to missing type annotation

D. Runtime error

Solution

1. Step 1: Understand struct instantiation with generics

   The struct Pair is instantiated with integers 5 and 10, so T is inferred as i32.

2. Step 2: Analyze the println! macro output

   The macro prints the values of pair.first and pair.second separated by " and ".

3. Final Answer:

   5 and 10 -> Option A

4. Quick Check:

   Printing struct fields = 5 and 10 [OK]

Hint: Generic type inferred from values; prints fields directly [OK]

Common Mistakes:

• Expecting struct debug print without {:?}
• Thinking type annotation is mandatory here
• Assuming runtime error without reason

4. Identify the error in this generic struct code and choose the fix:

struct Wrapper<T> {
    value: T
}

fn main() {
    let w: Wrapper = Wrapper { value: 42 };
}

medium

A. Wrapper struct must have a lifetime parameter

B. Missing semicolon after struct field declaration

C. Cannot assign integer to generic type T

D. Missing generic type parameter in variable declaration: use Wrapper<i32>

Solution

1. Step 1: Check struct usage with generics

   The variable w is declared as Wrapper without specifying the generic type <T>, which is required.

2. Step 2: Fix by specifying the type

   Adding <i32> to Wrapper in the declaration fixes the error: let w: Wrapper<i32> = ....

3. Final Answer:

   Missing generic type parameter in variable declaration: use Wrapper<i32> -> Option D

4. Quick Check:

   Specify generic type when declaring variables [OK]

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

Common Mistakes:

• Forgetting to add <T> in variable type
• Thinking semicolon is missing after field
• Assuming lifetime needed without context

5. Given this generic struct and function, what is the output?

struct Container<T> {
    item: T,
}

impl<T> Container<T> {
    fn new(item: T) -> Self {
        Container { item }
    }

    fn describe(&self) -> String {
        match &self.item {
            i if i.is::<i32>() => "Integer container".to_string(),
            _ => "Other container".to_string(),
        }
    }
}

fn main() {
    let c = Container::new(100);
    println!("{}", c.describe());
}

hard

A. Integer container

B. Other container

C. Compilation error due to is::<i32>() usage

D. Runtime panic

Solution

1. Step 1: Analyze the use of is::<i32>() in match

   The method is::<i32>() does not exist on generic references in Rust; this causes a compilation error.

2. Step 2: Understand Rust type checking limitations

   Rust does not support runtime type checking like is::<i32>() on generic types without special traits or macros.

3. Final Answer:

   Compilation error due to is::<i32>() usage -> Option C

4. Quick Check:

   Rust generics lack runtime type checks like is::<Type>() [OK]

Hint: Rust generics can't check type at runtime without traits [OK]

Common Mistakes:

• Assuming is::<Type>() works on generics
• Expecting output without compilation errors
• Ignoring Rust's static typing rules