Computation

Composes 2 independent computations parallelly (if possible), discarding result of the first.

Parallelism may be impossible, due to at least one of handlers in current scope being inherently sequential (e.g. State.handlers.local or Error.handlers.first). In such case, &! behaves like &&!.

Composes 2 independent computations sequentially, discarding result of the first.

Composes 2 independent computations sequentially, discarding result of the second.

Composes 2 independent computations parallelly (if possible), discarding result of the second.

Parallelism may be impossible, due to at least one of handlers in current scope being inherently sequential (e.g. State.handlers.local or Error.handlers.first). In such case, &<! behaves like &&<!.

Alias for zipPar.

Alias for zip.

Parallel version of ++!.

Applies plus operation from the innermost Choice effect in the current scope.

Similar to <|> operator of Alternative.

Alias for flatMap.

Alias of flatMapHandler

Discards the result, and replaces it by given pure value.

Creates a handler effectfully.

Passes computed value to handler constructor. Effect used to compute the value are absorbed by the handler, into its own dependencies.

Simplifies effectful creation of handlers.

Same as computation.flatMapHandler(handler => handler).

Run this computation in a new fiber.

Like fork, but the fiber is created as a child of specific warp, rather than the current warp.

Applies a handler to this computation.

Same as myHandler.handle(this).

Like if statement, but the condition and the body are computations.

Syntax for giving names to fibers.

Runs the computation, provided that it requests no effects.

Runs the computation, provided that it requests IO effect only, or none at all.

Like while statement, but the condition and the body are computations.

Widens the set of requested effects.

Discards the result, and replaces it by Unit.

Like while statement, but the condition and the body are computations.

Applies filter, using empty operation from the innermost Choice effect in the current scope.

Composes 2 independent computations sequentially

Composes 2 independent computations parallelly (if possible).

Parallelism may be impossible, due to at least one of handlers in current scope being inherently sequential (e.g. State.handlers.local or Error.handlers.first). In such case, zipPar behaves like zip.

Like zip, but followed by untupled map.

Like zipPar, but followed by untupled map.

Races 2 computations.

Runs both computations parallelly, each in fresh fiber. Once one of them finishes, the other is cancelled.

Sequential "or-else" operator.

Runs the first computations in fresh fiber. If it ends up cancelled, the second computation is run.