Package kotlin.coroutines
Basic primitives for creating and suspending coroutines: Continuation, CoroutineContext interfaces, coroutine creation and suspension top-level functions.
Types
AbstractCoroutineContextElement
Base class for CoroutineContext.Element implementations.
abstract class AbstractCoroutineContextElement : ElementAbstractCoroutineContextKey
Base class for CoroutineContext.Key associated with polymorphic CoroutineContext.Element implementation. Polymorphic element implementation implies delegating its get and minusKey to getPolymorphicElement and minusPolymorphicKey respectively.
abstract class AbstractCoroutineContextKey<B : Element, E : B> :
Key<E>Continuation
Interface representing a continuation after a suspension point that returns a value of type T.
interface Continuation<in T>ContinuationInterceptor
Marks coroutine context element that intercepts coroutine continuations. The coroutines framework uses ContinuationInterceptor.Key to retrieve the interceptor and intercepts all coroutine continuations with interceptContinuation invocations.
interface ContinuationInterceptor : ElementEmptyCoroutineContext
An empty coroutine context.
object EmptyCoroutineContext : CoroutineContext, SerializableSuspendFunction
Represents a value of a functional type, such as a lambda, an anonymous function or a function reference.
interface SuspendFunction<out R>Annotations
RestrictsSuspension
Classes and interfaces marked with this annotation are restricted when used as receivers for extension
suspend functions. These suspend extensions can only invoke other member or extension suspend functions on this particular
receiver and are restricted from calling arbitrary suspension functions.
annotation class RestrictsSuspensionProperties
coroutineContext
Returns the context of the current coroutine.
suspend val coroutineContext: CoroutineContextFunctions
Continuation
Creates a Continuation instance with the given context and implementation of resumeWith method.
fun <T> Continuation(
context: CoroutineContext,
resumeWith: (Result<T>) -> Unit
): Continuation<T>createCoroutine
Creates a coroutine without a receiver and with result type T. This function creates a new, fresh instance of suspendable computation every time it is invoked.
fun <T> (suspend () -> T).createCoroutine(
completion: Continuation<T>
): Continuation<Unit>Creates a coroutine with receiver type R and result type T. This function creates a new, fresh instance of suspendable computation every time it is invoked.
fun <R, T> (suspend R.() -> T).createCoroutine(
receiver: R,
completion: Continuation<T>
): Continuation<Unit>getPolymorphicElement
Returns the current element is it is associated with the given key in a polymorphic manner or null otherwise.
This method returns non-null value if either Element.key is equal to the given key or if the key is associated
with Element.key via AbstractCoroutineContextKey.
See AbstractCoroutineContextKey for the example of usage.
fun <E : Element> Element.getPolymorphicElement(
key: Key<E>
): E?minusPolymorphicKey
Returns empty coroutine context if the element is associated with the given key in a polymorphic manner
or null otherwise.
This method returns empty context if either Element.key is equal to the given key or if the key is associated
with Element.key via AbstractCoroutineContextKey.
See AbstractCoroutineContextKey for the example of usage.
fun Element.minusPolymorphicKey(
key: Key<*>
): CoroutineContextresume
Resumes the execution of the corresponding coroutine passing value as the return value of the last suspension point.
fun <T> Continuation<T>.resume(value: T)resumeWithException
Resumes the execution of the corresponding coroutine so that the exception is re-thrown right after the last suspension point.
fun <T> Continuation<T>.resumeWithException(
exception: Throwable)startCoroutine
Starts a coroutine without a receiver and with result type T. This function creates and starts a new, fresh instance of suspendable computation every time it is invoked. The completion continuation is invoked when the coroutine completes with a result or an exception.
fun <T> (suspend () -> T).startCoroutine(
completion: Continuation<T>)Starts a coroutine with receiver type R and result type T. This function creates and starts a new, fresh instance of suspendable computation every time it is invoked. The completion continuation is invoked when the coroutine completes with a result or an exception.
fun <R, T> (suspend R.() -> T).startCoroutine(
receiver: R,
completion: Continuation<T>)suspendCoroutine
Obtains the current continuation instance inside suspend functions and suspends the currently running coroutine.
suspend fun <T> suspendCoroutine(
block: (Continuation<T>) -> Unit
): T