Closures

Code

import Foundation

// Closure expression
let add: (Int, Int) -> Int = { a, b in a + b }
print(add(2, 3))

// Trailing closure syntax
let doubled = [1, 2, 3].map { $0 * 2 }
print(doubled)

// Sorted with closure
let sorted = [3, 1, 2].sorted(by: >)
print(sorted)

// Capture semantics
func makeCounter() -> () -> Int {
    var count = 0
    return { count += 1; return count }   // captures by reference
}
let counter = makeCounter()
print(counter(), counter(), counter())    // 1 2 3

// Escaping closure stored for later
class Loader {
    var completions: [(String) -> Void] = []
    func register(_ block: @escaping (String) -> Void) {
        completions.append(block)
    }
    func fire() { completions.forEach { $0("done") } }
}

let loader = Loader()
loader.register { msg in print("got \(msg)") }
loader.fire()

Explanation

Closures are self-contained blocks of functionality that capture their surrounding scope. Trailing closure syntax makes higher-order calls like map and sorted read naturally. @escaping marks closures that outlive the function they are passed to, which the compiler requires for stored callbacks.

More Swift Snippets