All Types
| (extensions in package arrow.fx.extensions.io.applicativeError) |
Async models how a data type runs an asynchronous computation that may fail.
Defined by the Proc signature, which is the consumption of a callback.
Internal wrapper for Atomic-FU Atomics to be used as local variables
Extension of MonadError exposing the bracket operation, a generalized abstracted pattern of safe resource
acquisition and release in the face of errors or interruption.
| (extensions in package arrow.fx.extensions.duration.monoid) |
| (extensions in package arrow.fx.extensions.io.monoid) |
| (extensions in package arrow.fx.extensions.resource.monoid) |
| (extensions in package arrow.fx.extensions.schedule.monoid) |
Type class for async data types that are cancellable and can be started concurrently.
| (extensions in package arrow.fx.extensions.io.async) |
| (extensions in package arrow.fx.extensions.io.concurrent) |
Dequeue allows peeking and taking values from a Queue, but doesn’t allow offering values to the Queue.
You can use Dequeue to restrict certain functions or layers of your applications to only consume values.
| (extensions in package arrow.fx.extensions) |
| (extensions in package arrow.fx.extensions.io.applicativeError) |
| (extensions in package arrow.fx.typeclasses) |
Enqueue allows offering values to a Queue, but doesn’t allow taking values from the Queue.
You can use Enqueue to restrict certain functions or layers of your applications to only produce values.
| (extensions in package arrow.fx) |
Fiber represents the pure result of an Async data type
being started concurrently and that can be either joined or cancelled.
| (extensions in package arrow.fx.typeclasses) |
Mix-in to enable parMapN N-arity on IO’s companion directly.
Port of scala.collection.immutable.Queue
Queue objects implement data structures that allow to
insert and retrieve elements in a first-in-first-out (FIFO) manner.
| (extensions in package arrow.fx.extensions.io.concurrent) |
| (extensions in package arrow.fx) |
| (extensions in package arrow.fx.extensions.invariant) |
| (extensions in package arrow.fx.extensions.io.applicative) |
| (extensions in package arrow.fx.extensions.io.applicativeError) |
| (extensions in package arrow.fx.extensions.io.apply) |
| (extensions in package arrow.fx.extensions.io.async) |
| (extensions in package arrow.fx.extensions.io.bracket) |
| (extensions in package arrow.fx.extensions.io.concurrent) |
| (extensions in package arrow.fx.extensions.io.concurrentEffect) |
| (extensions in package arrow.fx.extensions.io.effect) |
| (extensions in package arrow.fx.extensions.io.functor) |
| (extensions in package arrow.fx.extensions.io.monad) |
| (extensions in package arrow.fx.extensions.io.monadError) |
| (extensions in package arrow.fx.extensions.io.semigroupK) |
| (extensions in package arrow.fx.extensions.resource.applicative) |
| (extensions in package arrow.fx.extensions.resource.functor) |
| (extensions in package arrow.fx.extensions.resource.monad) |
| (extensions in package arrow.fx.extensions.resource.selective) |
| (extensions in package arrow.fx.extensions.schedule.applicative) |
| (extensions in package arrow.fx.extensions.schedule.apply) |
| (extensions in package arrow.fx.extensions.schedule.category) |
| (extensions in package arrow.fx.extensions.schedule.contravariant) |
| (extensions in package arrow.fx.extensions.schedule.functor) |
| (extensions in package arrow.fx.extensions.schedule.profunctor) |
| (extensions in package arrow.fx.extensions.schedule.semigroupK) |
| (extensions in package arrow.fx.typeclasses) |
| (extensions in package arrow.fx.typeclasses) |
The context required to defer evaluating a safe computation.
Lift concrete IO into a polymorphic monad M. This is used to call IO from mtl style programs which don’t have a concrete type.
This is in theory enough to define the entire effect hierarchy up to Concurrent however those instances might have different semantics for different
types which is why it is not done here. If one wants to use Concurrent methods by only delegating to IO simply perform the task in IO and lift it.
If that is not enough use the fx-mtl package for better instances of the effect hierarchy.
It’s a mutable variable with context F, that is either empty or contains a value of type A.
A pure concurrent queue of size 1.
Builds a MVar value for data types F
without deciding the type of the MVar’s value.
An asynchronous computation that might fail.
A asynchronous computation that might fail.
When made, a Promise is empty. Until it is fulfilled, which can only happen once.
Lightweight Concurrent Queue for values of A.
Builds a QueueFactory for data type F without fixing the Queue’s A type or the Queue.BackpressureStrategy.
Alias for Either structure to provide consistent signature for race methods.
Alias for Either structure to provide consistent signature for race methods.
An asynchronous, concurrent mutable reference.
Builds a Ref value for data types F
without deciding the type of the Ref’s value.
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.
When a resource is created one can make use of use to run a computation with the resource. The finalizers are then
guaranteed to run afterwards in reverse order of acquisition.
Retrying and repeating effects
A counting Semaphore is used to control access to a resource in a concurrent system.
It keeps track of the count of available resources.
| (extensions in package arrow.fx.extensions.io.applicativeError) |
| (extensions in package arrow.fx.extensions.io.monadThrow) |
Timer allows to sleep for a Duration in F.
This behaviour can be derived from Concurrent, and can be used to implement backing off retries etc.
| (extensions in package arrow.fx.extensions.io.unsafeCancellableRun) |
| (extensions in package arrow.fx.extensions.io.unsafeRun) |
