class MovieRepositoryImpl(private val api: MovieApi):MovieRepository {
    override suspend fun fetchMovie(): Movie {
      return api.fetchMovie()
    }

    override suspend fun fetchMoviePopular(): MoviePopular {
       return api.fetchMoviePopular()
    }

    override suspend fun fetchFaves(): Faves {
        return api.fetchFaves()
    }
}

fun fetchAll():Triple<Movie,MoviePopular,Faves> = supervisorScope {
        val movieDeferred = async { fetchMovie() }
        val moviePopularDeferred = async { fetchMoviePopular() }
        val favesDeferred = async { fetchFaves() }
        val movie = movieDeferred.await()
        val moviePopular = moviePopularDeferred.await()
        val faves = favesDeferred.await()
        return@supervisorScope Triple(movie,moviePopular,faves)
    }

// MyRepository.kt
class MyRepository<T>(coroutineScope: CoroutineScope) {
    private val scope = couroutineScope + Dispatchers.Default
    private val dataSource: DataSource<T> = DataSource()

    fun add(newValue: T) {
        scope.launch {
            dataSource.new(newValue)
        }
    }
}

// Example usage in a Compose Desktop app
// Main.kt
@Composeable
@Preview
fun App() {
    val appScope = rememberCoroutineScope { Dispatchers.Main }
    val repository = MyRepository(appScope)
    MainScreen(repository)
}

@JvmField
internal val CORE_POOL_SIZE = systemProp(
    "kotlinx.coroutines.scheduler.core.pool.size",
    AVAILABLE_PROCESSORS.coerceAtLeast(2),
    minValue = CoroutineScheduler.MIN_SUPPORTED_POOL_SIZE
)

internal val AVAILABLE_PROCESSORS = Runtime.getRuntime().availableProcessors()

class NetworkBackedBookRepository(
    private val api: ApiService,
) : BookRepository {
    override suspend fun getBook(id: String): Book? {
        val result = api.getBookById(id).execute()
        return result.body()?.firstOrNull()
    }
}

class PaymentViewModel(...) : ViewModel() { // in an android app
    private val _state = MutableStateFlow<PaymentStatus>()
    val state = _state.asStateFlow()

    fun pay() {
        ...
    }

    private fun payWithCard {
        paymentWithCard() // returns a flow of PaymentStatus
    }

    private fun payWithApp {
        payWithApp() // returns a flow of PaymentStatus
    }
}

_state

paymentWithCard()

paymentWithApp()

collect { … }

advanceTimeBy

currentTime

implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")

androinMain

Module with the Main dispatcher is missing. Add dependency providing the Main dispatcher, e.g. 'kotlin-coroutine-android' and ensure it has the same version as 'kotlin-coroutine-core'

List<Flow<String?>>

override val view: Flow<WidgetView> = combine(
        expandedBranches, isWidgetCollapsed
    ) { paths, isWidgetCollapsed -> Pair(paths, isWidgetCollapsed)
    }.flatMapLatest { switchToNewFlow() based on Pair  }

@Test
fun `Foobar is foo`() = runTest {
    val job = launch {
        println("Coroutine 1: Going to sleep for 3000. currentTime = $currentTime")
        delay(3000)
        println("Coroutine 1: Delay is over. currentTime = $currentTime")
    }
    launch {
        println("Coroutine 2: Going to sleep for 1000. currentTime = $currentTime")
        delay(1000)
        println("Coroutine 2: Delay is over, cancelling other Coroutine. currentTime = $currentTime")
        job.cancel()
    }
    advanceTimeBy(500)
    println("advance 500: currentTime 1 = $currentTime")

    advanceTimeBy(500)
    println("advance 500: currentTime 2 = $currentTime")

    advanceUntilIdle()
    println("advanceUntilIdle: currentTime 3 = $currentTime")

    assertEquals(1000, currentTime)
}

Coroutine 1: Going to sleep for 3000. currentTime = 0
Coroutine 2: Going to sleep for 1000. currentTime = 0
advance 500: currentTime 1 = 500
advance 500: currentTime 2 = 1000
Coroutine 2: Delay is over, cancelling other Coroutine. currentTime = 1000
advanceUntilIdle: currentTime 3 = 3000

expected:<1000> but was:<3000>
Expected :1000
Actual   :3000

currentTime 3

private fun CoroutineScope?.launchWithNullCheck(
        block: suspend () -> Unit
    ) {
        this?.let {
            Log.d("FUI", "Scope not null")
            val job = launch {
                Log.d("FUI", "executing block not null")
                block()
            }
            Log.d("FUI", "job isActive ${job.isActive}, isCompleted: ${job.isCompleted}, isCancelled: ${job.isCancelled}")
        }
}

subscriptionCount

MutableSharedFlow

SharedFlow

object MyObject {

    suspend fun repeatWork() {
        while (true) {
            // do something
            delay(5_000L)
        }
    }
}

class SomeClass {
    fun doWork() {
        someClassScope.launch { MyObject.repeatWork() } 
    }
}

class AnotherClass {
    fun doAnotherWork() {
        anotherClassScope.launch { MyObject.repeatWork() } 
    }
}

SomeClass().doWork()
AnotherClass().doAnotherWork()

object MyObject {

    private var repeatWorkJob: Job? = null

    suspend fun repeatWork() = coroutineScope {
        if (repeatWorkJob?.isActive == true) return
   
        repeatWorkJob = launch {
            while (true) {
                // do something
                delay(5_000L)
            }
        }
    }
}

class FooViewModel(private val appScope: CoroutineScope) : ViewModel() {

    fun fooClicked() {
        viewModelScope.launch {
            delay(2000)
            withContext(appScope.coroutineContext) { <---------------------------
                // Should run even when view user clicks back (i.e. view model cleared)
                delay(2000)
            }
        }
    }
}

appScope.launch { .. }

withContext

viewmodel this

CancellationExceptions

kotlinx.coroutines

kotlinx-atomicfu

StateFlow

Channel

Mutex

select

kotlinx-coroutines-core

kotlinx-coroutines-jdk8

kotlinx-coroutines-test

<http://Dispatchers.IO|Dispatchers.IO>

suspend fun Logout(token: String) {
    val userId = appService.currentUser!!.id       ///// this will execute 1st
    realm.write {                                  ///// this will execute 2nd
        var user = query<UserInfo>("_id = $0", userId).first().find()
        if (user != null) {
            user = findLatest(user)!!.also {
                it.FCMToken.remove(token)
            }
            copyToRealm(user)
        }
    }
    withContext(Dispatchers.Default) {             ///// this will execute 3rd

        realm.syncSession.uploadAllLocalChanges()  ///// this will execute 4rd

        appService.currentUser?.logOut()           ///// this will execute 5th
    }
}

class Processor {
    private val condition1 = MutableStateFlow(false)
    private val condition2 = MutableStateFlow(false)
    private suspend fun process(): Processed { ... }
    init {
        someScope.launch {
            combine(condition1, condition2) { a, b -> a || b }
                .collectLatest { process() }
        }
    }
    fun setCondition1() { condition1.value = true }
    fun setCondition2() { condition2.value = true }
}

process()

Deferred<Processed>