Mastering Closures in Swift: A Comprehensive Guide

Closures are self-contained blocks of functionality that can be passed around and used in your code. They are a fundamental building block in Swift, enabling elegant and concise solutions for a wide range of programming tasks, from asynchronous operations to UI event handling. This guide explores the intricacies of closures, providing a robust understanding for every Apple developer.

What Are Closures?

At their core, closures in Swift are similar to blocks in C and Objective-C, and to lambdas in other programming languages. They capture and store references to any constants and variables from the context in which they are defined. This capability is known as capturing values, and it allows the closure to access and modify those values even when the original scope is no longer available.

They can take parameters and return values, just like functions. Swift's syntax for closures is optimized for clarity and conciseness, allowing for several shorthand forms depending on the context in which they are used.

Closure Expression Syntax

The full, general form of a closure expression in Swift is:

{ (parameters) -> returnType in
    statements
}

Let's break down the components:

• { ... }: The curly braces enclose the closure's body.
• (parameters): A comma-separated list of input parameters.
• -> returnType: Indicates the type of value the closure will return.
• in: This keyword separates the parameter and return type definition from the closure's body. Everything before in is the closure's header, everything after is its body.

Basic Example

Consider a simple array sorting example:

let names = ["Chris", "Alex", "Ewa", "Barry", "Dani"]

func backwards(_ s1: String, _ s2: String) -> Bool {
    return s1 > s2
}

var reversedNames = names.sorted(by: backwards)
// reversedNames is ["Ewa", "Dani", "Chris", "Barry", "Alex"]

Using a closure expression for the same sorting logic:

reversedNames = names.sorted(by: {\ (s1: String, s2: String) -> Bool in
    return s1 > s2
})
// reversedNames is ["Ewa", "Dani", "Chris", "Barry", "Alex"]

While this syntax might seem verbose, Swift provides numerous ways to shorten it, making closures incredibly powerful and readable.

Shorthand Forms of Closures

Swift's type inference and context make many elements of closure syntax optional. This leads to several shorthand forms, enhancing code conciseness.

1. Inferring Type From Context

Because the sorted(by:) method expects a closure of type (String, String) -> Bool, Swift can infer the types of s1 and s2, as well as the return type. This allows you to omit them:

reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 })

2. Implicit Returns from Single-Expression Closures

If the closure's body consists of a single expression, Swift can implicitly return the result of that expression without the need for the return keyword:

reversedNames = names.sorted(by: { s1, s2 in s1 > s2 })

3. Shorthand Argument Names

Swift automatically provides shorthand argument names to inline closures: $0, $1, $2, and so on, for the closure's first, second, and subsequent arguments. If you use these shorthand argument names, you can omit the argument list and the in keyword entirely:

reversedNames = names.sorted(by: { $0 > $1 })

This is a very common and highly idiomatic way to write simple closures in Swift.

4. Operator Methods

Swift's String type defines its own implementation of the greater-than operator (>) as a method that takes two String parameters and returns a Bool. You can pass this operator directly to the sorted(by:) method:

reversedNames = names.sorted(by: >)
// This works because the `>` operator function has the signature (String, String) -> Bool

This is the most concise form for this particular use case.

Trailing Closures

If you need to pass a closure expression to a function as its last argument, and the closure expression is long, it can be useful to write it as a trailing closure. A trailing closure is written after the function call's parentheses, even if the closure is the function's only argument.

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // function body goes here
}

// Here's how you call this function without using a trailing closure:
someFunctionThatTakesAClosure(closure: {
    // closure body goes here
})

// Here's how you call this function with a trailing closure:
someFunctionThatTakesAClosure() {
    // trailing closure body goes here
}

When a closure is the only argument to a function, you can omit the parentheses completely after the function name:

reversedNames = names.sorted {
    $0 > $1
}

Trailing closures are extensively used in SwiftUI, asynchronous programming, and many other areas of iOS development for readability.

Capturing Values

A closure can capture constants and variables from the surrounding context in which it's defined. The closure can then refer to and modify the values of those constants and variables from within its body, even if the original scope has ceased to exist.

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

let incrementByTen = makeIncrementer(forIncrement: 10)
print(incrementByTen()) // Prints: 10
print(incrementByTen()) // Prints: 20
print(incrementByTen()) // Prints: 30

let incrementBySeven = makeIncrementer(forIncrement: 7)
print(incrementBySeven()) // Prints: 7
print(incrementByTen()) // Prints: 40 (incrementByTen still refers to its own runningTotal)

In this example, incrementer is a nested function (which is a form of closure). It captures runningTotal and amount from its surrounding context. It 'closes over' these variables, making them available even after makeIncrementer has finished executing.

Escaping Closures

A closure is said to escape a function when it is called after the function returns. When you declare a closure parameter, you can write @escaping before its type to indicate that the closure is allowed to escape. This is crucial when dealing with asynchronous operations, network requests, or storing closures in properties.

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

func functionWithEscapingClosure(completionHandler: @escaping () -> Void) {
    completionHandlers.append(completionHandler)
}

func functionWithNonEscapingClosure(closure: () -> Void) {
    closure() // The closure is executed before the function returns
}

class DataManager {
    var dataFetcher: (@escaping (String) -> Void)?

    func fetchData(completion: @escaping (String) -> Void) {
        // Simulate an asynchronous network request
        DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
            completion("Data successfully fetched!")
        }
    }
}

let manager = DataManager()
manager.fetchData { data in
    print(data)
}
// Output: (After 2 seconds) Data successfully fetched!

If a closure captures self within an escaping closure, you must be explicit about it to avoid strong reference cycles. You can do this by writing self explicitly, or by specifying a capture list.

Auto Closures

An autoclosure is a special type of closure that automatically wraps an expression passed as an argument. The autoclosure doesn't take any arguments, and when it's called, it returns the value of the expression that it wraps. This is primarily a syntactic convenience.

var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Dani"]
print(customersInLine.count) // Prints "5"

func serve(customer customerProvider: () -> String) {
    print("Now serving \(customerProvider())!")
}

serve(customer: { customersInLine.remove(at: 0) })
// Prints "Now serving Chris!"

// Using @autoclosure:
func serve(customer customerProvider: @autoclosure () -> String) {
    print("Now serving \(customerProvider())!")
}

serve(customer: customersInLine.remove(at: 0))
// Prints "Now serving Alex!"
print(customersInLine.count) // Prints "3"

Notice how, with @autoclosure, you can simply pass customersInLine.remove(at: 0) without wrapping it in an explicit closure. The system automatically creates the () -> String closure for you. Autoclosures are useful for deferring the evaluation of an expression in a concise way.

Strong Reference Cycles with Closures

As with classes, closures can cause strong reference cycles if you assign a closure to a property of a class instance, and the closure captures that instance. Swift provides capture lists to resolve this. A capture list defines the rules to use when capturing one or more reference types within the closure's body.

class HTMLElement {

    let name: String
    let text: String?

    lazy var asHTML: () -> String = {
        // This closure captures 'self' strongly by default, creating a strong reference cycle
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit { print("\(name) is being deinitialized") }
}

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello world")
print(paragraph!.asHTML())

paragraph = nil // deinit is never called due to strong reference cycle

To break this cycle, you use a capture list, which can be weak or unowned.

• weak self: Use weak when the captured reference might become nil at some point. The captured reference then becomes an optional and requires optional chaining.

• unowned self: Use unowned when the captured reference will never become nil during the lifetime of the closure. If the unowned reference does become nil, accessing it will cause a runtime error.

class HTMLElementFixed {

    let name: String
    let text: String?

    lazy var asHTML: () -> String = {
        [unowned self] in // Capture list: 'unowned self'
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit { print("\(name) is being deinitialized") }
}

var paragraphFixed: HTMLElementFixed? = HTMLElementFixed(name: "p", text: "hello world")
print(paragraphFixed!.asHTML())

paragraphFixed = nil // deinit is called. Prints: "p is being deinitialized"

Choosing between weak and unowned depends on the relationship between the closure and the instance it captures. If the closure and the instance will always have the same lifetime (i.e., the instance will not be deallocated before the closure), unowned is appropriate. Otherwise, weak is safer.

Conclusion

Closures are a cornerstone of modern Swift development, offering incredible flexibility and power. By mastering their various forms – from full syntax to shorthand, trailing closures, and understanding value capturing, escaping behavior, and strong reference cycle prevention – you unlock a more expressive, concise, and efficient programming style. Embrace closures, and your Swift code will be more robust and elegant.