coroutine recipies

class BlankViewModel : ViewModel() {

    fun testCoroutines() {
        viewModelScope.launch(Dispatchers.IO) {


        }

        runBlocking {
            launch {

            }

            launch {

            }

            var one = async {

                getOne()

            }

            var two = async {
                getTwo()
            }

            println("The answer is ${one.await() + two.await()}")
        }



        GlobalScope.launch {

        }
    }

    fun main() {
        val time = measureTimeMillis {
            // we can initiate async actions outside of a coroutine
            val one = somethingUsefulOneAsync()
            val two = somethingUsefulTwoAsync()
            // but waiting for a result must involve either suspending or blocking.
            // here we use `runBlocking { ... }` to block the main thread while waiting for the result
            runBlocking {
                println("The answer is ${one.await() + two.await()}")
            }
        }
        println("Completed in $time ms")
    }

    suspend fun getTwo(): Int {
        delay(1000L) // pretend we are doing something useful here, too
        return 2;
    }

    suspend fun getOne(): Int {
        delay(1000L) // pretend we are doing something useful here, too
        return 0;
    }

    fun somethingUsefulOneAsync() = GlobalScope.async {
        doSomethingUsefulOne()
    }

    // The result type of somethingUsefulTwoAsync is Deferred<Int>
    fun somethingUsefulTwoAsync() = GlobalScope.async {
        doSomethingUsefulTwo()
    }

    suspend fun doSomethingUsefulOne(): Int {
        delay(1000L) // pretend we are doing something useful here
        return 13
    }

    suspend fun doSomethingUsefulTwo(): Int {
        delay(1000L) // pretend we are doing something useful here, too
        return 29
    }

    suspend fun concurrentSum(): Int = coroutineScope {
        val one = async { doSomethingUsefulOne() }
        val two = async { doSomethingUsefulTwo() }
        one.await() + two.await()
    }

    private suspend fun doLongRunningTask() {
        withContext(Dispatchers.Default) {
            // your code for doing a long running task
            // Added delay to simulate
            delay(5000)
        }
    }
}