Franz Busch 8e16632775 [AsyncStreaming] Add bidirectional adapters for the async writers (#424)
* [AsyncStreaming] Add support for final elements

## Motivation

Real transports deliver structured data alongside end-of-stream and need to fuse the last write with the close. HTTP trailers and gRPC status are the obvious cases. Neither can be expressed by an empty-buffer terminator, and both lose H2/H3/QUIC's DATA+END_STREAM coalescing without a fused call.

## Modification

Adds `FinalElement: ~Copyable = Void` as a primary associated type on all four protocols. `AsyncReader` delivers it via a `consuming FinalElement?` closure parameter; `CallerAsyncReader` returns it. Both writers gain a consuming `finish` carrying the last chunk and the payload in one call.

`forEachBuffer`, `collect`, and the `pipe` variants thread the payload through. `collect` becomes consuming and gains a `Void`-final overload returning just the result.

Adds an "Alternatives considered" entry covering what would break without
this: HTTP body, gRPC, and fused close on H2/H3/QUIC.

## Result

The four protocols can back HTTP body, gRPC streaming, and similar shapes without giving up the fused close. Default `Void` keeps simple conformers unchanged; `Never` marks infinite streams. Custom and `~Copyable` payloads work end to end.

* [AsyncStreaming] Add bidirectional adapters for the async writers

## Motivation

It is quite common to have one type of writer and wanting to adapt to the other type of writer.

## Modifications

This PR adds two adapters into either direction between the writers to make conversion seamless.

## Result

It is easy to go from one type of writer to the other type.
2026-06-02 08:16:42 +02:00
2025-03-28 21:59:41 +01:00
2025-03-28 21:59:41 +01:00
2025-03-28 21:59:41 +01:00
2024-01-24 11:28:26 +00:00

swift-async-algorithms

Swift Async Algorithms is an open-source package of asynchronous sequence and advanced algorithms that involve concurrency, along with their related types.

This package has three main goals:

  • First-class integration with async/await
  • Provide a home for time-based algorithms
  • Be cross-platform and open source

Motivation

AsyncAlgorithms is a package for algorithms that work with values over time. That includes those primarily about time, like debounce and throttle, but also algorithms about order like combineLatest and merge. Operations that work with multiple inputs (like zip does on Sequence) can be surprisingly complex to implement, with subtle behaviors and many edge cases to consider. A shared package can get these details correct, with extensive testing and documentation, for the benefit of all Swift apps.

The foundation for AsyncAlgorithms was included in Swift 5.5 from AsyncSequence. Swift 5.5 also brings the ability to use a natural for/in loop with await to process the values in an AsyncSequence and Sequence-equivalent API like map and filter. Structured concurrency allows us to write code where intermediate state is simply a local variable, try can be used directly on functions that throw, and generally treat the logic for asynchronous code similar to that of synchronous code.

This package is the home for these APIs. Development and API design take place on GitHub and the Swift Forums.

Contents

Combining asynchronous sequences

  • chain(_:...): Concatenates two or more asynchronous sequences with the same element type.
  • combineLatest(_:...): Combines two or more asynchronous sequences into an asynchronous sequence producing a tuple of elements from those base asynchronous sequences that updates when any of the base sequences produce a value.
  • merge(_:...): Merges two or more asynchronous sequence into a single asynchronous sequence producing the elements of all of the underlying asynchronous sequences.
  • zip(_:...): Creates an asynchronous sequence of pairs built out of underlying asynchronous sequences.
  • joined(separator:): Concatenated elements of an asynchronous sequence of asynchronous sequences, inserting the given separator between each element.

Creating asynchronous sequences

  • async: Create an asynchronous sequence composed from a synchronous sequence.
  • AsyncChannel: An asynchronous sequence with back pressure sending semantics.
  • AsyncThrowingChannel: An asynchronous sequence with back pressure sending semantics that can emit failures.

Performance optimized asynchronous iterators

  • AsyncBufferedByteIterator: A highly efficient iterator useful for iterating byte sequences derived from asynchronous read functions.

Other useful asynchronous sequences

Asynchronous Sequences that transact in time

Obtaining all values from an asynchronous sequence

Effects

Each algorithm has specific behavioral effects. For throwing effects these can either be if the sequence throws, does not throw, or rethrows errors. Sendability effects in some asynchronous sequences are conditional whereas others require the composed parts to all be sendable to satisfy a requirement of Sendable. The effects are listed here.

Adding Swift Async Algorithms as a Dependency

To use the AsyncAlgorithms library in a SwiftPM project, add the following line to the dependencies in your Package.swift file:

.package(url: "https://github.com/apple/swift-async-algorithms", from: "1.0.0"),

Include "AsyncAlgorithms" as a dependency for your executable target:

.target(name: "<target>", dependencies: [
    .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
]),

Finally, add import AsyncAlgorithms to your source code.

Getting Started

⚠️ Please note that this package requires Xcode 14 on macOS hosts. Previous versions of Xcode do not contain the required Swift version.

Building/Testing Using Xcode on macOS

  1. In the swift-async-algorithms directory run swift build or swift test accordingly

Building/Testing on Linux

  1. Download the most recent development toolchain for your Linux distribution
  2. Decompress the archive to a path in which the swift executable is in the binary search path environment variable ($PATH)
  3. In the swift-async-algorithms directory run swift build or swift test accordingly

Source Stability

The Swift Async Algorithms package has a goal of being source stable as soon as possible; version numbers will follow Semantic Versioning. Source breaking changes to public API can only land in a new major version.

The public API of version 1.0 of the swift-async-algorithms package will consist of non-underscored declarations that are marked public in the AsyncAlgorithms module. Interfaces that aren't part of the public API may continue to change in any release, including patch releases.

Future minor versions of the package may introduce changes to these rules as needed.

We'd like this package to quickly embrace Swift language and toolchain improvements that are relevant to its mandate. Accordingly, from time to time, we expect that new versions of this package will require clients to upgrade to a more recent Swift toolchain release. Requiring a new Swift release will only require a minor version bump.

S
Description
Mirror of github.com/apple/swift-async-algorithms
Readme Apache-2.0
2.6 MiB
0 Stars 1 Watchers 0 Forks
Languages
Swift 99.2%
C++ 0.8%