just curious: what is the "kotlinx-coroutines-debug" gradle plugin?

executing one after another, like with andThen

invokeOnCompletion

is mostly designed for internal machinery. Franky, I think it should be somehow “hidden” from API to discourage its use from a general-purpose application code, but I don’t know what would be best way to do it. You should define

then

to get this “chained” style of programming like this:

fun <T, U> Deferred<T>.then(next: suspend (T) -> U): Deferred<U> = async { next(await()) }

We might include it in the future updates of

kotlinx.coroutines

for convenience.

Hey I guess I am stupid. How do I get coroutines lib in simple JVM project. Simplest InetlliJ with simplest Kotlin plugin 1.5.x and I can't import coroutines, and I don't see the lib anywhere...

Can someone explain the reasoning behind this: "In particular, it means that a parent coroutine invoking join on a child coroutine that was started using launch(coroutineContext) { ... } builder throws CancellationException if the child had crashed, unless a non-standard CoroutineExceptionHandler if installed in the context." ? It seems unintuitive at best. It makes something like this:

val outerJob = launch(CommonPool) {
    val inner1 = launch(coroutineContext) { /* blah */ }
    val inner2 = launch(coroutineContext) { /* blah */ }
    // do more stuff
    select<Unit> {
        // These lines will actually throw a CancellationException if either of the inner jobs are completed exceptionally!!!
        inner1.onJoin { val reason = inner1.getCompletionException(); /* blah */ }
        inner2.onJoin { val reason = inner2.getCompletionException(); /* blah */ }
    }
}

// Here I can call `outerJob.cancel()` to cancel everything

very awkward to write

Hello, does anyone know best case register # swaps that need to happen in order to switch from 2 coroutines multiplexed on the same running thread?

Hmm. I thought I could pass a continuation to the other and receive its continuation using createCoroutine. Isn't it possible?

Anybody having this issue on Android with Dexguard and kotlin coroutines? Unexpected error while computing stack sizes: Class = [kotlinx/coroutines/experimental/JobSupport] Method = [notifyHandlers(Lkotlinx/coroutines/experimental/JobSupport$NodeList;Ljava/lang/Throwable;)V] Exception = [java.lang.IllegalArgumentException] (Stack size becomes negative after instruction [164] pop in [kotlinx/coroutines/experimental/JobSupport.notifyHandlers(Lkotlinx/coroutines/experimental/JobSupport$NodeList;Ljava/lang/Throwable;)V])

Hi everybody, is it possible to execute a blocking IO operation (such as HTTP GET request) in a coroutine and make it suspend instead of blocking the thread?

@littlelightcz You’ll need to offload your blocking ops to a thread-pool. First, define a pool:

val ioPool = newThreadPoolContext(n, "ioPool")

Then you can wrap you IO operations into

run(ioPool) { ... }

. This will be a suspending operations from the invoker stand-point, the actual execution happening in the thread pool you’ve defined, so that the invoker thread (UI thread, of some other event thread like netty or vert.x) is not blocked.

Hey. Question. Because coroutines at the end of the day call "continuation.setValue()" how it is organised on the stack. Wouldn't it end on stackOverflowException ? If I would implement CPS using kotlin I would end up with full stack? Can I do CPS in kotlin, or I need to play carefully with tale call optimization?

Would it make sense to add coroutines support to a (streaming) JSON library? (+ wouldn’t turning all reads/writes into suspending functions slow down things a lot?)

What kind of thoughput you are looking for? A number of small http requests/sec or a number of bytes/sec downloading some big data?

Is there some kind of

produce { }

for a

BroadcastChannel

?

Oh, I thought I'd have to do that, I just wondered if I was missing something or it would be included eventually... Also, how does one make a class out of

actor { }

and still be thread safe, can the class member vars be used or do they have to be contained in the

actor { }

function? And there must be an actor val to keep and return the actor.. one can't call send straight from the class. It would be nice to be able to derive from an actor abstract class...

@SerGnat Try asking over on #ktor -- they are working on a pure-coroutine based http client to go along with their (experimental) pure coroutine based server backend

Yes, but I cannot do

use

BroadcastChannel

are kotlin coroutines still "experimental"? is there are a timeline for when people should actually use them?

Hi! Why is something like this not possible?

class F {
    suspend fun CoroutineScope.process() {

    }
}

fun main(args: Array<String>) {
    launch {
        val f = F()
        // unresolved reference
        f.process()
    }
}

there doesn't seem to be a cancelation hook when building a

Deferred

(via

CompletableDeferred

). Is there something else that offers this callback?

Is there idiomatic way to enforce JVM to do happens-before when nested coroutine returns to parent one? Performance overhead is acceptable.

i have got weird behavior with

delay

on different platforms: while

delay(Long.MAX_VALUE)

works as expected in

javafx

desktop project (infinite delay) in android this line does nothing. but this one works:

delay(Long.MAX_VALUE / 2)

and i have no clue why

@Fré Dumazy Use

Mutex

I read these messages into a concurrent queue, and another thread (this is handled by the connect framework) will poll this queue and release the memory.

sleep

can avoid putting too many messages in the queue.

Did you mean this:

while (queue.size < 10000) {
        queue.add(element)
    }

Then how to come back into the while loop?

Is it possible to use coroutines with Kotlin/JS yet?