kotlinlang #coroutines

I tried to achieve "well-designed" actor system. But in my experimentations I found very difficult to compose actors without using the ask & wait anti-pattern. It is possible, but it quickly leads overcomplicated code IMHO. Do you have good resources where I could learn how to nicely compose actors without ask & wait?

tiwiz

10/10/2018, 10:04 AM

Ehy y'all! I have a problem with testing with the new Coroutines. The problem is that I have a very long sync operation and I want to test the

runBlocking

behaviour happens even with a possible delay. In the following gist (https://gist.github.com/tiwiz/b85c72fb77148e6cc12aa378b762e94b) there is the code (the

delay

is only to test if the test waits or not). So far, we couldn't have it to wait, so we must be doing something wrong... does anyone have a clue about it?

rocketraman

10/10/2018, 12:54 PM

How best to call suspend functions from

Sequence.map

and

flatMap

? These operations on

Sequence

are not inlined, unlike

List

, so you get the error

Suspension functions can only be called within coroutine body

. I don't want to use

runBlocking

inside the lambda.

poohbar

10/10/2018, 4:21 PM

fun <A, B> Sequence<A>.pmap(f: suspend (A) -> B): Sequence<B> = runBlocking {
    map { async(Dispatchers.Default) { f(it) } }.map { it.await() }
}

how come this says

Suspension function can be called only within couroutine body

on the

it.await()

call?

serebit

10/10/2018, 5:52 PM

are coroutines going to be merged into the standard library (kotlin-stdlib) for the 1.3 release, or will they remain a separate artifact?

digitalsanctum

10/10/2018, 6:56 PM

I'm getting started using coroutines and attempting to do a fan out with single producer and multiple consumers. if executing via main, what's the best way to signal the main thread when consumers are done consuming without using

delay

otakusenpai

10/10/2018, 7:27 PM

Well I want the docs for ByteReadChannel and ByteWriteChannel But i can't find the io package here https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/

spand

10/11/2018, 6:13 AM

Is this correct and the most concise way of having cleanup in the implement CoroutineScope pattern?

class Activity : CoroutineScope {
    var job = Job()
    override val coroutineContext: CoroutineContext
        get() = Dispatchers.Default + job

    init {
        val workJob = launch(start = CoroutineStart.LAZY) {
            // Doing stuff
            delay(5000)
        }
        launch(start = CoroutineStart.ATOMIC) {
            try {
                workJob.join()
            } finally {
                println("Cleaning up")
            }
        }
    }

    fun destroy() {
        job.cancel()
    }
}

David W

10/11/2018, 3:36 PM

Any recommendations on how to unit test an

actor

? Basically I have a redux-ish pipeline where each input may result in 0+ state changes. Not sure how to tell when my pipeline is "inactive".

greatly_simplified_pipeline.kt

acando86

10/11/2018, 5:07 PM

I have a list of ids and for each single id i wanna perform a network request to fetch more data about that id, and return the list of "hydrated" ids.. this is a pretty standard usecase, so far so good. I have a suspend function to fetch the data for a single id, I wanna parallelise the network requests, and it's important for me that the final list is in the same order of the original list (aka, kind of

concatMap

of Rx). Is

awaitAll

order-preserving on lists? if not, what's the best way to be non-blocking on the map while keeping the order of the list?

Ruckus

10/11/2018, 8:45 PM

Does

Mutex.tryLock()

always return true? Or does it just not work like

ReentrantLock

Slackbot

10/12/2018, 5:15 AM

This message was deleted.

👍 1

Jan

10/12/2018, 9:13 AM

hi guys, i'd like to learn more about coroutines, can someone point me some good sources that explain error handling well?

mayojava

10/12/2018, 9:51 AM

while trying to explain the difference

runBlocking

and

coroutineScope

in the coroutine docs, it says

coroutineScope

does not block the current thread while waiting for all its children to complete. Then an example was given that shows otherwise.

coroutineScope

actually blocks the thread that

runBlocking

was invoked from while waiting for its children to complete. Have I understood this the wrong way?

mayojava

10/12/2018, 9:52 AM

This is the example:

fun main(args: Array<String>) = runBlocking { // this: CoroutineScope
    launch { 
        delay(200L)
        println("Task from runBlocking")
    }
    
    coroutineScope { // Creates a new coroutine scope
        launch {
            delay(500L) 
            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
}

enleur

10/12/2018, 10:31 AM

it is funny to watch how in Golang they are trying to solve problems that was solved in kotlin by design https://posener.github.io/goroutine-scoped-context/ (coroutineContext) https://github.com/golang/go/issues/27982 (job cancel) in my production code I found myself using channels only twice and never had to use selects. at the same time in Golang.. well, you don’t have any deferred/promise from the box and have to do workarounds with channels, selects, sync.Wait and if you want to do cancel or timeout you will end up with tons of boilerplate code

marcinmoskala

10/12/2018, 10:36 AM

Is there any explanation?

Vsevolod Tolstopyatov [JB]

10/12/2018, 12:21 PM

“Android Suspenders by Chris Banes” talk from KotlinConf'18 is now available on youtube:

https://www.youtube.com/watch?v=P7ov_r1JZ1g▾

Even if you are not an Android developer, this talk has a good explanation of coroutines mental model,

CoroutineScope

rationale and

kotlinx.coroutines

API overview in 30 minutes.

👍 17

❤️ 3

lukaswelte

10/12/2018, 1:13 PM

Is there a function on

CoroutineScope

which is

onError

? So in case any of the coroutines in the scope are cancelled or failing it will not cancel the parent scope routines, but instead invoke the error handler. Or is

try-catch

around the

coroutineScope {}

currently the only way?

muralimohan962

10/12/2018, 2:21 PM

Does the coroutineScope {} block the runBlocking coroutine code?

lukaswelte

10/12/2018, 3:16 PM

The “coroutines are lightweight” example will produce a OutOfMemory Exception in the kotlin playground. Is there something special about the playground or did something change in regard to how coroutines https://pl.kotl.in/SysF9E09m

import kotlinx.coroutines.*
    
fun main() = runBlocking {
    repeat(100_000) { // launch a lot of coroutines
        launch {
            delay(1000L)
            print(".")
        }
    }
}

🤣 3

spierce7

10/12/2018, 3:47 PM

Something I haven't quite figured out that has been bothering me about the

RendezvousChannel

. The

RendezvousChannel

seems like a

PublishSubject

from RX, but the documentation says something that worries me:

An element is transferred from sender to receiver only when send and receive invocations meet in time

So I understand that before I start listening to the

Channel

, all events emitted to it won't be received. Is it possible though that if I'm already listening to events on the

Channel

that I'll miss any?

Ruckus

10/12/2018, 4:54 PM

If you use a different scope for

launch

(like

GlobalScope

) your code will work without

yield

enleur

10/13/2018, 7:46 PM

suspend fun whatever() = coroutineScope{
    while(isActive){ ... }
}

Paul Woitaschek

10/13/2018, 7:59 PM

Thanks, that works (both)

TwoClocks

10/13/2018, 9:21 PM

How do I get a "handle" to a provuce<T> if the stuff I want to produce can't be done inside the {}? Or another way of asking : How do I create a one-way channel?

Allan Wang

10/14/2018, 12:13 AM

I’m still at the stage where I’m reading about coroutines rather than using it extensively, but I have a few more questions: When it comes to writing suspended functions, is there anything we should look out for in terms of potential memory leaks? If I compare Android coroutines with anko, anko tends to wrap the receiver with a weakreference, so that you can retrieve it again during your call. It’s written as type

(T) -> Unit

T.() -> Unit

, which strikes me as a bit odd as anyone can use the original variable and forget about trying to get it from the weak reference. With coroutines, I don’t think weak references are used correct? Would it stand that so long as we make the coroutine scope agree to our lifecycle, we don’t have to worry about leaking variables beyond what we would normally consider when writing synchronous code? More specifically to Android, is there a general practice for writing suspended functions dealing with

Context

in a utility class where context would be passed through as an argument? Is it fine that we keep a global hashmap of deferred results if the scope cancels the job when appropriate?

oshai

10/14/2018, 7:37 AM

Hi, I am working on an ObjectPool that is using coroutines Actor and I will really be thankful for any code review feedback. It is not done yet but the code is here: https://bit.ly/2CI5bQZ and there are tests here https://bit.ly/2RLX4al Thanks in advance

egorand

10/14/2018, 6:22 PM

I’ve got the following problem: here’s an interface called `Source`:

interface Source : Closeable {
  @Throws(IOException::class)
  fun read(sink: Buffer, byteCount: Long): Long
}

I’m declaring

SuspendingSource

like this:

interface SuspendingSource : Source {
  @Throws(IOException::class)
  override suspend fun read(sink: Buffer, byteCount: Long): Long
}

which doesn’t compile because of

Conflicting overloads

. Is it forbidden to override non-suspend functions with suspend ones?

Title

egorand

10/14/2018, 6:22 PM

I’ve got the following problem: here’s an interface called `Source`:

interface Source : Closeable {
  @Throws(IOException::class)
  fun read(sink: Buffer, byteCount: Long): Long
}

I’m declaring

SuspendingSource

like this:

interface SuspendingSource : Source {
  @Throws(IOException::class)
  override suspend fun read(sink: Buffer, byteCount: Long): Long
}

which doesn’t compile because of

Conflicting overloads

. Is it forbidden to override non-suspend functions with suspend ones?

Dominaezzz

10/14/2018, 6:43 PM

Yes, it is forbidden. Since the anyone calling

Source.read

doesn't not know to suspend.

egorand

10/14/2018, 6:47 PM

Ah, makes sense

Burkhard

10/14/2018, 11:42 PM

It’s also quite intuitive if you look at the generated bytecode of a suspend function. They work by passing a hidden extra argument which tells the function where to resume.

View count: 2