> ## 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 Async Let
`async let` is a structured concurrency construct in Swift that creates a concurrent child task and binds its future result to a local constant. It allows the parent task to initiate an asynchronous operation and immediately continue execution, deferring the suspension point (`await`) until the bound variable is explicitly accessed.
## Syntax
The declaration prefixes the `let` keyword with `async`. The right-hand side must be an asynchronous expression.
```swift theme={"dark"}
async let constantName = asynchronousFunction()
// Execution continues immediately without suspending
// Await is required at the point of access
let resolvedValue = await constantName
```
## Execution Mechanics
* **Implicit Task Spawning:** When the Swift runtime encounters an `async let` declaration, it spawns a new child task to evaluate the right-hand side expression.
* **Non-blocking Declaration:** The declaration itself is not a suspension point. The parent task does not yield the thread; it continues executing the subsequent lines of code synchronously.
* **Deferred Suspension:** The `await` keyword is enforced only when reading the variable. If the child task has finished by the time the variable is accessed, the parent task retrieves the value without suspending. If the child task is still running, the parent task suspends at the `await` point until the value is resolved.
* **Immutability:** The construct is strictly limited to constants. `async var` is not supported by the Swift compiler.
## Error Handling
If the asynchronous function being called can throw an error, the `try` keyword is omitted at the declaration site. The error is not evaluated until the value is demanded. Therefore, `try await` must be used at the access site.
```swift theme={"dark"}
// Declaration omits 'try'
async let throwingTask = throwingAsynchronousFunction()
// Access requires 'try await'
let result = try await throwingTask
```
## Structured Concurrency and Lifecycle
`async let` is deeply integrated into Swift's structured concurrency model, meaning the spawned task is strictly bound to the lexical scope in which it is declared.
* **Parent-Child Relationship:** The spawned task is a recognized child of the current task. It inherits task-local values and the priority of the parent task.
* **Implicit Cancellation:** If the parent scope exits before the `async let` variable is awaited—whether due to a `return` statement, a thrown error from another operation, or reaching the end of the block—Swift automatically signals cancellation to the unawaited child task.
* **Implicit Await on Exit:** To guarantee that no orphaned tasks leak, the Swift compiler inserts an implicit `await` at the end of the scope for any unawaited `async let` tasks. The parent scope will not fully exit until the cancelled child task has finished its execution.
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
