What would be the idiomatic way to emit a

Flow<Unit>

every 40 milliseconds? old solution:

channelFlow<Unit> {
  while (isActive) {
    delay(40)
    send(Unit)
  }
}

new, better solution:

flow {
    while (true) {
        delay(40)
        emit(Unit)
    }
}

This may be of relevance here. https://github.com/Kotlin/kotlinx.coroutines/issues/1186

updated original message with my current solution

What's wrong with using

flow

and

emit

?

flow and emit is cleaner

issue with flow & emit is that it does not account for the time spent in emit, so the question is do you want fixed rate or fixed delay. the former is better for fixed rate, latter for fixed delay, though you would probably need more code for a perfect fixed rate emission

I'm just trying to emulate

Oberservable.timer(..)

emit suspends, yes.

Oh. I think I want to not poll again until my logic to check if I am in the correct state completes

probably if you're polling, fixed delay is fine, and you can use flow/emit. reason being that you want to wait 40ms after the last result, regardless of how long it takes.

As the whole flow is just one Coroutine I think it achieves that

I guess

isActive

doesn’t matter because delay suspends

No, it's because

delay

is cancellable.

Version with channel is less efficient and you just don't need it. Use flow, not channel flow in this case, you can have exactly same semantics, if you want. Channel flow is needed if you want to emit from different threads or from non-suspend context (like if you write flow adapter for some callback)