Index

A B C D E F G H I J K L M N O P R S T U W Y Z

A

AbstractChannelKt - Class in kotlinx.coroutines.channels
actor($receiver, context, capacity, start, onCompletion, block) - Static method in class kotlinx.coroutines.channels.ActorKt: Launches new coroutine that is receiving messages from its mailbox channel and returns a reference to its mailbox channel as a interface SendChannel. The resulting object can be used to SendChannel.send messages to this coroutine.
ActorKt - Class in kotlinx.coroutines.channels
ActorScope<E> - Interface in kotlinx.coroutines.channels: Scope for ActorKt.actor coroutine builder.
advanceTimeBy(delayTime, unit) - Method in class kotlinx.coroutines.test.TestCoroutineContext: Moves the CoroutineContext's virtual clock forward by a specified amount of time.
advanceTimeTo(targetTime, unit) - Method in class kotlinx.coroutines.test.TestCoroutineContext: Moves the CoroutineContext's clock-time to a particular moment in time.
any($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns true if channel has at least one element.
asContextElement($receiver, value) - Static method in class kotlinx.coroutines.ThreadContextElementKt: Wraps ThreadLocal into interface ThreadContextElement. The resulting interface ThreadContextElement maintains the given value of the given ThreadLocal for coroutine regardless of the actual thread its is resumed on. By default ThreadLocal.get is used as a value for the thread-local variable, but it can be overridden with value parameter.
assertAllUnhandledExceptions(message, predicate) - Method in class kotlinx.coroutines.test.TestCoroutineContext: This method does nothing if there are no unhandled exceptions or all of them satisfy the given predicate. Otherwise it throws an AssertionError with the given message.
assertAnyUnhandledException(message, predicate) - Method in class kotlinx.coroutines.test.TestCoroutineContext: This method does nothing if one or more unhandled exceptions satisfy the given predicate. Otherwise it throws an AssertionError with the given message.
assertExceptions(message, predicate) - Method in class kotlinx.coroutines.test.TestCoroutineContext: This method does nothing if the list of unhandled exceptions satisfy the given predicate. Otherwise it throws an AssertionError with the given message.
assertUnhandledException(message, predicate) - Method in class kotlinx.coroutines.test.TestCoroutineContext: This method does nothing if there is one unhandled exception that satisfies the given predicate. Otherwise it throws an AssertionError with the given message.
async($receiver, context, start, block) - Static method in class kotlinx.coroutines.BuildersKt: Creates new coroutine and returns its future result as an implementation of interface Deferred. The running coroutine is cancelled when the resulting deferred is Job.cancel.
await(p) - Method in interface kotlinx.coroutines.Deferred: Awaits for completion of this value without blocking a thread and resumes when deferred computation is complete, returning the resulting value or throwing the corresponding exception if the deferred was cancelled.
awaitAll(deferreds, p) - Static method in class kotlinx.coroutines.AwaitKt: Awaits for completion of given deferred values without blocking a thread and resumes normally with the list of values when all deferred computations are complete or resumes with the first thrown exception if any of computations complete exceptionally including cancellation.
awaitAll($receiver, p) - Static method in class kotlinx.coroutines.AwaitKt: Awaits for completion of given deferred values without blocking a thread and resumes normally with the list of values when all deferred computations are complete or resumes with the first thrown exception if any of computations complete exceptionally including cancellation.
AwaitKt - Class in kotlinx.coroutines

B

broadcast($receiver, capacity, start) - Static method in class kotlinx.coroutines.channels.BroadcastKt: Broadcasts all elements of the channel.
broadcast($receiver, context, capacity, start, onCompletion, block) - Static method in class kotlinx.coroutines.channels.BroadcastKt: Launches new coroutine to produce a stream of values by sending them to a broadcast channel and returns a reference to the coroutine as a interface BroadcastChannel. The resulting object can be used to BroadcastChannel.openSubscription to elements produced by this coroutine.
BroadcastChannel<E> - Interface in kotlinx.coroutines.channels: Broadcast channel is a non-blocking primitive for communication between the sender and multiple receivers that subscribe for the elements using BroadcastChannel.openSubscription function and unsubscribe using ReceiveChannel.cancel function.
BroadcastChannel(capacity) - Static method in class kotlinx.coroutines.channels.BroadcastChannelKt: Creates a broadcast channel with the specified buffer capacity.
BroadcastChannelKt - Class in kotlinx.coroutines.channels
BroadcastKt - Class in kotlinx.coroutines.channels
BuildersKt - Class in kotlinx.coroutines

C

cancel(cause) - Method in interface kotlinx.coroutines.CancellableContinuation: Cancels this continuation with an optional cancellation cause. The result is true if this continuation was cancelled as a result of this invocation and false otherwise.
cancel(cause) - Method in interface kotlinx.coroutines.channels.BroadcastChannel: Cancels reception of remaining elements from this channel. This function closes the channel with the specified cause (unless it was already closed), removes all buffered sent elements from it, and ReceiveChannel.cancel all open subscriptions. This function returns true if the channel was not closed previously, or false otherwise.
cancel(cause) - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Closes this broadcast channel. Same as ConflatedBroadcastChannel.close.
cancel() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Cancels reception of remaining elements from this channel. This function closes the channel and removes all buffered sent elements from it.
cancel($receiver) - Static method in class kotlinx.coroutines.CoroutineScopeKt: Cancels this scope, including its job and all its children. Throws IllegalStateException if the scope does not have a job in it.
cancel() - Method in interface kotlinx.coroutines.Job: Cancels this job. See interface Job documentation for full explanation of cancellation machinery.
cancel($receiver) - Static method in class kotlinx.coroutines.JobKt: Cancels interface Job of this context. See Job.cancel for details.
cancelAllActions() - Method in class kotlinx.coroutines.test.TestCoroutineContext: Cancels all not yet triggered actions. Be careful calling this, since it can seriously mess with your coroutines work. This method should usually be called on tear-down of a unit test.
cancelAndJoin($receiver, p) - Static method in class kotlinx.coroutines.JobKt: Cancels the job and suspends invoking coroutine until the cancelled job is complete.
cancelChildren($receiver) - Static method in class kotlinx.coroutines.JobKt: Cancels all children of the interface Job in this context, without touching the the state of this job itself. It does not do anything if there is no job in the context or it has no children.
cancelChildren($receiver, cause) - Static method in class kotlinx.coroutines.JobKt: Deprecated.
cancelChildren($receiver) - Static method in class kotlinx.coroutines.JobKt: Cancels all Job.getChildren jobs of this coroutine using Job.cancel for all of them. Unlike Job.cancel on this job as a whole, the state of this job itself is not affected.
cancelFutureOnCancellation($receiver, future) - Static method in class kotlinx.coroutines.JobKt: Cancels a specified future when this job is cancelled. This is a shortcut for the following code with slightly more efficient implementation (one fewer object created).
CancellableContinuation<T> - Interface in kotlinx.coroutines: Cancellable continuation. It is completed when it is resumed or cancelled. When CancellableContinuation.cancel function is explicitly invoked, this continuation immediately resumes with CancellationException or with the specified cancel cause.
CancellableContinuationImplKt - Class in kotlinx.coroutines
CancellableContinuationKt - Class in kotlinx.coroutines
Channel<E> - Interface in kotlinx.coroutines.channels: Channel is a non-blocking primitive for communication between sender using interface SendChannel and receiver using interface ReceiveChannel. Conceptually, a channel is similar to BlockingQueue, but it has suspending operations instead of blocking ones and it can be closed.
Channel(capacity) - Static method in class kotlinx.coroutines.channels.ChannelKt: Creates a channel with the specified buffer capacity (or without a buffer by default). See interface Channel interface documentation for details.
Channel.Factory - Class in kotlinx.coroutines.channels: Constants for channel factory function Channel().
ChannelIterator<E> - Interface in kotlinx.coroutines.channels: Iterator for interface ReceiveChannel. Instances of this interface are not thread-safe and shall not be used from concurrent coroutines.
ChannelKt - Class in kotlinx.coroutines.channels
ChannelsKt - Class in kotlinx.coroutines.channels
close(cause) - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Closes this channel. This is an idempotent operation -- repeated invocations of this function have no effect and return false. Conceptually, its sends a special "close token" over this channel.
close(cause) - Method in interface kotlinx.coroutines.channels.SendChannel: Closes this channel. This is an idempotent operation -- repeated invocations of this function have no effect and return false. Conceptually, its sends a special "close token" over this channel.
close() - Method in class kotlinx.coroutines.ExecutorCoroutineDispatcher: Closes this coroutine dispatcher and shuts down its executor.
ClosedReceiveChannelException - Exception in kotlinx.coroutines.channels: Indicates attempt to ReceiveChannel.receive on ReceiveChannel.isClosedForReceive channel that was closed without a cause. A failed channel rethrows the original SendChannel.close cause exception on receive attempts.
ClosedReceiveChannelException(message) - Constructor for exception kotlinx.coroutines.channels.ClosedReceiveChannelException: Indicates attempt to ReceiveChannel.receive on ReceiveChannel.isClosedForReceive channel that was closed without a cause. A failed channel rethrows the original SendChannel.close cause exception on receive attempts.
ClosedSendChannelException - Exception in kotlinx.coroutines.channels: Indicates attempt to SendChannel.send on SendChannel.isClosedForSend channel that was closed without a cause. A failed channel rethrows the original SendChannel.close cause exception on send attempts.
ClosedSendChannelException(message) - Constructor for exception kotlinx.coroutines.channels.ClosedSendChannelException: Indicates attempt to SendChannel.send on SendChannel.isClosedForSend channel that was closed without a cause. A failed channel rethrows the original SendChannel.close cause exception on send attempts.
Companion - Static variable in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Deprecated.
CompletableDeferred<T> - Interface in kotlinx.coroutines: A interface Deferred that can be completed via public functions CompletableDeferred.complete or Job.cancel.
CompletableDeferred(parent) - Static method in class kotlinx.coroutines.CompletableDeferredKt: Creates a interface CompletableDeferred in an active state. It is optionally a child of a parent job.
CompletableDeferred(value) - Static method in class kotlinx.coroutines.CompletableDeferredKt: Creates an already completed interface CompletableDeferred with a given value.
CompletableDeferredKt - Class in kotlinx.coroutines
complete(value) - Method in interface kotlinx.coroutines.CompletableDeferred: Completes this deferred value with a given value. The result is true if this deferred was completed as a result of this invocation and false otherwise (if it was already completed).
CompletedExceptionallyKt - Class in kotlinx.coroutines
completeExceptionally(exception) - Method in interface kotlinx.coroutines.CompletableDeferred: Completes this deferred value exceptionally with a given exception. The result is true if this deferred was completed as a result of this invocation and false otherwise (if it was already completed).
CompletionHandler_commonKt - Class in kotlinx.coroutines
CompletionHandlerKt - Class in kotlinx.coroutines
component1() - Method in class kotlinx.coroutines.CoroutineName: User-defined coroutine name.
CONFLATED - Static variable in interface kotlinx.coroutines.channels.Channel: Requests conflated channel in Channel(...) factory function -- the ConflatedChannel gets created.
CONFLATED - Static variable in class kotlinx.coroutines.channels.Channel.Factory: Requests conflated channel in Channel(...) factory function -- the ConflatedChannel gets created.
ConflatedBroadcastChannel<E> - Class in kotlinx.coroutines.channels: Broadcasts the most recently sent element (aka ConflatedBroadcastChannel.getValue) to all ConflatedBroadcastChannel.openSubscription subscribers.
ConflatedBroadcastChannel() - Constructor for class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Broadcasts the most recently sent element (aka ConflatedBroadcastChannel.getValue) to all ConflatedBroadcastChannel.openSubscription subscribers.
ConflatedBroadcastChannel(value) - Constructor for class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Creates an instance of this class that already holds a value.
consume($receiver, block) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Opens subscription to this interface BroadcastChannel and makes sure that the given block consumes all elements from it by always invoking ReceiveChannel.cancel after the execution of the block.
consume($receiver, block) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Makes sure that the given block consumes all elements from the given channel by always invoking ReceiveChannel.cancel after the execution of the block.
consumes($receiver) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a CompletionHandler that invokes ReceiveChannel.cancel on the interface ReceiveChannel with the corresponding cause. See also ChannelsKt.consume.
consumesAll(channels) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a CompletionHandler that invokes ReceiveChannel.cancel on all the specified interface ReceiveChannel instances with the corresponding cause. See also ChannelsKt.consumes for a version on one channel.
copy(name) - Method in class kotlinx.coroutines.CoroutineName: User-specified name of coroutine. This name is used in debugging mode. See newCoroutineContext for the description of coroutine debugging facilities.
CoroutineContextKt - Class in kotlinx.coroutines
CoroutineDispatcher - Class in kotlinx.coroutines: Base class that shall be extended by all coroutine dispatcher implementations.
CoroutineDispatcher() - Constructor for class kotlinx.coroutines.CoroutineDispatcher: Base class that shall be extended by all coroutine dispatcher implementations.
CoroutineExceptionHandler - Interface in kotlinx.coroutines: An optional element in the coroutine context to handle uncaught exceptions.
CoroutineExceptionHandler(handler) - Static method in class kotlinx.coroutines.CoroutineExceptionHandlerKt: Creates new interface CoroutineExceptionHandler instance.
CoroutineExceptionHandler.Key - Class in kotlinx.coroutines: Key for interface CoroutineExceptionHandler instance in the coroutine context.
CoroutineExceptionHandlerImplKt - Class in kotlinx.coroutines
CoroutineExceptionHandlerKt - Class in kotlinx.coroutines
CoroutineName - Class in kotlinx.coroutines: User-specified name of coroutine. This name is used in debugging mode. See newCoroutineContext for the description of coroutine debugging facilities.
CoroutineName(name) - Constructor for class kotlinx.coroutines.CoroutineName: User-specified name of coroutine. This name is used in debugging mode. See newCoroutineContext for the description of coroutine debugging facilities.
CoroutineName.Key - Class in kotlinx.coroutines: Key for class CoroutineName instance in the coroutine context.
CoroutineScope - Interface in kotlinx.coroutines: Defines a scope for new coroutines. Every coroutine builder is an extension on interface CoroutineScope and inherits its CoroutineScope.getCoroutineContext to automatically propagate both context elements and cancellation.
coroutineScope(block, p) - Static method in class kotlinx.coroutines.CoroutineScopeKt: Creates new interface CoroutineScope and calls the specified suspend block with this scope. The provided scope inherits its CoroutineScope.getCoroutineContext from the outer scope, but overrides context's interface Job.
CoroutineScope(context) - Static method in class kotlinx.coroutines.CoroutineScopeKt: Creates interface CoroutineScope that wraps the given coroutine context.
CoroutineScopeKt - Class in kotlinx.coroutines
CoroutineStart - Enum in kotlinx.coroutines: Defines start options for coroutines builders. It is used in start parameter of BuildersKt.launch, BuildersKt.async, and other coroutine builder functions.
CoroutineStart() - Constructor for enum kotlinx.coroutines.CoroutineStart: Defines start options for coroutines builders. It is used in start parameter of BuildersKt.launch, BuildersKt.async, and other coroutine builder functions.
count($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the number of elements in this channel.

D

DEBUG_PROPERTY_NAME - Static variable in class kotlinx.coroutines.DebugKt: Name of the property that controls coroutine debugging. See newCoroutineContext.
DEBUG_PROPERTY_VALUE_AUTO - Static variable in class kotlinx.coroutines.DebugKt: Automatic debug configuration value for DEBUG_PROPERTY_NAME. See newCoroutineContext.
DEBUG_PROPERTY_VALUE_OFF - Static variable in class kotlinx.coroutines.DebugKt: Debug turned on value for DEBUG_PROPERTY_NAME. See newCoroutineContext.
DEBUG_PROPERTY_VALUE_ON - Static variable in class kotlinx.coroutines.DebugKt: Debug turned on value for DEBUG_PROPERTY_NAME. See newCoroutineContext.
DebugKt - Class in kotlinx.coroutines
DefaultExecutorKt - Class in kotlinx.coroutines
Deferred<T> - Interface in kotlinx.coroutines: Deferred value is a non-blocking cancellable future — it is a interface Job that has a result.
delay(timeMillis, p) - Static method in class kotlinx.coroutines.DelayKt: Delays coroutine for a given time without blocking a thread and resumes it after a specified time. This suspending function is cancellable. If the interface Job of the current coroutine is cancelled or completed while this suspending function is waiting, this function immediately resumes with CancellationException.
DelayKt - Class in kotlinx.coroutines
dispatch(context, block) - Method in class kotlinx.coroutines.CoroutineDispatcher: Dispatches execution of a runnable block onto another thread in the given context.
DispatchedKt - Class in kotlinx.coroutines
Dispatchers - Class in kotlinx.coroutines: Groups various implementations of class CoroutineDispatcher.
DispatchersKt - Class in kotlinx.coroutines
DisposableHandle - Interface in kotlinx.coroutines: A handle to an allocated object that can be disposed to make it eligible for garbage collection.
dispose() - Method in interface kotlinx.coroutines.DisposableHandle: Disposes the corresponding object, making it eligible for garbage collection. Repeated invocation of this function has no effect.
distinct($receiver) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only distinct elements from the given channel.
distinctBy($receiver, context, selector) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only elements from the given channel having distinct keys returned by the given selector function.
drop($receiver, n, context) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing all elements except first n elements.
dropWhile($receiver, context, predicate) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing all elements except first elements that satisfy the given predicate.

E

elementAt($receiver, index, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns an element at the given index or throws an IndexOutOfBoundsException if the index is out of bounds of this channel.
elementAtOrNull($receiver, index, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns an element at the given index or null if the index is out of bounds of this channel.
equals(p) - Method in class kotlinx.coroutines.CoroutineName
EventLoopKt - Class in kotlinx.coroutines
ExceptionsKt - Class in kotlinx.coroutines
ExecutorCoroutineDispatcher - Class in kotlinx.coroutines: class CoroutineDispatcher that has underlying Executor for dispatching tasks. Instances of class ExecutorCoroutineDispatcher should be closed by the owner of the dispatcher.
ExecutorCoroutineDispatcher() - Constructor for class kotlinx.coroutines.ExecutorCoroutineDispatcher: class CoroutineDispatcher that has underlying Executor for dispatching tasks. Instances of class ExecutorCoroutineDispatcher should be closed by the owner of the dispatcher.
ExecutorsKt - Class in kotlinx.coroutines
ExperimentalCoroutinesApi - Interface in kotlinx.coroutines: Marks declarations that are still experimental in coroutines API, which means that the design of the corresponding declarations has open issues which may (or may not) lead to their changes in the future. Roughly speaking, there is a chance that those declarations will be deprecated in the near future or the semantics of their behavior may change in some way that may break some code.

F

Factory - Static variable in interface kotlinx.coroutines.channels.Channel: Constants for channel factory function Channel().
filter($receiver, context, predicate) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only elements matching the given predicate.
filterIndexed($receiver, context, predicate) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only elements matching the given predicate.
filterNot($receiver, context, predicate) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing all elements not matching the given predicate.
filterNotNull($receiver) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing all elements that are not null.
filterNotNullTo($receiver, destination, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Appends all elements that are not null to the given destination.
filterNotNullTo($receiver, destination, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Appends all elements that are not null to the given destination.
first($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns first element.
firstOrNull($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the first element, or null if the channel is empty.
flatMap($receiver, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a single channel of all elements from results of transform function being invoked on each element of original channel.
fold(initial, operation) - Method in class kotlinx.coroutines.test.TestCoroutineContext
from($receiver) - Static method in class kotlinx.coroutines.ExecutorsKt: Converts an instance of ExecutorService to an implementation of class ExecutorCoroutineDispatcher.
from($receiver) - Static method in class kotlinx.coroutines.ExecutorsKt: Converts an instance of Executor to an implementation of class CoroutineDispatcher.

G

get(key) - Method in class kotlinx.coroutines.test.TestCoroutineContext
getChannel() - Method in interface kotlinx.coroutines.channels.ActorScope: A reference to the mailbox channel that this coroutine ReceiveChannel.receive messages from. It is provided for convenience, so that the code in the coroutine can refer to the channel as channel as apposed to this. All the interface ReceiveChannel functions on this interface delegate to the channel instance returned by this function.
getChannel() - Method in interface kotlinx.coroutines.channels.ProducerScope: A reference to the channel that this coroutine SendChannel.send elements to. It is provided for convenience, so that the code in the coroutine can refer to the channel as channel as apposed to this. All the interface SendChannel functions on this interface delegate to the channel instance returned by this function.
getChildren() - Method in interface kotlinx.coroutines.Job: Returns a sequence of this job's children.
getCompleted() - Method in interface kotlinx.coroutines.Deferred: Returns completed result or throws IllegalStateException if this deferred value has not Job.isCompleted yet. It throws the corresponding exception if this deferred was Job.isCancelled.
getCompletionExceptionOrNull() - Method in interface kotlinx.coroutines.Deferred: Returns completion exception result if this deferred was Job.isCancelled and has Job.isCompleted, null if it had completed normally, or throws IllegalStateException if this deferred value has not Job.isCompleted yet.
getCoroutineContext() - Method in interface kotlinx.coroutines.CoroutineScope: Context of this scope.
getCoroutineContext() - Method in class kotlinx.coroutines.GlobalScope: Returns EmptyCoroutineContext.
getDefault() - Static method in class kotlinx.coroutines.Dispatchers: The default class CoroutineDispatcher that is used by all standard builders like BuildersKt.launch, BuildersKt.async, etc if no dispatcher nor any other ContinuationInterceptor is specified in their context.
getExceptions() - Method in class kotlinx.coroutines.test.TestCoroutineContext: Exceptions that were caught during a BuildersKt.launch or a BuildersKt.async + Deferred.await.
getExecutor() - Method in class kotlinx.coroutines.ExecutorCoroutineDispatcher: Underlying executor of current class CoroutineDispatcher.
getImmediate() - Method in class kotlinx.coroutines.MainCoroutineDispatcher: Returns dispatcher that executes coroutines immediately when it is already in the right context (e.g. current looper is the same as this handler's looper). See CoroutineDispatcher.isDispatchNeeded documentation on why this should not be done by default. Method may throw UnsupportedOperationException if immediate dispatching is not supported by current dispatcher, please refer to specific dispatcher documentation.
getIO() - Static method in class kotlinx.coroutines.Dispatchers: The class CoroutineDispatcher that is designed for offloading blocking IO tasks to a shared pool of threads.
getMain() - Static method in class kotlinx.coroutines.Dispatchers: A coroutine dispatcher that is confined to the Main thread operating with UI objects. This dispatcher can be used either directly or via CoroutineScopeKt.MainScope factory. Usually such dispatcher is single-threaded.
getName() - Method in class kotlinx.coroutines.CoroutineName: User-defined coroutine name.
getOnAwait() - Method in interface kotlinx.coroutines.Deferred: Clause for select expression of Deferred.await suspending function that selects with the deferred value when it is resolved. The select invocation fails if the deferred value completes exceptionally (either fails or it cancelled).
getOnJoin() - Method in interface kotlinx.coroutines.Job: Clause for select expression of Job.join suspending function that selects when the job is complete. This clause never fails, even if the job completes exceptionally.
getOnLock() - Method in interface kotlinx.coroutines.sync.Mutex: Clause for select expression of Mutex.lock suspending function that selects when the mutex is locked. Additional parameter for the clause in the owner (see Mutex.lock) and when the clause is selected the reference to this mutex is passed into the corresponding block.
getOnReceive() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Clause for select expression of ReceiveChannel.receive suspending function that selects with the element that is received from the channel. The select invocation fails with exception if the channel ReceiveChannel.isClosedForReceive (see SendChannel.close for details).
getOnReceiveOrNull() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Clause for select expression of ReceiveChannel.receiveOrNull suspending function that selects with the element that is received from the channel or selects with null if if the channel ReceiveChannel.isClosedForReceive without cause. The select invocation fails with the original SendChannel.close cause exception if the channel has failed.
getOnSend() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Clause for select expression of ConflatedBroadcastChannel.send suspending function that selects when the element that is specified as parameter is sent to the channel. When the clause is selected the reference to this channel is passed into the corresponding block.
getOnSend() - Method in interface kotlinx.coroutines.channels.SendChannel: Clause for select expression of SendChannel.send suspending function that selects when the element that is specified as parameter is sent to the channel. When the clause is selected the reference to this channel is passed into the corresponding block.
getUnconfined() - Static method in class kotlinx.coroutines.Dispatchers: A coroutine dispatcher that is not confined to any specific thread. It executes initial continuation of the coroutine immediately in the current call-frame and lets the coroutine resume in whatever thread that is used by the corresponding suspending function, without mandating any specific threading policy. Note: use with extreme caution, not for general code.
getValue() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: The most recently sent element to this channel.
getValueOrNull() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: The most recently sent element to this channel or null when this class is constructed without initial value and no value was sent yet or if it was ConflatedBroadcastChannel.close.
GlobalScope - Class in kotlinx.coroutines: A global interface CoroutineScope not bound to any job.

H

handleCoroutineException(context, exception, caller) - Static method in class kotlinx.coroutines.CoroutineExceptionHandlerKt: Helper function for coroutine builder implementations to handle uncaught exception in coroutines.
handleException(context, exception) - Method in interface kotlinx.coroutines.CoroutineExceptionHandler: Handles uncaught exception in the given context. It is invoked if coroutine has an uncaught exception.
hashCode() - Method in class kotlinx.coroutines.CoroutineName
hasNext(p) - Method in interface kotlinx.coroutines.channels.ChannelIterator: Returns true if the channel has more elements suspending the caller while this channel ReceiveChannel.isEmpty or returns false if the channel ReceiveChannel.isClosedForReceive without cause. It throws the original SendChannel.close cause exception if the channel has failed.
holdsLock(owner) - Method in interface kotlinx.coroutines.sync.Mutex: Checks mutex locked by owner

I

indexOf($receiver, element, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns first index of element, or -1 if the channel does not contain element.
INSTANCE - Static variable in class kotlinx.coroutines.Dispatchers: Groups various implementations of class CoroutineDispatcher.
INSTANCE - Static variable in class kotlinx.coroutines.GlobalScope: A global interface CoroutineScope not bound to any job.
INSTANCE - Static variable in class kotlinx.coroutines.NonCancellable: A non-cancelable job that is always Job.isActive. It is designed for BuildersKt.withContext function to prevent cancellation of code blocks that need to be executed without cancellation.
interceptContinuation(continuation) - Method in class kotlinx.coroutines.CoroutineDispatcher: Returns continuation that wraps the original continuation, thus intercepting all resumptions.
invoke($this, $receiver, block) - Static method in class kotlinx.coroutines.selects.SelectBuilder.DefaultImpls: Registers clause in this select expression with additional parameter nullable parameter of type P with the null value for this parameter that selects value of type Q.
invoke($receiver, block) - Method in interface kotlinx.coroutines.selects.SelectBuilder: Registers clause in this select expression without additional parameters that does not select any value.
invoke($receiver, block) - Method in interface kotlinx.coroutines.selects.SelectBuilder: Registers clause in this select expression without additional parameters that selects value of type Q.
invoke($receiver, param, block) - Method in interface kotlinx.coroutines.selects.SelectBuilder: Registers clause in this select expression with additional parameter of type P that selects value of type Q.
invoke($receiver, block) - Method in interface kotlinx.coroutines.selects.SelectBuilder: Registers clause in this select expression with additional parameter nullable parameter of type P with the null value for this parameter that selects value of type Q.
invokeOnCancellation(handler) - Method in interface kotlinx.coroutines.CancellableContinuation: Registers handler that is synchronously invoked once on cancellation (both regular and exceptional) of this continuation. When the continuation is already cancelled, then the handler is immediately invoked with cancellation exception. Otherwise, the handler will be invoked once on cancellation if this continuation is cancelled.
invokeOnClose(handler) - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Registers handler which is synchronously invoked once the channel is ConflatedBroadcastChannel.close or receiving side of this channel is ReceiveChannel.cancel. Only one handler can be attached to the channel during channel's lifetime. Handler is invoked when ConflatedBroadcastChannel.isClosedForSend starts to return true. If channel is already closed, handler is invoked immediately.
invokeOnClose(handler) - Method in interface kotlinx.coroutines.channels.SendChannel: Registers handler which is synchronously invoked once the channel is SendChannel.close or receiving side of this channel is ReceiveChannel.cancel. Only one handler can be attached to the channel during channel's lifetime. Handler is invoked when SendChannel.isClosedForSend starts to return true. If channel is already closed, handler is invoked immediately.
invokeOnCompletion(handler) - Method in interface kotlinx.coroutines.Job: Registers handler that is synchronously invoked once on completion of this job. When job is already complete, then the handler is immediately invoked with a job's exception or cancellation cause or null. Otherwise, handler will be invoked once when this job is complete.
IO_PARALLELISM_PROPERTY_NAME - Static variable in class kotlinx.coroutines.DispatchersKt: Name of the property that defines the maximal number of threads that are used by Dispatchers.getIO coroutines dispatcher.
isActive() - Method in interface kotlinx.coroutines.CancellableContinuation: Returns true when this continuation is active -- it has not completed or cancelled yet.
isActive($receiver) - Static method in class kotlinx.coroutines.CoroutineScopeKt: Returns true when current interface Job is still active (has not completed and was not cancelled yet).
isActive() - Method in interface kotlinx.coroutines.Job: Returns true when this job is active -- it was already started and has not completed nor was cancelled yet. The job that is waiting for its Job.getChildren to complete is still considered to be active if it was not cancelled nor failed.
isActive($receiver) - Static method in class kotlinx.coroutines.JobKt: Returns true when the interface Job of the coroutine in this context is still active (has not completed and was not cancelled yet).
isCancelled() - Method in interface kotlinx.coroutines.CancellableContinuation: Returns true if this continuation was CancellableContinuation.cancel.
isCancelled() - Method in interface kotlinx.coroutines.Job: Returns true if this job was cancelled for any reason, either by explicit invocation of Job.cancel or because it had failed or its child or parent was cancelled. In the general case, it does not imply that the job has already Job.isCompleted, because it may still be finishing whatever it was doing and waiting for its Job.getChildren to complete.
isClosedForReceive() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Returns true if this channel was closed by invocation of SendChannel.close on the interface SendChannel side and all previously sent items were already received, so that the ReceiveChannel.receive attempt throws exception ClosedReceiveChannelException. If the channel was closed because of the exception, it is considered closed, too, but it is called a failed channel. All suspending attempts to receive an element from a failed channel throw the original SendChannel.close cause exception.
isClosedForSend() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Returns true if this channel was closed by invocation of ConflatedBroadcastChannel.close and thus the ConflatedBroadcastChannel.send and ConflatedBroadcastChannel.offer attempts throws exception.
isClosedForSend() - Method in interface kotlinx.coroutines.channels.SendChannel: Returns true if this channel was closed by invocation of SendChannel.close and thus the SendChannel.send and SendChannel.offer attempts throws exception.
isCompleted() - Method in interface kotlinx.coroutines.CancellableContinuation: Returns true when this continuation has completed for any reason. A continuation that was cancelled is also considered complete.
isCompleted() - Method in interface kotlinx.coroutines.Job: Returns true when this job has completed for any reason. A job that was cancelled or failed and has finished its execution is also considered complete. Job becomes complete only after all its Job.getChildren complete.
isDispatchNeeded(context) - Method in class kotlinx.coroutines.CoroutineDispatcher: Returns true if execution shall be dispatched onto another thread. The default behaviour for most dispatchers is to return true.
isEmpty() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Returns true if the channel is empty (contains no elements) and the ReceiveChannel.receive attempt will suspend. This function returns false for ReceiveChannel.isClosedForReceive channel.
isFull() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Returns true if the channel is full (out of capacity) and the ConflatedBroadcastChannel.send attempt will suspend. This function returns false for ConflatedBroadcastChannel.isClosedForSend channel.
isFull() - Method in interface kotlinx.coroutines.channels.SendChannel: Returns true if the channel is full (out of capacity) and the SendChannel.send attempt will suspend. This function returns false for SendChannel.isClosedForSend channel.
isLocked() - Method in interface kotlinx.coroutines.sync.Mutex: Returns true when this mutex is locked.
iterator() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Returns new iterator to receive elements from this channels using for loop. Iteration completes normally when the channel is ReceiveChannel.isClosedForReceive without cause and throws the original SendChannel.close cause exception if the channel has failed.

J

Job - Interface in kotlinx.coroutines: A background job. Conceptually, a job is a cancellable thing with a life-cycle that culminates in its completion.
Job(parent) - Static method in class kotlinx.coroutines.JobKt: Creates a new job object in an active state. A failure of any child of this job immediately causes this job to fail, too, and cancels the rest of its children.
Job.DefaultImpls - Class in kotlinx.coroutines: A background job. Conceptually, a job is a cancellable thing with a life-cycle that culminates in its completion.
Job.Key - Class in kotlinx.coroutines: Key for interface Job instance in the coroutine context.
JobKt - Class in kotlinx.coroutines
JobSupportKt - Class in kotlinx.coroutines
join(p) - Method in interface kotlinx.coroutines.Job: Suspends coroutine until this job is complete. This invocation resumes normally (without exception) when the job is complete for any reason and the interface Job of the invoking coroutine is still Job.isActive. This function also Job.start the corresponding coroutine if the interface Job was still in new state.
joinAll(jobs, p) - Static method in class kotlinx.coroutines.AwaitKt: Suspends current coroutine until all given jobs are complete. This method is semantically equivalent to joining all given jobs one by one with jobs.forEach { it.join() }.
joinAll($receiver, p) - Static method in class kotlinx.coroutines.AwaitKt: Suspends current coroutine until all given jobs are complete. This method is semantically equivalent to joining all given jobs one by one with forEach { it.join() }.

K

Key - Static variable in interface kotlinx.coroutines.CoroutineExceptionHandler: Key for interface CoroutineExceptionHandler instance in the coroutine context.
Key - Static variable in class kotlinx.coroutines.CoroutineName: Key for class CoroutineName instance in the coroutine context.
Key - Static variable in interface kotlinx.coroutines.Job: Key for interface Job instance in the coroutine context.
kotlinx.coroutines - package kotlinx.coroutines: General-purpose coroutine builders, contexts, and helper functions.
kotlinx.coroutines.channels - package kotlinx.coroutines.channels: Channels -- non-blocking primitives for communicating a stream of elements between coroutines.
kotlinx.coroutines.selects - package kotlinx.coroutines.selects: Select expression to perform multiple suspending operations simultaneously until one of them succeeds.
kotlinx.coroutines.sync - package kotlinx.coroutines.sync: Synchronization primitives (mutex).
kotlinx.coroutines.test - package kotlinx.coroutines.test: Components to ease writing unit-tests for code that contains coroutines with delays and timeouts.

L

last($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the last element.
lastIndexOf($receiver, element, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns last index of element, or -1 if the channel does not contain element.
lastOrNull($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the last element, or null if the channel is empty.
launch($receiver, context, start, block) - Static method in class kotlinx.coroutines.BuildersKt: Launches new coroutine without blocking current thread and returns a reference to the coroutine as a interface Job. The coroutine is cancelled when the resulting job is Job.cancel.
lock(owner, p) - Method in interface kotlinx.coroutines.sync.Mutex: Locks this mutex, suspending caller while the mutex is locked.

M

MainCoroutineDispatcher - Class in kotlinx.coroutines: Base class for special class CoroutineDispatcher which is confined to application "Main" or "UI" thread and used for any UI-based activities. Instance of MainDispatcher can be obtained by Dispatchers.getMain.
MainCoroutineDispatcher() - Constructor for class kotlinx.coroutines.MainCoroutineDispatcher: Base class for special class CoroutineDispatcher which is confined to application "Main" or "UI" thread and used for any UI-based activities. Instance of MainDispatcher can be obtained by Dispatchers.getMain.
MainScope() - Static method in class kotlinx.coroutines.CoroutineScopeKt: Creates the main interface CoroutineScope for UI components.
map($receiver, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing the results of applying the given transform function to each element in the original channel.
mapIndexed($receiver, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing the results of applying the given transform function to each element and its index in the original channel.
mapIndexedNotNull($receiver, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only the non-null results of applying the given transform function to each element and its index in the original channel.
mapNotNull($receiver, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only the non-null results of applying the given transform function to each element in the original channel.
maxWith($receiver, comparator, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the first element having the largest value according to the provided comparator or null if there are no elements.
minusKey(key) - Method in class kotlinx.coroutines.test.TestCoroutineContext
minWith($receiver, comparator, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the first element having the smallest value according to the provided comparator or null if there are no elements.
Mutex - Interface in kotlinx.coroutines.sync: Mutual exclusion for coroutines.
Mutex(locked) - Static method in class kotlinx.coroutines.sync.MutexKt: Creates new interface Mutex instance. The mutex created is fair: lock is granted in first come, first served order.
MutexKt - Class in kotlinx.coroutines.sync

N

newCoroutineContext($receiver, context) - Static method in class kotlinx.coroutines.CoroutineContextKt: Creates context for the new coroutine. It installs Dispatchers.getDefault when no other dispatcher nor ContinuationInterceptor is specified, and adds optional support for debugging facilities (when turned on).
newFixedThreadPoolContext(nThreads, name) - Static method in class kotlinx.coroutines.ThreadPoolDispatcherKt: Creates new coroutine execution context with the fixed-size thread-pool and built-in YieldKt.yield support. NOTE: The resulting class ExecutorCoroutineDispatcher owns native resources (its threads).Resources are reclaimed by ExecutorCoroutineDispatcher.close.
newSingleThreadContext(name) - Static method in class kotlinx.coroutines.ThreadPoolDispatcherKt: Creates a new coroutine execution context using a single thread with built-in YieldKt.yield support. NOTE: The resulting class ExecutorCoroutineDispatcher owns native resources (its thread).Resources are reclaimed by ExecutorCoroutineDispatcher.close.
next(p) - Method in interface kotlinx.coroutines.channels.ChannelIterator: Retrieves and removes the element from this channel suspending the caller while this channel ReceiveChannel.isEmpty or throws exception ClosedReceiveChannelException if the channel ReceiveChannel.isClosedForReceive without cause. It throws the original SendChannel.close cause exception if the channel has failed.
NonCancellable - Class in kotlinx.coroutines: A non-cancelable job that is always Job.isActive. It is designed for BuildersKt.withContext function to prevent cancellation of code blocks that need to be executed without cancellation.
none($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns true if the channel has no elements.
now(unit) - Method in class kotlinx.coroutines.test.TestCoroutineContext: Returns the current virtual clock-time as it is known to this CoroutineContext.

O

ObsoleteCoroutinesApi - Interface in kotlinx.coroutines: Marks declarations that are obsolete in coroutines API, which means that the design of the corresponding declarations has serious known flaws and they will be redesigned in the future. Roughly speaking, these declarations will be deprecated in the future but there is no replacement for them yet, so they cannot be deprecated right away.
offer(element) - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Sends the value to all subscribed receives and stores this value as the most recent state for future subscribers. This implementation always returns true. It throws exception if the channel ConflatedBroadcastChannel.isClosedForSend (see ConflatedBroadcastChannel.close for details).
offer(element) - Method in interface kotlinx.coroutines.channels.SendChannel: Adds element into this queue if it is possible to do so immediately without violating capacity restrictions and returns true. Otherwise, it returns false immediately or throws exception if the channel SendChannel.isClosedForSend (see SendChannel.close for details).
onTimeout(timeMillis, block) - Method in interface kotlinx.coroutines.selects.SelectBuilder: Clause that selects the given block after a specified timeout passes. If timeout is negative or zero, block is selected immediately.
openSubscription() - Method in interface kotlinx.coroutines.channels.BroadcastChannel: Subscribes to this interface BroadcastChannel and returns a channel to receive elements from it. The resulting channel shall be ReceiveChannel.cancel to unsubscribe from this broadcast channel.
openSubscription() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Subscribes to this interface BroadcastChannel and returns a channel to receive elements from it. The resulting channel shall be ReceiveChannel.cancel to unsubscribe from this broadcast channel.

P

plus($receiver, context) - Static method in class kotlinx.coroutines.CoroutineScopeKt: Adds the specified coroutine context to this scope, overriding existing elements in the current scope's context with the corresponding keys.
poll() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Retrieves and removes the element from this channel, or returns null if this channel isEmpty or is ReceiveChannel.isClosedForReceive without cause. It throws the original SendChannel.close cause exception if the channel has failed.
produce($receiver, context, capacity, block) - Static method in class kotlinx.coroutines.channels.ProduceKt: Launches new coroutine to produce a stream of values by sending them to a channel and returns a reference to the coroutine as a interface ReceiveChannel. This resulting object can be used to ReceiveChannel.receive elements produced by this coroutine.
ProduceKt - Class in kotlinx.coroutines.channels
ProducerScope<E> - Interface in kotlinx.coroutines.channels: Scope for ProduceKt.produce coroutine builder.

R

receive(p) - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Retrieves and removes the element from this channel suspending the caller while this channel isEmpty or throws exception ClosedReceiveChannelException if the channel ReceiveChannel.isClosedForReceive. If the channel was closed because of the exception, it is called a failed channel and this function throws the original SendChannel.close cause exception.
ReceiveChannel<E> - Interface in kotlinx.coroutines.channels: Receiver's interface to interface Channel.
ReceiveChannel.DefaultImpls - Class in kotlinx.coroutines.channels: Receiver's interface to interface Channel.
receiveOrNull(p) - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Retrieves and removes the element from this channel suspending the caller while this channel isEmpty or returns null if the channel is ReceiveChannel.isClosedForReceive without cause or throws the original SendChannel.close cause exception if the channel has failed.
RENDEZVOUS - Static variable in class kotlinx.coroutines.channels.Channel.Factory: Requests rendezvous channel in Channel(...) factory function -- the RendezvousChannel gets created.
RENDEZVOUS - Static variable in interface kotlinx.coroutines.channels.Channel: Requests rendezvous channel in Channel(...) factory function -- the RendezvousChannel gets created.
requireNoNulls($receiver) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns an original collection containing all the non-null elements, throwing an IllegalArgumentException if there are any null elements.
restoreThreadContext(context, oldState) - Method in interface kotlinx.coroutines.ThreadContextElement: Restores context of the current thread. This function is invoked after the coroutine in the specified context is suspended in the current thread if ThreadContextElement.updateThreadContext was previously invoked on resume of this coroutine. The value of oldState is the result of the previous invocation of ThreadContextElement.updateThreadContext and it should be restored in the thread-local state by this function. This method should handle its own exceptions and do not rethrow it. Thrown exceptions will leave coroutine which context is updated in an undefined state.
ResumeModeKt - Class in kotlinx.coroutines
resumeUndispatched($receiver, value) - Method in interface kotlinx.coroutines.CancellableContinuation: Resumes this continuation with a given value in the invoker thread without going though CoroutineDispatcher.dispatch function of the class CoroutineDispatcher in the context. This function is designed to be used only by the class CoroutineDispatcher implementations themselves. It should not be used in general code.
resumeUndispatchedWithException($receiver, exception) - Method in interface kotlinx.coroutines.CancellableContinuation: Resumes this continuation with a given exception in the invoker thread without going though CoroutineDispatcher.dispatch function of the class CoroutineDispatcher in the context. This function is designed to be used only by the class CoroutineDispatcher implementations themselves. It should not be used in general code.
runBlocking(context, block) - Static method in class kotlinx.coroutines.BuildersKt: Runs new coroutine and blocks current thread interruptibly until its completion. This function should not be used from coroutine. It is designed to bridge regular blocking code to libraries that are written in suspending style, to be used in main functions and in tests.
Runnable(block) - Static method in class kotlinx.coroutines.RunnableKt: Creates Runnable task instance.
RunnableKt - Class in kotlinx.coroutines

S

SchedulerTaskKt - Class in kotlinx.coroutines
SelectBuilder<R> - Interface in kotlinx.coroutines.selects: Scope for select invocation.
SelectBuilder.DefaultImpls - Class in kotlinx.coroutines.selects: Scope for select invocation.
SelectClause0 - Interface in kotlinx.coroutines.selects: Clause for select expression without additional parameters that does not select any value.
SelectClause1<Q> - Interface in kotlinx.coroutines.selects: Clause for select expression without additional parameters that selects value of type Q.
SelectClause2<P,Q> - Interface in kotlinx.coroutines.selects: Clause for select expression with additional parameter of type P that selects value of type Q.
SelectKt - Class in kotlinx.coroutines.selects
SelectUnbiasedKt - Class in kotlinx.coroutines.selects
send(element, p) - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Sends the value to all subscribed receives and stores this value as the most recent state for future subscribers. This implementation never suspends. It throws exception if the channel ConflatedBroadcastChannel.isClosedForSend (see ConflatedBroadcastChannel.close for details).
send(element, p) - Method in interface kotlinx.coroutines.channels.SendChannel: Adds element into to this channel, suspending the caller while this channel SendChannel.isFull, or throws exception if the channel SendChannel.isClosedForSend (see SendChannel.close for details).
sendBlocking($receiver, element) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Adds element into to this channel, blocking the caller while this channel SendChannel.isFull, or throws exception if the channel SendChannel.isClosedForSend (see SendChannel.close for details).
SendChannel<E> - Interface in kotlinx.coroutines.channels: Sender's interface to interface Channel.
single($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the single element, or throws an exception if the channel is empty or has more than one element.
singleOrNull($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns single element, or null if the channel is empty or has more than one element.
start() - Method in interface kotlinx.coroutines.Job: Starts coroutine related to this job (if any) if it was not started yet. The result true if this invocation actually started coroutine or false if it was already started or completed.
SupervisorJob(parent) - Static method in class kotlinx.coroutines.SupervisorKt: Creates a new supervisor job object in an active state. Children of a supervisor job can fail independently of each other.
SupervisorKt - Class in kotlinx.coroutines
supervisorScope(block, p) - Static method in class kotlinx.coroutines.SupervisorKt: Creates new interface CoroutineScope with SupervisorKt.SupervisorJob and calls the specified suspend block with this scope. The provided scope inherits its CoroutineScope.getCoroutineContext from the outer scope, but overrides context's interface Job with SupervisorKt.SupervisorJob.

T

take($receiver, n, context) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing first n elements.
takeWhile($receiver, context, predicate) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing first elements satisfying the given predicate.
TestCoroutineContext - Class in kotlinx.coroutines.test: This CoroutineContext dispatcher can be used to simulate virtual time to speed up code, especially tests, that deal with delays and timeouts in Coroutines.
TestCoroutineContext(name) - Constructor for class kotlinx.coroutines.test.TestCoroutineContext: This CoroutineContext dispatcher can be used to simulate virtual time to speed up code, especially tests, that deal with delays and timeouts in Coroutines.
TestCoroutineContext() - Constructor for class kotlinx.coroutines.test.TestCoroutineContext: This CoroutineContext dispatcher can be used to simulate virtual time to speed up code, especially tests, that deal with delays and timeouts in Coroutines.
TestCoroutineContextKt - Class in kotlinx.coroutines.test
ThreadContextElement<S> - Interface in kotlinx.coroutines: Defines elements in CoroutineContext that are installed into thread context every time the coroutine with this element in the context is resumed on a thread.
ThreadContextElementKt - Class in kotlinx.coroutines
ThreadPoolDispatcherKt - Class in kotlinx.coroutines
ticker(delayMillis, initialDelayMillis, context, mode) - Static method in class kotlinx.coroutines.channels.TickerChannelsKt: Creates a channel that produces the first item after the given initial delay and subsequent items with the given delay between them.
TickerChannelsKt - Class in kotlinx.coroutines.channels
TickerMode - Enum in kotlinx.coroutines.channels: Mode for TickerChannelsKt.ticker function.
TickerMode() - Constructor for enum kotlinx.coroutines.channels.TickerMode: Mode for TickerChannelsKt.ticker function.
TimeoutCancellationException - Exception in kotlinx.coroutines: This exception is thrown by TimeoutKt.withTimeout to indicate timeout.
TimeoutKt - Class in kotlinx.coroutines
TimeSourceKt - Class in kotlinx.coroutines
toChannel($receiver, destination, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Send each element of the original channel and appends the results to the given destination.
toCollection($receiver, destination, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Appends all elements to the given destination collection.
toList($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a List containing all elements.
toMap($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a Map filled with all elements of this channel.
toMap($receiver, destination, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a MutableMap filled with all elements of this channel.
toMutableList($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a MutableList filled with all elements of this channel.
toMutableSet($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a mutable set containing all distinct elements from the given channel.
toSet($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a Set of all elements.
toString() - Method in class kotlinx.coroutines.CoroutineName: Returns a string representation of the object.
toString() - Method in class kotlinx.coroutines.test.TestCoroutineContext
triggerActions() - Method in class kotlinx.coroutines.test.TestCoroutineContext: Triggers any actions that have not yet been triggered and that are scheduled to be triggered at or before this CoroutineContext's present virtual clock-time.
tryLock(owner) - Method in interface kotlinx.coroutines.sync.Mutex: Tries to lock this mutex, returning false if this mutex is already locked.

U

UNLIMITED - Static variable in class kotlinx.coroutines.channels.Channel.Factory: Requests channel with unlimited capacity buffer in Channel(...) factory function
UNLIMITED - Static variable in interface kotlinx.coroutines.channels.Channel: Requests channel with unlimited capacity buffer in Channel(...) factory function
unlock(owner) - Method in interface kotlinx.coroutines.sync.Mutex: Unlocks this mutex. Throws IllegalStateException if invoked on a mutex that is not locked or was locked with a different owner token (by identity).
updateThreadContext(context) - Method in interface kotlinx.coroutines.ThreadContextElement: Updates context of the current thread. This function is invoked before the coroutine in the specified context is resumed in the current thread when the context of the coroutine this element. The result of this function is the old value of the thread-local state that will be passed to ThreadContextElement.restoreThreadContext. This method should handle its own exceptions and do not rethrow it. Thrown exceptions will leave coroutine which context is updated in an undefined state.

W

WhileSelectKt - Class in kotlinx.coroutines.selects
withContext(context, block, p) - Static method in class kotlinx.coroutines.BuildersKt: Calls the specified suspending block with a given coroutine context, suspends until it completes, and returns the result.
withIndex($receiver, context) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel of IndexedValue for each element of the original channel.
withTestContext(testContext, testBody) - Static method in class kotlinx.coroutines.test.TestCoroutineContextKt: Executes a block of code in which a unit-test can be written using the provided class TestCoroutineContext. The provided class TestCoroutineContext is available in the testBody as the this receiver.
withTimeout(timeMillis, block, p) - Static method in class kotlinx.coroutines.TimeoutKt: Runs a given suspending block of code inside a coroutine with a specified timeout and throws exception TimeoutCancellationException if timeout was exceeded.
withTimeoutOrNull(timeMillis, block, p) - Static method in class kotlinx.coroutines.TimeoutKt: Runs a given suspending block of code inside a coroutine with a specified timeout and returns null if this timeout was exceeded.

Y

yield(p) - Static method in class kotlinx.coroutines.YieldKt: Yields a thread (or thread pool) of the current coroutine dispatcher to other coroutines to run. If the coroutine dispatcher does not have its own thread pool (like Dispatchers.getUnconfined) then this function does nothing, but checks if the coroutine interface Job was completed. This suspending function is cancellable. If the interface Job of the current coroutine is cancelled or completed when this suspending function is invoked or while this function is waiting for dispatching, it resumes with CancellationException.
YieldKt - Class in kotlinx.coroutines

Z

zip($receiver, other) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel of pairs built from elements of both channels with same indexes. Resulting channel has length of shortest input channel.
zip($receiver, other, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel of values built from elements of both collections with same indexes using provided transform. Resulting channel has length of shortest input channels.

A B C D E F G H I J K L M N O P R S T U W Y Z