All Types

arrow.fx.coroutines.Atomic

Creates an AtomicRef with a initial value of A.

arrow.fx.coroutines.AtomicBooleanW
arrow.fx.coroutines.AtomicIntW
(extensions in package arrow.fx.coroutines.stream.concurrent)
kotlinx.atomicfu.AtomicRef
arrow.fx.coroutines.AtomicRefW
arrow.fx.coroutines.CancellableContinuation

Type to constraint startCoroutineCancellable to the CancellableContinuation constructor.

arrow.fx.coroutines.CancelToken

Inline marker to mark a CancelToken, This allows for clearer APIs in functions that expect a CancelToken to be returned.

arrow.fx.coroutines.stream.Chunk

Strict, finite sequence of values that allows index-based random access of elements.

arrow.fx.coroutines.CircuitBreaker
arrow.fx.coroutines.ConcurrentVar

ConcurrentVar is a mutable concurrent safe variable which is either empty or contains a single value of type A. It behaves as a single element arrow.fx.coroutines.stream.concurrent.Queue. When trying to put or take, it will suspend when it is respectively isEmpty or isNotEmpty.

(extensions in package arrow.fx.coroutines)
kotlinx.coroutines.Deferred
arrow.fx.coroutines.stream.concurrent.Dequeue

Provides the ability to dequeue chunks of elements from a Queue as streams.

arrow.fx.coroutines.stream.concurrent.Dequeue1

Provides the ability to dequeue individual elements from a Queue.

arrow.fx.coroutines.Disposable
arrow.fx.coroutines.Duration
(extensions in package arrow.fx.coroutines)
arrow.core.Either
arrow.fx.coroutines.stream.EmitterSyntax
arrow.fx.coroutines.stream.concurrent.Enqueue

Provides the ability to enqueue elements to a Queue.

arrow.fx.coroutines.Environment

An Environment can run suspend programs using startCoroutine and startCoroutineCancellable.

arrow.fx.coroutines.ExitCase
arrow.fx.coroutines.Fiber

Fiber represents a pure value that contains a running suspend () -> A.

(extensions in package arrow.fx.coroutines)
kotlinx.coroutines.flow.Flow
arrow.fx.coroutines.stream.ForStream
(extensions in package arrow.fx.coroutines.stream)
kotlin.Function1
(extensions in package arrow.fx.coroutines)
kotlin.Int
arrow.fx.coroutines.IQueue

Port of scala.collection.immutable.Queue

(extensions in package arrow.fx.coroutines)
kotlin.collections.Iterable
(extensions in package arrow.fx.coroutines.stream)
arrow.Kind
(extensions in package arrow.fx.coroutines)
kotlin.Long
arrow.fx.coroutines.stream.concurrent.NoneTerminatedQueue
arrow.fx.coroutines.stream.Pipe

A stream transformation can be represented as a function from stream to stream. This means that Pipe is also an alias for fun Stream<I>.name(): Stream<O>.

arrow.fx.coroutines.stream.Pipe2

A stream transformation that combines two streams in to a single stream, represented as a function from two streams to a single stream.

arrow.fx.coroutines.Platform
arrow.fx.coroutines.Promise

A Promise is commonly used to provide and receive a value from 2 different threads. Since Promise can only be completed once unlike ConcurrentVar, we can consider it a synchronization primitive.

arrow.fx.coroutines.stream.Pull
arrow.fx.coroutines.stream.PullUncons
arrow.fx.coroutines.stream.PullUncons1
arrow.fx.coroutines.stream.concurrent.Queue

A queue of elements. Operations are all nonblocking in their implementations, but may be ‘semantically’ blocking. For instance, a queue may have a bound on its size, in which case enqueuing may block (be delayed asynchronously) until there is an offsetting dequeue.

arrow.fx.coroutines.Race3
arrow.fx.coroutines.RacePair
arrow.fx.coroutines.RaceTriple
arrow.fx.coroutines.Resource

Resource models resource allocation and releasing. It is especially useful when multiple resources that depend on each other need to be acquired and later released in reverse order.

arrow.fx.coroutines.stream.ResourceOps

DSL boundary to access terminal operators as a Resource Allows for consume a Stream as a Resource, meaning the root scope of the Stream remains open until Resource.use returns.

arrow.fx.coroutines.Schedule

Retrying and repeating effects

arrow.fx.coroutines.stream.Scope

Implementation of Scope for the internal stream interpreter.

arrow.fx.coroutines.Semaphore

A counting Semaphore has a non-negative number of permits available. It is used to track how many permits are in-use, and to automatically await a number of permits to become available.

arrow.fx.coroutines.stream.concurrent.Signal

Pure holder of a single value of type A that can be read in the effect F.

arrow.fx.coroutines.stream.concurrent.SignallingAtomic

Pure holder of a single atomic value of type A that can be both read and updated. Composes Signal and Atomic together to make an signalling atomic value.

arrow.fx.coroutines.stream.StepLeg

When merging multiple streams, this represents step of one leg.

arrow.fx.coroutines.stream.Stream
arrow.fx.coroutines.stream.StreamOf
(extensions in package arrow.fx.coroutines)
kotlin.coroutines.SuspendFunction0
(extensions in package arrow.fx.coroutines)
kotlin.Throwable
arrow.fx.coroutines.stream.concurrent.Topic

Asynchronous Topic.

arrow.fx.coroutines.Use

Marker for suspend () -> A to be marked as the Use action of a Resource. Offers a convenient DSL to use Resource for simple resources.

arrow.fx.coroutines.stream.ZipWithCont

Do you like Arrow?

Arrow Org
<