Closures are reference types in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean that closures are reference types in Swift?

It means that when you assign a closure to a new variable or constant, both refer to the same closure instance in memory. Changes to one affect the other.

beginner

How do closures behave differently from value types like structs in Swift?

Closures are reference types, so they share the same instance when assigned or passed around. Structs are value types, so they get copied each time.

intermediate

What happens if you modify a variable captured by a closure that is a reference type?

The closure keeps a reference to the original variable, so changes inside the closure affect the original variable outside it.

intermediate

Explain with an example why closures being reference types matters in Swift.

If you assign a closure to two variables and call one, both see the same captured variables. For example, incrementing a counter inside one closure affects the other because they share the same reference.

advanced

Can closures cause memory leaks because they are reference types? Why or why not?

Yes, closures can cause memory leaks if they capture self strongly in classes, creating a strong reference cycle. Using [weak self] or [unowned self] in capture lists helps avoid this.

What happens when you assign a closure to a new variable in Swift?

A Both variables refer to the same closure instance

B A new copy of the closure is created

C The closure is converted to a value type

D The closure is deleted from memory

Closures are reference types, so assigning them copies the reference, not the closure itself.

Which of these is a value type in Swift?

A Struct

B Closure

C Class

D Function

Structs are value types; closures and classes are reference types.

Why can closures cause memory leaks in Swift?

A Because they cannot capture variables

B Because they are value types

C Because they are copied too many times

D Because they capture variables strongly creating reference cycles

Closures can capture self strongly, causing reference cycles and memory leaks.

If two variables hold the same closure reference, what happens if you modify a captured variable inside one closure?

A The program crashes

B The other variable keeps the old value

C The change is visible through the other variable

D The closure is copied automatically

Because closures are reference types, they share captured variables.

How can you avoid strong reference cycles with closures in Swift?

A Use structs instead of closures

B Use [weak self] or [unowned self] in capture lists

C Avoid using closures

D Assign closures to constants only

Using weak or unowned references in capture lists prevents strong reference cycles.

Explain why closures are considered reference types in Swift and how this affects variable assignment.

Think about how two variables can point to the same closure.

Describe a scenario where closures being reference types can lead to a memory leak and how to prevent it.

Consider how closures capture class instances.

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