Type Members

1.  type /=[M[_], R] = MemberInOut[M, R]
2.  type <=[M[_], R] = Member[M, R]
3.  final case class AppendMemberIn[T[_], L, R, X](isRight: Boolean, member: MemberIn[T, X]) extends MemberIn[T, FxAppend[L, R]] with Product with Serializable
4.  final case class AppendMemberInOut[T[_], L, R, X](isRight: Boolean, append: MemberInOut[T, X]) extends MemberInOut[T, FxAppend[L, R]] with Product with Serializable
5.  trait Augment[T[_], O[_]] extends AnyRef
6.  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

7.  trait Batchable[T[_]] extends AnyRef
8.  trait Cache extends AnyRef

   This cache is used to memoize values for the Memoized effect

9.  sealed trait Choose[T] extends AnyRef
10.  trait ChooseCreation extends AnyRef
11.  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
12.  trait ChooseImplicits extends AnyRef
13.  trait ChooseInterpretation extends AnyRef
14.  case class ChooseZero[T]() extends Choose[T] with Product with Serializable
15.  case class CollectedUnions[M[_], R, U](effects: Vector[M[Any]], otherEffects: Vector[Union[U, Any]], indices: Vector[Int], otherIndices: Vector[Int]) extends Product with Serializable

    Collection of effects of a given type from a Unions objects

16.  case class ConcurrentHashMapCache(map: ConcurrentHashMap[AnyRef, Eval[Any]] = new ConcurrentHashMap[AnyRef, Eval[Any]]) extends Cache with Product with Serializable
17.  class ConcurrentWeakIdentityHashMap[K, V] extends ConcurrentMap[K, V]

18.  case class ConcurrentWeakIdentityHashMapCache(map: ConcurrentWeakIdentityHashMap[AnyRef, Eval[Any]] = new ConcurrentWeakIdentityHashMap[AnyRef, Eval[Any]]) extends Cache with Product with Serializable
19.  case class Cons[H, T <: Members](head: H, tail: T) extends Members with Product with Serializable
20.  trait ConsLower1 extends AnyRef
21.  case class Continuation[R, A, B](functions: Vector[(Any) => Eff[R, Any]], onNone: Last[R] = Last.none[R]) 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]

    An alternate unit value can also be set on this function in case the argument A is not available. This value can be set by an effect to do some cleanup if it doesn't even get the chance to add its own effect. See SafeEffect.bracket

22.  case class Correct[E]() extends Validate[E, Unit] with Product with Serializable
23.  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

24.  trait EffCreation extends AnyRef
25.  trait EffImplicits extends AnyRef
26.  trait EffInterpretation extends AnyRef
27.  sealed trait Effect[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

    The effect tree is represented by four possible cases:

    • fx1[T]
    • fx2[T1, T2]
    • fx3[T1, T2, T3]
    • FxAppend[L, R]

    The union type has three concrete constructors:

    • UnionAppendL(nested: Union[L]): Union[FxAppend[L, R]]
    • UnionAppendR(nested: Union[R]): Union[FxAppend[L, R]]
    • UnionTagged(valueUnsafe: Any, index: Int): Union[R] (for R in fx1, fx2, fx3...) In that respect UnionTagged behaves similarly to a tagged union in C or C++.
28.  trait EitherCreation extends AnyRef
29.  trait EitherEffect extends EitherCreation with EitherInterpretation

    Effect for computation which can fail

30.  trait EitherImplicits extends AnyRef
31.  trait EitherInterpretation extends AnyRef
32.  trait ErrorCreation[F] extends ErrorTypes[F]
33.  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.

34.  trait ErrorInterpretation[F] extends ErrorCreation[F]
35.  trait ErrorTypes[F] extends AnyRef
36.  trait EvalCreation extends EvalTypes
37.  trait EvalEffect extends EvalTypes with EvalCreation with EvalInterpretation

    Effect for delayed computations

    Effect for delayed computations

    uses cats.Eval as a supporting data structure

38.  trait EvalInterpretation extends EvalTypes
39.  trait EvalTypes extends AnyRef
40.  case class Evaluate[F, A](run: Either[Either[Throwable, F], Eval[A]]) extends Product with Serializable
41.  case class EvaluateValue[A](run: Eval[A]) extends Safe[A] with Product with Serializable
42.  case class ExecutorServices(executorServiceEval: Eval[ExecutorService], scheduledExecutorEval: Eval[ScheduledExecutorService], executionContextEval: Eval[ExecutionContext]) extends Product with Serializable
43.  trait ExtractLower1 extends AnyRef
44.  trait ExtractMember[T, +H] extends AnyRef

    Type class to extract members from a list of Member instances

45.  case class FailedFinalizer(t: Throwable) extends Safe[Unit] with Product with Serializable
46.  case class FailedValue[A](t: Throwable) extends Safe[A] with Product with Serializable
47.  trait FutureCreation extends FutureTypes
48.  trait FutureEffect extends FutureCreation with FutureInterpretation
49.  trait FutureInterpretation extends FutureTypes
50.  trait FutureTypes extends AnyRef
51.  sealed trait Fx extends AnyRef

    Base type for a tree of effect types

52.  trait Fx1[+F[_]] extends Fx
53.  trait Fx2[+L[_], +R[_]] extends Fx
54.  trait Fx3[+L[_], +M[_], +R[_]] extends Fx
55.  trait FxAppend[+L, +R] extends Fx

    Append a tree of effects to another one

56.  case class GetCache() extends Memoized[Cache] with Product with Serializable
57.  case class Impure[R, X, A](union: Effect[R, X], continuation: Continuation[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

58.  case class ImpureAp[R, X, A](unions: Unions[R, X], continuation: Continuation[R, Vector[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: Vector[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
59.  trait Interpret extends AnyRef

    The Interpret trait provides method to interpret (or "handle") effects.

    The Interpret trait provides method to interpret (or "handle") effects.

    An interpreter generally handles a given effect M and a value Eff[R, A] where M is a member of R.

    The most general way of interpreting an effect is to implement the Interpreter trait for that effect and use the runInterpreter method. With the Interpreter trait you need to define:

    • what to do with pure values
    • what to do with an effect
    • what to do with a list of effects (the "applicative" case)
    • what to do with a "last" effect, in case of having side-effects to finalize resources (see the SafeEffect)

    For each of those methods you get access to a continuation which you may or may not invoke to create the next effect in a sequence of effects. For example with the EitherEffect once you arrive on a Left value you don't trigger the continuation because there is no value to trigger it with.

    There are also easier ways to define interpreters. The recurse method and the Recurser trait define:

    • onPure(a: A): B: how to map a pure value A to the result B
    • onEffect[X](mx: M[X]): X Either Eff[R, B]: either extract a value from the effect or return another effect
    • onApplicative[X](tx: T[M[X]]): T[X] Either M[T[X]]: either extract individual values from each effect or "sequence" the effect

    Even simpler, the Translate trait does a translation from an effect M[X] to other effects in the stack.

    There are also a few intercept methods to use an effect but still leave it in the stack

60.  trait Interpreter[M[_], R, A, B] extends AnyRef

    Interpret eff values

    Interpret eff values

    For stack-safety reasons, the continuation must *never* be called with a value directly, but always with Eff.impure:

    Eff.impure(a, continuation)

    * *Note* it is the responsibility of the implementation to call continuation.onNone if the continuation is not used to create the return value.

61.  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

62.  trait IntoPolyLower1 extends IntoPolyLower2
63.  trait IntoPolyLower2 extends IntoPolyLower3
64.  trait IntoPolyLower3 extends IntoPolyLower4
65.  trait IntoPolyLower4 extends IntoPolyLower5
66.  trait IntoPolyLower5 extends AnyRef
67.  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

68.  trait ListCreation extends AnyRef
69.  trait ListEffect extends ListCreation with ListInterpretation

    Effect for computations possibly returning several values

70.  trait ListInterpretation extends AnyRef
71.  trait Member[T[_], R] extends MemberInOut[T, R]

    Annotations

    @implicitNotFound("No instance found for Member[${T}, ${R}].\nThe effect ${T} is not part of the stack ${R}\n or it was not possible to determine the stack that would result from removing ${T} from ${R}")

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

    Annotations

    @implicitNotFound("No instance found for MemberIn[${T}, ${R}].\nThe effect ${T} is not part of the stack ${R}")

73.  trait MemberInLower1 extends MemberInLower2
74.  trait MemberInLower2 extends MemberInLower3
75.  trait MemberInLower3 extends MemberInLower4
76.  trait MemberInLower4 extends MemberInLower5
77.  trait MemberInLower5 extends AnyRef
78.  trait MemberInOut[T[_], R] extends MemberIn[T, R]

    Annotations

    @implicitNotFound("No instance found for MemberInOut[${T}, ${R}].\nThe effect ${T} is not part of the stack ${R} or cannot be extracted from ${R}")

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

     list of Member instances for a given stack R

104.  trait MemoCreation extends MemoTypes
105.  trait MemoEffect extends MemoTypes with MemoCreation with MemoInterpretation

     Memoization effect

     Memoization effect

     Memoize a computation for a given key

     This effect can be interpreted with a cache implemented with many different libraries. See Cache.scala for 2 default implementations:

     • one concurrent hashmap (meaning an unbounded cache)
     • one concurrent hashmap with weak references (to evict entries based on garbage collection)

     You can implement your own version using ScalaCache for example

106.  trait MemoInterpretation extends MemoTypes
107.  trait MemoTypes extends AnyRef
108.  sealed trait Memoized[A] extends AnyRef
109.  case class NoEffect[R, A](a: A) extends Effect[R, A] with Product with Serializable
110.  class NoFx extends Fx

     The "empty" tree of effects

111.  case class NoMember() extends Members with Product with Serializable
112.  trait OptionCreation extends AnyRef
113.  trait OptionEffect extends OptionCreation with OptionInterpretation

     Effect for optional computations

114.  trait OptionInterpretation extends AnyRef
115.  case class Pure[R, A](value: A, last: Last[R] = Last.none[R]) extends Eff[R, A] with Product with Serializable
116.  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

117.  trait ReaderCreation extends AnyRef
118.  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

119.  trait ReaderInterpretation extends AnyRef
120.  trait Recurser[M[_], R, A, B] 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

121.  trait RightFold[A, B] extends AnyRef

     support trait for folding values while possibly keeping some internal state

122.  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

123.  trait SafeCreation extends SafeTypes
124.  trait SafeEffect extends SafeCreation with SafeInterpretation
125.  trait SafeInterpretation extends SafeCreation
126.  trait SafeTypes extends AnyRef
127.  trait SequenceCached[M[_]] extends AnyRef

     type class for effects which can be cached in a SequenceCache

128.  trait SideEffect[T[_]] extends AnyRef
129.  trait StateCreation extends AnyRef
130.  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

131.  trait StateImplicits extends AnyRef
132.  trait StateInterpretation extends AnyRef
133.  case class Store[A](key: AnyRef, a: () => A) extends Memoized[A] with Product with Serializable
134.  final case class TaggedMemberIn[T[_], R](tag: Int) extends MemberIn[T, R] with Product with Serializable
135.  final case class TaggedMemberInOut[T[_], R](tag: Int) extends MemberInOut[T, R] with Product with Serializable
136.  final case class TimedFuture[A](callback: (Scheduler, ExecutionContext) => Future[A], timeout: Option[FiniteDuration] = None) extends Product with Serializable
137.  trait Translate[T[_], U] extends AnyRef

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

138.  sealed trait Union[R, A] extends Effect[R, A]
139.  case class UnionAppendL[L, R, A](value: Union[L, A]) extends Union[FxAppend[L, R], A] with Product with Serializable
140.  case class UnionAppendR[L, R, A](value: Union[R, A]) extends Union[FxAppend[L, R], A] with Product with Serializable
141.  trait UnionInto[R, S] extends AnyRef

     transform a Union for a given stack into a Union for another stack

142.  case class UnionTagged[R, A](valueUnsafe: Any, index: Int) extends Union[R, A] with Product with Serializable
143.  case class Unions[R, A](first: Union[R, A], rest: Vector[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

144.  sealed trait Validate[+E, A] extends AnyRef
145.  trait ValidateCreation extends AnyRef
146.  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

147.  trait ValidateInterpretation extends ValidateCreation
148.  case class Warning[E](e: E) extends Validate[E, Unit] with Product with Serializable
149.  trait Write[T[_], O] extends AnyRef
150.  trait WriterCreation extends AnyRef
151.  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
152.  trait WriterInterpretation extends AnyRef
153.  case class Wrong[E](e: E) extends Validate[E, Unit] with Product with Serializable
154.  type |=[M[_], R] = MemberIn[M, R]