arrow-fx / arrow.fx

Package arrow.fx


ConcurrentQueue Lightweight, asynchronous queue for values of A in a Concurrent context F A Queue can be implemented using 4 different strategiesclass ConcurrentQueue<F, A> : Concurrent<F>, Queue<F, A>
ConnectionCancellationException object ConnectionCancellationException : JavaCancellationException
DecisionOf typealias DecisionOf<A, B> = Kind2<ForDecision, A, B>
DecisionPartialOf typealias DecisionPartialOf<A> = Kind<ForDecision, A>
Dequeue interface Dequeue<F, A>
Enqueue interface Enqueue<F, A>
ForDecision class ForDecision
ForIO class ForIO
ForQueue class ForQueue
ForResource class ForResource
ForSchedule class ForSchedule
IO sealed class IO<out A> : IOOf<A>
IOConnection typealias IOConnection = KindConnection<ForIO>
IODispatchers object IODispatchers
IOOf typealias IOOf<A> = Kind<ForIO, A>
IOParMap Mix-in to enable parMapN 2-arity on IO’s companion directly.interface IOParMap
IOProc typealias IOProc<A> = ((Either<Throwable, A>) -> Unit) -> Unit
IOProcF typealias IOProcF<A> = ((Either<Throwable, A>) -> Unit) -> IOOf<Unit>
IORace interface IORace
KindConnection Connection for kinded type F.sealed class ~~KindConnection~~<F>
MVar 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.interface MVar<F, A>
MVarFactory Builds a MVar value for data types F without deciding the type of the MVar’s value.interface MVarFactory<F>
OnCancel enum class OnCancel
Promise When made, a Promise is empty. Until it is fulfilled, which can only happen once.interface Promise<F, A>
Queue interface Queue<F, A> : QueueOf<F, A>, Dequeue<F, A>, Enqueue<F, A>
QueueOf typealias QueueOf<F, A> = Kind2<ForQueue, F, A>
QueuePartialOf typealias QueuePartialOf<F> = Kind<ForQueue, F>
QueueShutdown object QueueShutdown : RuntimeException
Race2 Alias for Either structure to provide consistent signature for race methods.typealias Race2<A, B> = Either<A, B>
Race3 sealed class Race3<out A, out B, out C>
Race4 sealed class Race4<out A, out B, out C, out D>
Race5 sealed class Race5<out A, out B, out C, out D, out E>
Race6 sealed class Race6<out A, out B, out C, out D, out E, out F>
Race7 sealed class Race7<out A, out B, out C, out D, out E, out F, out G>
Race8 sealed class Race8<out A, out B, out C, out D, out E, out F, out G, out H>
Race9 sealed class Race9<out A, out B, out C, out D, out E, out F, out G, out H, out I>
RacePair Alias for Either structure to provide consistent signature for race methods.sealed class RacePair<F, A, B>
RaceTriple sealed class RaceTriple<F, A, B, C>
Ref An asynchronous, concurrent mutable reference.interface Ref<F, A>
RefFactory Builds a Ref value for data types F without deciding the type of the Ref’s value.interface RefFactory<F>
Resource interface Resource<F, E, A> : ResourceOf<F, E, A>
ResourceKindedJ typealias ResourceKindedJ<F, E, A> = HkJ3<ForResource, F, E, A>
ResourceOf typealias ResourceOf<F, E, A> = Kind3<ForResource, F, E, A>
ResourcePartialOf typealias ResourcePartialOf<F, E> = Kind2<ForResource, F, E>
Schedule Retrying and repeating effectssealed class Schedule<F, Input, Output> : ScheduleOf<F, Input, Output>
ScheduleKindedJ typealias ScheduleKindedJ<M, Input, Output> = HkJ3<ForSchedule, M, Input, Output>
ScheduleOf typealias ScheduleOf<M, Input, Output> = Kind3<ForSchedule, M, Input, Output>
SchedulePartialOf typealias SchedulePartialOf<M, Input> = Kind2<ForSchedule, M, Input>
Semaphore A counting Semaphore is used to control access to a resource in a concurrent system. It keeps track of the count of available resources.interface Semaphore<F>
Timer 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.interface Timer<F>

Extensions for External Classes



IOConnection fun IOConnection(dummy: Unit = Unit): IOConnection
toDisposable fun IOConnection.toDisposable(): Disposable

Type Class Hierarchy

Do you like Arrow?

Arrow Org