Kotlin Coroutines are not just about concurrency

public interface Continuation<in T> {
    public val context: CoroutineContext
    public fun resumeWith(result: Result<T>)
}

suspend fun executeNetworkRequest(): String = 
	suspendCoroutine { continuation ->
		thread {
			continuation.resumeWith(someBlockingRequest())
		}
	}

suspend fun executeNetworkRequest(): String =
	suspendCoroutine { continuation ->
		apiService.getSomething()
			// onSuccess & onFailure is a callback
			.onSuccess(continuation::resume)
			.onFailure(continuation::resumeWithException)
			.executeAsync()
	}

import kotlin.coroutines.*

fun main() {
	val operation: suspend () -> Unit = ::a
	operation.startCoroutine(
		object : Continuation<Unit> {
			// we will talk about it lower
			override val coroutineContext = EmptyCoroutineContext
			
			// called when coroutine finished its work
			override fun resumeWith(result: Result<Unit>) {
				println(
					if(result.isSuccess) 
						"Successfully done" 
					else "Error happenned: ${result.exceptionOrNull()}"
				)
			}
		}
	)
}

suspend fun a() {...}

import kotlin.coroutines.*

// define our container for data we need inside coroutine
// it should always inherit 'CoroutineContext.Element'
data class ExecutionContext(val someInt: Int) : CoroutineContext.Element {
    override val key = EXECUTION_CONTEXT_KEY
}

// define type-safe key using which we will get our value
val EXECUTION_CONTEXT_KEY = object : CoroutineContext.Key<ExecutionContext> {}

// define coroutine context that we will pass into Continuation
private val myCoroutineContext = object : CoroutineContext {
	private val values = mapOf<CoroutineContext.Key<*>, CoroutineContext.Element>(
        EXECUTION_CONTEXT_KEY to ExecutionContext(10000)
    )

	override operator fun <E : CoroutineContext.Element> get(key: CoroutineContext.Key<E>): E? {
		return values[key] as? E
	}

	// .. we omit other functions for simplicity
}

suspend fun a() {
	// here we retrieve value from coroutine context
	// coroutineContext is compiler intrinsic, can be called
	// only from suspend world
	val executionContext = coroutineContext[EXECUTION_CONTEXT_KEY]!!
	println(executionContext.someInt!!)
}

fun main() {
	val operation: suspend () -> Unit = ::a
	operation.startCoroutine(
		object : Continuation<Unit> {
			override val context: CoroutineContext = myCoroutineContext
			
			override fun resumeWith(result: Result<Unit>) {
				println(
					if(result.isSuccess) 
						"Successfully done" 
					else "Error happenned: ${result.exceptionOrNull()}"
				)
			}
		}
	)
}

// let's define an element that will persist in `CoroutineContext`
data class AuthorizationContext(
    val accessHash: String?,
    val provider: AuthorizationProvider,
) : CoroutineContext.Element {
    companion object Key : CoroutineContext.Key<AuthorizationContext>

    override val key: CoroutineContext.Key<*> = Key
}

// now we define our interceptor
class AuthorizationInterceptor(
    private val authorizationProvider: AuthorizationProvider,
) : CoroutineContextServerInterceptor() {
    companion object {
        private val ACCESS_TOKEN_METADATA_KEY: Metadata.Key<String> =
            Metadata.Key.of("access-token", Metadata.ASCII_STRING_MARSHALLER)
    }

    override fun coroutineContext(call: ServerCall<*, *>, headers: Metadata): CoroutineContext {
        return AuthorizationContext(
            accessHash = headers.get(ACCESS_TOKEN_METADATA_KEY),
            provider = authorizationProvider,
        )
    }
}

suspend inline fun provideAuthorization(block: (UserId) -> Unit) {
	val authContext = coroutineContext[AuthorizationContext]
	authContext.accessHash ?: throw StatusException(Status.UNAUTHORIZED)
	
	val userId = authContext.provider.provide(authContext.accessHash)
	return block(userId)
}

@RestrictSuspension
public abstract class SequenceScope<in T> internal constructor() {
    /**
     * Yields a value to the [Iterator] being built and suspends
     * until the next value is requested.
     */
    public abstract suspend fun yield(value: T)

    // ... other
}

private typealias State = Int  
  
private const val State_NotReady: State = 0  
private const val State_ManyNotReady: State = 1  
private const val State_ManyReady: State = 2  
private const val State_Ready: State = 3  
private const val State_Done: State = 4  
private const val State_Failed: State = 5  
  
private class SequenceBuilderIterator<T> : SequenceScope<T>(), Iterator<T>, Continuation<Unit> {  
	private var state = State_NotReady  
	private var nextValue: T? = null  
	private var nextIterator: Iterator<T>? = null  
	var nextStep: Continuation<Unit>? = null  
  
	override fun hasNext(): Boolean {  
		while (true) {  
			when (state) {  
				State_NotReady -> {}  
				State_ManyNotReady ->  
				if (nextIterator!!.hasNext()) {  
					state = State_ManyReady  
					return true  
				} else {  
					nextIterator = null  
				}  
				State_Done -> return false  
				State_Ready, State_ManyReady -> return true  
				else -> throw exceptionalState()  
			}  
  
			state = State_Failed  
			val step = nextStep!!  
			nextStep = null  
			step.resume(Unit) // IMPORTANT: it starts executing next yield 
		}  
	}  
  
	override fun next(): T {  
		when (state) {  
			State_NotReady, State_ManyNotReady -> return nextNotReady()  
			State_ManyReady -> {  
				state = State_ManyNotReady  
				return nextIterator!!.next()  
			}  
			State_Ready -> {  
				state = State_NotReady  
				@Suppress("UNCHECKED_CAST")  
				val result = nextValue as T  
				nextValue = null  
				return result  
			}  
			else -> throw exceptionalState()  
		}  
	}  
  
	private fun nextNotReady(): T {  
		if (!hasNext()) throw NoSuchElementException() else return next()  
	}  
  
	private fun exceptionalState(): Throwable = when (state) {  
		State_Done -> NoSuchElementException()  
		State_Failed -> IllegalStateException("Iterator has failed.")  
		else -> IllegalStateException("Unexpected state of the iterator: $state")  
	}  
  
  
	override suspend fun yield(value: T) {  
		nextValue = value  
		state = State_Ready  
		return suspendCoroutineUninterceptedOrReturn { c ->  
			nextStep = c  
			COROUTINE_SUSPENDED  
		}  
	}    
	override fun resumeWith(result: Result<Unit>) {  
		result.getOrThrow() // just rethrow exception if it is there  
		state = State_Done  
	}  
  
	override val context: CoroutineContext  
		get() = EmptyCoroutineContext  
}

val sequence = sequence {
    yield(1) {
        yield(2) {
            yield(3) { /* ... */ }
        }
    }
}

val fibonacci = DeepRecursiveFunction<Int, Int> { x ->
    when {
        x < 0 -> 0
        x == 1 -> 1
        else -> callRecursive(x - 1) + callRecursive(x - 2)
    }
}

println(fibonacci(12)) // output: 144

@RestrictsSuspension // <---
@JvmDefaultWithCompatibility
interface AwaitPointerEventScope : Density {
	// ...
	
	suspend fun awaitPointerEvent(
        pass: PointerEventPass = PointerEventPass.Main
    ): PointerEvent
    
	suspend fun <T> withTimeoutOrNull(
        timeMillis: Long,
        block: suspend AwaitPointerEventScope.() -> T
    ): T? = block()
    
	suspend fun <T> withTimeout(
        timeMillis: Long,
        block: suspend AwaitPointerEventScope.() -> T
    ): T = block()
    
	// ...
}

This is a restricted suspension scope. Code in this scope is
always called un-dispatched and may only suspend for calls 
to [awaitPointerEvent]. These functions resume synchronously and the caller may mutate the result
**before** the next await call to affect the next stage of the input processing pipeline.