all

apply a function to an Eff value using the applicative instance

get the environment

try to execute an action an report any issue

catch possible left values

Attempt to execute a safe action including finalizers

get a resource A and use it. Call the release function whether an exception is thrown or not when using the resource

NOTE: Eff interpreters are independent so if there is an effect short-circuiting all computations inside 'use', like Option or Either then the release function will not be called. If you want to make sure that the release function is always called "at the end of the world and whatever happens" you need to call Eff.bracketLast

bracket an action with one last action to execute at the end of the program

catch and handle all wrong values

catch and handle the first wrong value

catch and handle the last wrong value

catch and handle a possible left value

catch and handle a possible left value. The value is the combination of all failures in case of an applicative

create an Either effect from a value possibly throwing a Throwable

evaluate first action possibly having error effects

Execute a second action if the first one is not successful, based on the error

catch and handle possible wrong values

use the internal effect as one of the stack effects

create a correct value

peel-off the only present effect

peel-off the only present effect

peel-off the only present effect, using an Applicative instance where possible

peel-off the only present effect, using an Applicative instance where possible

An Eff[R, A] value can be transformed into an Eff[U, A] value provided that all the effects in R are also in U

create a list effect with no values

run a state effect, with an initial value, return only the value

run a state effect, with a Monoidal state

run a safe effect but drop the finalizer errors

run a state effect, with an initial value, return only the state

run a state effect, with a monoidal state, return only the state

use the applicative instance of Eff to sequence a list of values, then flatten it

use the applicative instance of Eff to traverse a list of values, then flatten it

create an Either effect from a value possibly throwing an exception

create an Either effect from a single Either value

create a list effect from a list of values

create an Option effect from a single Option value

get the current state value

get the current state value and map it with a function f

ignore one possible exception that could be thrown

create a delayed impure value

create a delayed impure value

create a impure value from an union of effects and a continuation

General lifting of a state effect into another from one stack to another. This will require a type annotation

create a failed value

Lift a computation over a "small" state (for a subsystem) into a computation over a "bigger" state (for the full application state)

modify the environment

Update the error value, the stack of the Eff computation stays the same

modify the environment using a Kleisli[F, T, *]

Update the read value, the stack of the Eff computation stays the same

Update the state value, the stack of the Eff computation stays the same

Memoize an effect using a cache

all the consecutive effects M[X] leading to the computation of Eff[R, A] will be cached in the cache and retrieved from there if the Eff[R, A] computation is executed again

modify the current state value

no value returned

create an Either effect from a single Option value

evaluate first action possibly having exceptions

Execute a second action if the first one is not successful

create a pure value

store a new state value

evaluate first action possibly having error effects

Execute a second action if the first one is not successful and second is defined for the error

create a correct value

base runner for an Eff value having no effects at all the execution is trampolined using Eval

run the Either effect, yielding E Either A

run the Either effect, handling E (with effects) and yielding A

run the Either effect, yielding E Either A and combine all Es

run the validate effect, yielding a list of failures or A or both

run the validate effect, yielding a non-empty list of failures or A or both

interpret the Kleisli effect by providing an environment when required and translating the resulting target effect into the same stack

run an effect stack starting with a list effect

run the validate effect, yielding a list of failures Either A

run the validate effect, yielding a non-empty list of failures Either A

Interpret the Option effect

Stop all computations if None is present once

get the pure value if there is no effect

interpret the Reader effect by providing an environment when required

Run a safe effect

Collect finalizer exceptions if any

run a state effect, with an initial value

run a state effect, with an initial value

run the validate effect, yielding a ValidatedNel

run a writer effect and return the list of written values

This uses a ListBuffer internally to append values

More general fold of runWriter where we can use a fold to accumulate values in a mutable buffer

Run a side-effecting fold

Memoize safe effects using a cache

if this method is called with the same key the previous value will be returned

create an Eff[R, A] value from an effectful value of type T[V] provided that T is one of the effects of R

use the applicative instance of Eff to sequence a list of values

create a list effect from a single value

a value is returned

write a given value

evaluate first action possibly having error effects execute a second action whether the first is successful or not but keep track of finalizer exceptions

Translate an error effect to another one in the same stack a computation over a "bigger" error (for the full application)

Interpret a Reader effect by using another Reader effect in the same stack

use the applicative instance of Eff to traverse a list of values

create an Eff value for ()

check a correct condition

create an Validate effect from a single Either value

create an Validate effect from a single Ior value

create an Validate effect from a single Option value

check a correct value

create a list effect from a list of values

create a correct value with warning

create a pure warning

evaluate first action possibly throwing exceptions

Execute a second action if the first one is not successful, based on the exception

The final value type is the same as the original type

attach a clean-up action to the continuation (if any)

evaluate first action possibly throwing exceptions

Execute a second action if the first one is not successful and second is defined for the error

The final value type is the same as the original type

create a failed value

Modify the type of the read value

This changes the stack of the Eff computation

Modify the type of the read value

This changes the stack of the Eff computation

catch and handle possible wrong values

the monad error instance for Eval is useful for using detach on Eff[Fx1[Eval], A]