> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Swift Escaping Closure An escaping closure is a closure passed as an argument to a function that is invoked *after* the function has returned. It outlives the execution scope of the function it was passed into, requiring the compiler to allocate the closure and its captured environment on the heap rather than the stack. By default, all closure parameters in Swift are non-escaping. To indicate that a closure is allowed to escape the function's scope, you must explicitly annotate the parameter type with the `@escaping` attribute. ## Syntax The `@escaping` attribute is placed directly before the closure's type signature in the function declaration. ```swift theme={"dark"} func performDeferredAction(action: @escaping () -> Void) { // The closure is stored or dispatched to outlive this function's execution } ``` ## Technical Mechanics A closure "escapes" a function under two primary conditions: 1. **Storage:** The closure is assigned to a variable, property, or data structure defined outside the function's local scope. 2. **Asynchronous Execution:** The closure is dispatched to a different thread or queue where its execution is deferred until after the original function completes. ```swift theme={"dark"} class ClosureHandler { // Property exists outside the function scope var storedClosure: (() -> Void)? func assignClosure(closure: @escaping () -> Void) { // The closure escapes because it is retained by the class property self.storedClosure = closure } } ``` ## Memory Semantics and Capture Rules Because an escaping closure is allocated on the heap, it maintains strong references to any variables or object instances it captures from its surrounding context. **Reference Types:** When capturing `self` within an instance of a class, escaping closures introduce the risk of strong reference cycles (memory leaks). To enforce memory safety, the Swift compiler mandates explicit acknowledgment of `self` within escaping closures for reference types. You must either write `self.` explicitly or capture `self` in the closure's capture list. ```swift theme={"dark"} class ContextManager { var state: Int = 0 let handler = ClosureHandler() func configure() { // The compiler requires explicit 'self' capture handling // because the escaping closure will retain the class instance on the heap. handler.assignClosure { [weak self] in guard let self = self else { return } self.state = 1 } } } ``` **Value Types:** As of Swift 5.3, value types (structs and enums) do not require explicit `self` acknowledgment in escaping closures. The closure captures a copy of the value type instance. However, if the value type contains properties that are reference types, the captured copy will retain those references. This means reference cycles can still occur if the value type holds a reference to an object that, in turn, retains the closure. ```swift theme={"dark"} struct ValueContext { var state: Int = 0 // The handler is passed in rather than stored as a property, // preventing the struct copy from retaining the handler. func readState(using handler: ClosureHandler) { // Implicit 'self' is permitted for value types. // The closure captures a copy of the 'ValueContext' struct. handler.assignClosure { print(state) } } } ``` ## `inout` Parameters and Mutating Constraints A fundamental constraint of escaping closures is that they **cannot capture `inout` parameters**. This is because the `inout` variable is only guaranteed to be valid for the duration of the function call; an escaping closure executing later would access invalid memory. Non-escaping closures do not have this restriction. Consequently, an escaping closure cannot capture `self` inside a `mutating` method of a struct or enum. In Swift, `self` is implicitly passed as an `inout` parameter to `mutating` methods, making it illegal to capture within an escaping context. ```swift theme={"dark"} struct MutatingContext { var state: Int = 0 mutating func configure(using handler: ClosureHandler) { // ERROR: Escaping closure cannot capture a mutating 'self' parameter /* handler.assignClosure { self.state = 1 } */ } } ``` ## Additional Constraints * **Optional Closures:** Closures wrapped in an `Optional` type (e.g., `(() -> Void)?`) are implicitly escaping. The `@escaping` attribute is invalid on optional closures because the optional wrapper itself is an enumeration (`enum Optional`), meaning the closure is stored as an associated value, inherently escaping the function scope. * **Type Aliases:** If a closure type is defined via a `typealias`, you cannot apply `@escaping` to the type alias declaration. The attribute must be applied at the call site where the type alias is used as a parameter.
Tired of Poor Swift Skills? Fix That With Deep Grasping! Learn More