`launch`: fire and forget `async`: wait for something

Hello guys, could you please tell me why exactly in examples

Job

was added to the

coroutineContext

override val coroutineContext: CoroutineContext
        get() = Dispatchers.Main + job

?

hey here's a basic question: is

Channel

a monad?

Any chance of ever seeing coroutines in androidNative? It would be greatly appreciated to be able to use both iOS and androidNative directly instead of having to use JNI communication

Hello all, I have a question about

structured concurrency

. If I understand, the thing is to ensure that we reuse a proper

CoroutineScope

instead of launching coroutines in the `Global`f scope. Then here is my question. I have 2 components:

A

&

B

. My component

A

initiate a coroutine scope and I can run functions against that. How do I share/propagate it to my component

B

on which I want to call functions.

class A {
	val coroutineContext: CoroutineContext ...
}

class B {
	fun myFunction(){
		// run with A.coroutineContext?
	}
}

Do we have to pass the

coroutineContext

as an argument to any call of

B

?

anyone else still having issues with breakpoints in

suspend

functions / coroutines not working?

Am I correct that

.produce

immediately starts its

block

even if there is no subscriber for the

ReceiveChannel

yet? If so, how can I avoid that?

How to wrap

Deffered

into another

Deferred

with a custom exception? There is no coroutine context in that place, so I can't use

.await()

fun <A, B> Deferred<Pair<A, B>>.split(): Pair<Deferred<A>, Deferred<B>>

Is this possible?

Are `ReceiveChannel`s closed automatically somehow if you for-loop over them even if you

break

at some point?

I find myself needing something like this for use in

while (true)

loops because

while (isActive)

continues execution and doesn't throw:

@UseExperimental(InternalCoroutinesApi::class)
fun CoroutineContext.checkIsActiveOrCancelNow() {
    val job = get(Job)
    if (job != null && !job.isActive) throw job.getCancellationException()
}

This is quite useful in loops where I implement retrying. The alternative to that

coroutineContext.checkIsActiveOrCancelNow()

call is to use

if (isActive.not()) yield()

, but I find that it doesn't communicate the intent well. Do you think this should be integrated into kotlinx.coroutines? I'm personally inclined to open an issue there, but I want to know if I'm not alone first.

Is there a way for a child coroutine to access it's parent coroutine context?

What is the difference between actor model and fan out from the guide? https://github.com/Kotlin/kotlinx.coroutines/blob/master/docs/channels.md#fan-out

We're converting a callback-style API into a coroutine using

suspendCancellableCoroutine

. We're looking for ways to signal progress in addition to completion and error. Currently, we pass a channel as a parameter to the suspending function through which we signal progress (this is conceptually similar to having a callback for progress). Are there other options? Like using the continuation object to signal progress?

Is is possible to change the parallelism of the Default dispatcher (if yes, how?) or I'll need to create a dispatcher from a pool with $parallelism number of threads?

Dunno if the question makes sense

if you have something like javalin a simple http server

import io.javalin.Javalin

fun main(args: Array<String>) {
    val app = Javalin.create().start(7000)
    app.get("/") { ctx -> ctx.result("Hello World") }
}

is it possible somehow to add coroutine support to this i.e. each request gets launched in its own coroutine and allows me to have controllers which are composed of suspending functions - maybe allow me to return a response on the context object from a launched coroutine?

How would I implement a sequence doing HTTP request using the Ktor client? I get an error about restricted suspending functions when using

sequence { }

Hi, I am a newbie in coroutines, And I am trying to use

ScheduledExecutorService

with coroutines, and I am not getting anywhere. I have a scheduled task that does not return anything. So I somehow want to use

launch

with the

ScheduledExecutorService

. Can anyone please help

I.e. that a coroutine launched in onStart will get cancelled in onStop, onCreateView -> onDestroyView, onCreate -> onDestroy; etc?

I am quite new to coroutines and I don't seem to understand some basic examples:

fun main() = runBlocking {
//sampleStart
    launch {
        repeat(1000) { i ->
            println("I'm sleeping $i ...")
            delay(500L)
        }
    }
    delay(1300L) // just quit after delay
//sampleEnd    
}

Prints 3 lines and exits because it uses a daemon thread

I'm sleeping 0 ...
I'm sleeping 1 ...
I'm sleeping 2 ...

But main waits for

coroutineScope

to finish execution

fun main() = runBlocking { // this: CoroutineScope
    launch { 
        delay(200L)
        println("Task from runBlocking")
    }

    coroutineScope { // Creates a new coroutine scope
        launch {
            delay(900L) 
            println("Task from nested launch")
        }

        delay(100L)
        println("Task from coroutine scope") // This line will be printed before nested launch
    }

    println("Coroutine scope is over") // This line is not printed until nested launch completes
}

And prints this

Task from coroutine scope
Task from runBlocking
Task from nested launch
Coroutine scope is over

Is there a magic done by

coroutineScope

that makes it block the main from finishing? Any help is appreciated.

Hello folks, we have recently started experimenting with CoroutineWorker APIs from WorkManager. Is there any way to customize the underlying scope and exceptionHandler in for these workers(given the job object is internal in the class and we can only override the dispatcher)?

📣 📣 📣

kotlinx.coroutines

1.2.0-alpha is here! This is an alpha version of the major release with a lot of improvements in debuggability, diagnostics and performance. Changelog: * Debug agent now merges real stacktraces with coroutine stacktraces, its API is cleaned up and debug agent is on its road to stabilization *

CoroutineTimeout

test rule for JUnit4 to simplify testing and debugging with coroutines * Futures are now integrated with structured concurrency *

Dispatchers.Unconfined

,

MainCoroutineDispatcher.immediate

,

MainScope

and

CoroutineScope.cancel

are promoted to stable API *

CompletableJob

is introduced,

Job()

and

SupervisorJob()

are now completable *

ensurePresent

and

isPresent

extensions for

ThreadLocal

*

ensureActive

extensions for

CoroutineContext

,

CoroutineScope

and

Job

* Operator

invoke

on

CoroutineDispatcher

...and a lot more, full changelog: https://github.com/Kotlin/kotlinx.coroutines/releases/tag/1.2.0-alpha

Hi everyone I'm working with Kafka via Kotlin and we want to transform its

Future

implementation (https://github.com/apache/kafka/blob/trunk/clients/src/main/java/org/apache/kafka/clients/producer/internals/FutureRecordMetadata.java) as

Deferred

. Could this be a solution?

fun <T> Future<T>.asDeferred(): Deferred<T> {
    return GlobalScope.async(<http://Dispatchers.IO|Dispatchers.IO>) {
        get()
    }
}

@rocketraman suggested to follow also this solution: https://stackoverflow.com/questions/50793362/how-to-use-suspendcoroutine-to-turn-java-7-future-into-kotlin-suspending-functio#answer-52901712 Which of these two is the most correct?

Hi there, We are migrating some parts of our over-used RxJava codes to Coroutines, but we cannot decide which one is the best practice as a new learners! old code is something like this:

interface CallLogDataStore {
    fun getCallLogs(): Single<Array<CallLogEntity>>
}

class CallLogDataStoreImpl @Inject internal constructor(
    private val contentResolver: ContentResolver
) : CallLogDataStore {

    override fun getCallLogs(): Single<Array<CallLogEntity>> = Single.fromCallable(::queryAllCallLogs)

we can change it to

Deferred

from the source:

interface CallLogDataStore {
    suspend fun getCallLogsAsync(): Deferred<Array<CallLogEntity>>
}

class CallLogDataStoreImpl @Inject internal constructor(
    private val contentResolver: ContentResolver
) : CallLogDataStore {

    override suspend fun getCallLogsAsync(): Deferred<Array<CallLogEntity>> =
        suspendCoroutine { queryAllCallLogs() }

or just keep it simple and let the use-case decide to execute it using Coroutines or not,

interface CallLogDataStore {
    fun getCallLogs(): Array<CallLogEntity>
}

class CallLogDataStoreImpl @Inject internal constructor(
    private val contentResolver: ContentResolver
) : CallLogDataStore {

    override fun getCallLogs(): Array<CallLogEntity> =
        queryAllCallLogs()

interface CallLogRepository {
    suspend fun getCallLogsAsync(): Deferred<Array<CallLog>>
}

class CallLogRepositoryImpl @Inject internal constructor(
    private val dataStore: CallLogDataStore,
    private val mapper: CallLogMapper
) : CallLogRepository {

    override suspend fun getCallLogsAsync(): Deferred<Array<CallLog>> =
        GlobalScope.async { dataStore.getCallLogs().map(mapper::mapFromEntity).toTypedArray() }
}

any suggestion?

I/System.out: RendezvousChannel@6d58005{ReceiveQueued,queueSize=4}

can anyone elaborate what

queueSize

means?

Is there a suggested approach to cooperative cancellation when calling into code from a coroutine that may not know or care that it's executing inside of a coroutine? The best thought I had was to pass along a facade around the

Job

.

interface ActiveIndicator {
  val isActive: Boolean
  fun ensureActive()
}

private class JobActiveIndicator(private val job: Job) : ActiveIndicator {

  override val isActive: Boolean get() = job.isActive

  override fun ensureActive() {
    job.ensureActive()
  }

}

suspend fun doSomething() {
  val job = coroutineContext[Job]!!
  executeCancellableTask(JobActiveIndicator(job))
}

// (Possibly even in Java code somewhere)
fun executeCancellableTask(activeIndicator: ActiveIndicator) {
  while (activeIndicator.isActive) {
    // Do some work
  }
}

What's the recommended way for swapping Default and IO schedulers for UI tests on Android

Folks I know how to convert

ExecutorService

to a coroutine dispatcher. How can I do it the other way around i.e. get ExecutorService from disptacher