I m still not sure about coroutine extensions does this look

Question

I m still not sure about coroutine extensions does this look ok to you ```suspend fun lt T gt withMinimumDuration duration Long block suspend CoroutineScope gt T = coroutineScope val delay = async delay duration val task = async block delay join task await ```

gildor · Answer

it looks fine for me

gildor · Answer

but you don t need async

ribesg · Answer

How would you do it without async

gildor · Answer

oh I see

gildor · Answer

sorry

gildor · Answer

anyway in general looks just fine

ribesg · Answer

Technically I don t need 2 async calls I think

gildor · Answer

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

ribesg · Answer

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 · Answer

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 · Answer

your function will suspend until delay or until block is finished

gildor · Answer

it looks as correct approach for this use case

ribesg · Answer

How about this ```suspend fun lt T gt withMinimumDuration scope CoroutineScope duration Long block suspend gt T T val delay = scope async delay duration try val result = block delay join return result catch e Throwable delay join throw e ```

gildor · Answer

~you don t need suspend in this case~

gildor · Answer

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

ribesg · Answer

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

ribesg · Answer

I could use `coroutineScope` with a try catch inside maybe

gildor · Answer

yes sure

ribesg · Answer

Oh

ribesg · Answer

What about this one ```suspend fun lt T gt withMinimumDuration duration Long block suspend gt T = coroutineScope val delay = async delay duration try block finally delay join ```

gildor · Answer

but this changes original semantics withMinimumDuration What if `block ` will return faster than delay

ribesg · Answer

Let s say `duration` is 1000 and `block` is `delay 500 ` I want the call to withMinimumDuration to last 1000ms

gildor · Answer

It should be opposit ```val task = async block start block delay duration minimal delay task await ```

ribesg · Answer

Same if `block` is `throw Error `

gildor · Answer

yes but function from previous example violates this contract

ribesg · Answer

I don t see how

gildor · Answer

if block return in `500` than withMinimumDuration will return

gildor · Answer

so less than minimal 1000 delay

ribesg · Answer

But the finally block should get called

gildor · Answer

ah it s final

gildor · Answer

why not just <https kotlinlang slack com archives C1CFAFJSK p1556011514177100 thread ts=1556009996 170800 amp cid=C1CFAFJSK>

gildor · Answer

no try catch more simple semantics works in the same way

ribesg · Answer

Yeah I didn t say your solution was not better just that mine worked too stuck out tongue Thanks removing the try

gildor · Answer

but probably you need supervisorScope in this case instead of coroutineScope

gildor · Answer

to avoid delay cancellation

ribesg · Answer

Oh right that s why I had a try

ribesg · Answer

But with supervisorScope the error is lost isn t it

gildor · Answer

no it will be thrown on `await `

ribesg · Answer

Oh yeah

ribesg · Answer

Final function ```suspend fun lt T gt withMinimumDuration duration Long block suspend CoroutineScope gt T = supervisorScope val task = async block = block delay duration task await ```

gildor · Answer

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