> ## 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 Attribute
The `@autoclosure` attribute is a parameter declaration modifier in Swift that automatically wraps an expression passed as an argument into a parameterless closure. It provides syntactic sugar by allowing the caller to omit the explicit closure braces `{}` at the call site, while preserving the deferred execution semantics inherent to closures.
## Syntax and Mechanics
When a function parameter is annotated 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.
```swift theme={"dark"}
// Standard closure parameter
func standardClosure(_ predicate: () -> Bool) {
_ = predicate()
}
standardClosure({ 5 > 3 }) // Requires explicit braces
// Autoclosure parameter
func autoClosure(_ predicate: @autoclosure () -> Bool) {
let result = predicate()
print(result)
}
autoClosure(5 > 3) // Braces are omitted; compiler wraps the expression
```
## Technical Constraints and Behavior
* **Signature Requirement:** The attribute can only be applied to closures that take no arguments. Applying `@autoclosure` to a closure type that requires parameters (e.g., `(Int) -> Bool`) will result in a compiler error.
* **Deferred Evaluation:** The expression passed as the argument is not evaluated at the time of the function call. Evaluation is strictly deferred until the closure is explicitly invoked within the function body. If the closure is never called, the expression is never evaluated.
* **Escaping Contexts:** By default, closures created by `@autoclosure` are non-escaping. If the wrapped expression needs to outlive the scope of the function (e.g., stored in a property or executed asynchronously), the parameter must be annotated with both `@autoclosure` and `@escaping`.
```swift theme={"dark"}
var deferredOperations: [() -> Void] = []
// Requires @escaping to append to an external array
func queueOperation(_ operation: @autoclosure @escaping () -> Void) {
deferredOperations.append(operation)
}
queueOperation(print("Operation queued"))
```
* **Error Handling:** If the expression being wrapped can throw an error, the autoclosure must be marked with `throws`. The `try` keyword is placed at the call site of the function, not inside the omitted closure braces.
```swift theme={"dark"}
func someThrowingFunction() throws -> Int {
return 42
}
func evaluateThrowing(_ expression: @autoclosure () throws -> Int) rethrows -> Int {
return try expression()
}
// The 'try' is applied to the function call, but applies to the deferred expression
let result = try evaluateThrowing(someThrowingFunction())
print(result)
```
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
