> ## 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 Autoclosure
An `@autoclosure` is a parameter attribute that automatically wraps an expression passed as an argument into a parameterless closure. It allows the caller to omit explicit closure syntax (curly braces) at the call site while preserving the deferred execution semantics of a closure.
When a function parameter is marked with `@autoclosure`, the Swift compiler intercepts the passed expression and encapsulates it within a closure of type `() -> T`, where `T` is the return type of the expression. The expression is not evaluated at the point of the function call; instead, evaluation is deferred until the closure is explicitly invoked within the function's body.
## Syntax and Compiler Transformation
Without `@autoclosure`, passing an expression that requires deferred execution mandates explicit closure syntax:
```swift theme={"dark"}
func standardClosure(evaluate: () -> Bool) {
let result = evaluate()
}
// The caller must explicitly wrap the expression in {}
standardClosure(evaluate: { 2 > 1 })
```
By applying `@autoclosure`, the compiler automatically performs the wrapping operation, allowing the caller to pass a standard expression:
```swift theme={"dark"}
func autoClosure(evaluate: @autoclosure () -> Bool) {
let result = evaluate()
}
// The compiler transforms `2 > 1` into `{ 2 > 1 }`
autoClosure(evaluate: 2 > 1)
```
## Technical Constraints and Characteristics
* **Parameterless Requirement:** An autoclosure must always take zero arguments. The type signature must strictly follow the pattern `() -> T`. It is a compile-time error to apply `@autoclosure` to a closure that accepts parameters (e.g., `(Int) -> T`).
* **Deferred Evaluation:** The wrapped expression is only executed if and when the function's internal logic invokes the closure. If the function returns before calling the closure, the expression is never evaluated.
* **Non-Escaping Default:** By default, closures marked with `@autoclosure` are non-escaping, meaning they cannot outlive the scope of the function they are passed into.
## Escaping Autoclosures
If the autoclosure needs to be stored in a property, appended to a collection, or executed asynchronously, it must be explicitly marked with the `@escaping` attribute alongside `@autoclosure`. Order does not matter, but convention places `@autoclosure` first.
```swift theme={"dark"}
var deferredOperations: [() -> String] = []
// Requires both attributes to allow the closure to leave the function scope
func queueOperation(_ operation: @autoclosure @escaping () -> String) {
deferredOperations.append(operation)
}
queueOperation("Operation Pending")
```
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
