fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job

fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T>

val dispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher
launch(dispatcher) {
    delay(1000)
    println("Single thread dispatcher")
}

fun primes(start: Int): Sequence<Int> = sequence {
    println("Infinite prime sequence:")
    var n = start
    while (true) {
        if (n > 1 && (2 until n).none { i -> n % i == 0 }) {
            yield(n)
            println("\tGenerating next prime after $n")
        }
        n++
    }
}

fun main() {
    for (prime in primes(start = 10)) {
        println("Received $prime")
        if (prime > 30) {
            break
        }
    }
}

Infinite prime sequence:
Received 11
  Generating next prime after 11
Received 13
  Generating next prime after 13
Received 17
  Generating next prime after 17
Received 19
  Generating next prime after 19
Received 23
  Generating next prime after 23
Received 29
  Generating next prime after 29
Received 31

fun <T> sequence(
    block: suspend SequenceScope<T>.() -> Unit
): Sequence<T>

val job = launch {
    repeat(1000) { i ->
        println("job: I'm sleeping $i ...")
        delay(500L)
    }
}
delay(1300L) // delay a bit
println("main: I'm tired of waiting!")
job.cancel() // cancels the job
job.join() // waits for job's completion 
println("main: Now I can quit.")

job: I'm sleeping 0 ...
job: I'm sleeping 1 ...
job: I'm sleeping 2 ...
main: I'm tired of waiting!
main: Now I can quit.

val job = launch {
    try {
        repeat(1000) { i ->
            println("job: I'm sleeping $i ...")
            delay(500L)
        }
    } finally {
        withContext(NonCancellable) {
            println("job: I'm running finally")
            delay(1000L)
            println("job: And I've just delayed for 1 sec because I'm non-cancellable")
        }
    }
}
delay(1300L) // delay a bit
println("main: I'm tired of waiting!")
job.cancelAndJoin() // cancels the job and waits for its completion
println("main: Now I can quit.")

withTimeout(1300L) {
    repeat(1000) { i ->
        println("I'm sleeping $i ...")
        delay(500L)
    }
}
//I'm sleeping 0 ...
//I'm sleeping 1 ...
//I'm sleeping 2 ...
//Exception in thread "main" kotlinx.coroutines.TimeoutCancellationException: Timed out waiting for 1300 ms

fun boo() {
    try {
        // do some sync works that may throw exceptions
    } catch (e: Exception) {
        println("Got you, no where to run!!!")
    }
}

fun main() = runBlocking {
    try {
        val job = launch(Dispatchers.Default + SupervisorJob()) {
            println("Ready to run!")
            delay(400)
            throw Exception("You will never catch me, hahaha!")
        }
        job.join()
    } catch (e: Exception) {
        println("Try to handle everything: ${e.message}")
    }
}
//Ready to run!
//Exception in thread "DefaultDispatcher-worker-1" java.lang.Exception: You will never catch me, hahaha!

fun main() = runBlocking {
    try {
        val deferred = async(Dispatchers.Default + SupervisorJob()) {
            println("Ready to run!")
            delay(400)
            throw Exception("You will never catch me, hahaha!")
        }
        deferred.await()
    } catch (e: Exception) {
        println("No where to run: ${e.message}")
    }
}
//Ready to run!
//No where to run: You will never catch me, hahaha!

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("Totally under control: ${exception.message}")
    }

    val job1 = launch(Dispatchers.Default + SupervisorJob() + handler) {
        delay(200)
        throw Exception("Exploded!!!")
    }

    val job2 = launch(Dispatchers.Default + SupervisorJob() + handler) {
        delay(800)
        throw Exception("Can I run away???")
    }

    val deferred = async(Dispatchers.Default + SupervisorJob() + handler) {
        delay(400)
        throw Exception("You will never catch me, hahaha!")
    }

    joinAll(job1, job2, deferred)
}
//Totally under control: Exploded!!!
//Totally under control: Can I run away???

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("Totally under control: ${exception.message}")
    }

    val job1 = launch(Dispatchers.Default + SupervisorJob() + handler) {
        val subHandler = CoroutineExceptionHandler { _, exp ->
            println("Try to intercept exceptions: ${exp.message}")
        }
        val subJob = launch(Dispatchers.Default + subHandler) {
            val grandJob = launch(Dispatchers.Default + subHandler) {
                throw Exception("Bad thing happened deep down!")
            }
            grandJob.join()
        }
        subJob.join()
    }

    val job2 = launch(Dispatchers.Default + SupervisorJob() + handler) {
        delay(800)
        throw Exception("Can I run away???")
    }

    joinAll(job1, job2)
}
//Totally under control: Bad thing happened deep down!
//Totally under control: Can I run away???

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("Totally under control: ${exception.message}")
    }

    val root = launch(Dispatchers.Default + SupervisorJob() + handler) {
        val subJob1 = launch {
            val grandJob = launch {
                delay(100)
                throw Exception("Bad thing happened from deep down!")
            }
            grandJob.join()
            println("Sub coroutine #1 completed")
        }

        val subJob2 = launch {
            try {
                delay(60 * 1000)
            } finally {
                println("Sub coroutine #2 cancelled!!")
            }
        }

        val subJob3 = launch {
            try {
                delay(60 * 1000)
            } finally {
                println("Sub coroutine #3 cancelled!!!")
            }
        }

        val subJob4 = launch {
            try {
                delay(60 * 1000)
            } finally {
                println("Sub coroutine #4 cancelled!!!!")
            }
        }

        joinAll(subJob1, subJob2, subJob3, subJob4)
    }

    root.join()
}
//Sub coroutine #2 cancelled!!
//Sub coroutine #4 cancelled!!!!
//Sub coroutine #3 cancelled!!!
//Totally under control: Bad thing happened from deep down!

val handler = CoroutineExceptionHandler { _, exception ->
    println("CoroutineExceptionHandler got $exception")
}
val job = GlobalScope.launch(handler) {
    launch { // the first child
        try {
            delay(Long.MAX_VALUE)
        } finally {
            withContext(NonCancellable) {
                println("Children are cancelled, but exception is not handled until all children terminate")
                delay(100)
                println("The first child finished its non cancellable block")
            }
        }
    }
    launch { // the second child
        delay(10)
        println("Second child throws an exception")
        throw ArithmeticException()
    }
}
job.join()
//Second child throws an exception
//Children are cancelled, but exception is not handled until all children terminate
//The first child finished its non cancellable block
//CoroutineExceptionHandler got java.lang.ArithmeticException

val supervisor = SupervisorJob()
with(CoroutineScope(coroutineContext + supervisor)) {
    // launch the first child -- its exception is ignored for this example (don't do this in practice!)
    val firstChild = launch(CoroutineExceptionHandler { _, _ ->  }) {
        println("The first child is failing")
        throw AssertionError("The first child is cancelled")
    }
    // launch the second child
    val secondChild = launch {
        firstChild.join()
        // Cancellation of the first child is not propagated to the second child
        println("The first child is cancelled: ${firstChild.isCancelled}, but the second one is still active")
        try {
            delay(Long.MAX_VALUE)
        } finally {
            // But cancellation of the supervisor is propagated
            println("The second child is cancelled because the supervisor was cancelled")
        }
    }
    // wait until the first child fails & completes
    firstChild.join()
    println("Cancelling the supervisor")
    supervisor.cancel()
    secondChild.join()
}
//The first child is failing
//The first child is cancelled: true, but the second one is still active
//Cancelling the supervisor
//The second child is cancelled because the supervisor was cancelled

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("Totally under control: ${exception.message}")
    }

    val root = launch(Dispatchers.Default + SupervisorJob() + handler) {
        val subJob1 = launch {
            val grandJob = launch(SupervisorJob()) {
                delay(100)
                throw Exception("Bad thing happened from deep down!")
            }
            grandJob.join()
            println("Sub coroutine #1 completed")
        }

        val subJob2 = launch {
            try {
                delay(10 * 1000)
            } finally {
                println("Sub coroutine #2 cancelled!!")
            }
        }

        val subJob3 = launch {
            try {
                delay(20 * 1000)
            } finally {
                println("Sub coroutine #3 cancelled!!!")
            }
        }

        val subJob4 = launch {
            try {
                delay(30 * 1000)
            } finally {
                println("Sub coroutine #4 cancelled!!!!")
            }
        }

        joinAll(subJob1, subJob2, subJob3, subJob4)
    }

    root.join()
}
//Totally under control: Bad thing happened from deep down!
//Sub coroutine #1 completed
//Sub coroutine #2 cancelled!!
//Sub coroutine #3 cancelled!!!
//Sub coroutine #4 cancelled!!!!

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("CoroutineExceptionHandler got $exception")
    }
    val job = GlobalScope.launch(handler) {
        supervisorScope {
            launch { // the first child
                try {
                    delay(10 * 1000)
                } finally {
                    withContext(NonCancellable) {
                        println("Children are cancelled, but exception is not handled until all children terminate")
                        delay(100)
                        println("The first child finished its non cancellable block")
                    }
                }
            }
            launch { // the second child
                delay(10)
                println("Second child throws an exception")
                throw ArithmeticException()
            }
        }
    }
    job.join()
}
//Second child throws an exception
//CoroutineExceptionHandler got java.lang.ArithmeticException
//Children are cancelled, but exception is not handled until all children terminate
//The first child finished its non cancellable block

fun log(msg: String) = println("[${Thread.currentThread().name}] $msg")

fun main() = runBlocking {
    val a = async {
        log("I'm computing a piece of the answer")
        6
    }
    val b = async {
        log("I'm computing another piece of the answer")
        7
    }
    log("The answer is ${a.await() * b.await()}")
}
//[main @coroutine#2] I'm computing a piece of the answer
//[main @coroutine#3] I'm computing another piece of the answer
//[main @coroutine#1] The answer is 42

# Output without -Dkotlinx.coroutines.debug

[main] I'm computing a piece of the answer
[main] I'm computing another piece of the answer
[main] The answer is 42

System.setProperty("kotlinx.coroutines.debug", if (BuildConfig.DEBUG) "on" else "off")

fun main() = runBlocking<Unit> {
    val channel = Channel<String>()

    launch(Dispatchers.Default) {
        channel.send("A1")
        delay(10)
        channel.send("A2")
        logd("Producer A done")
    }
    launch(Dispatchers.IO) {
        channel.send("B1")
        logd("Producer B done")
    }

    launch {
        repeat(3) {
            val x = channel.receive()
            logd("Got $x")
        }
    }
}

fun logd(message: Any?) {
    println("[${Thread.currentThread().name}] $message")
}
//[main @coroutine#4] Got A1
//[main @coroutine#4] Got B1
//[DefaultDispatcher-worker-1 @coroutine#3] Producer B done
//[DefaultDispatcher-worker-2 @coroutine#2] Producer A done
//[main @coroutine#4] Got A2