import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

open class SuspendLazy<out T>(
    private val dispatcher: CoroutineDispatcher = Dispatchers.Default,
    initializer: () -> T
) {
    private val lazyValue = lazy(initializer)
    suspend operator fun invoke(): T = with(lazyValue) {
        if (isInitialized()) value else withContext(dispatcher) { value }
    }
}

withContext

suspendCoroutine

class LambdaClass : suspend () -> Unit {

    override fun invoke() {
        // do something
    }

}

await

withContext

java.lang.NoClassDefFoundError: kotlinx/coroutines/SupervisorJobImpl

fun main( args : Array<String> ) {

    val handler = CoroutineExceptionHandler { _, throwable -> println( "Handled $throwable" ) }

    runBlocking(handler) {

        launch {
            println( "Handler is ${coroutineContext[CoroutineExceptionHandler]}" )
            delay( 1000)
            println( "first task" )
            throw UnsupportedOperationException()
        }

    }

}

Job()

CoroutineExceptionHandler

launch {
   val isYes = channel.receive
   if(!isYes) {
       coroutineContext.cancel()
       return@launch
   }
   
   //process further logic
}

val job = GlobalScope.launch {
    <How do I access the Job from here>
}

suspend fun doLoad() = suspendCancellableCoroutine<Result> {
        val cancellationSignal = CancellationSignal()
        it.invokeOnCancellation { cancellationSignal.cancel() }
        val result = query.cancellationSignal(cancellationSignal).executeAsync()
        if (cancellationSignal.isCanceled) {
            it.resume(Result.Cancelled)
        } else {
            it.resume(Result.Success(result))
        }
    }