You cannot create class that inherits from a function

kind of android related, but which coroutine scope would you use in background services? e.g. intent services or job services?

I haven't touched coroutines in a while.

runBlocking

is now showing a

deprecated

warning, but I can find no information about this anywhere on the internet, not even the actual documentation https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html. Anyone know what is up with

runBlocking

? What will it be in 1.4?

I'm looking for a coroutine equivalent of CountdownLatch (even just for the most basic n=1 case) where one coroutine can block until another coroutine says it can go. What am I looking for?

There seems to be a lot of experimental/obsolete annotations on things - any ideas when those will go away? Specifically around things like tickers/produce/consume etc

Trying to run macx64Test of

native-mt

branch of the coroutines library using kotlin 1.3.70 and getting the below error message:

Expiring Daemon because JVM heap space is exhausted

Any pointers? When I've been running into ios-specific issues in my codebase, I've been using the nativeTest setup in coroutines to write sanity tests to confirm or reject learnings. It takes a good 1-2 minutes with kotlin 1.3.61 to compile and run the tests though, so I am eager to see some improvement.

/**
 * You can edit, run, and share this code. 
 * <http://play.kotlinlang.org|play.kotlinlang.org> 
 */

import kotlinx.coroutines.*

fun main() {
    println("Hello, world!!!")
    CoroutineScope(<http://Dispatchers.IO|Dispatchers.IO>).launch {
        (1..1000).forEach {
            suspend {
                delay(2000)
                print("Testing...")
            }
        }
    }
}

What kind of block is

suspend {}

?

In Flow, Why there's a

completion

listener with throwable , wouldn't be just simpler to provide it for just completion, and we already have

catch {}

Hi all. Imagine I have a server that is adding an objects to queue continuously and I have a n-amount of threads that taking an object from queue, does some computation and saving result to database. Is it possible to do the task in the same way with coroutines, and if it is can someone help me please?

Is there a way to add suspended functions in processing Queue (or similar). I have use case where I am getting different callbacks that updates same entity in database. Instead of execute suspended functions async, I want to execute them in same order that callback was received. Is there a way to do it?

is a channel always first in first out? Can I receive from a channel based on a filter, and if that filter fails to pass, leave those items in that channel? I have

Channel<T>

, and that

T

has two subclasses,

T.One

and

T.Two

. I need the first emission of

T.Two

to initialize some state in a coroutine, and after that I want to observe all emissions of

T

. But if

T.One

emits first, I want to queue it up (leave it in the channel), and allow it to emit once the first instance of

T.Two

finishes emitting.

porting some c++ code to kotlin, I'm dealing with this right now. Since I'm a newbie in coroutines, I'd like to ask you if I'm better implementing this via a

Thread

or a kotlin coroutine..

Hi, has anyone came across InvalidMutabilityExceptions when using Flow combine operators on native targets? I'm using the 1.3.3-native-mt version.

I think I got a lint issue when I use a suspend function as parameter

calling launch within launch is not structured concurrency anymore right?

val upperJob = launch {
 val jobFoo1 = launch {
      foo1()
   }
   val jobFoo2 = launch {
      foo2()  
   } 
}
upperJob.cancel() //won't cancel jobFoo1 and jobFoo2

right? I have to use

async

here

supervisorScope {
    async {
        throw Exception()
    }

    async {
        throw Exception()    
    }
}

^ app doesn't crash

supervisorScope {
    launch {
        throw Exception()
    }

    launch {
        throw Exception()    
    }
}

^ app crashes what am I doing wrong?

@elizarov https://bintray.com/kotlin/kotlinx/kotlinx.coroutines/1.3.4 Somethings wrong

📣 📣 📣 kotlinx.coroutines 1.3.4 is here! • Size of the resulting DEX of kotlinx.coroutines basic usages is significantly reduced • A human-readable actionable error is thrown when

awaitClose

is missing from

callbackFlow

•

Flow

exception transparency is now deterministically ensured •

ReceiveChannel.asFlow

extension added • Kotlin 1.3.70: opt-in annotations,

coroutineContext[CoroutineDispatcher]

API support • Performance improvements in

Job

,

Channel

and

Dispatchers.Default

Full changelog: https://github.com/Kotlin/kotlinx.coroutines/releases/tag/1.3.4

This message was deleted.

For a channel what is the opposite of a flatMap, in other words how to take a channel of some array and start sending the values individually?

Hi. I'm just starting to use coroutines. I need to create a refreshable countdown thingie. Basically it has to do something 10 minutes after some event, if the event happens during those 10 minutes again, countdown should be refreshed. Here's my naive implementation, any suggestions? Am I shooting myself in the foot here? Should I add synchronization/locking?

Hello everyone. Is there a alternative to

ObservableTransformer

when using

Flow

or

Channel

?

Hi. I’m starting to learn about coroutines and flows, and I’m wondering how one might do the equivalent of reactor’s

Flux.flatMapSequential()

, i.e. a flattenMerge(), but which would emit the values in the initial order of the merged flows. Any idea? I find such an operator quite useful, for example when you want to send HTTP requests in parallel, but with a limited concurrency, and still want to process the responses as if they had been sent sequentially.

I need to return last element of the flow along with its index, is there a prettier way?

Hey all can you guys explain me a little bit about EmptyCoroutineContext and ContinuationInterceptor I do not get it at all. I'm learning about coroutine contexts and I found these

If I have a

Channel<Unit>(capacity = Channel.UNLIMITED)

and I never close it, is it guaranteed that

offer

will always succeed?

Can someone explain why

Result

was added to the standard lib, when it’s effectively useless outside of Coroutines? https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-result/ A standard

Result<T>

type that we could use as a return value would be incredible useful, and this seems to be a waste of a namespace?

What is the current status of the Actor API in the KotlinX Coroutines library? I have a program (Industrial software that behaves like a Linux Daemon) running in production that heavily relies on the API, and would very likely break if a newer version of the KotlinX Coroutines library is used.