Skip to main content

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.

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: 
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: 
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. 
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")
Master Swift with Deep Grasping Methodology!Learn More