# eff

#### package eff

Linear Supertypes
Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. eff
2. AnyRef
3. Any
1. Hide All
2. Show All
Visibility
1. Public
2. All

### Type Members

2. #### case class Apps[R, A, B](functions: Vector[Eff[R, (Any) ⇒ Any]]) extends Product with Serializable

Sequence of applicative functions from A to B: Eff[R, A => B]

3. #### case class Arrs[R, A, B](functions: Vector[(Any) ⇒ Eff[R, Any]]) extends Product with Serializable

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]

6. #### trait ChooseEffect extends ChooseCreation with ChooseInterpretation

The Choose effect models non-determinism So we can get results, either:

The Choose effect models non-determinism So we can get results, either:

• the result for action1 or the result for action b (when using ChoosePlus)

When running this effect we can "collect" the results with any F which has an Alternative instance.

For example if F is List then:

• the result for a or b is List(a, b)

If F is Option then:

• the result for a or b is Some(a) or Some(b

11. #### sealed trait Eff[R, A] extends AnyRef

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:

• the "pure" case is a pure value of type A
• the "impure" case is:
• a disjoint union of possible effects
• a continuation of type X => Eff[R, A] indicating what to do if the current effect is of type M[X] this type is represented by the `Arrs` type

The monad implementation for this type is really simple:

• `point` is Pure
• `bind` simply appends the binding function to the `Arrs` continuation

Important:

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!

15. #### sealed trait Effect[F[_]] extends AnyRef

one effect, basically a type constructor

16. #### trait Effects extends AnyRef

Effects is a type level representing a list of effects which might take place in a computation

Effects is a type level representing a list of effects which might take place in a computation

Note that each "effect" is a type constructor

17. #### final case class EffectsCons[F[_], T <: Effects](head: Effect[F], tail: T) extends Effects with Product with Serializable

Append an effect at the beginning of a list of effects

19. #### trait ErrorEffect[F] extends ErrorCreation[F] with ErrorInterpretation[F]

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 Xor 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.

23. #### trait EvalEffect extends EvalTypes with EvalCreation with EvalInterpretation

Effect for delayed computations

Effect for delayed computations

uses cats.Eval as a supporting data structure

26. #### trait Fold[A, B] extends AnyRef

support trait for folding values while possibly keeping some internal state

28. #### trait FutureEffect extends FutureCreation with FutureInterpretation

Effect for Future computations

30. #### case class Impure[R, X, A](union: Union[R, X], continuation: Arrs[R, X, A]) extends Eff[R, A] with Product with Serializable

union is a disjoint union of effects returning a value of type X (not specified)

31. #### case class ImpureAp[R, X, A](union: Union[R, X], continuation: Apps[R, X, A]) extends Eff[R, A] with Product with Serializable

union is a disjoint union of effects returning a value of type X (not specified)

32. #### trait Interpret extends AnyRef

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:

1. interpret + Recurse

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)

33. #### trait IntoPoly[R <: Effects, U, A] extends AnyRef

Trait for polymorphic recursion into Eff[?, A]

Trait for polymorphic recursion into Eff[?, A]

The idea is to deal with one effect at the time:

• if the effect stack is M |: R and if U contains M we transform each "Union[R, X]" in the Impure case into a Union for U and we try to recurse on other effects present in R
• if the effect stack is M |: NoEffect and if U contains M we just "inject" the M[X] effect into Eff[U, A] using the Member typeclass if M is not present when we decompose we throw an exception. This case should never happen because if there is no other effect in the stack there should be at least something producing a value of type A

36. #### trait ListEffect extends ListCreation with ListInterpretation

Effect for computations possibly returning several values

38. #### trait Member[T[_], R] extends AnyRef

Member typeclass for effects belonging to a stack of effects R

Member typeclass for effects belonging to a stack of effects R

If T is a member of R then we can:

- create a Union of effects from a single effect with "inject" - extract an effect value from a union if there is such an effect in the stack

Annotations
@implicitNotFound( ... )

42. #### class NoEffect extends Effects

Nil case for the list of effects

44. #### trait OptionEffect extends OptionCreation with OptionInterpretation

Effect for optional computations

47. #### trait ReaderCreation extends AnyRef

Effect for computations depending on an environment.

Effect for computations depending on an environment.

The inside datatype for this effect is cats.data.Reader

51. #### trait StateEffect extends StateCreation with StateInterpretation

Effect for passing state along computations

Effect for passing state along computations

Internally backed up by cats.data.State

53. #### sealed trait Union[+R, A] extends AnyRef

Open union of effects

Open union of effects

They are modelled as a list of

UnionNext(UnionNext(...(UnionNow(M[X])))

where M[X] is an effect. The depth of the nesting in an Union value corresponds to the place of the effect in a type E1 |: E2 |: E3 |: .. |: NoEffect

58. #### trait ValidateEffect extends ValidateCreation with ValidateInterpretation

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

61. #### trait WriterEffect extends WriterCreation with WriterInterpretation

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:

• log values to the console or to a file as soon as they are produced
• accumulate values in a list

65. #### trait XorEffect extends XorCreation with XorInterpretation

Effect for computation which can fail

### Value Members

13. #### object Effects extends Effects

Aliases for declaring effects with the following syntax

Aliases for declaring effects with the following syntax

A |: B |: C |: NoEffect

14. #### object ErrorEffect extends ErrorEffect[String]

Simple instantiation of the ErrorEffect trait with String as a Failure type

36. #### object Union

create union objects