eff

Type Members

1. type <=[M[_], R] = Member[M, R]

   

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]

4. sealed trait Choose[T] extends AnyRef

   

5. trait ChooseCreation extends AnyRef

   

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:

   • 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

7. trait ChooseImplicits extends AnyRef

   

8. trait ChooseInterpretation extends AnyRef

   

9. case class ChooseZero[T]() extends Choose[T] with Product with Serializable

   

10. case class Correct[E]() extends Validate[E, Unit] with Product with Serializable

    

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 ErrorCreation[F] extends ErrorTypes[F]

    

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

18. trait ErrorInterpretation[F] extends ErrorCreation[F]

    

19. trait ErrorTypes[F] extends AnyRef

    

20. trait EvalCreation extends EvalTypes

    

21. trait EvalEffect extends EvalTypes with EvalCreation with EvalInterpretation

    

    Effect for delayed computations

    Effect for delayed computations

    uses cats.Eval as a supporting data structure

22. trait EvalInterpretation extends EvalTypes

    

23. trait EvalTypes extends AnyRef

    

24. case class Evaluate[F, A](run: Xor[Xor[Throwable, F], Eval[A]]) extends Product with Serializable

    

25. case class EvaluateValue[A](a: Eval[A]) extends Safe[A] with Product with Serializable

    

26. case class FailedFinalizer(t: Throwable) extends Safe[Unit] with Product with Serializable

    

27. case class FailedValue[A](t: Throwable) extends Safe[A] with Product with Serializable

    

28. trait FutureCreation extends AnyRef

    

29. trait FutureEffect extends FutureCreation with FutureInterpretation

    

    Effect for Future computations

30. trait FutureInterpretation extends AnyRef

    

31. sealed trait Fx extends AnyRef

    

    Base type for a tree of effect types

32. final case class Fx1[F[_]](e: Effect[F]) extends Fx with Product with Serializable

    

33. final case class Fx2[L[_], R[_]](left: Effect[L], right: Effect[R]) extends Fx with Product with Serializable

    

34. final case class Fx3[L[_], M[_], R[_]](left: Effect[L], middle: Effect[M], right: Effect[R]) extends Fx with Product with Serializable

    

35. final case class FxAppend[L, R](left: L, right: R) extends Fx with Product with Serializable

    

    Append a tree of effects to another one

36. 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)

37. 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)

38. 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)

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

40. trait IntoPolyLower1 extends IntoPolyLower2

    

41. trait IntoPolyLower2 extends IntoPolyLower3

    

42. trait IntoPolyLower3 extends IntoPolyLower4

    

43. trait IntoPolyLower4 extends AnyRef

    

44. trait LeftFold[A, B] extends AnyRef

    

    support trait for folding values while possibly keeping some internal state

45. trait ListCreation extends AnyRef

    

46. trait ListEffect extends ListCreation with ListInterpretation

    

    Effect for computations possibly returning several values

47. trait ListInterpretation extends AnyRef

    

48. trait Member[T[_], R] extends MemberIn[T, R]

    

    Annotations

    @implicitNotFound( ... )

49. trait MemberIn[T[_], R] extends AnyRef

    

    Annotations

    @implicitNotFound( ... )

50. trait MemberInLower1 extends MemberInLower2

    

51. trait MemberInLower2 extends MemberInLower3

    

52. trait MemberInLower3 extends MemberInLower4

    

53. trait MemberInLower4 extends MemberInLower5

    

54. trait MemberInLower5 extends AnyRef

    

55. trait MemberLower1 extends MemberLower2

    

56. trait MemberLower10 extends MemberLower11

    

57. trait MemberLower11 extends MemberLower12

    

58. trait MemberLower12 extends MemberLower13

    

59. trait MemberLower13 extends AnyRef

    

60. trait MemberLower2 extends MemberLower3

    

61. trait MemberLower3 extends MemberLower4

    

62. trait MemberLower4 extends MemberLower5

    

63. trait MemberLower5 extends MemberLower6

    

64. trait MemberLower6 extends MemberLower7

    

65. trait MemberLower7 extends MemberLower8

    

66. trait MemberLower8 extends MemberLower9

    

67. trait MemberLower9 extends MemberLower10

    

68. class NoFx extends Fx

    

    The "empty" tree of effects

69. trait OptionCreation extends AnyRef

    

70. trait OptionEffect extends OptionCreation with OptionInterpretation

    

    Effect for optional computations

71. trait OptionInterpretation extends AnyRef

    

72. case class Pure[R, A](value: A) extends Eff[R, A] with Product with Serializable

    

73. trait ReaderCreation extends AnyRef

    

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

75. trait ReaderInterpretation extends AnyRef

    

76. sealed trait Safe[A] extends AnyRef

    

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

77. trait SafeCreation extends SafeTypes

    

78. trait SafeEffect extends SafeCreation with SafeInterpretation

    

79. trait SafeInterpretation extends SafeCreation

    

80. trait SafeTypes extends AnyRef

    

81. trait StateCreation extends AnyRef

    

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

83. trait StateInterpretation extends AnyRef

    

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

85. case class Union1[T[_], A](ta: T[A]) extends Union[Fx1[T], A] with Product with Serializable

    

86. sealed trait Union2[R, A] extends Union[R, A]

    

87. case class Union2L[L[_], R[_], A](t: L[A]) extends Union2[Fx2[L, R], A] with Product with Serializable

    

88. case class Union2R[L[_], R[_], A](t: R[A]) extends Union2[Fx2[L, R], A] with Product with Serializable

    

89. sealed trait Union3[R, A] extends Union[R, A]

    

90. case class Union3L[L[_], M[_], R[_], A](t: L[A]) extends Union3[Fx3[L, M, R], A] with Product with Serializable

    

91. case class Union3M[L[_], M[_], R[_], A](t: M[A]) extends Union3[Fx3[L, M, R], A] with Product with Serializable

    

92. case class Union3R[L[_], M[_], R[_], A](t: R[A]) extends Union3[Fx3[L, M, R], A] with Product with Serializable

    

93. sealed trait UnionAppend[R, A] extends Union[R, A]

    

94. case class UnionAppendL[L, R, A](t: Union[L, A]) extends UnionAppend[FxAppend[L, R], A] with Product with Serializable

    

95. case class UnionAppendR[L, R, A](t: Union[R, A]) extends UnionAppend[FxAppend[L, R], A] with Product with Serializable

    

96. sealed trait Validate[+E, A] extends AnyRef

    

97. trait ValidateCreation extends AnyRef

    

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

99. trait ValidateInterpretation extends ValidateCreation

    

100. trait WriterCreation extends AnyRef

     

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

102. trait WriterInterpretation extends AnyRef

     

103. case class Wrong[E](e: E) extends Validate[E, Unit] with Product with Serializable

     

104. trait XorCreation extends AnyRef

     

105. trait XorEffect extends XorCreation with XorInterpretation

     

     Effect for computation which can fail

106. trait XorInterpretation extends AnyRef

     

107. type |=[M[_], R] = MemberIn[M, R]