Type Members

1.  type /=[M[_], R] = MemberInOut[M, R]
2.  type <=[M[_], R] = Member[M, R]
3.  case class Arrs [R, A, B](functions: Vector[(Any) ⇒ Eff[R, Any]]) extends (A) ⇒ Eff[R, B] with 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]

4.  sealed trait Async [A] extends Any
5.  trait AsyncCreation extends AnyRef
6.  case class AsyncDelayed [A](a: Eval[A], timeout: Option[FiniteDuration] = None) extends Async[A] with Product with Serializable
7.  case class AsyncEff [A](e: Eff[FS, A], timeout: Option[FiniteDuration] = None) extends Async[A] with Product with Serializable
8.  trait AsyncEffect extends AsyncCreation
9.  case class AsyncFailed [A](t: Throwable) extends Async[A] with Product with Serializable
10.  case class AsyncFutureInterpreter (executors: ExecutorServices) extends AsyncInterpreter[Future] with Product with Serializable
11.  trait AsyncInterpretation extends AnyRef
12.  trait AsyncInterpreter [F[_]] extends AnyRef
13.  case class AsyncNow [A](a: A) extends Async[A] with Product with Serializable
14.  final class AttemptOps [R, A] extends AnyVal
15.  trait Augment [T[_], O[_]] extends AnyRef
16.  trait Batch extends AnyRef

    This trait provides a way to rewrite applicative effects when there is an operation allowing the batching of some effects based on the Batchable typeclass

17.  trait Batchable [T[_]] extends AnyRef
18.  sealed trait Choose [T] extends AnyRef
19.  trait ChooseCreation extends AnyRef
20.  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:

    • no results (when using ChooseZero)
    • 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:

    • no results is the empty list
    • the result for a or b is List(a, b)

    If F is Option then:

    • no results is the None
    • the result for a or b is Some(a) or Some(b
21.  trait ChooseImplicits extends AnyRef
22.  trait ChooseInterpretation extends AnyRef
23.  case class ChooseZero [T]() extends Choose[T] with Product with Serializable
24.  case class CollectedUnions [M[_], R, U](effects: List[M[Any]], otherEffects: List[Union[U, Any]], indices: List[Int], otherIndices: List[Int]) extends Product with Serializable

    Collection of effects of a given type from a Unions objects

25.  case class Correct [E]() extends Validate[E, Unit] with Product with Serializable
26.  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 "impure applicative" case is:
      • list of disjoint unions of possible effects
      • a function to apply to the values resulting from those effects

    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!

    Similarly the list of effects in the applicative case is untyped and interpreters for those effects are supposed to create a list of values to feed the mapping function. If an interpreter doesn't create a list of values of the right size and with the right types, there will be a runtime exception.

    The Pure, Impure and ImpureAp cases also incorporate a "last" action returning no value but just used for side-effects (shutting down an execution context for example). This action is meant to be executed at the end of all computations, regardless of the number of flatMaps added on the Eff value.

    Since this last action will be executed, its value never collected so if it throws an exception it is possible to print it by defining the eff.debuglast system property (-Deff.debuglast=true)

    See also

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

27.  trait EffCreation extends AnyRef
28.  trait EffImplicits extends AnyRef
29.  trait EffInterpretation extends AnyRef
30.  sealed trait Effect [F[_]] extends AnyRef

    one effect, basically a type constructor

31.  trait EitherCreation extends AnyRef
32.  trait EitherEffect extends EitherCreation with EitherInterpretation

    Effect for computation which can fail

33.  trait EitherImplicits extends AnyRef
34.  trait EitherInterpretation extends AnyRef
35.  trait ErrorCreation [F] extends ErrorTypes[F]
36.  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 Either 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.

37.  trait ErrorInterpretation [F] extends ErrorCreation[F]
38.  trait ErrorTypes [F] extends AnyRef
39.  trait EvalCreation extends EvalTypes
40.  trait EvalEffect extends EvalTypes with EvalCreation with EvalInterpretation

    Effect for delayed computations

    Effect for delayed computations

    uses cats.Eval as a supporting data structure

41.  trait EvalInterpretation extends EvalTypes
42.  trait EvalTypes extends AnyRef
43.  case class Evaluate [F, A](run: Either[Either[Throwable, F], Eval[A]]) extends Product with Serializable
44.  case class EvaluateValue [A](a: Eval[A]) extends Safe[A] with Product with Serializable
45.  case class ExecutorServices (executorServiceEval: Eval[ExecutorService], scheduledExecutorEval: Eval[ScheduledExecutorService], executionContextEval: Eval[ExecutionContext]) extends Product with Serializable
46.  case class FailedFinalizer (t: Throwable) extends Safe[Unit] with Product with Serializable
47.  case class FailedValue [A](t: Throwable) extends Safe[A] with Product with Serializable
48.  sealed trait Fx extends AnyRef

    Base type for a tree of effect types

49.  final case class Fx1 [F[_]](e: Effect[F]) extends Fx with Product with Serializable
50.  final case class Fx2 [L[_], R[_]](left: Effect[L], right: Effect[R]) extends Fx with Product with Serializable
51.  final case class Fx3 [L[_], M[_], R[_]](left: Effect[L], middle: Effect[M], right: Effect[R]) extends Fx with Product with Serializable
52.  final case class FxAppend [L, R](left: L, right: R) extends Fx with Product with Serializable

    Append a tree of effects to another one

53.  case class Impure [R, X, A](union: Union[R, X], continuation: Arrs[R, X, A], last: Last[R] = Last.none[R]) extends Eff[R, A] with Product with Serializable

    Impure is an effect (encoded as one possibility among other effects, a Union) and a continuation providing the next Eff value.

    Impure is an effect (encoded as one possibility among other effects, a Union) and a continuation providing the next Eff value.

    This essentially models a flatMap operation with the current effect and the monadic function to apply to a value once the effect is interpreted

    One effect can always be executed last, just for side-effects

54.  case class ImpureAp [R, X, A](unions: Unions[R, X], continuation: Arrs[R, List[Any], A], last: Last[R] = Last.none[R]) extends Eff[R, A] with Product with Serializable

    ImpureAp is a list of independent effects and a pure function creating a value with all the resulting values once all effects have been interpreted.

    ImpureAp is a list of independent effects and a pure function creating a value with all the resulting values once all effects have been interpreted.

    This essentially models a sequence + map operation but it is important to understand that the list of Union objects can represent different effects and be like: List[Option[Int], Future[String], Option[Int]].

    Interpreting such an Eff value for a given effect (say Option) consists in:

    • grouping all the Option values,
    • sequencing them
    • pass them to a continuation which will apply the 'map' functions when the other effects (Future in the example above) will have been interpreted

    VERY IMPORTANT:

    • this object is highly unsafe
    • the size of the list argument to 'map' must always be equal to the number of unions in the Unions object
    • the types of the elements in the list argument to 'map' must be the exact types of each effect in unions.unions
55.  trait Interpret extends AnyRef

    Support methods to create interpreters (or "effect handlers") for a given effect M and a value Eff[R, A] when M is a member of R.

    Support methods to create interpreters (or "effect handlers") for a given effect M and a value Eff[R, A] when M is a member of R.

    Those methods guarantee a stack-safe behaviour when running on a large list of effects (in list.traverse(f) for example).

    There are 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)

    4. "intercept / interceptState / interceptLoop" methods are similar but they transform an effect to other effects in the same stack without removing it from the stack

    5. "transform" to swap an effect T of a stack to another effect, using a Natural Transformation

    6. "translate" to interpret one effect of a stack into other effects of the same stack using a Natural Transformation this is a specialized version of interpret + Recurse

    7. "interpretUnsafe + SideEffect" when you have a side effecting function M[X] => X

56.  trait IntoPoly [R, U] extends AnyRef

    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

57.  trait IntoPolyLower1 extends IntoPolyLower2
58.  trait IntoPolyLower2 extends IntoPolyLower3
59.  trait IntoPolyLower3 extends IntoPolyLower4
60.  trait IntoPolyLower4 extends IntoPolyLower5
61.  trait IntoPolyLower5 extends AnyRef
62.  case class Last [R](value: Option[Eval[Eff[R, Unit]]]) extends Product with Serializable

    Encapsulation of one optional last action to execute at the end of the program

63.  trait LeftFold [A, B] extends AnyRef

    support trait for folding values while possibly keeping some internal state

64.  trait ListCreation extends AnyRef
65.  trait ListEffect extends ListCreation with ListInterpretation

    Effect for computations possibly returning several values

66.  trait ListInterpretation extends AnyRef
67.  trait Loop [M[_], R, A, B, C] extends AnyRef

    Generalisation of Recurse and StateRecurse

    Generalisation of Recurse and StateRecurse

    The loop defines some state with an initial value which is maintained at each step of the interpretation.

    A is the type of Eff values to interpret, and B is the result of the interpretation (generally an other Eff value)

    C is the type of result for "last" actions.

    - the interpretation of a Pure value either returns the final result or possibly one more Eff value to interpret

    - onEffect interprets one effect and possibly uses the continuation to produce the next value to interpret. If no X can be used to run the continuation we might just output one final B value

    • onLastEffect interprets the last effect of an Eff value. The only difference with onEffect is the fact that last actions return Unit values (and not A values)
    • onApplicativeEff interprets a list of effects and possibly uses the continuation to get to the next value to interpret. If no interpretation can be done, a B value might be returned
    • onLastApplicativeEffect does the same thing for last actions
68.  trait Member [T[_], R] extends MemberInOut[T, R]

    Annotations

    @implicitNotFound( ... )

69.  trait MemberIn [T[_], R] extends AnyRef

    Annotations

    @implicitNotFound( ... )

70.  trait MemberInLower1 extends MemberInLower2
71.  trait MemberInLower2 extends MemberInLower3
72.  trait MemberInLower3 extends MemberInLower4
73.  trait MemberInLower4 extends MemberInLower5
74.  trait MemberInLower5 extends AnyRef
75.  trait MemberInOut [T[_], R] extends MemberIn[T, R]

    Annotations

    @implicitNotFound( ... )

76.  trait MemberInOutLower1 extends MemberInOutLower2
77.  trait MemberInOutLower2 extends MemberInOutLower3
78.  trait MemberInOutLower3 extends MemberInOutLower4
79.  trait MemberInOutLower4 extends MemberInOutLower5
80.  trait MemberInOutLower5 extends AnyRef
81.  trait MemberLower1 extends MemberLower2
82.  trait MemberLower10 extends MemberLower11
83.  trait MemberLower11 extends MemberLower12
84.  trait MemberLower12 extends MemberLower13
85.  trait MemberLower13 extends MemberLower14
86.  trait MemberLower14 extends MemberLower15
87.  trait MemberLower15 extends MemberLower16
88.  trait MemberLower16 extends MemberLower17
89.  trait MemberLower17 extends MemberLower18
90.  trait MemberLower18 extends MemberLower19
91.  trait MemberLower19 extends AnyRef
92.  trait MemberLower2 extends MemberLower3
93.  trait MemberLower3 extends MemberLower4
94.  trait MemberLower4 extends MemberLower5
95.  trait MemberLower5 extends MemberLower6
96.  trait MemberLower6 extends MemberLower7
97.  trait MemberLower7 extends MemberLower8
98.  trait MemberLower8 extends MemberLower9
99.  trait MemberLower9 extends MemberLower10
100.  class NoFx extends Fx

     The "empty" tree of effects

101.  trait OptionCreation extends AnyRef
102.  trait OptionEffect extends OptionCreation with OptionInterpretation

     Effect for optional computations

103.  trait OptionInterpretation extends AnyRef
104.  case class Pure [R, A](value: A, last: Last[R] = Last.none[R]) extends Eff[R, A] with Product with Serializable
105.  case class Rand [A](run: (Random) ⇒ Option[A]) extends Product with Serializable

     This class can be used as a F in runChoose to generate random alternatives

106.  trait ReaderCreation extends AnyRef
107.  trait ReaderEffect extends ReaderCreation with ReaderInterpretation

     Effect for computations depending on an environment.

     Effect for computations depending on an environment.

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

108.  trait ReaderInterpretation extends AnyRef
109.  trait Recurse [M[_], R, A] extends AnyRef

     Helper trait for computations which might produce several M[X] in a stack of effects.

     Helper trait for computations which might produce several M[X] in a stack of effects.

     Either we can produce an X to pass to a continuation or we're done

     For the applicative case we expect to be able to traverse a list of effects and return an effect of a list of results OR completely consume the effect and return a pure list of values

110.  sealed trait Safe [A] extends AnyRef

     The Safe type is a mix of a ThrowableEither / Eval effect and a writer effect to collect finalizer failures

111.  trait SafeCreation extends SafeTypes
112.  trait SafeEffect extends SafeCreation with SafeInterpretation
113.  trait SafeInterpretation extends SafeCreation
114.  trait SafeTypes extends AnyRef
115.  trait SideEffect [T[_]] extends AnyRef
116.  trait StateCreation extends AnyRef
117.  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

118.  trait StateImplicits extends AnyRef
119.  trait StateInterpretation extends AnyRef
120.  trait StatelessLoop [M[_], R, A, B, C] extends AnyRef

     Generalisation of Recurse

121.  trait Translate [T[_], U] extends AnyRef

     trait for translating one effect into other ones in the same stack

122.  sealed trait Union [+R, A] extends AnyRef

     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:

     • Fx1[T]
     • Fx2[T1, T2]
     • Fx3[T1, T2, T3]
     • FxAppend[L, R]

     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

123.  case class Union1 [T[_], A](ta: T[A]) extends Union[Fx1[T], A] with Product with Serializable
124.  sealed trait Union2 [R, A] extends Union[R, A]
125.  case class Union2L [L[_], R[_], A](t: L[A]) extends Union2[Fx2[L, R], A] with Product with Serializable
126.  case class Union2R [L[_], R[_], A](t: R[A]) extends Union2[Fx2[L, R], A] with Product with Serializable
127.  sealed trait Union3 [R, A] extends Union[R, A]
128.  case class Union3L [L[_], M[_], R[_], A](t: L[A]) extends Union3[Fx3[L, M, R], A] with Product with Serializable
129.  case class Union3M [L[_], M[_], R[_], A](t: M[A]) extends Union3[Fx3[L, M, R], A] with Product with Serializable
130.  case class Union3R [L[_], M[_], R[_], A](t: R[A]) extends Union3[Fx3[L, M, R], A] with Product with Serializable
131.  sealed trait UnionAppend [R, A] extends Union[R, A]
132.  case class UnionAppendL [L, R, A](t: Union[L, A]) extends UnionAppend[FxAppend[L, R], A] with Product with Serializable
133.  case class UnionAppendR [L, R, A](t: Union[R, A]) extends UnionAppend[FxAppend[L, R], A] with Product with Serializable
134.  trait UnionInto [R, S] extends AnyRef
135.  case class Unions [R, A](first: Union[R, A], rest: List[Union[R, Any]]) extends Product with Serializable

     A non-empty list of Unions.

     A non-empty list of Unions.

     It is only partially typed, we just keep track of the type of the first object

136.  sealed trait Validate [+E, A] extends AnyRef
137.  trait ValidateCreation extends AnyRef
138.  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

139.  trait ValidateInterpretation extends ValidateCreation
140.  trait Write [T[_], O] extends AnyRef
141.  trait WriterCreation extends AnyRef
142.  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
143.  trait WriterInterpretation extends AnyRef
144.  case class Wrong [E](e: E) extends Validate[E, Unit] with Product with Serializable
145.  type |=[M[_], R] = MemberIn[M, R]