<!--
{
  "availability" : [
    "iOS: 13.0.0 -",
    "iPadOS: 13.0.0 -",
    "macCatalyst: 13.0.0 -",
    "macOS: 10.15.0 -",
    "tvOS: 13.0.0 -",
    "visionOS: 1.0.0 -",
    "watchOS: 6.0.0 -"
  ],
  "documentType" : "symbol",
  "framework" : "Swift",
  "identifier" : "/documentation/Swift/AsyncThrowingStream/init(_:bufferingPolicy:_:)",
  "metadataVersion" : "0.1.0",
  "role" : "Initializer",
  "symbol" : {
    "kind" : "Initializer",
    "modules" : [
      "Swift"
    ],
    "preciseIdentifier" : "s:Scs_15bufferingPolicy_Scsyxs5Error_pGxm_Scs12ContinuationV09BufferingB0OyxsAB_p__GyAEyxsAB_p_GXEtcsAB_pRs_rlufc"
  },
  "title" : "init(_:bufferingPolicy:_:)"
}
-->

# init(_:bufferingPolicy:_:)

Constructs an asynchronous stream for an element type, using the
specified buffering policy and element-producing closure.

```
init(_ elementType: Element.Type = Element.self, bufferingPolicy limit: AsyncThrowingStream<Element, Failure>.Continuation.BufferingPolicy = .unbounded, _ build: (AsyncThrowingStream<Element, Failure>.Continuation) -> Void) where Failure == any Error
```

## Parameters

`elementType`

The type of element the `AsyncThrowingStream`
produces.

`limit`

The maximum number of elements to
hold in the buffer. By default, this value is unlimited. Use a
`Continuation.BufferingPolicy` to buffer a specified number of oldest
or newest elements.

`build`

A custom closure that yields values to the
`AsyncThrowingStream`. This closure receives an
`AsyncThrowingStream.Continuation` instance that it uses to provide
elements to the stream and terminate the stream when finished.

## Discussion

The `AsyncStream.Continuation` received by the `build` closure is
appropriate for use in concurrent contexts. It is thread safe to send and
finish; all calls to the continuation are serialized. However, calling
this from multiple concurrent contexts could result in out-of-order
delivery.

The following example shows an `AsyncStream` created with this
initializer that produces 100 random numbers on a one-second interval,
calling `yield(_:)` to deliver each element to the awaiting call point.
When the `for` loop exits, the stream finishes by calling the
continuation’s `finish()` method. If the random number is divisible by 5
with no remainder, the stream throws a `MyRandomNumberError`.

```
let stream = AsyncThrowingStream<Int, Error>(Int.self,
                                             bufferingPolicy: .bufferingNewest(5)) { continuation in
    Task.detached {
        for _ in 0..<100 {
            await Task.sleep(1 * 1_000_000_000)
            let random = Int.random(in: 1...10)
            if random % 5 == 0 {
                continuation.finish(throwing: MyRandomNumberError())
                return
            } else {
                continuation.yield(random)
            }
        }
        continuation.finish()
    }
}

// Call point:
do {
    for try await random in stream {
        print(random)
    }
} catch {
    print(error)
}
```

---

Copyright &copy; 2026 Apple Inc. All rights reserved. | [Terms of Use](https://www.apple.com/legal/internet-services/terms/site.html) | [Privacy Policy](https://www.apple.com/privacy/privacy-policy)