Type Members

1.  type <=[M[_], R] = Member[M, R]
2.  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]

3.  type Console[A] = AnyRef { ... /* 2 definitions in type refinement */ }
4.  trait ConsoleEffect extends AnyRef
5.  trait ConsoleImplicits extends ConsoleImplicits1
6.  trait ConsoleImplicits1 extends AnyRef
7.  trait ConsoleTag extends AnyRef
8.  trait DisjunctionCreation extends AnyRef
9.  trait DisjunctionEffect extends DisjunctionCreation with DisjunctionInterpretation

   Effect for computation which can fail

10.  trait DisjunctionInterpretation extends AnyRef
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!

    See also

    http://okmij.org/ftp/Haskell/extensible/more.pdf

12.  trait EffCreation extends AnyRef
13.  trait EffImplicits extends AnyRef
14.  trait EffInterpretation extends AnyRef
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

18.  trait ErrorCreation [F] extends ErrorTypes[F]
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 \/ 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.

20.  trait ErrorInterpretation [F] extends ErrorCreation[F]
21.  trait ErrorTypes [F] extends AnyRef
22.  trait EvalCreation extends EvalTypes
23.  trait EvalEffect extends EvalTypes with EvalCreation with EvalInterpretation

    Effect for delayed computations

    Effect for delayed computations

    uses scalaz.Need as a supporting data structure

24.  trait EvalInterpretation extends EvalTypes
25.  trait EvalTypes extends AnyRef
26.  trait Fold [A, B] extends AnyRef

    support trait for folding values while possibly keeping some internal state

27.  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)

28.  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)

29.  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
30.  trait IntoPolyLower extends AnyRef
31.  trait ListCreation extends AnyRef
32.  trait ListEffect extends ListCreation with ListInterpretation

    Effect for computations possibly returning several values

33.  trait ListInterpretation extends AnyRef
34.  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( ... )

35.  trait MemberImplicits extends MemberImplicits1
36.  trait MemberImplicits1 extends MemberImplicits2
37.  trait MemberImplicits2 extends AnyRef
38.  class NoEffect extends Effects

    Nil case for the list of effects

39.  trait OptionCreation extends AnyRef
40.  trait OptionEffect extends OptionCreation with OptionInterpretation

    Effect for optional computations

41.  trait OptionInterpretation extends AnyRef
42.  case class Pure [R, A](value: A) extends Eff[R, A] with Product with Serializable
43.  trait ReaderCreation extends AnyRef
44.  trait ReaderEffect extends ReaderCreation with ReaderInterpretation with ReaderImplicits

    Effect for computations depending on an environment.

    Effect for computations depending on an environment.

    The inside datatype for this effect is scalaz.Reader

    Several Reader effects can be present in a given stack provided that they are tagged with scala.Tag.

    A tagged Reader effect can be run with runTaggedReader

45.  trait ReaderImplicits extends ReaderImplicits1
46.  trait ReaderImplicits1 extends AnyRef
47.  trait ReaderInterpretation extends AnyRef
48.  trait StateCreation extends AnyRef
49.  trait StateEffect extends StateCreation with StateInterpretation with StateImplicits

    Effect for passing state along computations

    Effect for passing state along computations

    Several state effects can be used in the same stack if they are tagged

    Internally backed up by scalaz.State

50.  trait StateImplicits extends StateImplicits1
51.  trait StateImplicits1 extends AnyRef
52.  trait StateInterpretation extends AnyRef
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

54.  case class UnionNext [O[_], R <: Effects, A](u: Union[R, A]) extends Union[eff.Effects.|:[O, R], A] with Product with Serializable
55.  case class UnionNow [T[_], R <: Effects, A](ta: T[A]) extends Union[eff.Effects.|:[T, R], A] with Product with Serializable
56.  type Warnings[A] = AnyRef { ... /* 2 definitions in type refinement */ }
57.  trait WarningsEffect extends AnyRef
58.  trait WarningsImplicits extends WarningsImplicits1
59.  trait WarningsImplicits1 extends AnyRef
60.  trait WarningsTag extends AnyRef
61.  trait WriterCreation extends AnyRef
62.  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

    Several writer effects can be used in the same stack if they are tagged.

63.  trait WriterInterpretation extends AnyRef