what would be the best way to implement RxJava's

interval

in coroutines?

while true loop + delay

that simple eh? nice

Anyone ran into a error like this

shl(Int): UInt' is only available since Kotlin 1.4 and cannot be used in Kotlin 1.3

Ive updated to 1.4 , but for some strange reason this shows up. but wasn't show up in 1.3 🤷‍♂️

I have read the whole documentation, seen a lot of video conferences from Elizarov and is still not clear

Anybody knows when connetable Flows (publish,share, replay..) will be released? they seem to be merged already

Unfortunately not merged yet https://github.com/Kotlin/kotlinx.coroutines/pull/2069 🙂 Many are waiting just be patient 🙂

I'm reading this but I think it's lacking an example, so I have to imagine it myself... https://kotlinlang.org/docs/reference/coroutines/channels.html#building-channel-producers

The pattern where a coroutine is producing a sequence of elements is quite common. This is a part of producer-consumer pattern that is often found in concurrent code. You could abstract such a producer into a function that takes channel as its parameter, but this goes contrary to common sense that results must be returned from functions.

It means something like this?

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

suspend fun produceSquares(channel: Channel<Int>) {
    for (x in 1..5) channel.send(x * x)
    channel.close()
}

fun main() = runBlocking {
    val squares: Channel<Int> = Channel()
    launch {
        produceSquares(squares)
    }

    for (value in squares) {
        println(value)
    }
    println("Done!")
}

Hola, I've upgraded my Android project to use 

ext.kotlin_version = "1.4.0"

 and I cannot import Coroutine 

kotlinx.coroutines.channels.actor

. I know Actors were marked as obsolete. Have Complex Actors replaced them? Did I miss a memo 😉 🤔 My Gradle resembles this:-

api 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.9'
api 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9'

I hit the same error as described here: https://github.com/Kotlin/kotlinx.coroutines/issues/1909 I am on 1.4 and I checked to make sure that I am using 1.3.9 coroutines. I then ran

./gradlew dependencies

and I saw this for the kotlin-scriptin-compiler-embeddable jar that I use:

kotlinCompilerPluginClasspath
\--- org.jetbrains.kotlin:kotlin-scripting-compiler-embeddable:1.4.0
     +--- org.jetbrains.kotlin:kotlin-scripting-compiler-impl-embeddable:1.4.0
     |    +--- org.jetbrains.kotlin:kotlin-scripting-common:1.4.0
     |    |    +--- org.jetbrains.kotlin:kotlin-stdlib:1.4.0
     |    |    |    +--- org.jetbrains.kotlin:kotlin-stdlib-common:1.4.0
     |    |    |    \--- org.jetbrains:annotations:13.0
     |    |    \--- org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7
     |    |         +--- org.jetbrains.kotlin:kotlin-stdlib:1.3.71 -> 1.4.0 (*)
     |    |         \--- org.jetbrains.kotlin:kotlin-stdlib-common:1.3.71 -> 1.4.0
     |    +--- org.jetbrains.kotlin:kotlin-scripting-jvm:1.4.0
     |    |    +--- org.jetbrains.kotlin:kotlin-script-runtime:1.4.0
     |    |    +--- org.jetbrains.kotlin:kotlin-stdlib:1.4.0 (*)
     |    |    \--- org.jetbrains.kotlin:kotlin-scripting-common:1.4.0 (*)
     |    +--- org.jetbrains.kotlin:kotlin-stdlib:1.4.0 (*)
     |    \--- org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7 (*)
     \--- org.jetbrains.kotlin:kotlin-stdlib:1.4.0 (*)

Should I be worried about kotlinx-coroutines-core:1.3.7 being pulled in?

Is there any way to prevent a coroutine from being cancelled when its

Job

is cancelled but still having it be cancelled if the parent job is cancelled. Here is a short snippet showcasing the issue:

val job = launch {
  delay(400.milliseconds)
  showView()
  try {
    // Ideally I would like this part to mean job.cancel() has no effect
    // but if the parent job is cancelled it should cancel immediatly
    withContext(NonCancellable) {
      delay(400.milliseconds)
    }
  } finally {
    hideView()
  }
}

Hi Everyone... I have a very crude demo of a new project with Kotlin and Coroutines. Basically what VHDL is to Circuit Design, this project is to music production (replaces DAWs). It will likely take me a long time to build it 6months-1year but would rather do it quicker with some help. If anyone is interesting on working on something like that and knows kotlin/coroutines let me know, I can give you more information.

Hi everyone Is there a way to use Flow in swift interop without loosing generic type info?

MutableStateFlow

is defined as a function and since obj-c supports generics only for classes you get

Any?

in swift :/

Hello everyone. I am carrying out some research on optimizing JPEG2000 image processing on Android, using coroutines instead of AsyncTask. But I ran into something weird. The results I obtain with AsyncTask are better than those I obtain with coroutines. Please can anyone help me out here?

Hi! Does anybody have a rough idea about how likely it is for the experimental

kotlinx-coroutines-test

to change and when it will become stable? Thanks!

Is it expected that the coroutine debugger does not work if I pause the program manually instead of hitting a breakpoint?

is the typesafe actors implementation ever going to be revived?

Any idea what can I do to fix this? Or maybe I shouldn’t be using 

StateFlow

 at all? 🤔

Hi all 👋🏼 Curious if `TestCoroutineDispatcher`’s

advanceTimeBy(...)

needs to be called inside a

TestBuilders

runBlockingTest { ... }

. Can it be used without the

TestBuilders

runBlockingTest { … }

?

(

runBlockingTest

is running on the same injected dispatcher )

How do you, from a coroutine A, run something on another thread (a Ktor request or any coroutine B) and suspend while waiting for the result, without freezing coroutine A, using 1.3.9-native-mt? Slack Conversation

So I'm trying to write a test that uses a main dispatcher that should mirror how the standard Android main dispatcher works (with immediate support) but I'm not getting the immediate part to work. I've correctly wired

isDispatchNeeded

to work and I see that it tried to run it directly but it gets caught in

DispatchedContinuation<*>.executeUnconfined(...)

because

eventLoop.isUnconfinedLoopActive

is true. Is there a sane approach to testing this?

I'm not sure how the standard android dispatcher avoid this actually since its run loop would also be busy I assume?

I have no idea what I did but it resolved itself ¯\_(ツ)_/¯

is there any operator like debounce, but emitting the first x items without it ? It's tricky to make an operator for that:pP

Hey folks! I'm starting with Flows and have a question, especifically with StateFlow. I found a use case that I'm not sure whether it's a good one or not. I'm writing a simple paging system for an Android App, where I inform the VM of the current latest visible item in the adapter, and then this calls the repository to check whether it has the current page or it needs to go the server to get the next one. I initially did it with a regular

launch

, but of course this is not a good idea, because the latest visible item can change several times before the request is finished, and it will run the request to the same page several times too. So I used a StateFlow in the ViewModel, which is public and mutable, so that the Activity can modify the value with the latest visible item, and then I collect it in the ViewModel and run the request to the repository. As the next value is not processed until the previous one is processed, it works perfectly. But I'm not sure if I'm "hacking" the system somehow 😅 Here's the code for reference:

recycler.addOnScrollListener(object : RecyclerView.OnScrollListener() {
                override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
                    viewModel.lastVisible.value = layoutManager.findLastVisibleItemPosition()
                }
            })

init {
        viewModelScope.launch {
            lastVisible.collect { value ->
                repository.checkRequireNewPage(value)
                _spinner.value = false
            }
        }
    }

That

_spinner

is also a MutableStateFlow that I'm then exposing with a public non mutable property, which I think is the regular use of StateFlow (an equivalent to LiveData). That's why I'm not sure if my other code is right or I'm missing something.

Is there a good reference for Kotlin coroutine API naming of API facades?

We’re adding Coroutine support to a Redis client which follows the following naming scheme:

// for reference: 
val api: RedisClusterCommands<String, String> = connection.sync()
val api: RedisClusterAsyncCommands<String, String> = connection.async()

any news on

Flow,shareIn

release?