Transforming AsyncStream with Swift Async Algorithms

When we explored how we can use AsyncStream to implement reactive-style listening patterns, we also talked about one of its limitations: Swift's standard library doesn’t include many operators for transforming or combining asynchronous values.

That's where the Swift Async Algorithms package comes in. It extends the AsyncSequence protocol with operators like debounce, throttle, merge, and combineLatest, bringing Combine-like expressiveness to Swift concurrency.

Let's look at how this works.

Architecture & Design Patterns for iOS

This book is a practical guide to essential architectural principles and design patterns for iOS development. It covers strategies for building maintainable apps with Swift and SwiftUI, including dependency injection, navigation, common patterns, and modularization.

LEARN MORE

Why it's not part of the Swift standard library (yet)

The Swift Async Algorithms package is developed and maintained by Apple as part of the official Swift open-source project: https://github.com/apple/swift-async-algorithms.

Apple uses these standalone "incubation" packages to evolve and stabilize new APIs before locking them into the language. Once a package's design has matured, it may eventually become part of Swift itself.

So to use it, we currently need to add it to our project, for example via Swift Package Manager.

Useful operators the package provides

The Swift Async Algorithms package includes many familiar operators from the reactive programming world, built to fit into Swift's async/await model. Here are some examples:

• debounce(for:clock:) - delays emissions until a pause in values
• throttle(for:clock:) - limits how often new values are emitted
• merge(::) - merges multiple async sequences into one
• combineLatest(::) - emits pairs of the latest values from two sequences
• zip(::) – pairs values from two sequences positionally
• buffer(policy:) - controls how to handle slow consumers
• chain(::) - sequences two async sequences one after another
• latest(::) - keeps only the most recent value from each source

Because AsyncStream conforms to AsyncSequence, all operators in Swift Async Algorithms automatically work with it.

Example: Debouncing user input

Let's look at a common use case: debouncing text input to avoid triggering too many requests while a user types:

searchTask = Task {
    for await query in await searchInput.stream()
        .debounce(for: .seconds(0.5), clock: .continuous)
        .removeDuplicates()
    {
        await performSearch(for: query)
    }
}

Here, searchInput is the AsyncPassthrough we have built in this article.

With this setup, when the user types into a search field, performSearch only fires once the user stops typing for half a second. This pattern mirrors Combine's .debounce operator.

Example: Combining streams

Another area where reactive programming shines is combining multiple streams. Let's see how the merge operator can be applied:

import AsyncAlgorithms

let numbers = AsyncStream<Int> { continuation in
    Task {
        for i in 1...3 {
            continuation.yield(i)
            try await Task.sleep(for: .milliseconds(300))
        }
        continuation.finish()
    }
}

let letters = AsyncStream<String> { continuation in
    Task {
        for char in ["A", "B", "C"] {
            continuation.yield(char)
            try await Task.sleep(for: .milliseconds(500))
        }
        continuation.finish()
    }
}

Task {
    for await value in merge(numbers, letters) {
        print("Received:", value)
    }
}

The result is an interleaved async sequence that emits values as they arrive.

Beyond operators: AsyncChannel

In addition to operators, the package also provides new async types such as AsyncChannel. We'll explore it in a follow-up article.