Declarative Operator Composition

Declarative operator composition is the practice of building stream-processing pipelines by chaining pure transformation functions—`map`, `filter`, `scan`, `reduce`, `take`, `skip`, `distinctUntilChanged`—rather than writing imperative loops with mutable state. The result is code that reads as a description of what happens to data, not how the machinery manages it. RxJS formalizes this with `pipe()`, which accepts a variadic list of operators and returns a new Observable. Each operator in the chain is a function from `Observable<T>` to `Observable<U>`, making the pipeline type-safe and trivially testable in isolation. Reactor's `Flux` API exposes the same pattern through method chaining: `Flux.from(publisher).map(...).filter(...).scan(...)`. Kotlin Flow's operators—`map`, `filter`, `transform`, `onEach`—are all `suspend` functions, making them safe for use inside coroutine scopes without blocking threads. The TC39 async-iterator-helpers proposal (Stage 2 as of mid-2025) brings `map`, `filter`, `flatMap`, `take`, and `drop` to native JavaScript async iterators, standardizing the same composition model at the language level. This is the formal acknowledgment that declarative stream composition belongs in the platform, not just in libraries. Apache Pekko Streams' `Source`/`Flow`/`Sink` triad applies the same model to graph-structured pipelines where linear chains are insufficient—fan-out, fan-in, broadcast, merge. The 200+ operators in Pekko Streams are all composable graph stages. The practical advantage is testability. Because each operator is a pure function, you test operators in isolation with a known input sequence and assert the output sequence. No mocking, no dependency injection, no async test infrastructure. RxJS ships a `TestScheduler` for deterministic time-based operator testing; Reactor ships `StepVerifier`. This testing story is dramatically better than testing equivalent imperative async code. `scan` deserves special mention: it maintains running state across emissions—think running totals, accumulated lists, state machines—making it the reactive equivalent of `Array.reduce` applied to an infinite stream. Angular applications using NgRx build their entire state management layer on this one operator.