go funcs

suspendCancellableCoroutine

isCancelled

resumeWithException

CoroutineContext

coroutines-core

std-lib

internal

fun foo(): Deferred<Foo>

suspend fun foo(): Foo

withContext

suspend

suspend

select

actor

runBlocking

runNonBlocking

launch {
    val cookie = web.loadLogin { refresh(it != 100) }
    L.d { "Login found" }
    FbCookie.save(cookie.id)
    web.fadeOut(onFinish = {
        profile.fadeIn()
        this@LoginActivity.launch { loadInfo(cookie) }
    })
}

launch

launch

withContext(Dispatchers.Main)

fun sampleProducer(): Channel<Int>{
        val channel = Channel<Int>(UNLIMITED)
        val thread = Thread {
            var i = 0
            while(true) {
                channel.offer(i++)
                Thread.sleep(1000)
            }
        }

        // the bellow doesn't work but it would be nice if it did
        channel.doOnCancel {
              // terminate the thread
        }
        thread.start()

        return channel
    }

    @Test
    fun main() {
        val channel = sampleProducer()

        runBlocking {
            for (i in 1..5) {
                System.out.println("received: ${channel.receive()}")
            }
            channel.cancel()
            // How can I make sure the thread is joined here or very shortly after here ?
        }
    }

Deferred<A>

NonCancelable

withContext

val def = thisWasPassedToMe()
val result = withContext(NonCancelable) {
  def.await()
}

Flow

channel.isClosedForReceive

This declaration is experimental and its usage must be marked with '@kotlinx.coroutines.InternalCoroutinesApi' or '@UseExperimental(kotlinx.coroutines.InternalCoroutinesApi::class)'

urls.map { async { loadUrl(it) } }.map { it.await() }

awaitAll()

extension

await

withContext

withContext

withContext

async(SupervisorJob(coroutineContext[Job])) { ... }

async

suspendable lambdas + continuation + yeild

mainScope.launch {

            try{
                val attr1 = async(<http://dispatchers.IO|dispatchers.IO>) { networkUser.setUserAttrs(userId, mappedServerData.weight).blockingFirst() }catch(){} }

mainScore = CoroutineScope(dispatchers.MAIN + job)

val threadPool = newSingleThreadContext("git-clone-subprocess-pool")

suspend fun clone(urL: String) {
    val result = withContext(threadPool) {
        async {
            val pb = NuProcessBuilder(listOf("/bin/cat"))
            val process = pb.start()
            process.waitFor(0, TimeUnit.SECONDS)
        }
    }
    
    val exitcode = result.await()
}

DefaultDispatcher

suspend

n