kotlinx-coroutines-test:1.3.8-1.4.0-rc

suspend fun doWork(progress: (Progress) -> Unit)

fun doWork(): Flow<Progress>

fun doWorkIn(scope: CoroutineScope): StateFlow<Progress>

tunnel.pipe.send("LOPI")

            tunnel.pipe.asFlow().flowOn(Dispatchers.Main).collect {

                tvPUI.text = it.toString()
            }

            delay(2000)

            tunnel.pipe.send("HOLA")

e: org.jetbrains.kotlin.codegen.CompilationException: Back-end (JVM) Internal error: Couldn't inline method call 'collectInMainBy' into

inline fun <reified T> Flow<T>.collectInMainBy(
    crossinline onCollect: suspend (T) -> Unit,
    crossinline onFailure: suspend (Throwable) -> Unit = { Timber.e(it, tag) }
) {
    onEachCatching(onCollect, onFailure).launchInMain(lifecycleScope)
}

inline fun <reified T> Flow<T>.onEachCatching(
    crossinline onEach: suspend (T) -> Unit,
    crossinline onFailure: suspend (Throwable) -> Unit
) : Flow<T> {
    return onEach {
        onEach(it)
    }.catch {
        onFailure(it)
    }
}

fun <T> Flow<T>.launchInMain(scope: CoroutineScope): Job = scope.launch(Dispatchers.Main) {
    collect()
}

buttonProceed.clicks().collectInMainBy(
    onCollect = { viewModel.proceedButtonClicked() }
)

fun main() = runBlocking {

    val job = launch {
        repeat(5) { index ->
            println("operation number $index")
            ensureActive()
            Thread.sleep(100)
        }
    }
    delay(150)
    job.cancel()

}

fun home(): Flow<HomeResponse> =
        flow { emit(ApiService.home()) }.flowOn(<http://Dispatchers.IO|Dispatchers.IO>)

@ExperimentalCoroutinesApi
fun home() {
    viewModelScope.launch {
        repository.home()
            .onStart { _homeLiveData.postValue(Resource.loading(null)) }
            .catch { _homeLiveData.postValue(Resource.error(it.message ?: "", null)) }
            .collect { _homeLiveData.postValue(Resource.success(it)) }
    }
}

home()

// This is in a loop
val e = async {
  writeFileToDisk()
}
filesBeingWritten.add(e)

//somewhere else 
filesBeingWritten.awaitAll()

// This is in a loop
writeFileToDisk()

writeFileToDisk()

withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
  val get = Paths.get(imageFilename)
  Files.write(get, bytes)
}

delay

launch

fun processMessages(){
    for (message in messages) {
        val foo = async {processMessage(message)
        val bar = foo.await()? // Is this how we await on a suspending function?
        when (bar) {
            is Outcome.Error -> {// don't delete message, log error}
            is Outcome.Success -> {deleteMessage()}
        }
     }
}

suspend fun processMessage(message): Outcome<Foo>

sealed class Outcome<out T : Any> {

    data class Error(val message: String, val cause: Exception? = null) : Outcome<Nothing>()

    data class Success<out T : Any>(val value: T) : Outcome<T>()
}

Continuation.invokeOnCancellation

suspend operator

suspend inline operator fun <T> SuspendableLazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T
    = ...

private val value by suspendableLazy { getValue() }

fun test() = println(value)

private suspend fun getValue() { ... }

java.lang.NoClassDefFoundError: kotlin/coroutines/AbstractCoroutineContextKey

/**
 * Every time a new value is emitted from A, it will emit instead the latest value from B.
 */
fun <A, B : Any> Flow<A>.switchToLatestFrom(other: Flow<B>): Flow<B> = flow {
    coroutineScope {
        val latestB = AtomicReference<B?>()
        val outerScope = this
        launch {
            try {
                other.collect { latestB.set(it) }
            } catch (e: CancellationException) {
                outerScope.cancel(e)
            }
        }
        collect {
            latestB.get()?.let { b -> emit(b) }
        }
    }
}

@Test
fun `should emit the latest value from B every time A emits something`() {
    val a = flowOf(1, 2, 3).onEach { delay(100) }
    val b =  flowOf('A', 'B', 'C', 'D').onEach { delay(25) }

    runBlocking {
        val result = a.switchToLatestFrom(b).toList()
        val expected = listOf('C', 'D', 'D')

        assertEquals(
            expected = expected,
            actual = result
        )
    }
}

java.lang.AssertionError:

Expected :[C, D, D]

Actual   :[B, D, D]

1.4.0