Sequence of applicative functions from A to B: Eff[R, A => B]
Sequence of monadic functions from A to B: A => Eff[B]
Sequence of monadic functions from A to B: A => Eff[B]
Internally it is represented as a Vector of functions:
A => Eff[R, X1]; X1 => Eff[R, X2]; X2 => Eff[R, X3]; ...; X3 => Eff[R, B]
The Choose effect models non-determinism So we can get results, either:
The Choose effect models non-determinism So we can get results, either:
When running this effect we can "collect" the results with any F which has an Alternative instance.
For example if F is List then:
If F is Option then:
Effect for computation which can fail
Effects of type R, returning a value of type A
Effects of type R, returning a value of type A
It is implemented as a "Free-er" monad with extensible effects:
Arrs
typeThe monad implementation for this type is really simple:
point
is Purebind
simply appends the binding function to the Arrs
continuationImportant:
The list of continuations is NOT implemented as a type sequence but simply as a Vector[Any => Eff[R, Any]]
This means that various .asInstanceOf
are present in the implementation and could lead
to burns and severe harm. Use with caution!
http://okmij.org/ftp/Haskell/extensible/more.pdf
one effect, basically a type constructor
Effect for computation which can fail and return a Throwable, or just stop with a failure
Effect for computation which can fail and return a Throwable, or just stop with a failure
This effect is a mix of Eval and \/ in the sense that every computation passed to this effect (with the ok method) is considered "impure" or "faulty" by default.
The type F is used to represent the failure type.
Effect for delayed computations
Effect for delayed computations
uses scalaz.Need as a supporting data structure
support trait for folding values while possibly keeping some internal state
Effect for Future computations
Base type for a tree of effect types
Append a tree of effects to another one
union is a disjoint union of effects returning a value of type X (not specified)
union is a disjoint union of effects returning a value of type X (not specified)
Support methods to create an interpreter (or "effect handlers") for a given Eff[M |: R, A].
Support methods to create an interpreter (or "effect handlers") for a given Eff[M |: R, A]. The aim being to "consume" just that effect and produce a value of type B with possibly other effects: Eff[R, B]
Those methods guarantee a stack-safe behaviour when running on a large list of effects (in a list.traverseU(f) for example).
There are 3 different types of supported interpreters:
This interpreter is used to handle effects which either return a value X from M[X] or stops with Eff[R, B] See an example of such an interpreter in Eval where we just evaluate a computation X for each Eval[X].
2. interpretState + StateRecurse
This interpreter is used to handle effects which either return a value X from M[X] or stops with Eff[R, B]
3. interpretLoop + Loop
The most generic kind of interpreter where we can even recurse in the case of Pure(a) (See ListEffect for such a use)
Typeclass proving that it is possible to send a tree of effects R into another tree of effects U
Typeclass proving that it is possible to send a tree of effects R into another tree of effects U
for example
send[Option1, Fx.fx3[Option1, Option2, Option3], Int](Option1(1)). into[Fx.fx5[Option1, Option2, Option3, Option4, Option5]]
should work because all the effects of the first stack are present in the second
Note: some implicit definitions are probably missing in some cases
Effect for computations possibly returning several values
The "empty" tree of effects
Effect for optional computations
Effect for computations depending on an environment.
Effect for computations depending on an environment.
The inside datatype for this effect is scalaz.Reader
The Safe type is a mix of a Throwable \/ ? / Eval effect and a writer effect to collect finalizer failures
Effect for passing state along computations
Effect for passing state along computations
Internally backed up by scalaz.State
Union represents one effect T[_] embedded in a tree of possible effects R
Union represents one effect T[_] embedded in a tree of possible effects R
Since the effect tree is represented with the following cases:
We have the corresponding Union cases. For example T2 is in the "middle" of Fx3[T1, T2, T3] so creating a Union object for that effect uses Union3M
Effect for computation which can fail but will accumulate errors
Effect for computation which can fail but will accumulate errors
The runValidate interpreter just collects the messages and returns them at the end
Effect for logging values alongside computations
Effect for logging values alongside computations
Compared to traditional Writer monad which accumulates values by default this effect can be interpreted in different ways:
Simple instantiation of the ErrorEffect trait with String as a Failure type