Kotlin Coroutinen gehen über die reine Nebenläufigkeit hinaus

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 sind Callbacks
			.onSuccess(continuation::resume)
			.onFailure(continuation::resumeWithException)
			.executeAsync()
	}

import kotlin.coroutines.*

fun main() {
	val operation: suspend () -> Unit = ::a
	operation.startCoroutine(
		object : Continuation<Unit> {
			// Wir werden später darüber sprechen
			override val coroutineContext = EmptyCoroutineContext

			// Wird aufgerufen, wenn die Coroutine ihre Arbeit beendet hat
			override fun resumeWith(result: Result<Unit>) {
				println(
					if(result.isSuccess)
						"Erfolgreich abgeschlossen"
					else "Fehler aufgetreten: ${result.exceptionOrNull()}"
				)
			}
		}
	)
}

suspend fun a() {...}

import kotlin.coroutines.*

// definieren wir unseren Container für Daten, die wir innerhalb der Coroutine benötigen
// er sollte immer von 'CoroutineContext.Element' erben
data class ExecutionContext(val someInt: Int) : CoroutineContext.Element {
    override val key = EXECUTION_CONTEXT_KEY
}

// definieren wir einen typensicheren Schlüssel, mit dem wir unseren Wert erhalten
val EXECUTION_CONTEXT_KEY = object : CoroutineContext.Key<ExecutionContext> {}

// definieren wir den Coroutine-Kontext, den wir an Continuation übergeben werden
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
	}

	// .. wir lassen andere Funktionen der Einfachheit halber weg
}

suspend fun a() {
	// hier rufen wir den Wert aus dem Coroutine-Kontext ab
	// coroutineContext ist Compiler-intrinsisch, kann nur
	// aus der Suspend-Welt aufgerufen werden
	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)
						"Erfolgreich abgeschlossen"
					else "Fehler aufgetreten: ${result.exceptionOrNull()}"
				)
			}
		}
	)
}

// definieren wir ein Element, das in `CoroutineContext` bestehen bleibt
data class AuthorizationContext(
    val accessHash: String?,
    val provider: AuthorizationProvider,
) : CoroutineContext.Element {
    companion object Key : CoroutineContext.Key<AuthorizationContext>

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

// jetzt definieren wir unseren 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() {
    /**
     * Liefert einen Wert an den erstellten [Iterator] und suspendiert
     * bis der nächste Wert angefordert wird.
     */
    public abstract suspend fun yield(value: T)

    // ... andere
}

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) // WICHTIG: Es beginnt die Ausführung des nächsten Yields
		}
	}

	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() // wirft einfach die Ausnahme erneut, falls vorhanden
		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)) // Ausgabe: 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()

	// ...
}

Dies ist ein eingeschränkter Suspendierungsbereich. Code in diesem Bereich wird
immer un-dispatched aufgerufen und darf nur für Aufrufe von
[awaitPointerEvent] suspendiert werden. Diese Funktionen werden synchron fortgesetzt und der Aufrufer kann das Ergebnis
**vor** dem nächsten await-Aufruf mutieren, um die nächste Stufe der Eingabeverarbeitungspipeline zu beeinflussen.