Operators

Each emitted value can itself produce a flow. These operators flatten those inner flows into one stream. Concat runs them one after another, Merge runs them at the same time, Latest cancels the old inner flow when a new value comes.

A terminal operator is the function that actually starts a Flow running and consumes its values. Without one, nothing happens because Flows are lazy. Examples: collect and toList.

map turns each emitted value into a new value; filter keeps only values matching a condition. They do nothing until a terminal operator (like collect) runs the flow, and each collection re-runs the work.

Concat processes inner flows one at a time, so output keeps the input order. Merge processes several at once, so faster inner flows can finish first and outputs interleave. Merge lets you cap how many run together; the default is 16.

transform is the general operator: for each incoming value you can emit zero, one, or many results by calling emit() as often as you like. map and filter are restricted special cases of it.

combine emits its first value only after every source has produced one. If a source emits faster than the collector consumes, combine may skip older values and use only the most recent of each.

merge runs several flows at once and forwards each item as it arrives into one flow. It does not pair or transform values — it just interleaves them in arrival order.

Autocomplete uses flatMapLatest (drop stale searches). Ordered pagination uses flatMapConcat (keep order). Parallel HTTP fan-out uses flatMapMerge with a concurrency cap (run several at once but bounded).

first() returns the first value and stops the flow. first { } returns the first matching value. single() expects exactly one value and throws if there are zero or more than one.

Both combine all emitted values into one result. fold starts from a value you provide; reduce starts from the first emitted value. reduce throws on an empty flow; fold returns the initial value.

take(n) lets through only the first n values then stops the flow; drop(n) skips the first n and emits the rest. take cancels the upstream once it has enough by throwing an internal exception that take catches.

Use combine to build one UI state from the three inputs because it reacts to the latest of each. Use merge to pool the many same-type event flows into one stream. Avoid zip here — you don't want lockstep pairing.

zip collects both flows concurrently but emits a pair only when both have produced the next item. The faster flow waits for the slower one, so the slow side sets the pace.

When a new value arrives, flatMapLatest cancels the coroutine running the previous inner flow and starts a new one. Your inner flow must be cancellation-cooperative — use suspending calls or check for cancellation — so it actually stops.

launchIn(scope) starts collecting a flow in the background inside the given scope and returns a Job, instead of suspending the current code like collect does. It's used for fire-and-forget collection tied to a scope's lifecycle.

onEach runs a side effect for each value but passes the value through unchanged, returning a Flow. collect is terminal and returns Unit. onEach + launchIn lets you start the flow in a scope without writing a collect lambda.

flattenConcat and flattenMerge flatten an existing Flow<Flow<T>>. flatMapConcat/Merge are just map-then-flatten shortcuts. Some of these operators were experimental and need an opt-in annotation; check your kotlinx-coroutines version.

By default the producer runs in the same context as the collector that called toList(). If that coroutine is cancelled while collecting, collection stops with a CancellationException and toList() does not return.

By default every operator and emission runs in the collector's coroutine context (context preservation). You must not switch dispatcher inside map with withContext; instead change the upstream context declaratively with flowOn.