I’m still not sure about coroutine extensions, does this look ok to you? ```suspend fun <T> wi...

# coroutines

[ribesg]

I’m still not sure about coroutine extensions, does this look ok to you?

suspend fun <T> withMinimumDuration(duration: Long, block: suspend CoroutineScope.() -> T) =
    coroutineScope {
        val delay = async { delay(duration) }
        val task = async { block() }
        delay.join()
        task.await()
    }

[gildor]

it looks fine for me

[gildor]

but you don’t need async

[ribesg]

How would you do it without async?

[gildor]

oh, I see

[gildor]

sorry

[gildor]

anyway, in general looks just fine

[ribesg]

Technically I don’t need 2 async calls I think

[gildor]

yeah, you can remove async for delay, should be the same

[ribesg]

I wanted to have it be an extension on CoroutineScope like launch and async but I don’t know. I didn’t even know coroutineScope, it was a quickfix to a warning. I’m not sure I want that. Maybe I want the delay even if there’s an error.

[ribesg]

I’ll use this to basically show a clear loading state while doing network requests. But I think with this current implementation, if there’s an error immediately in the request, the loading state will just show for some ms

[gildor]

your function will suspend until delay or until block() is finished

[gildor]

it looks as correct approach for this use case

[ribesg]

How about this

suspend fun <T> withMinimumDuration(scope: CoroutineScope, duration: Long, block: suspend () -> T): T {
    val delay = scope.async { delay(duration) }
    try {
        val result = block()
        delay.join()
        return result
    } catch (e: Throwable) {
        delay.join()
        throw e
    }
}

[gildor]

you don’t need suspend in this case

[gildor]

No, i don’t see any reason to implement it like this

[ribesg]

Well I just expect a function named this way to always last duration, even if there is an error when calling block

[ribesg]

I could use coroutineScope with a try-catch inside maybe?

[gildor]

yes, sure

[ribesg]

Oh

[ribesg]

What about this one

suspend fun <T> withMinimumDuration(duration: Long, block: suspend () -> T) =
    coroutineScope {
        val delay = async { delay(duration) }
        try {
            block()
        } finally {
            delay.join()
        }
    }

[gildor]

but this changes original semantics ( withMinimumDuration), . What if block() will return faster than delay?

[ribesg]

Let’s say duration is 1000 and block is delay(500). I want the call to withMinimumDuration to last 1000ms

[gildor]

It should be opposit:

val task = async { block() } // start block
delay(duration) // minimal delay
task.await()

[ribesg]

Same if block is throw Error()

[gildor]

yes, but function from previous example violates this contract

[ribesg]

I don’t see how

[gildor]

if block return in 500 than withMinimumDuration will return

[gildor]

so less than minimal 1000 delay

[ribesg]

But the finally block should get called

[gildor]

ah, it’s final

[gildor]

why not just:
https://kotlinlang.slack.com/archives/C1CFAFJSK/p1556011514177100?thread_ts=1556009996.170800&cid=C1CFAFJSK

[gildor]

no try catch, more simple semantics, works in the same way,

[ribesg]

Yeah I didn’t say your solution was not better, just that mine worked too 😛 Thanks, removing the try

[gildor]

but probably you need supervisorScope in this case instead of coroutineScope

[gildor]

to avoid delay cancellation

[ribesg]

Oh right, that’s why I had a try

[ribesg]

But with supervisorScope the error is lost isn’t it?

[gildor]

no, it will be thrown on await()

[ribesg]

Oh, yeah.

[ribesg]

Final function

suspend fun <T> withMinimumDuration(duration: Long, block: suspend CoroutineScope.() -> T) =
    supervisorScope {
        val task = async(block = block)
        delay(duration)
        task.await()
    }

[gildor]

I would write test for it to be sure, but looks fine for me