Package-level declarations

Flow — asynchronous cold stream of elements.

Types

Link copied to clipboard

Base class for stateful implementations of Flow. It tracks all the properties required for context preservation and throws an IllegalStateException if any of the properties are violated.

Link copied to clipboard
interface Flow<out T>

An asynchronous data stream that sequentially emits values and completes normally or with an exception.

Link copied to clipboard
fun interface FlowCollector<in T>

FlowCollector is used as an intermediate or a terminal collector of the flow and represents an entity that accepts values emitted by the Flow.

Link copied to clipboard

A mutable SharedFlow that provides functions to emit values to the flow. An instance of MutableSharedFlow with the given configuration parameters can be created using MutableSharedFlow(...) constructor function.

Link copied to clipboard

A mutable StateFlow that provides a setter for value. An instance of MutableStateFlow with the given initial value can be created using MutableStateFlow(value) constructor function.

Link copied to clipboard
interface SharedFlow<out T> : Flow<T>

A hot Flow that shares emitted values among all its collectors in a broadcast fashion, so that all collectors get all emitted values. A shared flow is called hot because its active instance exists independently of the presence of collectors. This is opposed to a regular Flow, such as defined by the flow { ... } function, which is cold and is started separately for each collector.

Link copied to clipboard

A command emitted by SharingStarted implementations to control the sharing coroutine in the shareIn and stateIn operators.

Link copied to clipboard
fun interface SharingStarted

A strategy for starting and stopping the sharing coroutine in shareIn and stateIn operators.

Link copied to clipboard
interface StateFlow<out T> : SharedFlow<T>

A SharedFlow that represents a read-only state with a single updatable data value that emits updates to the value to its collectors. A state flow is a hot flow because its active instance exists independently of the presence of collectors. Its current value can be retrieved via the value property.

Properties

Link copied to clipboard

Default concurrency limit that is used by flattenMerge and flatMapMerge operators. It is 16 by default and can be changed on JVM using DEFAULT_CONCURRENCY_PROPERTY_NAME property. This is a preview API and can be changed in a backwards-incompatible manner within a single release.

Link copied to clipboard

Name of the property that defines the value of DEFAULT_CONCURRENCY. This is a preview API and can be changed in a backwards-incompatible manner within a single release.

Functions

Link copied to clipboard
fun <T> Array<T>.asFlow(): Flow<T>

Creates a cold flow that produces values from the given array. The flow being cold means that the array components are read every time a terminal operator is applied to the resulting flow.

fun <T> () -> T.asFlow(): Flow<T>
fun <T> suspend () -> T.asFlow(): Flow<T>

Creates a cold flow that produces a single value from the given functional type.

Creates a cold flow that produces values from the array. The flow being cold means that the array components are read every time a terminal operator is applied to the resulting flow.

fun <T> Iterable<T>.asFlow(): Flow<T>

Creates a cold flow that produces values from the given iterable.

fun <T> Iterator<T>.asFlow(): Flow<T>

Creates a cold flow that produces values from the given iterator.

Creates a flow that produces values from the range.

fun <T> Sequence<T>.asFlow(): Flow<T>

Creates a cold flow that produces values from the given sequence.

Represents the given broadcast channel as a hot flow. Every flow collector will trigger a new broadcast channel subscription.

Link copied to clipboard

Represents this mutable shared flow as a read-only shared flow.

Link copied to clipboard

Represents this mutable state flow as a read-only state flow.

Link copied to clipboard
fun <T> Flow<T>.buffer(capacity: Int = BUFFERED, onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND): Flow<T>

Buffers flow emissions via channel of a specified capacity and runs collector in a separate coroutine.

Link copied to clipboard
fun <T> callbackFlow(block: suspend ProducerScope<T>.() -> Unit): Flow<T>

Creates an instance of a cold Flow with elements that are sent to a SendChannel provided to the builder's block of code via ProducerScope. It allows elements to be produced by code that is running in a different context or concurrently.

Link copied to clipboard
fun <T> Flow<T>.cancellable(): Flow<T>

Returns a flow which checks cancellation status on each emission and throws the corresponding cancellation cause if flow collector was cancelled. Note that flow builder and all implementations of SharedFlow are cancellable by default.

Link copied to clipboard
fun <T> Flow<T>.catch(action: suspend FlowCollector<T>.(cause: Throwable) -> Unit): Flow<T>

Catches exceptions in the flow completion and calls a specified action with the caught exception. This operator is transparent to exceptions that occur in downstream flow and does not catch exceptions that are thrown to cancel the flow.

Link copied to clipboard
fun <T> channelFlow(block: suspend ProducerScope<T>.() -> Unit): Flow<T>

Creates an instance of a cold Flow with elements that are sent to a SendChannel provided to the builder's block of code via ProducerScope. It allows elements to be produced by code that is running in a different context or concurrently. The resulting flow is cold, which means that block is called every time a terminal operator is applied to the resulting flow.

Link copied to clipboard
suspend fun Flow<*>.collect()

Terminal flow operator that collects the given flow but ignores all emitted values. If any exception occurs during collect or in the provided flow, this exception is rethrown from this method.

Link copied to clipboard
inline suspend fun <T> Flow<T>.collectIndexed(crossinline action: suspend (index: Int, value: T) -> Unit)

Terminal flow operator that collects the given flow with a provided action that takes the index of an element (zero-based) and the element. If any exception occurs during collect or in the provided flow, this exception is rethrown from this method.

Link copied to clipboard
suspend fun <T> Flow<T>.collectLatest(action: suspend (value: T) -> Unit)

Terminal flow operator that collects the given flow with a provided action. The crucial difference from collect is that when the original flow emits a new value then the action block for the previous value is cancelled.

Link copied to clipboard
inline fun <T, R> combine(vararg flows: Flow<T>, crossinline transform: suspend (Array<T>) -> R): Flow<R>
inline fun <T, R> combine(flows: Iterable<Flow<T>>, crossinline transform: suspend (Array<T>) -> R): Flow<R>
fun <T1, T2, R> combine(flow: Flow<T1>, flow2: Flow<T2>, transform: suspend (a: T1, b: T2) -> R): Flow<R>
fun <T1, T2, T3, R> combine(flow: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, transform: suspend (T1, T2, T3) -> R): Flow<R>
fun <T1, T2, T3, T4, R> combine(flow: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, flow4: Flow<T4>, transform: suspend (T1, T2, T3, T4) -> R): Flow<R>
fun <T1, T2, T3, T4, T5, R> combine(flow: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, flow4: Flow<T4>, flow5: Flow<T5>, transform: suspend (T1, T2, T3, T4, T5) -> R): Flow<R>

Returns a Flow whose values are generated with transform function by combining the most recently emitted values by each flow.

Link copied to clipboard
@JvmName(name = "flowCombine")
fun <T1, T2, R> Flow<T1>.combine(flow: Flow<T2>, transform: suspend (a: T1, b: T2) -> R): Flow<R>

Returns a Flow whose values are generated with transform function by combining the most recently emitted values by each flow.

Link copied to clipboard
inline fun <T, R> combineTransform(vararg flows: Flow<T>, crossinline transform: suspend FlowCollector<R>.(Array<T>) -> Unit): Flow<R>
inline fun <T, R> combineTransform(flows: Iterable<Flow<T>>, crossinline transform: suspend FlowCollector<R>.(Array<T>) -> Unit): Flow<R>
fun <T1, T2, R> combineTransform(flow: Flow<T1>, flow2: Flow<T2>, transform: suspend FlowCollector<R>.(a: T1, b: T2) -> Unit): Flow<R>
fun <T1, T2, T3, R> combineTransform(flow: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, transform: suspend FlowCollector<R>.(T1, T2, T3) -> Unit): Flow<R>
fun <T1, T2, T3, T4, R> combineTransform(flow: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, flow4: Flow<T4>, transform: suspend FlowCollector<R>.(T1, T2, T3, T4) -> Unit): Flow<R>
fun <T1, T2, T3, T4, T5, R> combineTransform(flow: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, flow4: Flow<T4>, flow5: Flow<T5>, transform: suspend FlowCollector<R>.(T1, T2, T3, T4, T5) -> Unit): Flow<R>

Returns a Flow whose values are generated by transform function that process the most recently emitted values by each flow.

Link copied to clipboard
@JvmName(name = "flowCombineTransform")
fun <T1, T2, R> Flow<T1>.combineTransform(flow: Flow<T2>, transform: suspend FlowCollector<R>.(a: T1, b: T2) -> Unit): Flow<R>

Returns a Flow whose values are generated by transform function that process the most recently emitted values by each flow.

Link copied to clipboard
fun <T> Flow<T>.conflate(): Flow<T>

Conflates flow emissions via conflated channel and runs collector in a separate coroutine. The effect of this is that emitter is never suspended due to a slow collector, but collector always gets the most recent value emitted.

Link copied to clipboard

Represents the given receive channel as a hot flow and consumes the channel on the first collection from this flow. The resulting flow can be collected just once and throws IllegalStateException when trying to collect it more than once.

Link copied to clipboard
suspend fun <T> Flow<T>.count(): Int

Returns the number of elements in this flow.

suspend fun <T> Flow<T>.count(predicate: suspend (T) -> Boolean): Int

Returns the number of elements matching the given predicate.

Link copied to clipboard
fun <T> Flow<T>.debounce(timeoutMillis: (T) -> Long): Flow<T>
@JvmName(name = "debounceDuration")
fun <T> Flow<T>.debounce(timeout: (T) -> Duration): Flow<T>
fun <T> Flow<T>.debounce(timeoutMillis: Long): Flow<T>
fun <T> Flow<T>.debounce(timeout: Duration): Flow<T>

Returns a flow that mirrors the original flow, but filters out values that are followed by the newer values within the given timeout. The latest value is always emitted.

Link copied to clipboard

Returns flow where all subsequent repetitions of the same value are filtered out.

fun <T> Flow<T>.distinctUntilChanged(areEquivalent: (old: T, new: T) -> Boolean): Flow<T>

Returns flow where all subsequent repetitions of the same value are filtered out, when compared with each other via the provided areEquivalent function.

Link copied to clipboard
fun <T, K> Flow<T>.distinctUntilChangedBy(keySelector: (T) -> K): Flow<T>

Returns flow where all subsequent repetitions of the same key are filtered out, where key is extracted with keySelector function.

Link copied to clipboard
fun <T> Flow<T>.drop(count: Int): Flow<T>

Returns a flow that ignores first count elements. Throws IllegalArgumentException if count is negative.

Link copied to clipboard
fun <T> Flow<T>.dropWhile(predicate: suspend (T) -> Boolean): Flow<T>

Returns a flow containing all elements except first elements that satisfy the given predicate.

Link copied to clipboard
suspend fun <T> FlowCollector<T>.emitAll(channel: ReceiveChannel<T>)

Emits all elements from the given channel to this flow collector and cancels (consumes) the channel afterwards. If you need to iterate over the channel without consuming it, a regular for loop should be used instead.

suspend fun <T> FlowCollector<T>.emitAll(flow: Flow<T>)

Collects all the values from the given flow and emits them to the collector. It is a shorthand for flow.collect { value -> emit(value) }.

Link copied to clipboard
fun <T> emptyFlow(): Flow<T>

Returns an empty flow.

Link copied to clipboard
inline fun <T> Flow<T>.filter(crossinline predicate: suspend (T) -> Boolean): Flow<T>

Returns a flow containing only values of the original flow that match the given predicate.

Link copied to clipboard
inline fun <R> Flow<*>.filterIsInstance(): Flow<R>

Returns a flow containing only values that are instances of specified type R.

fun <R : Any> Flow<*>.filterIsInstance(klass: KClass<R>): Flow<R>

Returns a flow containing only values that are instances of the given klass.

Link copied to clipboard
inline fun <T> Flow<T>.filterNot(crossinline predicate: suspend (T) -> Boolean): Flow<T>

Returns a flow containing only values of the original flow that do not match the given predicate.

Link copied to clipboard
fun <T : Any> Flow<T?>.filterNotNull(): Flow<T>

Returns a flow containing only values of the original flow that are not null.

Link copied to clipboard
suspend fun <T> Flow<T>.first(): T

The terminal operator that returns the first element emitted by the flow and then cancels flow's collection. Throws NoSuchElementException if the flow was empty.

suspend fun <T> Flow<T>.first(predicate: suspend (T) -> Boolean): T

The terminal operator that returns the first element emitted by the flow matching the given predicate and then cancels flow's collection. Throws NoSuchElementException if the flow has not contained elements matching the predicate.

Link copied to clipboard
suspend fun <T> Flow<T>.firstOrNull(): T?

The terminal operator that returns the first element emitted by the flow and then cancels flow's collection. Returns null if the flow was empty.

suspend fun <T> Flow<T>.firstOrNull(predicate: suspend (T) -> Boolean): T?

The terminal operator that returns the first element emitted by the flow matching the given predicate and then cancels flow's collection. Returns null if the flow did not contain an element matching the predicate.

Link copied to clipboard
fun <T, R> Flow<T>.flatMapConcat(transform: suspend (value: T) -> Flow<R>): Flow<R>

Transforms elements emitted by the original flow by applying transform, that returns another flow, and then concatenating and flattening these flows.

Link copied to clipboard
inline fun <T, R> Flow<T>.flatMapLatest(crossinline transform: suspend (value: T) -> Flow<R>): Flow<R>

Returns a flow that switches to a new flow produced by transform function every time the original flow emits a value. When the original flow emits a new value, the previous flow produced by transform block is cancelled.

Link copied to clipboard
fun <T, R> Flow<T>.flatMapMerge(concurrency: Int = DEFAULT_CONCURRENCY, transform: suspend (value: T) -> Flow<R>): Flow<R>

Transforms elements emitted by the original flow by applying transform, that returns another flow, and then merging and flattening these flows.

Link copied to clipboard

Flattens the given flow of flows into a single flow in a sequential manner, without interleaving nested flows.

Link copied to clipboard
fun <T> Flow<Flow<T>>.flattenMerge(concurrency: Int = DEFAULT_CONCURRENCY): Flow<T>

Flattens the given flow of flows into a single flow with a concurrency limit on the number of concurrently collected flows.

Link copied to clipboard
fun <T> flow(block: suspend FlowCollector<T>.() -> Unit): Flow<T>

Creates a cold flow from the given suspendable block. The flow being cold means that the block is called every time a terminal operator is applied to the resulting flow.

Link copied to clipboard
fun <T> flowOf(value: T): Flow<T>

Creates a flow that produces the given value.

fun <T> flowOf(vararg elements: T): Flow<T>

Creates a flow that produces values from the specified vararg-arguments.

Link copied to clipboard
fun <T> Flow<T>.flowOn(context: CoroutineContext): Flow<T>

Changes the context where this flow is executed to the given context. This operator is composable and affects only preceding operators that do not have its own context. This operator is context preserving: context does not leak into the downstream flow.

Link copied to clipboard
inline suspend fun <T, R> Flow<T>.fold(initial: R, crossinline operation: suspend (acc: R, value: T) -> R): R

Accumulates value starting with initial value and applying operation current accumulator value and each element

Link copied to clipboard
inline fun <T> MutableStateFlow<T>.getAndUpdate(function: (T) -> T): T

Updates the MutableStateFlow.value atomically using the specified function of its value, and returns its prior value.

Link copied to clipboard
suspend fun <T> Flow<T>.last(): T

The terminal operator that returns the last element emitted by the flow.

Link copied to clipboard
suspend fun <T> Flow<T>.lastOrNull(): T?

The terminal operator that returns the last element emitted by the flow or null if the flow was empty.

Link copied to clipboard
fun <T> Flow<T>.launchIn(scope: CoroutineScope): Job

Terminal flow operator that launches the collection of the given flow in the scope. It is a shorthand for scope.launch { flow.collect() }.

Link copied to clipboard
inline fun <T, R> Flow<T>.map(crossinline transform: suspend (value: T) -> R): Flow<R>

Returns a flow containing the results of applying the given transform function to each value of the original flow.

Link copied to clipboard
fun <T, R> Flow<T>.mapLatest(transform: suspend (value: T) -> R): Flow<R>

Returns a flow that emits elements from the original flow transformed by transform function. When the original flow emits a new value, computation of the transform block for previous value is cancelled.

Link copied to clipboard
inline fun <T, R : Any> Flow<T>.mapNotNull(crossinline transform: suspend (value: T) -> R?): Flow<R>

Returns a flow that contains only non-null results of applying the given transform function to each value of the original flow.

Link copied to clipboard
fun <T> merge(vararg flows: Flow<T>): Flow<T>

Merges the given flows into a single flow without preserving an order of elements. All flows are merged concurrently, without limit on the number of simultaneously collected flows.

Link copied to clipboard
fun <T> Iterable<Flow<T>>.merge(): Flow<T>

Merges the given flows into a single flow without preserving an order of elements. All flows are merged concurrently, without limit on the number of simultaneously collected flows.

Link copied to clipboard
fun <T> MutableSharedFlow(replay: Int = 0, extraBufferCapacity: Int = 0, onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND): MutableSharedFlow<T>

Creates a MutableSharedFlow with the given configuration parameters.

Link copied to clipboard

Creates a MutableStateFlow with the given initial value.

Link copied to clipboard
fun <T> Flow<T>.onCompletion(action: suspend FlowCollector<T>.(cause: Throwable?) -> Unit): Flow<T>

Returns a flow that invokes the given action after the flow is completed or cancelled, passing the cancellation exception or failure as cause parameter of action.

Link copied to clipboard
fun <T> Flow<T>.onEach(action: suspend (T) -> Unit): Flow<T>

Returns a flow that invokes the given action before each value of the upstream flow is emitted downstream.

Link copied to clipboard
fun <T> Flow<T>.onEmpty(action: suspend FlowCollector<T>.() -> Unit): Flow<T>

Invokes the given action when this flow completes without emitting any elements. The receiver of the action is FlowCollector, so onEmpty can emit additional elements. For example:

Link copied to clipboard
fun <T> Flow<T>.onStart(action: suspend FlowCollector<T>.() -> Unit): Flow<T>

Returns a flow that invokes the given action before this flow starts to be collected.

Link copied to clipboard
fun <T> SharedFlow<T>.onSubscription(action: suspend FlowCollector<T>.() -> Unit): SharedFlow<T>

Returns a flow that invokes the given action after this shared flow starts to be collected (after the subscription is registered).

Link copied to clipboard

Creates a produce coroutine that collects the given flow.

Link copied to clipboard

Represents the given receive channel as a hot flow and receives from the channel in fan-out fashion every time this flow is collected. One element will be emitted to one collector only.

Link copied to clipboard
suspend fun <S, T : S> Flow<T>.reduce(operation: suspend (accumulator: S, value: T) -> S): S

Accumulates value starting with the first element and applying operation to current accumulator value and each element. Throws NoSuchElementException if flow was empty.

Link copied to clipboard
fun <T> Flow<T>.retry(retries: Long = Long.MAX_VALUE, predicate: suspend (cause: Throwable) -> Boolean = { true }): Flow<T>

Retries collection of the given flow up to retries times when an exception that matches the given predicate occurs in the upstream flow. This operator is transparent to exceptions that occur in downstream flow and does not retry on exceptions that are thrown to cancel the flow.

Link copied to clipboard
fun <T> Flow<T>.retryWhen(predicate: suspend FlowCollector<T>.(cause: Throwable, attempt: Long) -> Boolean): Flow<T>

Retries collection of the given flow when an exception occurs in the upstream flow and the predicate returns true. The predicate also receives an attempt number as parameter, starting from zero on the initial call. This operator is transparent to exceptions that occur in downstream flow and does not retry on exceptions that are thrown to cancel the flow.

Link copied to clipboard
fun <T, R> Flow<T>.runningFold(initial: R, operation: suspend (accumulator: R, value: T) -> R): Flow<R>

Folds the given flow with operation, emitting every intermediate result, including initial value. Note that initial value should be immutable (or should not be mutated) as it is shared between different collectors. For example:

Link copied to clipboard
fun <T> Flow<T>.runningReduce(operation: suspend (accumulator: T, value: T) -> T): Flow<T>

Reduces the given flow with operation, emitting every intermediate result, including initial value. The first element is taken as initial value for operation accumulator. This operator has a sibling with initial value -- scan.

Link copied to clipboard
fun <T> Flow<T>.sample(periodMillis: Long): Flow<T>
fun <T> Flow<T>.sample(period: Duration): Flow<T>

Returns a flow that emits only the latest value emitted by the original flow during the given sampling period.

Link copied to clipboard
fun <T, R> Flow<T>.scan(initial: R, operation: suspend (accumulator: R, value: T) -> R): Flow<R>

Folds the given flow with operation, emitting every intermediate result, including initial value. Note that initial value should be immutable (or should not be mutated) as it is shared between different collectors. For example:

Link copied to clipboard
fun <T> Flow<T>.shareIn(scope: CoroutineScope, started: SharingStarted, replay: Int = 0): SharedFlow<T>

Converts a cold Flow into a hot SharedFlow that is started in the given coroutine scope, sharing emissions from a single running instance of the upstream flow with multiple downstream subscribers, and replaying a specified number of replay values to new subscribers. See the SharedFlow documentation for the general concepts of shared flows.

Link copied to clipboard
suspend fun <T> Flow<T>.single(): T

The terminal operator that awaits for one and only one value to be emitted. Throws NoSuchElementException for empty flow and IllegalArgumentException for flow that contains more than one element.

Link copied to clipboard
suspend fun <T> Flow<T>.singleOrNull(): T?

The terminal operator that awaits for one and only one value to be emitted. Returns the single value or null, if the flow was empty or emitted more than one value.

Link copied to clipboard
suspend fun <T> Flow<T>.stateIn(scope: CoroutineScope): StateFlow<T>

Starts the upstream flow in a given scope, suspends until the first value is emitted, and returns a hot StateFlow of future emissions, sharing the most recently emitted value from this running instance of the upstream flow with multiple downstream subscribers. See the StateFlow documentation for the general concepts of state flows.

fun <T> Flow<T>.stateIn(scope: CoroutineScope, started: SharingStarted, initialValue: T): StateFlow<T>

Converts a cold Flow into a hot StateFlow that is started in the given coroutine scope, sharing the most recently emitted value from a single running instance of the upstream flow with multiple downstream subscribers. See the StateFlow documentation for the general concepts of state flows.

Link copied to clipboard
fun <T> Flow<T>.take(count: Int): Flow<T>

Returns a flow that contains first count elements. When count elements are consumed, the original flow is cancelled. Throws IllegalArgumentException if count is not positive.

Link copied to clipboard
fun <T> Flow<T>.takeWhile(predicate: suspend (T) -> Boolean): Flow<T>

Returns a flow that contains first elements satisfying the given predicate.

Link copied to clipboard
fun <T> Flow<T>.timeout(timeout: Duration): Flow<T>

Returns a flow that will emit a TimeoutCancellationException if the upstream doesn't emit an item within the given time.

Link copied to clipboard
suspend fun <T, C : MutableCollection<in T>> Flow<T>.toCollection(destination: C): C

Collects given flow into a destination

Link copied to clipboard
suspend fun <T> Flow<T>.toList(destination: MutableList<T> = ArrayList()): List<T>

Collects given flow into a destination

inline suspend fun <T> SharedFlow<T>.toList(destination: MutableList<T>): Nothing

A specialized version of Flow.toList that returns Nothing to indicate that SharedFlow collection never completes.

Link copied to clipboard
suspend fun <T> Flow<T>.toSet(destination: MutableSet<T> = LinkedHashSet()): Set<T>

Collects given flow into a destination

inline suspend fun <T> SharedFlow<T>.toSet(destination: MutableSet<T>): Nothing

A specialized version of Flow.toSet that returns Nothing to indicate that SharedFlow collection never completes.

Link copied to clipboard
inline fun <T, R> Flow<T>.transform(crossinline transform: suspend FlowCollector<R>.(value: T) -> Unit): Flow<R>

Applies transform function to each value of the given flow.

Link copied to clipboard
fun <T, R> Flow<T>.transformLatest(transform: suspend FlowCollector<R>.(value: T) -> Unit): Flow<R>

Returns a flow that produces element by transform function every time the original flow emits a value. When the original flow emits a new value, the previous transform block is cancelled, thus the name transformLatest.

Link copied to clipboard
fun <T, R> Flow<T>.transformWhile(transform: suspend FlowCollector<R>.(value: T) -> Boolean): Flow<R>

Applies transform function to each value of the given flow while this function returns true.

Link copied to clipboard
inline fun <T> MutableStateFlow<T>.update(function: (T) -> T)

Updates the MutableStateFlow.value atomically using the specified function of its value.

Link copied to clipboard
inline fun <T> MutableStateFlow<T>.updateAndGet(function: (T) -> T): T

Updates the MutableStateFlow.value atomically using the specified function of its value, and returns the new value.

Link copied to clipboard
fun SharingStarted.Companion.WhileSubscribed(stopTimeout: Duration = Duration.ZERO, replayExpiration: Duration = Duration.INFINITE): SharingStarted

Sharing is started when the first subscriber appears, immediately stops when the last subscriber disappears (by default), keeping the replay cache forever (by default).

Link copied to clipboard

Returns a flow that wraps each element into IndexedValue, containing value and its index (starting from zero).

Link copied to clipboard
fun <T1, T2, R> Flow<T1>.zip(other: Flow<T2>, transform: suspend (T1, T2) -> R): Flow<R>

Zips values from the current flow (this) with other flow using provided transform function applied to each pair of values. The resulting flow completes as soon as one of the flows completes and cancel is called on the remaining flow.