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.