Generic type declaration in Swift - Step-by-Step Execution

Concept Flow - Generic type declaration

Start

↓

Declare generic type <T>

↓

Use <T> as placeholder

↓

Create instance with specific type

↓

Use instance with that type

↓

End

This flow shows declaring a generic type placeholder <T>, using it in code, then creating instances with specific types.

Execution Sample

Swift

struct Box<T> {
    var value: T
}

let intBox = Box<Int>(value: 10)
let strBox = Box<String>(value: "Hi")

Defines a generic struct Box that can hold any type T, then creates two instances with Int and String types.

Execution Table

Step	Action	Generic Type <T>	Instance Created	Value Stored
1	Declare struct Box with generic <T>	<T> is a placeholder	No instance yet	No value yet
2	Create intBox as Box<Int>	<T> replaced by Int	intBox	10 (Int)
3	Create strBox as Box<String>	<T> replaced by String	strBox	"Hi" (String)
4	Access intBox.value	Int	intBox	10
5	Access strBox.value	String	strBox	"Hi"

💡 All instances created and values stored; generic type replaced by specific types Int and String.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
intBox	nil	Box<Int>(value: 10)	Box<Int>(value: 10)	Box<Int>(value: 10)
strBox	nil	nil	Box<String>(value: "Hi")	Box<String>(value: "Hi")

Key Moments - 3 Insights

Why do we use <T> instead of a real type name when declaring Box?

Because <T> is a placeholder that lets Box work with any type. The actual type is chosen when creating an instance, as shown in steps 2 and 3.

What happens to <T> when we create intBox as Box<Int>?

At step 2, <T> is replaced by Int for that instance, so intBox.value holds an Int value.

Can intBox hold a String value?

No, because intBox is Box<Int>, it only holds Int values. strBox is Box<String> and holds String values, as seen in steps 2 and 3.

Visual Quiz - 3 Questions

Look at the execution table, what type does <T> represent when creating strBox?

A String

B Double

C Int

D Generic placeholder still

💡 Hint

Check step 3 in the execution table where strBox is created.

At which step is the first instance of Box created?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look for when intBox is assigned a value in the execution table.

If we tried to assign a String to intBox.value, what would happen?

A It would work fine

B Compile error because intBox expects Int

C intBox.value would change type to String

D Runtime error only

💡 Hint

Refer to variable_tracker and key moment about type safety.

Concept Snapshot

Generic type declaration syntax:
struct Box<T> { var value: T }

- <T> is a placeholder type
- Replace <T> with real type when creating instance
- Enables code reuse for any type
- Type safety ensured by compiler
- Use angle brackets <> for generics

Full Transcript

This visual execution shows how to declare and use a generic type in Swift. We start by declaring a struct Box with a generic placeholder <T>. This placeholder means Box can hold any type, but we don't specify which yet. When we create instances like intBox and strBox, we replace <T> with Int and String respectively. The execution table traces each step: declaring the generic, creating instances with specific types, and accessing their stored values. The variable tracker shows how intBox and strBox hold different types safely. Key moments clarify why <T> is a placeholder and how it is replaced. The quiz tests understanding of when and how <T> is replaced and type safety. The snapshot summarizes the syntax and rules for generic type declaration in Swift.