@elizarov What do you think about my suggestion to install an rx exception handler to all

rxXYZ

methods?

Hi, is there a way to have a

ReceiveChannel

/ actor that cancels the work done for a value if a new one is received? My goal is to perform a computation for the latest received value and drop any in progress work.

I wish it were

launch(CommonPool.copy(parent = job)) {}

Starting to think that the

+

was too cryptic to begin with

Is there a recommended amount of time to use with

delay

if I want to make sure my routine is cooperative, but I don't need to actually delay anything? Is 1ms too little time? Curious if there is some best practice around that yet

Why can't local functions be suspendable

Assumed I have an infinite source of tasks, for example some

ReceiveChannel

which lazily produces work and I want to schedule these on

CommonPool

. I can't just take every task from the source, because there are infinite. What's a good way to assure that for example always 1000 tasks are currently in my thread pool?

Is there some practical use for the new

suspend

function in stdlib in 1.2.30? The release notes have an example that's not too clear to me what the point is...?

suspend {     val result = deferredResult.await()     renderResult() }.startCoroutine(completion)

I'm starting to write a Medium article that aims to guide Android developers to use kotlinx.coroutines. I'll cover the basics to use coroutines correctly in Android apps. That includes how to use

launch

,

withContext

,

async

, the

suspend

modifier, which CoroutineContext to pick, what a

Job

is, how to wrap a callback with

suspendCoroutine

, how to handle errors, how to handle lifecycles of Android components. I'll also talk about some good libraries made on coroutines. Namely, @gildor and @jw ones for Retrofit. I'll also talk about channels and how it can be used for actors and to wrap true callback hells. Since this is my first public article, I'm unsure about the results, but I'm determined. I can share the draft to anyone willing to give feedback or willing to help in any other way. The current title of the draft article is kotlinx.coroutines intro for Android Devs. Please tell me if you dislike it or if you think you have a better one.

I already observed that when the second response arrived the

isActive

predicate returns

false

but I don't know how to prevent it

Roman, are there any plans to publish

kotlinx-coroutines-core-js

on npm?

Not necessarily kotlin related, hope to not be OT, but i was wondering whether someone has good book/readings recommendation to learn more about concurrency models like CSP, actors etc in depth? i've started reading tony hoare's CSP book , but i was looking more for a comprehensive survey of different models.. i've some code examples in mind, but i still lack a solid understanding of the foundations of the subject.. any suggestion?

If I create an interface with a method which potentially could be suspendible in some of the implementations in the future, do I get any penalty from marking this method

suspend

just in case?

looks like

kotlinx-coroutines-core-js

doesn't work with

create-react-kotlin-app

? i'm doing

npm i kotlinx-coroutines-core --save

and still can't use launch/async etc. or should i import these functions with @JsModule?

What is the best way to get a future into the coroutine world?

But in Android

FutureTask

can receive a callback when it's finished, so you wouldn't have to block an extra thread to wait for the result... and it implements Future from api level 1...

coroutines are just callbacks!

Roman and

kotlinc

suffer in it on our behalf

java.lang.IllegalStateException: Already resumed

So, `CoroutineContext`s are not reusable

channel.consumeEach { …. }

. The rest of the code will execute only when the channel is closed

@elizarov

public fun <E, R> ReceiveChannel<E>.flatMap(context: CoroutineContext = Unconfined, transform: suspend (E) -> ReceiveChannel<R>): ReceiveChannel<R>

is there any chance we will see overloaded flatmap in the lib with such param signature

transform: (E) -> Iterable<R>

?

I may have missed it but is there anyway to fire and forget an async call within a suspend function?

Hi, just had an idea: What about showing an icon in the gutter or a "bar" on the left in the IDE to show where a higher order suspend function starts (e.g.

launch

and any other function whose lambda is a

suspend

one)? This could be a play sign with the curve, similar to the arrow with the curve we have for suspension points. This would help knowing where suspend calls are allowed in current code, helping to see potentially unneeded coroutines launches

I'm looking for some kind of permanent continuation. I have a function that at some point has to wait on a callback. So I could use suspendCoroutine and store the continuations in a queue. The callback could then then pop the queue items and call resume on each. However it would be more elegant to have some kind of lock object so suspending functions could lock on it and then all resume when the lock object gets unlocked. Is there something built in for that?

I'm looking for some examples about migrating a Rx based code base to a more coroutines based. any blog post about wrapping `Single`s and `Observable`s that you would suggest?

@elizarov did you write any adapter between CoroutineContext and Rx Schedulers? Is there even any correlation?

@Jonathan that wasn't the question i asked, callback is there for a reason

@gildor sure

fun main(args: Array<String>) {
    launch(EmptyCoroutineContext) {
        withContext(EmptyCoroutineContext) {
            CompletableFuture.runAsync {
                print("Hello")
            }.await()
        }
    }
}

suspend fun <T> CompletableFuture<T>.await() = suspendCoroutine<T> { cont ->
    cont.resume(join())
}

Hello

would never be printed in this case

why are you even bothering to use

launch

and

withContext

?

@Jonathan example with single thread context you proposed

fun main(args: Array<String>) {
    val context = newSingleThreadContext("test")
    launch(context) {
        withContext(context) {
            CompletableFuture.runAsync {
                print("Hello")
            }.await()
        }
    }
}

suspend fun <T> CompletableFuture<T>.await() = suspendCoroutine<T> { cont ->
    cont.resume(join())
}

Not working😮