Does AsyncStream Replace Combine? No.

Find out why the latest and greatest hammer in the Swift toolbox might not be the best tool for a given job.

Photo by Daniel Olah on Unsplash

Over the last few years, Swift developers have been slowly shifting from Combine to Swift Concurrency and async/await for handling events and asynchronous workflows.

With async/await, you’re no longer wiring together chains of closures or Combine operators or nested completion handlers.

Instead, you’re writing logic that reads from top to bottom, just like synchronous code.

It’s easier to follow, it’s easier to reason about, and it’s usually easier to debug.

The advantages were pretty clear.

But that wasn’t the only thing Swift Concurrency brought to the party.

AsyncSequence

AsyncSequence is a protocol in Swift Concurrency that represents a sequence of values that are produced asynchronously over time.

Conceptually, it seems to do a lot of the same things that Combine does.

From a coding standpoint, it’s similar to Sequence. But instead of pulling values using for-in, you use for await-in to consume elements as they become available, which allows the loop to suspend until the next value is emitted.

Text("Sample")
    .task {
        for await item in viewModel.items {
            handle(item: item)
        }
    }

This makes it ideal for modeling streams of data or events—such as user input, network responses, or timers—where values arrive incrementally and without blocking.

The syntax is cleaner. The control flow is linear. The “vibe” is more modern.

And as such, there’s an understandable pull toward abandoning Combine and publishers altogether in favor of for await loops and AsyncStreams.

But are they actually better?

Let’s break it down.

Combine

Combine, despite its somewhat steep learning curve, is still an extremely efficient tool for modeling ongoing streams of values.