Functions and closures in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a closure capturing a variable

What will be printed when this Swift code runs?

iOS Swift

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

let incrementByTen = makeIncrementer(amount: 10)
print(incrementByTen())
print(incrementByTen())

A 10\n20

B 0\n10

C 10\n10

D 20\n30

💡 Hint

Closures can capture and modify variables from their surrounding context.

The closure captures the variable 'total' and adds 'amount' each time it is called. The first call adds 10 to 0, returning 10. The second call adds 10 to 10, returning 20.

❓ ui_behavior

intermediate

Closure as a button action handler

In SwiftUI, what happens when this button is tapped?

iOS Swift

struct ContentView: View {
  @State private var count = 0
  var body: some View {
    Button(action: {
      count += 1
    }) {
      Text("Tap count: \(count)")
    }
  }
}

A The button label updates to show the number of taps.

B The button does nothing when tapped.

C The app crashes due to state mutation in closure.

D The button label shows a fixed number 0 always.

💡 Hint

State variables update the UI when changed inside closures.

The closure increments the @State variable 'count' on each tap, causing the view to update and show the new count.

❓ lifecycle

advanced

Memory management with closures

What problem can occur with this Swift code involving closures?

iOS Swift

class ViewController {
  var completionHandler: (() -> Void)?
  func setup() {
    completionHandler = {
      print(self)
    }
  }
}

A No problem; closure captures 'self' weakly by default.

B Closure runs before 'self' is initialized causing crash.

C Strong reference cycle causing memory leak.

D Compilation error due to missing capture list.

💡 Hint

Closures capture variables strongly unless specified otherwise.

The closure captures 'self' strongly, and 'self' holds the closure, creating a retain cycle that prevents deallocation.

📝 Syntax

advanced

Correct syntax for a closure with parameters and return value

Which option correctly defines a closure that takes two Ints and returns their sum?

A let sum = { (a, b) -> Int in a + b }

B let sum = { (a: Int, b: Int) -> Int in return a + b }

C let sum = { a, b in a + b }

D let sum = (a: Int, b: Int) -> Int { a + b }

💡 Hint

Closures with parameters and return types need 'in' keyword separating parameters and body.

Option B uses the full closure syntax with parameter types, return type, and 'in' keyword correctly. Option B is invalid syntax. Option B lacks parameter types and return type, so it won't compile. Option B lacks parameter types, causing a compile error.

🔧 Debug

expert

Why does this closure cause a crash?

This Swift code crashes at runtime. What is the cause?

iOS Swift

class Example {
  var closure: (() -> Void)?
  func configure() {
    closure = { [unowned self] in
      print(self.description)
    }
  }
}

var example: Example? = Example()
example?.configure()
let capturedClosure = example!.closure!
example = nil
capturedClosure()

A No crash; code runs and prints description.

B Closure is nil so calling it crashes.

C Unowned capture causes compile-time error.

D Accessing 'self' after it was deallocated causes a crash.

💡 Hint

Unowned references do not keep the object alive and cause crash if accessed after deallocation.

The closure captures 'self' as unowned. After 'example' is set to nil, 'self' is deallocated. Calling the closure tries to access a deallocated object, causing a runtime crash.