Closures are reference types in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using closures?

Consider the following Swift code. What will be printed?

Swift

func makeIncrementer() -> () -> Int {
    var total = 0
    let incrementer: () -> Int = {
        total += 1
        return total
    }
    return incrementer
}

let increment = makeIncrementer()
print(increment())
print(increment())

A 2\n3

B 0\n1

C 1\n1

D 1\n2

💡 Hint

Remember that closures capture variables by reference, so the variable total keeps its value between calls.

The closure incrementer captures the variable total by reference. Each time increment() is called, total increases by 1. So the first call prints 1, the second prints 2.

🧠 Conceptual

intermediate

Why are closures considered reference types in Swift?

Choose the best explanation why closures in Swift behave as reference types.

A Because closures capture variables and share the same instance when assigned or passed around.

B Because closures are copied every time they are assigned to a new variable.

C Because closures cannot capture variables from their surrounding context.

D Because closures are stored on the stack and destroyed after use.

💡 Hint

Think about what happens when you assign a closure to multiple variables.

Closures capture variables from their surrounding context and share the same instance when assigned or passed around, so they behave like reference types.

🔧 Debug

advanced

What error occurs in this Swift closure code?

Examine the code below. What error will it produce when compiled?

Swift

func createClosure() -> () -> Int {
    var count = 0
    return {
        count += 1
        return count
    }
}

let closure1 = createClosure()
let closure2 = closure1
closure2 = createClosure()

A Type mismatch: cannot assign closure to closure2

B No error, code compiles and runs

C Cannot assign to value: 'closure2' is a 'let' constant

D Runtime error: variable 'count' not captured

💡 Hint

Look at how closure2 is declared and used.

closure2 is declared with let, so it cannot be assigned a new value after initialization. The line closure2 = createClosure() causes a compile-time error.

❓ Predict Output

advanced

What is the output when modifying a captured variable through two closures?

What will this Swift code print?

Swift

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

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

A 1\n1

B 1\n2

C 2\n3

D 0\n1

💡 Hint

Remember closures are reference types and share captured variables.

Both counter1 and counter2 refer to the same closure instance, so the count variable is shared. The first call increments to 1, the second increments to 2.

🚀 Application

expert

How many unique closure instances are created here?

Given the code below, how many unique closure instances exist after execution?

Swift

func createClosure() -> () -> Int {
    var value = 0
    return {
        value += 1
        return value
    }
}

let c1 = createClosure()
let c2 = createClosure()
let c3 = c1
let c4 = c2
let c5 = c1

A 2

B 3

C 5

D 4

💡 Hint

Closures created by separate calls to createClosure() are unique instances.

Each call to createClosure() creates a new closure instance. c1 and c3 and c5 refer to the same instance, and c2 and c4 refer to another. So there are 2 unique closure instances.