eff

package eff

Linear Supertypes
AnyRef, Any
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

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]

5. trait Cache extends AnyRef

This cache is used to memoize values for the Memoized effect

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

11. trait DisjunctionEffect extends DisjunctionCreation with DisjunctionInterpretation

Effect for computation which can fail

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

17. sealed trait Effect[F[_]] extends AnyRef

one effect, basically a type constructor

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

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

35. sealed trait Fx extends AnyRef

Base type for a tree of effect types

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

Append a tree of effects to another one

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

41. 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
42. 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

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

49. case class Last[R](value: Option[Name[Eff[R, Unit]]]) extends Product with Serializable

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

50. 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
51. trait Member[T[_], R] extends MemberInOut[T, R]

Annotations
@implicitNotFound( ... )
52. trait MemberIn[T[_], R] extends AnyRef

Annotations
@implicitNotFound( ... )

58. trait MemberInOut[T[_], R] extends MemberIn[T, R]

Annotations
@implicitNotFound( ... )

84. class NoFx extends Fx

The "empty" tree of effects

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

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

92. trait SequenceCached[M[_]] extends AnyRef

type class for effects which can be cached in a SequenceCache

94. trait StatelessLoop[M[_], R, A, B, C] extends AnyRef

Generalisation of Recurse

96. trait Translate[T[_], U] extends AnyRef

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

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

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

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

Value Members

10. object ErrorEffect extends ErrorEffect[String]

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