| Async |
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.interface ~~Async~~<F> : MonadDefer<F> |
| AsyncContinuation |
open class ~~AsyncContinuation~~<F, A> : MonadThrowContinuation<F, A>, Async<F>, AsyncSyntax<F> |
| AsyncFx |
interface ~~AsyncFx~~<F> : MonadThrowFx<F> |
| AsyncSyntax |
interface ~~AsyncSyntax~~<F> : MonadThrowSyntax<F>, Async<F> |
| Bracket |
Extension of MonadError exposing the bracket operation, a generalized abstracted pattern of safe resource acquisition and release in the face of errors or interruption.interface ~~Bracket~~<F, E> : MonadError<F, E> |
| CancelToken |
typealias ~~CancelToken~~<F> = Kind<F, Unit> |
| Concurrent |
Type class for async data types that are cancellable and can be started concurrently.interface ~~Concurrent~~<F> : Async<F> |
| ConcurrentContinuation |
open class ~~ConcurrentContinuation~~<F, A> : AsyncContinuation<F, A>, Concurrent<F>, ConcurrentSyntax<F> |
| ConcurrentEffect |
interface ~~ConcurrentEffect~~<F> : Effect<F> |
| ConcurrentFx |
interface ~~ConcurrentFx~~<F> : AsyncFx<F> |
| ConcurrentSyntax |
interface ~~ConcurrentSyntax~~<F> : Concurrent<F>, AsyncSyntax<F> |
| Dispatchers |
interface ~~Dispatchers~~<F> |
| Disposable |
typealias ~~Disposable~~ = () -> Unit |
| Duration |
data class ~~Duration~~ |
| Effect |
interface ~~Effect~~<F> : Async<F> |
| Environment |
interface ~~Environment~~<F> |
| ExitCase |
sealed class ~~ExitCase~~<out E> |
| Fiber |
Fiber represents the pure result of an Async data type being started concurrently and that can be either joined or cancelled.interface ~~Fiber~~<F, out A> : FiberOf<F, A> |
| FiberOf |
typealias ~~FiberOf~~<F, A> = Kind2<ForFiber, F, A> |
| FiberPartialOf |
typealias ~~FiberPartialOf~~<F> = Kind<ForFiber, F> |
| ForFiber |
class ~~ForFiber~~ |
| MonadDefer |
The context required to defer evaluating a safe computation.interface ~~MonadDefer~~<F> : MonadThrow<F>, Bracket<F, Throwable> |
| MonadIO |
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.interface ~~MonadIO~~<M> : Monad<M> |
| Proc |
An asynchronous computation that might fail.typealias ~~Proc~~<A> = ((Either<Throwable, A>) -> Unit) -> Unit |
| ProcF |
A asynchronous computation that might fail.typealias ~~ProcF~~<F, A> = ((Either<Throwable, A>) -> Unit) -> Kind<F, Unit> |
| UnsafeCancellableRun |
interface ~~UnsafeCancellableRun~~<F> : UnsafeRun<F> |
| UnsafeRun |
interface ~~UnsafeRun~~<F> |
