Transforming Streams

Akka Streams provides a rich set of operators on Source and Flow that mirror Scala's collection API but run asynchronously and respect backpressure.

Each operator returns a new blueprint, so transformations are composed declaratively before the stream ever runs.

map applies a synchronous function to every element; filter drops elements that fail a predicate. These are the workhorses of element-wise transformation.

Both preserve ordering and propagate completion and failure downstream.

When one input should produce several outputs, use mapConcat. It takes a function returning an iterable and flattens the results into the stream.

Returning an empty collection effectively drops the element.

grouped(n) batches consecutive elements into a Seq of up to n items, useful for bulk database writes. sliding(n) emits overlapping windows.

Batching reduces per-element overhead in I/O-heavy pipelines.

scan emits the running accumulator after each element, giving an evolving state stream. fold emits only the final accumulated value once upstream completes.

Use scan for live counters and fold for terminal aggregates.

mapAsync(parallelism) calls a function returning a Future and emits results in order, running up to parallelism futures concurrently.

Use it for asynchronous calls like database lookups or HTTP requests where ordering matters.

mapAsyncUnordered behaves like mapAsync but emits each result as soon as it completes, ignoring input order.

It can improve throughput when downstream does not care about ordering, since a slow future no longer blocks faster ones.

For per-element transformations that need mutable local state, statefulMapConcat creates fresh state per materialization and returns an iterable of outputs.

It is the safe way to keep counters or buffers without sharing state across stream runs.

Streams can transform on time as well as content. throttle caps the emission rate, groupedWithin batches by size or elapsed time, and takeWithin limits duration.

These are essential for rate-limiting external APIs.

A thrown exception inside an operator fails the whole stream by default. A supervision strategy can instead resume (drop the bad element) or restart the stage.

Attach the strategy with withAttributes on the Flow.

Small Flows compose into larger ones with via, producing a single reusable Flow. This keeps each transformation focused and independently testable.

The composed Flow has the input type of the first and the output type of the last.

Consider asynchronous transformations and their ordering guarantees.

You explored transformation operators: element-wise map/filter, one-to-many mapConcat, batching grouped, accumulation with scan and fold, and async work via mapAsync.

You also saw stateful transforms, time-based operators like throttle, supervision strategies for errors, and how Flows compose with via. Next: how backpressure keeps these stages safe.