I would assume that one of its children havent completed or yield early enough to cancel futher processing

Any plans to support the actor model in kotlin/native code?

Any examples on how to use channels on iOS? I have a library that expects me to give a

ReceiveChannel

object, but in iOS I cannot instantiate

Kotlinx_coroutines_core_nativeReceiveChannel

because it has no accessible initializers

Hi. guys! I’m stuck with an issue in coroutines with switching back to the main thread after I updated - the kotlin version from ‘1.2.70’ to ‘1.3.20’ - the gradle plugin versino “3.2.1” to “3.3.1" I’m still using coroutines experimental lib version 0.19 : org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19 org.jetbrains.kotlinx:kotlinx-coroutines-android:0.19 The output is of that code is: I/System.out: Thread launchUI coroutine main I/System.out: Thread inside coroutine is ForkJoinPool.commonPool-worker-0 I/System.out: Thread after coroutine join ForkJoinPool.commonPool-worker-0 Also, I see the same with not switching to Main thread when use actor with default context(CommonPool) and then via the channel notify about updates and in consumeEach the thread didn’t change to main. Does anybody having such troubles?

Any of you coroutine pros want to tell me everything that is wrong with this function? I’m not 💯 with coroutines yet and have nobody to do reviews: https://github.com/pardom/oolong/blob/effect-typealias/oolong/src/main/kotlin/oolong/Oolong.kt#L12

You've missed a

return

in case

response.body()

is null, i.e. the

let

path is not executed

I want to create a Dispatcher that limits concurrency to 1, but I don’t want the expense of creating a new thread dispatcher. Is there a way to create a limited concurrency dispatcher from the Default dispatcher?

hello everyone. I came here to ask about https://github.com/Kotlin/kotlinx.coroutines/issues/172 . I have been looking up and down google/stackoverflow/github to find a good example for this pattern, with no success. In the github issue, user gildor said "This pattern is so often, I see questions about implementation at least each week on Kotlin Slack

#coroutines

channel", so I figured I come here ^^ Anyone have a link for an example? Thank you so much.

Lazy async inside suspend function blocks forever? I have such code:

fun main() = runBlocking {
        sth().await()
    }

    suspend fun sth() = coroutineScope {
        async(start = CoroutineStart.LAZY) {
            println("async execution")
        }
    }

The main function blocks forever, and the “async execution” is never printed. Could anyone give a hand, thanks. 😘

FYI I have created https://youtrack.jetbrains.com/issue/KT-30042

Hi, Is it possible to make suspend function calls to tail recursive when nested function calls outer function? Now in the example I'm getting stackoverflow. Do anyone have a suggestions what the proper way to implement this logic?

suspend fun connectToSocket() {
            suspend fun process(session: DefaultClientWebSocketSession) {
                while (session.isActive) {
                    session.incoming.onReceiveOrNull { frame ->
                        if (frame == null) {
                            session.close()
                            delay(2000)
                            connectToSocket() // <- do reconnect
                        }
                    }
                }
            }
            process(startSession())
        }
        connectToSocket()

I’m getting a crash on Android when I cancel my job, it seems like my uncaught exception handler is being called when one of the children is being cancelled. The exception is

JobCancelledException

which I thought was never supposed to cause a crash

Is there any way to handle dropped return values from a suspending coroutine? Say I do this:

fun processImage() {
  val file = createFile()
  try {
    // Do stuff with the file
  } finally {
    file.delete
  }
}

suspend fun createFile(): File = withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
  return File.createTemporaryFile("foo", "temp")
}

There is a case where

createFile

has finished but

processImage

has not yet been resumed. If during this time the job is cancelled we’ll never get a chance to clean up the file. Is there a way around this?

Can anyone explain what

CoroutineStart.ATOMIC

does? The documentation isn't very clear to me.

If I know my block will execute in the same coroutine context, how can I achieve the above by passing something into the block?

Hello, I have a question about fixed thread pools. I see that fixed thread pools are now obsolete https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/new-fixed-thread-pool-context.html Is there any suggested way to replace this? or should we continue with newFixedThredPoolContext (or java style executors) (Sorry for crospostng from #general)

We have a case where we need coroutines to work with a Java library with lambdas in-between two Kotlin libraries with coroutines. What would be the most elegant way to make this snippet work?

When you call

.freeze()

on an object, somewhere along the line it calls

FreezeSubgraph

internally. What is it that determines what is part of an object's subgraph that also gets frozen as a part of that object's freeze operation?

launching

coroutine

takes more than 700+

millis

. is it normal ? ,does

launch

builder takes that much of time?,i'm using this in android while displaying splash screen and then after 3 seconds delay closing splash

(Sorry, hit send too soon...)

getTESTInventoryPage(pg: Int)

makes a long-running SOAP call. I expected things to blow up--instead it appears to make the calls in an arbitrary order, but eight at a time (which happens to be the number of virtual cores on my machine. Which is exactly what I want. Which is extremely suspicious... 🙂

Hi. I need to create an actor that will own some mutable state and offer a request-response interface to manipulate it. What is the proper way to achieve that with coroutines and channels? Perhaps: - One single inbound channel that the clients use to send requests. - Each client creates its own reply channel, that is added to the request. - The actor coroutine sequentially fetch requests from the inbound channel, processes them, and sends the response to the reply channel referenced in the request. So, there will be a single request channel and one reply channel per client. Does this make sense? Is it possible to avoid having a reply channel per client?

Is there a clear pattern for launching true background work? Does supervisorScope instead of coroutineScope allow the work to continue in the background, while coroutineScope returns sooner?

What’s more idiomatic:

fun events(channel: SendChannel<Event>)
fun events(scope: CoroutineScope): ReceiveChannel<Event>

In my case I need to add a listener when calling

events

and remove it when the channel is closed

Hello, why does it not print 1 2 3

runBlocking {
            val producer = async {
                produce {
                    send(1)
                    send(2)
                    send(3)
                }
            }

            launch {
                producer.await().consumeEach { println(it) }
            }
        }

For such cases, I usually do something like this:

var delayedJob: Job? = null

fun onEvent() {
  delayedJob?.cancel()
  delayedJob = launch {
    delay(1000)
    // Do stuff
  }
}

is it thread safe to iterate over job’s children

job.children.toList()

? By looking into source seems should be fine, but want to confirm

Hello, I’m getting the attached warning in a suspend function inside an Android activity that implements the CoroutineScope. The code seems to work as expected but I’m a bit confused with the warning. Any ideas?

Mutex is there but I need the permits logic of semaphores