Hi, I need to insert a initial value to a stream that sometimes doesn't emit, however if it emits within a window of time, take the real value, not the manual initial one TLDR; debounce first value - I have this

private fun <T> Flow<T>.onStartDebounced(initialValue: T, debounceMillis: Long): Flow<T> {
    return onStart { emit(initialValue) }
        .withIndex()
        .debounce { if (it.index == 0) debounceMillis else 0L }
        .map { it.value }
}

Works, but im a Rx guy, is there something more idiomatic / performant (so I can actually learn something)?

How would you write this logic in Rx? Once you have that, check out the

Migration.kt

file for some insight on how to migrate it to

Flow

. That's normally helped some of my teammates when I work with them on getting something new as a Flow. Just remember,

Single

and

Maybe

are

suspend

functions now.

it's not more performant, but my first thought would be to stitch together a few other primitives,

fun <T> Flow<T>.onStartDebounced(
    initialValue: T,
    debounceMillis: Long
) = channelFlow<T> {
    val job = launch {
        delay(debounceMillis)
        send(initialValue)
    }
    collect {
        job.cancel()
        send(it)
    }
}

@ephemient yea something like that, thanks

something like this would have less overhead than that

fun <T> Flow<T>.onStartDebounced(
    initialValue: T,
    debounceMillis: Long
) = flow<T> {
    var hasValue = false
    emitAll(
        merge(
            onEach { hasValue = true },
            flowOf(initialValue)
                .onStart { delay(debounceMillis) }
                .filter { !hasValue }
        )
    )
}

the first is less performant becuase of the launch?

mostly because it requires bouncing through a channel

arent channels primitives backing all Flows?

most flows are probably cold and they don't involve channels

I see, i like both your samples. Btw is it safe to have hasValue as a plain boolean, not atomic one? (also it will continue to delay even when left side already emitted)

I believe it is safe because collection can only happen sequentially. yes, it will continue to delay even if the left side has emitted, so if you're creating millions of short-lived flows that could be an issue.

and because of that it needs to be atomic i believe. im going to go with first one, thanks!