To follow the example of functions like withTimeout and debounce, I think we should add the Millis suffix to these parameter names, and maybe provide an overload using kotlin.time.Duration?

Good point for naming and we have .receiveAsFlow() extension function.

Directly we can use kotlinx-coroutine's ticker. Also this can be better idea to have single implementation.
What do you think about it?

It could indeed be done this way, but that would couple it to JVM platform 😥
I am not sure a channel would be necessary behind the scenes to implement it, but I will let the maintainers comment on this.

EDIT: moved part of this comment to the relevant conversation

This implementation uses a background thread and is JVM-specific.
Couldn't we simply use a loop with delay() and make it multiplatform? Or am I naive here?
I fail to see the benefit of running another thread here.

Thanks! very good point.
Also ticker implementation can be moved to commonMain.

I can see now why a concurrent behaviour is necessary and would like to backtrack a bit: we can't use a simple loop with delays because otherwise the ticker delay is impacted by the execution time of the collector code, which is probably not desirable in this case.

That's why we do need some concurrent process (a coroutine?) to send the ticks.
This still doesn't mean we have to use a thread and Java's timer.
There may be a multiplatform way to do this.

I'll let the maintainers of the lib comment on this, though

Because the channel is hidden here, we probably want to handle cancellation properly.
Using consumeAsFlow() instead of receiveAsFlow() should do the trick I think.