Hi there! Is it possible to implement this better? Without do/while?

Or without

var

?

@voddan commented on @nil2l’s file https://kotlinlang.slack.com/files/U5XDSK718/F8DF2T26A/-.kt: looks like some of the code was lost

@louiscad commented on @nil2l’s file https://kotlinlang.slack.com/files/U5XDSK718/F8DF2T26A/-.kt: @voddan There's a bug in Slack that makes expand not work properly, showing only the first 5 lines of this 15 lines snippet

There is one class in 15 strings. NetworkCallState<T> – would be any.

@gildor commented on @nil2l’s file https://kotlinlang.slack.com/files/U5XDSK718/F8DF2T26A/-.kt: Better to use Channel for such case instead of

produce

, code will be less magic

@gildor commented on @nil2l’s file https://kotlinlang.slack.com/files/U5XDSK718/F8DF2T26A/-.kt: but you still need

while

, just because it’s potentially infinite sequence of events

Hm. But in which case then I should use

produce

?

If you can encapsulate your logic inside

produce

, but here you cache continuation to solve your problem and it looks ugly

anyone using zipkin to instrument http client calls where the http client uses coroutines?

@rrva I’m using CompleteableFuture with retrofit to hand-off the network calls to coroutines. Perhaps there’s CFs available through zipkin? (I’m not personally familiar with it)

does kotlinx.coroutines have any API to make two cancellable Jobs/Deferreds “race”, meaning that when one finishes the other gets cancelled

you can just

select

on them and cancel when you get a result

https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-guide.md#selecting-from-channels this should help

okay, thank you 😄

K kotlin coroutines question: is better to have multiple atomic async procedures/task/jobs/thingtodo or encapsulate some of those async procedures in a medium size task, why I ask this? the time to suspend and awake having many small atomic procedures can have a cost if there're a lot, or not? Thread in Slack Conversation

Hi again 🙂, I continued with my coroutines experiments and to put it simply, here is my code: https://pastebin.com/pGgqgh1c The expected result was e.g.: Sending request 1 Sending request 2 Sending request 3 Received response for 1 Received response for 2 Received response for 3 Total length: 684 But instead I got: Sending request 1 Received response for 1 Sending request 2 Received response for 2 Sending request 3 Received response for 3 Total length: 684 What am I doing wrong? 🙂

Remove the runblocking

And expected result also doesn't have to be in order - can be sending 2 sending 1 sending 3

Can use a .await() or thread.sleep to prevent jvm from exiting from under u

Asad: I can't remove it entirely because asyncGet is suspending function which can be called only inside coroutines context, but when I switch it to launch {} I still get the same result

Any specific reason why ur using suspendCoroutine instead of async?

the calls are already async

runBlocking

is definitely preferred to sleeping as it spins a looper on the current thread allowing it to do work while waiting instead of nothing

btw when I call it like this: .map { launch { asyncGet(it)?.body()?.string() ?: "" } }

then I get the result I expect, but it doesn't wait until all tasks are done

Yeah - the jvm ends underneath u