I am currently out of reach from computer.. I will let you know when I try

hmm do I understand correctly that coroutines is very good for gaming Like Each object in the game can be represented by coroutine running in infinite loop and each loop ends with "yield" and you can have like zillion of sprites moving on the same shared thread and be sure that kotlin itself will fairly deal with state changes (given I yield)

I'm not sure if I already mentioned it before, anyway, after a few weeks of coding TornadoFX apps I got used to create these 2 extension functions to ease up my code a bit:

launchUI {}

for

launch(JavaFx) {}

and

commonPool {}

for

withContext(CommonPool) {}

. If something similar would be considered to be added to the coroutines-javafx and base coroutines libraries, that would be a thumbs up from me 👍🙂

@Martin Devillers have you tried verifying the 2nd argument passed is a

Continuation

?

Kind of an open ended question but how are folks handling backpressure in relation to coroutines? Say I have an existing pipeline in project reactor, messages are pumped in one side, queued, fed into a ParallelFlux and then transformed and ultimately consumed by the app. The queue and the "rails" in the pflux effectively give you back pressure so only X messages are in flight in the pipeline concurrently and as one message on a rail finishes it picks up the next from the queue. That seems like it'd be pretty hard to model as easily with coroutines. Am I missing something?

Is there a way I can specify to

produce

that I dont want it to run its block until somebody calls

recieve

from it? IE a kind of pull based channel?

oh, here's a wonderfully esoteric question: I encountered this while refactoring...

Is CommonPool a default dispatcher?

pseudocode:

fun funToTest() = async {
   registerDevice()
   //... and lots of extra logic here
}

private suspend fun registerDevice() = suspendCoroutine {
 // handle complex callback logic and do it.resume(data) for suspendCoroutine
}

How I test it now:

@Test
    fun `ok result of registration results in success`() = blocking {
        val result = classToTest.execute(appConfig).await()
        mockRegisterResponseSuccess(ApiResponseStatus.OK)
        mockInitAppPurchasesSuccess()
        result.should.be.equal(trackingId)
    }

📣 📣 📣

kotlinx.coroutines

version

0.25.0

is released. It has reworked/consistent/documented exception handling model, convenient thread-locals for coroutines, SLF4J MDC integration, and more. See https://github.com/Kotlin/kotlinx.coroutines/releases/tag/0.25.0

so we should be catching

JobCancellationException

instead of

CancellationException

?

I’ve written some

debounce

extensions for

SendChannel

and `ReceiveChannel`… any interest in a PR? anybody else find they’ve needed these?

I am a little confused. So if I will not wrap

await()

call in try/catch I might never ever know that there was an exception inside? Or will that exception then thrown as usual?

fun main(args: Array<String>) = runBlocking {
    val job = launch {
        println("Throwing exception from launch")
        throw IndexOutOfBoundsException() // Will be printed to the console by Thread.defaultUncaughtExceptionHandler
    }
    job.join()
    println("Joined failed job")
    val deferred = async {
        println("Throwing exception from async")
        throw ArithmeticException() // Nothing is printed, relying on user to call await
    }
    try {
        deferred.await()
        println("Unreached")
    } catch (e: ArithmeticException) {
        println("Caught ArithmeticException")
    }
}

async and produce ... are relying on the user to consume the final exception

– what if user doesn’t consume final exception, will it be thrown out of async/produce or just quietely hidden?

Wild idea: allow

suspend val

and

suspend operator fun getValue

to allow

by suspendLazy { ... /* a coroutine */ }

delegation. I'm not sure It's a good idea though

So yes, I tried and code inside

async

only runs when I call

await

@withoutclass Always use

consume

or

consumeEach

. BTW, this is getting me wondering if

for

loop on a channel without

consumption

should raise a warning…

They don’t work for me when I’m reading in batches

Sometimes I wish to have a compiler flag for not inlining anything for debugging

I’m trying to implement something like

UI

dispatcher from anko but on iOS My

build.gradle

buildscript {
    ext.kotlin_version = '1.2.51'
    ext {
        coroutines_version = "0.25.0"
    }
}

apply plugin: 'kotlin-platform-native'

sourceSets {
    main {
        component {
            baseName.set("NF")
            outputKinds = [FRAMEWORK]
            target 'ios_arm64', 'ios_x64'//, 'ios_arm32'
        }
    }
}

dependencies {
    compile "org.jetbrains.kotlinx:kotlinx-coroutines-core-native:$coroutines_version"
    <...>
}

IosDisplayContext.swift

import NF

@objc
class IosDisplayContext: NSObject, NFCoroutineDispatcher {

}

I’m getting error

Use of undeclared type 'NFCoroutineDispatcher'

. How can I implement public protocols of coroutines library by my Swift code?

Is it possible to wrap around callback with

produce

somehow, similar to

suspendCancellableCoroutine

? I am trying to have coroutines for Firebase Firestore and they use

addSnapshotCallback

to observe hot data

At the moment I get an error that

send

can only be called in coroutine context, that is hidden by the callback function

@elizarov will the

AbstractChannel

APIs stabilize before release? I may have a use for a

Channel

backed by a priority queue but want to re-use as much as possible…

Here in guide https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-guide.md#cancellation-and-exceptions in the code example delay() is called in a child coroutine, and then the child coroutine is cancelled. If yield() is not called on the parent coroutine then child won’t be canceled. Why calling yield() on parent makes child cancellable, whereas delay() has to be cancellable by default?

This may be interesting to those who started working with coroutines: https://twitter.com/dmytrodanylyk/status/1034357859293622272 We have been discussing with @nemi today, maybe custom coroutine dispatcher would be a way to handle such use-case?

Anyone have a list of all the functions that are added for coroutines? (like async, runBlocking etc) or know where I can find it I find that it's something I'm missing when trying to learn them, to kinda answer the question "is there a better way of doing this?"

Hi, is there a function that waits for multiple tasks to finish and aggregates their exceptions if so?