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.

Practice

1. What is a closure in Swift?
func greet() { print("Hello") }

easy

A. An unnamed block of code that can be stored and passed around

B. A named function that cannot be reused

C. A variable that holds a number

D. A type of loop

Solution

1. Step 1: Understand closure definition

   A closure is a block of code without a name that can be saved and used later.

2. Step 2: Compare with function

   Functions have names, closures do not but both can be reused.

3. Final Answer:

   An unnamed block of code that can be stored and passed around -> Option A

4. Quick Check:

   Closure = unnamed reusable code block [OK]

Hint: Closures are like functions without names [OK]

Common Mistakes:

• Confusing closures with variables
• Thinking closures must have names
• Mixing closures with loops

2. Which of the following is the correct syntax to declare a closure that takes no parameters and returns an Int?

easy

A. let closure = (Int) -> { return 5 }

B. let closure = { () -> Int in return 5 }

C. let closure = func() -> Int { return 5 }

D. func closure() -> Int { return 5 }

Solution

1. Step 1: Identify closure syntax

   Closures use curly braces with parameters and return type before 'in'.

2. Step 2: Check each option

   'let closure = { () -> Int in return 5 }' matches closure syntax. 'func closure() -> Int { return 5 }' declares a named function. 'let closure = func() -> Int { return 5 }' uses invalid syntax. 'let closure = (Int) -> { return 5 }' lacks 'in' keyword and has wrong parameter placement.

3. Final Answer:

   let closure = { () -> Int in return 5 } -> Option B

4. Quick Check:

   Closure syntax = curly braces + 'in' [OK]

Hint: Closures use braces and 'in' keyword [OK]

Common Mistakes:

• Using func keyword inside closure
• Missing 'in' keyword
• Wrong parameter syntax

3. What will be printed by this Swift code?

let multiply = { (a: Int, b: Int) -> Int in
  return a * b
}
print(multiply(3, 4))

medium

A. 34

B. 7

C. 12

D. Error

Solution

1. Step 1: Understand closure parameters and return

   The closure takes two Ints and returns their product.

2. Step 2: Calculate multiply(3, 4)

   3 * 4 equals 12, so print outputs 12.

3. Final Answer:

   12 -> Option C

4. Quick Check:

   3 times 4 = 12 [OK]

Hint: Closures return calculated values like functions [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Syntax errors in closure call

4. Identify the error in this closure declaration:

let add = { (a: Int, b: Int) Int in
  return a + b
}

medium

A. Missing '->' before return type

B. Missing 'in' keyword

C. Parameters should not have types

D. Closure cannot return Int

Solution

1. Step 1: Check closure signature syntax

   Return type must be preceded by '->' in closure signature.

2. Step 2: Identify missing arrow

   Code has '(a: Int, b: Int) Int' but should be '(a: Int, b: Int) -> Int'.

3. Final Answer:

   Missing '->' before return type -> Option A

4. Quick Check:

   Closure return type needs '->' [OK]

Hint: Return type needs '->' before it in closures [OK]

Common Mistakes:

• Omitting '->' in closure signature
• Placing 'in' incorrectly
• Removing parameter types

5. You want to sort an array of names alphabetically using a closure. Which code correctly uses a closure with the sorted(by:) method?

hard

A. let sortedNames = names.sorted(by: { s1, s2 -> Bool { return s1 > s2 } })

B. let sortedNames = names.sorted(by: { s1, s2 in s1 + s2 })

C. let sortedNames = names.sorted(by: (s1, s2) -> s1 < s2)

D. let sortedNames = names.sorted(by: { s1, s2 in s1 < s2 })

Solution

1. Step 1: Understand sorted(by:) closure

   It expects a closure that returns true if first element should come before second.

2. Step 2: Check each option

   'let sortedNames = names.sorted(by: { s1, s2 in s1 < s2 })' returns true when s1 < s2 (correct for ascending alphabetical order). The version with s1 > s2 sorts descending. The version with (s1, s2) -> s1 < s2 uses invalid syntax without braces or 'in'. The version with s1 + s2 returns String, not Bool.

3. Final Answer:

   let sortedNames = names.sorted(by: { s1, s2 in s1 < s2 }) -> Option D

4. Quick Check:

   sorted(by:) needs Bool-returning closure [OK]

Hint: sorted(by:) needs closure returning true/false [OK]

Common Mistakes:

• Returning wrong type from closure
• Using wrong comparison operator
• Incorrect closure syntax