```suspend fun <T> ???(millis: Long, action: suspend () -> T): T { val start = System.c...

# coroutines

[ursus]

suspend fun <T> ???(millis: Long, action: suspend () -> T): T {
    val start = System.currentMillis()
    val value = action()
    val end = System.currentMillis()
    val took = end - start
    if (took < millis) {
        delay(millis - took)
    }
    return value
}

does this have a name already? it makes sure the suspend function takes atleast N millis, so its not too fast

its not debounce since its calcualtes the delay …so I guess I need my own name

[Richard Gomez]

This sounds like a "constant time" operation, which is important in cryptography to prevent timing attacks (e.g. https://codahale.com/a-lesson-in-timing-attacks/), albeit not exactly.

I don't know if there's a name for it. I'd be inclined to just name it something unsexy like runForAtLeast(1000) { }

[ursus]

yea buts not really constant, its min constrained 😄

[ephemient]

better to build it up out of existing primitives,

coroutineScope {
    launch {
        delay(millis)
    }
    action()
}

[ursus]

don’t I need to launch the action as well there?

[Richard Gomez]

No. coroutineScope will wait for all child coroutines to finish before it returns, so if action() completes but delay() is still running, it will wait.

This function returns as soon as the given block and all its children coroutines are completed

https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/coroutine-scope.html

[ursus]

I see, I thought it only waited for launched stuff for some reason, thanks

[Michael Marshall]

Watch out that with action() outside the launch block, any side effects from action will take place before the delay.

[ephemient]

that is the intention here