Both conflate() and collectLatest help a slow consumer keep up with a fast producer. How do they differ in what they do with the in-progress work?

## The shared goal When a producer outpaces the collector, you usually only care about the **latest** value. Both `conflate()` and `collectLatest { }` deliver "latest wins", but they treat the **already-running** processing block differently. (This question lives at the conflate↔collectLatest boundary; the focus here is the contrast, not collectLatest's full mechanics.) ## conflate() — finish, then skip `conflate()` is an **intermediate** operator. It buffers one value (`buffer(1, DROP_OLDEST)`). The collector block runs **to completion** for whatever value it started; it is never cancelled. When it returns and asks for the next value, it gets the **latest** one currently buffered, and the intermediates that arrived meanwhile are dropped. - Non-preemptive: in-flight work is honoured. - Works even if the collector body is non-cancellable. ```kotlin flow { repeat(5) { delay(50); emit(it) } } .conflate() .collect { delay(200); println("done $it") } // each println completes ``` ## collectLatest — cancel and restart `collectLatest { }` is a **terminal** operator. Each emission launches the block in a coroutine; when a **newer** value arrives, the block processing the previous value is **cancelled** and a fresh one starts with the new value. ```kotlin flow { repeat(5) { delay(50); emit(it) } } .collectLatest { delay(200); println("done $it") } // earlier blocks get cancelled mid-flight ``` Because it relies on coroutine cancellation, the block must hit a **suspension point** (e.g. `delay`, a suspending call) for the cancel to take effect — otherwise a tight CPU loop runs to completion anyway. ## Side-by-side | Aspect | conflate() | collectLatest | |---|---|---| | Operator kind | intermediate | terminal | | In-flight value | runs to completion | cancelled when newer arrives | | Preemptive? | no | yes | | Needs cancellable work | no | yes (suspension point) | | Good for | cheap, atomic renders | expensive work made obsolete by newer input | ## Choosing between them - **conflate():** repaint a progress bar, draw the latest sensor value — each render is quick and you don't want to abort it. - **collectLatest():** restart an expensive autocomplete query on every keystroke — finishing the old query is wasted, so cancelling is correct. The practical risk of `conflate()` here: if each item is slow, you can still lag because conflate won't cancel the slow in-flight work; collectLatest would.