Closures are reference types in Swift - Step-by-Step Execution

Concept Flow - Closures are reference types

Create closure instance

↓

Assign closure to variable A

↓

Assign variable A to variable B

↓

Modify closure via B

↓

Observe change via A

↓

Both A and B refer to same closure instance

This flow shows how closures are created and assigned to variables, and how multiple variables can reference the same closure instance, demonstrating closures are reference types.

Execution Sample

Swift

var closureA = { () -> Int in
    var count = 0
    return { count += 1; return count }
}()

var closureB = closureA
closureB()
closureA()

This code creates a closure that increments a count, assigns it to two variables, and calls it via both to show shared state.

Execution Table

Step	Action	Variable States	Output	Notes
1	Create closureA with internal count=0	closureA: closure with count=0	-	Closure instance created with count=0
2	Assign closureA to closureB	closureA: closure with count=0, closureB: same closure	-	closureB references same closure instance as closureA
3	Call closureB()	count increments to 1	1	Closure called via closureB, count becomes 1
4	Call closureA()	count increments to 2	2	Closure called via closureA, count becomes 2
5	End	closureA and closureB share count=2	-	Both variables reference same closure instance

💡 Execution ends after demonstrating shared state through closure references

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
closureA.count	0	1	2	2
closureB.count	0	1	2	2

Key Moments - 2 Insights

Why does calling closureA() after closureB() show the incremented count?

Because closureA and closureB reference the same closure instance, changes via closureB affect closureA as shown in steps 3 and 4 of the execution_table.

Is a new closure created when assigning closureA to closureB?

No, closureB points to the same closure instance as closureA, so no new closure is created (see step 2 in execution_table).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of count inside the closure after calling closureB()?

A 2

B 0

C 1

D Undefined

💡 Hint

Check the 'Variable States' column at step 3 in execution_table.

At which step does closureA and closureB share the same updated count value?

A Step 4

B Step 2

C Step 1

D Step 5

💡 Hint

Look at the 'Variable States' and 'Notes' columns at step 4 in execution_table.

If closureB was assigned a new closure instead of closureA, how would the variable_tracker change?

A closureA.count and closureB.count would increment together

B closureB.count would stay at 0 after calls

C closureA.count would reset to 0 after step 3

D closureB.count would be undefined

💡 Hint

Consider that separate closures have independent internal states, unlike shared references shown in variable_tracker.

Concept Snapshot

Closures in Swift are reference types.
Assigning a closure to another variable copies the reference, not the closure itself.
Calling the closure via any reference affects the same internal state.
This means closures share captured variables when referenced.
Use this to maintain shared state across calls.

Full Transcript

This visual execution trace shows how closures in Swift behave as reference types. We start by creating a closure that captures a variable count initialized to zero. This closure is assigned to closureA. Then closureA is assigned to closureB, so both variables point to the same closure instance. When closureB is called, it increments count to 1. Calling closureA next increments count to 2, showing that both variables share the same closure and internal state. The variable tracker confirms count changes are shared. Key moments clarify that no new closure is created on assignment and that both variables reference the same closure instance. The quiz tests understanding of closure state sharing and reference behavior. This demonstrates closures keep shared state because they are reference types in Swift.

Practice

1. What does it mean when we say closures are reference types in Swift?

easy

A. Multiple variables can point to the same closure instance, sharing changes.

B. Closures cannot capture variables from their surrounding context.

C. Each time you assign a closure, a new copy is created.

D. Closures are stored only as values, not references.

Solution

1. Step 1: Understand what reference types mean

   Reference types mean multiple variables can point to the same instance in memory.

2. Step 2: Apply this to closures

   Since closures are reference types, assigning them copies the reference, not the code itself.

3. Final Answer:

   Multiple variables can point to the same closure instance, sharing changes. -> Option A

4. Quick Check:

   Closures share instance references [OK]

Hint: Reference types share instances, not copies [OK]

Common Mistakes:

• Thinking closures always create new copies
• Confusing closures with value types like structs
• Ignoring that closures capture variables by reference

2. Which of the following is the correct way to assign a closure to a variable in Swift?

easy

A. func closure = { print("Hello") }

B. let closure = { print("Hello") }

C. closure := { print("Hello") }

D. var closure = function printHello() {}

Solution

1. Step 1: Recall Swift closure syntax

   Closures are assigned using curly braces and can be stored in variables with let or var.

2. Step 2: Check each option

   let closure = { print("Hello") } uses correct syntax: let closure = { print("Hello") }.

3. Final Answer:

   let closure = { print("Hello") } -> Option B

4. Quick Check:

   Correct closure assignment syntax [OK]

Hint: Closures use curly braces and assign with let or var [OK]

Common Mistakes:

• Using := which is not Swift syntax
• Trying to declare closures like functions
• Using func keyword incorrectly for closures

3. What will be printed by this Swift code?

var closureA = { print("Count: 0") }
var closureB = closureA
closureA = { print("Count: 1") }
closureB()

medium

A. Count: 0

B. Count: 1

C. No output, error occurs

D. Count: 0 and Count: 1

Solution

1. Step 1: Understand closure assignment

   closureB is assigned closureA's original closure printing "Count: 0".

2. Step 2: Reassign closureA

   closureA is changed to a new closure printing "Count: 1", but closureB still points to the old closure.

3. Final Answer:

   Count: 0 -> Option A

4. Quick Check:

   closureB keeps original closure [OK]

Hint: Reassigning closureA doesn't change closureB's reference [OK]

Common Mistakes:

• Assuming closureB changes when closureA is reassigned
• Confusing closure references with copies
• Expecting both closures to print the same after reassignment

4. Identify the error in this Swift code involving closures:

var closure1 = { print("Hello") }
var closure2 = closure1
closure1 = { print("World") }
closure2 = closure1

medium

A. Closure syntax is invalid

B. Cannot assign closure1 to closure2 after reassignment

C. No error, code runs fine

D. Variables closure1 and closure2 must be constants

Solution

1. Step 1: Check closure assignments

   Both closure1 and closure2 are variables and can be reassigned closures.

2. Step 2: Validate syntax and assignments

   All closure assignments use correct syntax and valid variable usage.

3. Final Answer:

   No error, code runs fine -> Option C

4. Quick Check:

   Valid closure reassignment [OK]

Hint: Variables can be reassigned closures freely [OK]

Common Mistakes:

• Thinking reassignment causes errors
• Confusing closure syntax with function syntax
• Assuming closures must be constants

5. Given this Swift code, what will be printed?

func makeCounter() -> () -> Int {
    var count = 0
    let increment: () -> Int = {
        count += 1
        return count
    }
    return increment
}

let counter1 = makeCounter()
let counter2 = counter1
print(counter1())
print(counter2())

hard

A. 1 and 1

B. 0 and 1

C. 2 and 2

D. 1 and 2

Solution

1. Step 1: Understand closure capturing

   The closure increments and returns the same captured variable 'count'.

2. Step 2: Analyze reference sharing

   counter1 and counter2 reference the same closure instance, so increments affect both.

3. Step 3: Trace calls

   First call counter1() returns 1, second call counter2() increments count to 2 and returns 2.

4. Final Answer:

   1 and 2 -> Option D

5. Quick Check:

   Shared closure state increments count [OK]

Hint: Closures share captured variables and state [OK]

Common Mistakes:

• Thinking counter2 is independent copy
• Ignoring closure captures and shared state
• Assuming count resets on each call