Package-level declarations

An interface representing a non-blocking semaphore.

Simple wrapper around a channel that provides a context for receiving items in a more flexible manner.

A class representing a concurrency strategy for handling concurrent operations.

A sealed interface representing different strategies for grouping items in a Flow. The GroupStrategy can be used in various contexts to control the way items are grouped together, optimizing the trade-off between latency and throughput.

Extension property on a suspend function that allows it to be called asynchronously. The result of the suspend function is wrapped in a Deferred object.

Extension property on a suspend function that allows it to be called asynchronously. The result of the suspend function is wrapped in a Deferred object and is computed only upon the first invocation of Deferred.await or Deferred.join.

Allows the Flow to be collected and transformed into another Flow concurrently. The transformed Flow is collected asynchronously in the provided coroutineScope. The original flow and the transformed flow share the same buffer with the specified bufferCapacity, onBufferOverflow policy, and onUndeliveredElement handler.

Converts the Flow of ByteArray to a Flow of String.

Converts the Flow of Byte to a Flow of String.

Catches exceptions that occur while collecting the flow and emits the result of the provided function f with the caught exception as a parameter.

The chunked function is used to group the elements emitted by the current Flow into chunks based on the provided GroupStrategy. This can be useful for batch processing or aggregating streams of data more efficiently by combining them into larger pieces.

The chunked function is used to group the elements emitted by the current Flow into fixed-size chunks based on the number of elements. This can be useful for batch processing or aggregating streams of data more efficiently by combining them into larger pieces.

The chunked function is used to group the elements emitted by the current Flow into fixed-size chunks based on a time window. This can be useful for batch processing or aggregating streams of data more efficiently by combining them into larger, more manageable pieces.

Collects the items emitted by this Flow into a ChannelReceiverContext and applies the given block to it.

Collects all the values emitted by the Flow, applying the block function to each value. The processing of items in the flow is concurrent and limited by concurrency level.

Collects all the values emitted by the Flow, applying the block function to each value. The concurrency is managed by an AsyncSemaphore created by the semaphore suspending function.

The collectCatching function collects the elements emitted by the current Flow in a suspending way and returns a Result instance that represents the result of the operation.

Collects the flow with a specified timeout duration. If the flow takes longer than the provided duration to complete, it throws a TimeoutCancellationException.

Completes all the CompletableDeferred objects in the list with the corresponding values from the values list.

Completes all the CompletableDeferred objects in the list with the values from the result if it is successful or completes them exceptionally with the error from the result if it is a failure.

Creates a Channel with the specified capacity, buffer overflow behavior, and undelivered element handler, and then consumes elements from this channel using the given consumer function.

Counts the number of items emitted by the flow within the specified duration window.

Completes the Flow early if the specified stopPredicate is met for any element.

Flattens a Flow of T items into a Flow of individual items R.

Flattens a Flow of Iterable items into a Flow of individual items.

Transforms the elements of the iterable concurrently using the provided transform function, and then flattens the result.

Transforms the elements of the iterable concurrently using the provided transform function with a specified concurrency limit, and then flattens the result.

Applies the given transformation function transform to each value of the original Flow and emits the results. The processing of items in the flow is concurrent and limited by concurrency level. Each transformed value is then flattened and emitted individually.

Applies the given transformation function transform to each value of the original Flow and emits the results. The concurrency is managed by an AsyncSemaphore created by the semaphore suspending function. Each transformed value is then flattened and emitted individually.

Flattens a Flow of Flow items into a Flow of individual items.

Flattens a Flow of Iterable items into a Flow of individual items.

Creates a Flow that emits a single item, which is the result of invoking the provided suspending function item.

Creates an infinite Flow that repeatedly emits the provided item.

Intersperses the elements of the Flow with the specified start, between, and end elements.

Joins the elements of the Flow into a single string using the provided f function to transform each element to a string.

Joins the elements of the Flow into a single string, separated by the specified between string, using the provided f function to transform each element to a string.

Joins the elements of the Flow into a single string, enclosed by the specified start and end strings, and separated by the specified between string. Uses the provided f function to transform each element to a string.

Creates a lazily started coroutine which runs the provided suspend function. The result of the suspend function is wrapped in a Deferred object and is computed only upon the first invocation of Deferred.await or Deferred.join.

Splits and buffers the Flow of String into lines, emitting each line as a separate element in the resulting Flow.

Transforms the elements of the iterable concurrently using the provided transform function.

Transforms the elements of the iterable concurrently using the provided transform function with a specified concurrency limit.

Applies the given transformation function transform to each value of the original Flow and emits the results. The processing of items in the flow is concurrent and limited by concurrency level.

Applies the given transformation function transform to each value of the original Flow and emits the results. The concurrency is managed by an AsyncSemaphore created by the semaphore suspending function.

Applies the given function block to each value of the original Flow and reemits them downstream. The processing of items in the flow is concurrent and limited by concurrency level.

Applies the given function block to each value of the original Flow and reemits them downstream. The concurrency is managed by an AsyncSemaphore created by the semaphore suspending function.

Combines two Flows of the same base type T into a single Flow by concatenating their elements.

Creates a flow that continuously polls elements concurrently by successively applying the f function. The flow stops based on the stopOnEmptyList parameter or when the coroutine context is no longer active. Concurrency is controlled by the concurrency strategy.

Creates a flow that continuously polls elements using the f function, starting with an initial state initial.

The split function is used to group the elements emitted by the current Flow into smaller Flows based on the provided GroupStrategy. This function is useful when smaller Flows are preferred over the original one, some scenarios include file processing, database operations, and so on.

The split function is used to group the elements emitted by the current Flow into smaller Flows based a max number of items. This function is useful when smaller Flows are preferred over the original one, some scenarios include file processing, database operations, and so on.

The split function is used to group the elements emitted by the current Flow into smaller Flows based on size and timeout duration. This function is useful when smaller Flows are preferred over the original one, some scenarios include file processing, database operations, and so on.

Splits and buffers the Flow of String based on the provided delimiter, emitting each piece as a separate element in the resulting Flow.

Creates a Flow with the ability to stop its collection early based on a custom condition.

Sums the elements of this Flow of Byte and returns the result.

Sums the elements of this Flow of Double and returns the result.

Sums the elements of this Flow of Float and returns the result.

Sums the elements of this Flow of Int and returns the result.

Sums the elements of this Flow of Long and returns the result.

Sums the elements of this Flow of Short and returns the result.

Throttles the emission of elements from the Flow based on the specified semaphore, interval, and strategy.

Throttles the emission of elements from the Flow based on the specified elementsPerInterval, interval, and strategy.

This function collects the items emitted by the Flow and sends each one to the given channel.

Collects the specified number of items size from the Flow into a List.

Collects the items from the Flow into a List within the given duration.

Collects the specified number of items size from the Flow into a List within the given duration.

Creates an (almost) infinite Flow that emits sequentially incremented Long numbers starting from the startAt parameter.

Applies the given transformation function transform to each value of the original Flow and emits the results. The processing of items in the flow is concurrent and limited by concurrency level. Each transformed value is then flattened and emitted individually.

Applies the given transformation function transform to each value of the original Flow and emits the results. The concurrency is managed by an AsyncSemaphore created by the semaphore suspending function. Each transformed value is then flattened and emitted individually.

Applies the given transformation function transform to each value of the original Flow and emits the results. The processing of items in the flow is concurrent and limited by concurrency level.

Applies the given transformation function transform to each value of the original Flow and emits the results. The concurrency is managed by an AsyncSemaphore created by the semaphore suspending function.

Applies the given function block to each value of the original Flow and reemits them downstream. The processing of items in the flow is concurrent and limited by concurrency level.

Applies the given function block to each value of the original Flow and reemits them downstream. The concurrency is managed by an AsyncSemaphore created by the semaphore suspending function.

Function that takes two suspend functions and a zip function as parameters. It executes the suspend functions asynchronously and then applies the zip function to their results.

Function that takes three suspend functions and a zip function as parameters. It executes the suspend functions asynchronously and then applies the zip function to their results.

Function that takes four suspend functions and a zip function as parameters. It executes the suspend functions asynchronously and then applies the zip function to their results.

Function that takes five suspend functions and a zip function as parameters. It executes the suspend functions asynchronously and then applies the zip function to their results.

Function that takes six suspend functions and a zip function as parameters. It executes the suspend functions asynchronously and then applies the zip function to their results.

Function that takes seven suspend functions and a zip function as parameters. It executes the suspend functions asynchronously and then applies the zip function to their results.