Context

In the Allegiant mobile app, closures are common in async networking, UI callbacks, and view model bindings. A Mobile Engineer should understand how Swift memory management interacts with closures to prevent leaks.

Core Question

Explain how you manage memory and avoid retain cycles when using closures in Swift.

Your answer should cover:

1. How closures capture values and references under ARC.
2. How a retain cycle forms between an object and a closure stored by that object or another long-lived object.
3. When to use [weak self] versus [unowned self], and how to safely handle each.
4. How you would reason about common Allegiant app cases, such as network completion handlers, timers, and view controller callbacks.

Scope Guidance

The interviewer expects a practical engineering explanation, not just definitions. You should describe what happens under the hood, show short Swift examples, explain trade-offs, and mention common mistakes such as overusing weak, force-unwrapping self, or assuming every closure creates a cycle.

Automatic Reference Counting (ARC)

Swift uses ARC to track strong references to class instances. When the strong reference count reaches zero, the instance is deallocated. Memory leaks occur when strong references keep objects alive longer than intended.

class FlightSearchViewModel {
    deinit { print("deallocated") }
}

Closure Capture Semantics

Closures capture variables from their surrounding scope. If a closure captures self strongly and the closure is also retained by self or another object retained by self, a retain cycle can form.

class BookingViewController {
    var onRefresh: (() -> Void)?

    func bind() {
        onRefresh = {
            self.loadTrips()
        }
    }
}

Weak References

weak references do not increase the reference count and automatically become nil when the object is deallocated. They are appropriate when the captured object may disappear before the closure runs.

onRefresh = { [weak self] in
    self?.loadTrips()
}

Unowned References

unowned also avoids increasing the reference count, but it assumes the referenced object will still exist when accessed. It is useful when lifetimes are tightly coupled, but it will crash if the object has already been deallocated.

lazy var formatter: () -> String = { [unowned self] in
    return self.title
}

Not Every Closure Causes a Cycle

A closure only causes a retain cycle when there is a reference path back to the owning object. Short-lived closures passed to APIs and not retained after execution often do not create cycles, though they may still extend object lifetime temporarily.

apiClient.fetchTrips { result in
    self.handle(result)
}