Closures

The same function, five ways

Start with the long form and remove one thing at a time. Every version below does the same job.

let names = ["Charlie", "alice", "Bob"]

// 1. Full form: parameter types, return type, explicit return
names.sorted(by: { (a: String, b: String) -> Bool in
    return a.lowercased() < b.lowercased()
})

// 2. Types inferred from context
names.sorted(by: { a, b in
    return a.lowercased() < b.lowercased()
})

// 3. Single expression: `return` is implicit
names.sorted(by: { a, b in a.lowercased() < b.lowercased() })

// 4. Shorthand argument names
names.sorted(by: { $0.lowercased() < $1.lowercased() })

// 5. Trailing closure: the last argument moves outside the parentheses
names.sorted { $0.lowercased() < $1.lowercased() }

Version 5 is what you will write, and version 1 is what it means. When a closure gets confusing, expanding it back toward version 1 is usually enough to see what is going on.

Trailing closure syntax

If the final argument is a closure, it can move outside the parentheses. If it is the only argument, the parentheses disappear entirely.

items.forEach({ print($0) })   // ordinary
items.forEach { print($0) }    // trailing

Multiple trailing closures get labels after the first:

UIView.animate(withDuration: 0.3) {
    view.alpha = 0
} completion: { finished in
    view.removeFromSuperview()
}

This syntax is the reason SwiftUI reads the way it does. VStack { … } is a function call whose only argument is a closure that builds the contents. Once you see that, SwiftUI's syntax stops looking like a special language feature and starts looking like ordinary Swift.

Capturing

A closure captures the variables it refers to from its surrounding scope, and keeps them alive for as long as the closure lives.

Two things worth noticing:

1. count outlives makeCounter. The closure holds it.
2. first and second have separate counts. Each call to makeCounter creates a fresh count, and each closure captures its own.

Capture is by reference, not by value: the closure sees the variable, not a snapshot of it.

Escaping closures

By default, Swift assumes a closure is used and discarded before the function returns. If you store it for later — in a property, an array, a completion handler — you must mark it @escaping:

var handlers: [() -> Void] = []

func register(_ handler: @escaping () -> Void) {
    handlers.append(handler)   // stored: outlives the call
}

This is not bureaucracy. An escaping closure keeps everything it captured alive, which is where retain cycles come from — the subject of a later lesson. Marking it makes that cost visible.

When self is a class instance, an escaping closure also forces you to acknowledge the capture — write self. explicitly at each use, or put self in the capture list — precisely so the capture is impossible to miss. (Structs and enums are exempt: their self is a value, so implicit access stays allowed.)

Capture lists

A capture list, in square brackets before the parameters, changes how something is captured:

// Capture the value as it is now, not as it will be
let snapshot = { [count] in print(count) }

// Do not keep `self` alive — the standard fix for retain cycles
let handler = { [weak self] in self?.refresh() }

[weak self] makes self optional inside the closure, so the closure no longer prevents the object from being deallocated. You will write this constantly in UIKit and in any long-lived callback. Lesson S3-02 covers exactly when it is required.