Hello, I'm using IntelliJ to try out coroutines on the JVM. I have a pretty simple method that calls

GlobalScope.launch

, awaits a deferred value, prints its contents, and then outside of the launch method, prints a concluding String. All of this is working great. The process is still running when these two print tasks complete however. What is keeping it alive, and can I gracefully shutdown when all my work has been completed? Edit: Updated code block from Louis' comments

suspend fun main() {
    val api = createRestApi<RestApi>("<https://catfact.ninja/>", okHttpClient(), moshi)

    coroutineScope {
        val facts = api.getFacts().await()
        println(facts.data)
    }
    println("That's all")
}

@Ilmir Usmanov [JB] I've looked up

runTest

and sadly, it does not solve the problem with "blocking" calls in JS (also it could be run only from test). I am still thinking if it is really necessary. My use case is that I have an interface with a regular blocking function and implementation which utilizes coroutines for parallel computations. Currently I can't do it since I can't collect parallel elements in a non-blocking way. Maybe there are better ways.

Hey guys, I have a function inside a coroutinescope which I need to call every few seconds. How do I do that? It's a timer kind of thing.

Hi guys. I got a strange situation with

suspend

function which I can't solve: I got function

suspend fun one()

which executes some code and then calls a function that accepts a callback function as a param. But, this param function is not suspend. The issue is that I need to call another suspend fun from that callback param function. Here's an example:

suspend fun one() {
    doSomething()
    funWithNonSuspendCallback("data") {
        two() // I need to call it from here but this is not suspend scope anymore
    }
}

suspend fun two() {
}

Trying to understand why it's never completed:

fun main(){
    runBlocking{
    	foo().consumeEach{ println(it) }
    }
}

suspend fun foo(): ReceiveChannel<Int> = coroutineScope {
    produce<Int>{
		channel.send(42)
               channel.close()
    }
}

Is it not possible to recover from a failed

Deferred<A>

? I was expecting to be able to define a

handleErrorWith

operator that wraps an existing

Deferred

to recover from errors but the program results in the original error.

Is kotlinx.coroutines debug not supported on Android? I tried to call

DebugProbes.install()

but got this runtime exception: java.lang.NoClassDefFoundError: Failed resolution of: Ljava/lang/management/ManagementFactory;

Is

select { deferreds.forEach { it.onAwait { it } } }

elegant enough?

Is there any special trick about breakpoints in coroutines? The test is green, but the breakpoint point doesn't stop:

@Test
    fun test() {
        runBlocking {
            val channel = produce<Int> { channel.send(42) }
            channel.consumeEach { assertEquals(42, it) } // <--- break point is on this lambda
        }
    }

P.S. I'm using

Dispatchers.setMain()

on android

I want to create extension to convert Promise type

Which way is correct to make my suspend coroutine to be in same scope for calling coroutine scope?

Any rough estimations from officials of when Channels are going to be production ready? The quarter of the year maybe. (Note: it's not about push or faster delivering, it's about roadmaps and planning)

hi guys, when channels will be a stable feature?

I have a simple question regarding coroutines, if anyone could help me. I must be missing something... Kotlin MPP project, using following dependencies, I am unable to resolve

runBlocking

at all:

commonMain.dependencies {
            implementation 'org.jetbrains.kotlin:kotlin-stdlib-common'
            implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime:0.9.1"
            implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.0'
            implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core-common:1.1.0'
        }

        androidMain.dependencies {
            implementation 'org.jetbrains.kotlin:kotlin-stdlib'
            implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.0'
        }

        iosMain.dependencies {
            implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime-native:0.9.1"
            implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core-native:1.1.0'
        }

Also, using Kotlin 1.3.11

How do you test coroutines started with

launch

? If I understand correctly

launch

always run asynchronously and in tests we would like to run it sequentially.

If I have a suspend function that does nothing but change contexts, how do I ensure that I catch any failures and ensure that my logic continues? My parent scope is already a supervisor job, and I try catch my suspended calls. However, I notice that I need to do so multiple times to ensure that I actually catch errors After some tests, I can use a

supervisorScope

and try catch it. However, it still doesn’t stop the cancellation of every other job, despite the main context already being a supervisor

Is there any way to get the in flight & finished task count of

<http://Dispatchers.IO|Dispatchers.IO>

?

it says there is an error processing

kotlinx-coroutines-debug

but we don't have that module listed in our gradle file 🤔

Hi all, does coroutines (or continuations) have some kind of "hooks" that we can attach to on resume? Basically I want to intercept the resumption of continuations to do some custom behavior before actually resuming. I hope this question makes sense to you.

Has there been any news about cold streams for coroutines?

The

@RestrictSuspension

annotations does a great job and has proven very useful for controlling side effects in Arrow. Kudos to everyone involved with the suspend system! The only problem I'm having is that the compiler error messages for restricted contexts are not very useful. They just state the arbitrary suspended function can't run there. I would like to customize such error messages a la carte to provide reasons why functions are restricted in a suspended receiver. For example:

save() can't be invoked in this [UI] scope because is scoped to [DB]

Is there a way to customize such error messages? If not is this something that would change in the compiler or std lib?

Didn't know

@RestrictSuspension

! What is it good for? Is there an article about it? 😮

private val topics = mutableMapOf<String, Publisher>()
    private val lock = Mutex()

    suspend fun method(key: String) {
        lock.withLock { 
            topics.getOrPut(key) { //... }
        }
    }

is lock gives guarantee that other coroutines will see changes in

topics

?

The documentation says that only

launch

will use the CoroutineExceptionHandler For

async

, the exception is thrown when using

await()

Just to clarify my understanding after reading a bunch of documentation: if we want a property that anybody can observe, we would use

ConflatedBroadcastChannel

, correct?

Hi! I am trying to call a

suspend fun

from Java, but I can't access any properties of

Result

- when implementing

Continuation

, I only get an

Object

in

resumeWith

. Can anybody help with that? 🙂

Yeah, but I'd like to avoid making a whole JSON library suspend 😄 And try…finally will make the logic really complex because you cannot wrap a code into a lambda anymore and it will affect plenty of functions 😞