package eff
- Source
- package.scala
- Alphabetic
- By Inheritance
- eff
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Package Members
- package concurrent
- package syntax
Type Members
- type /=[M[_], R] = MemberInOut[M, R]
- type <=[M[_], R] = Member[M, R]
- final case class AppendMemberIn[T[_], L, R, X](isRight: Boolean, member: MemberIn[T, X]) extends MemberIn[T, FxAppend[L, R]] with Product with Serializable
- final case class AppendMemberInOut[T[_], L, R, X](isRight: Boolean, append: MemberInOut[T, X]) extends MemberInOut[T, FxAppend[L, R]] with Product with Serializable
- trait Augment[T[_], O[_]] extends AnyRef
- 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
- trait Batchable[T[_]] extends AnyRef
- trait Cache extends AnyRef
This cache is used to memoize values for the Memoized effect
- sealed trait Choose[T] extends AnyRef
- trait ChooseCreation extends AnyRef
- 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
- trait ChooseImplicits extends AnyRef
- trait ChooseInterpretation extends AnyRef
- case class ChooseZero[T]() extends Choose[T] with Product with Serializable
- 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
- case class ConcurrentHashMapCache(map: ConcurrentHashMap[AnyRef, Eval[Any]] = new ConcurrentHashMap[AnyRef, Eval[Any]]) extends Cache with Product with Serializable
- class ConcurrentWeakIdentityHashMap[K, V] extends ConcurrentMap[K, V]
- case class ConcurrentWeakIdentityHashMapCache(map: ConcurrentWeakIdentityHashMap[AnyRef, Eval[Any]] = new ConcurrentWeakIdentityHashMap[AnyRef, Eval[Any]]) extends Cache with Product with Serializable
- case class Cons[H, T <: Members](head: H, tail: T) extends Members with Product with Serializable
- trait ConsLower1 extends AnyRef
- 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
- case class Correct[E]() extends Validate[E, Unit] with Product with Serializable
- 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 Purebind
simply appends the binding function to theArrs
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)
- trait EffCreation extends AnyRef
- trait EffImplicits extends AnyRef
- class EffImpossibleException extends RuntimeException
- trait EffInterpretation extends AnyRef
- 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++.
- trait EitherCreation extends AnyRef
- trait EitherEffect extends EitherCreation with EitherInterpretation
Effect for computation which can fail
- trait EitherImplicits extends AnyRef
- trait EitherInterpretation extends AnyRef
- trait ErrorCreation[F] extends ErrorTypes[F]
- 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.
- trait ErrorInterpretation[F] extends ErrorCreation[F]
- trait ErrorTypes[F] extends AnyRef
- trait EvalCreation extends EvalTypes
- trait EvalEffect extends EvalTypes with EvalCreation with EvalInterpretation
Effect for delayed computations
Effect for delayed computations
uses cats.Eval as a supporting data structure
- trait EvalInterpretation extends EvalTypes
- trait EvalTypes extends AnyRef
- case class Evaluate[F, A](run: Either[Either[Throwable, F], Eval[A]]) extends Product with Serializable
- case class EvaluateValue[A](run: Eval[A]) extends Safe[A] with Product with Serializable
- case class ExecutorServices(executorServiceEval: Eval[ExecutorService], scheduledExecutorEval: Eval[ScheduledExecutorService], executionContextEval: Eval[ExecutionContext]) extends Product with Serializable
- trait ExtractLower1 extends AnyRef
- trait ExtractMember[T, +H] extends AnyRef
Type class to extract members from a list of Member instances
- case class FailedFinalizer(t: Throwable) extends Safe[Unit] with Product with Serializable
- case class FailedValue[A](t: Throwable) extends Safe[A] with Product with Serializable
- trait FutureCreation extends FutureTypes
- trait FutureEffect extends FutureCreation with FutureInterpretation
- trait FutureInterpretation extends FutureTypes
- trait FutureTypes extends AnyRef
- sealed trait Fx extends AnyRef
Base type for a tree of effect types
- trait Fx1[+F[_]] extends Fx
- trait Fx2[+L[_], +R[_]] extends Fx
- trait Fx3[+L[_], +M[_], +R[_]] extends Fx
- trait FxAppend[+L, +R] extends Fx
Append a tree of effects to another one
- case class GetCache() extends Memoized[Cache] with Product with Serializable
- 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
- 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
- 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 theRecurser
trait define:onPure(a: A): B
: how to map a pure value A to the result BonEffect[X](mx: M[X]): X Either Eff[R, B]
: either extract a value from the effect or return another effectonApplicative[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 effectM[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 - 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.
- 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
Example: - trait IntoPolyLower1 extends IntoPolyLower2
- trait IntoPolyLower2 extends IntoPolyLower3
- trait IntoPolyLower3 extends IntoPolyLower4
- trait IntoPolyLower4 extends IntoPolyLower5
- trait IntoPolyLower5 extends AnyRef
- 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
- trait ListCreation extends AnyRef
- trait ListEffect extends ListCreation with ListInterpretation
Effect for computations possibly returning several values
- trait ListInterpretation extends AnyRef
- trait Member[T[_], R] extends MemberInOut[T, R]
- Annotations
- @implicitNotFound()
- trait MemberIn[T[_], R] extends AnyRef
- Annotations
- @implicitNotFound()
- trait MemberInLower1 extends MemberInLower2
- trait MemberInLower2 extends MemberInLower3
- trait MemberInLower3 extends MemberInLower4
- trait MemberInLower4 extends MemberInLower5
- trait MemberInLower5 extends AnyRef
- trait MemberInOut[T[_], R] extends MemberIn[T, R]
- Annotations
- @implicitNotFound()
- trait MemberInOutLower1 extends MemberInOutLower2
- trait MemberInOutLower2 extends MemberInOutLower3
- trait MemberInOutLower3 extends MemberInOutLower4
- trait MemberInOutLower4 extends MemberInOutLower5
- trait MemberInOutLower5 extends AnyRef
- trait MemberLower1 extends MemberLower2
- trait MemberLower10 extends MemberLower11
- trait MemberLower11 extends MemberLower12
- trait MemberLower12 extends MemberLower13
- trait MemberLower13 extends MemberLower14
- trait MemberLower14 extends MemberLower15
- trait MemberLower15 extends MemberLower16
- trait MemberLower16 extends MemberLower17
- trait MemberLower17 extends MemberLower18
- trait MemberLower18 extends MemberLower19
- trait MemberLower19 extends AnyRef
- trait MemberLower2 extends MemberLower3
- trait MemberLower3 extends MemberLower4
- trait MemberLower4 extends MemberLower5
- trait MemberLower5 extends MemberLower6
- trait MemberLower6 extends MemberLower7
- trait MemberLower7 extends MemberLower8
- trait MemberLower8 extends MemberLower9
- trait MemberLower9 extends MemberLower10
- sealed trait Members extends AnyRef
list of Member instances for a given stack R
- trait MemoCreation extends MemoTypes
- 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
- trait MemoInterpretation extends MemoTypes
- trait MemoTypes extends AnyRef
- sealed trait Memoized[A] extends AnyRef
- case class NoEffect[R, A](a: A) extends Effect[R, A] with Product with Serializable
- class NoFx extends Fx
The "empty" tree of effects
- case class NoMember() extends Members with Product with Serializable
- trait OptionCreation extends AnyRef
- trait OptionEffect extends OptionCreation with OptionInterpretation
Effect for optional computations
- trait OptionInterpretation extends AnyRef
- case class Pure[R, A](value: A, last: Last[R] = Last.none[R]) extends Eff[R, A] with Product with Serializable
- 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
- trait ReaderCreation extends AnyRef
- 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
- trait ReaderInterpretation extends AnyRef
- 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
- trait RightFold[A, B] extends AnyRef
support trait for folding values while possibly keeping some internal state
- 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
- trait SafeCreation extends SafeTypes
- trait SafeEffect extends SafeCreation with SafeInterpretation
- trait SafeInterpretation extends SafeCreation
- trait SafeTypes extends AnyRef
- trait SequenceCached[M[_]] extends AnyRef
type class for effects which can be cached in a SequenceCache
- trait SideEffect[T[_]] extends AnyRef
- trait StateCreation extends AnyRef
- 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
- trait StateImplicits extends AnyRef
- trait StateInterpretation extends AnyRef
- case class Store[A](key: AnyRef, a: () => A) extends Memoized[A] with Product with Serializable
- final case class TaggedMemberIn[T[_], R](tag: Int) extends MemberIn[T, R] with Product with Serializable
- final case class TaggedMemberInOut[T[_], R](tag: Int) extends MemberInOut[T, R] with Product with Serializable
- final case class TimedFuture[A](callback: (Scheduler, ExecutionContext) => Future[A], timeout: Option[FiniteDuration] = None) extends Product with Serializable
- trait Translate[T[_], U] extends AnyRef
trait for translating one effect into other ones in the same stack
- sealed trait Union[R, A] extends Effect[R, A]
- case class UnionAppendL[L, R, A](value: Union[L, A]) extends Union[FxAppend[L, R], A] with Product with Serializable
- case class UnionAppendR[L, R, A](value: Union[R, A]) extends Union[FxAppend[L, R], A] with Product with Serializable
- trait UnionInto[R, S] extends AnyRef
transform a Union for a given stack into a Union for another stack
- case class UnionTagged[R, A](valueUnsafe: Any, index: Int) extends Union[R, A] with Product with Serializable
- 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
- sealed trait Validate[+E, A] extends AnyRef
- trait ValidateCreation extends AnyRef
- 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
- trait ValidateInterpretation extends ValidateCreation
- case class Warning[E](e: E) extends Validate[E, Unit] with Product with Serializable
- trait Write[T[_], O] extends AnyRef
- trait WriterCreation extends AnyRef
- 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
- trait WriterInterpretation extends AnyRef
- case class Wrong[E](e: E) extends Validate[E, Unit] with Product with Serializable
- type |=[M[_], R] = MemberIn[M, R]
Value Members
- object Batch extends Batch
- object ChooseCreation extends ChooseCreation
- object ChooseEffect extends ChooseEffect
- object ChooseImplicits extends ChooseImplicits
- object ChooseInterpretation extends ChooseInterpretation
- case object ChoosePlus extends Choose[Boolean] with Product with Serializable
- object Cons extends ConsLower1 with Serializable
- object Continuation extends Serializable
- object Eff extends EffCreation with EffInterpretation with EffImplicits
- object EffCreation extends EffCreation
- object EffImplicits extends EffImplicits
- object EffInterpretation extends EffInterpretation
- object EitherCreation extends EitherCreation
- object EitherEffect extends EitherEffect
- object EitherImplicits extends EitherImplicits
- object EitherInterpretation extends EitherInterpretation
- object ErrorEffect extends ErrorEffect[String]
Simple instantiation of the ErrorEffect trait with String as a Failure type
- object EvalEffect extends EvalEffect
- object EvalInterpretation extends EvalInterpretation
- object EvalTypes extends EvalTypes
- object Evaluate extends Serializable
- object ExecutorServices extends Schedulers with Serializable
- object ExtractMember extends ExtractLower1
- object FutureCreation extends FutureCreation
- object FutureEffect extends FutureEffect
- object FutureInterpretation extends FutureInterpretation
- object Fx
- object Interpret extends Interpret
- object Interpreter
- object IntoPoly extends IntoPolyLower1
- object Last extends Serializable
- object ListCreation extends ListCreation
- object ListEffect extends ListEffect
- object ListInterpretation extends ListInterpretation
- object Member extends MemberLower1
- object MemberIn extends MemberInLower1
- object MemberInOut extends MemberInOutLower1
- object Members
- object MemoEffect extends MemoEffect
- object MemoInterpretation extends MemoInterpretation
- object MemoTypes extends MemoTypes
- object NoFx extends NoFx
- object OptionCreation extends OptionCreation
- object OptionEffect extends OptionEffect
- object OptionInterpretation extends OptionInterpretation
- object Rand extends Serializable
- object ReaderCreation extends ReaderCreation
- object ReaderEffect extends ReaderEffect
- object ReaderInterpretation extends ReaderInterpretation
- object Safe
- object SafeEffect extends SafeEffect
- object SafeInterpretation extends SafeInterpretation
- object StateCreation extends StateCreation
- object StateEffect extends StateEffect
- object StateImplicits extends StateImplicits
- object StateInterpretation extends StateInterpretation
- object SubscribeEffect
This effect is used in the implementation of the Async effect
- object TimedFuture extends Serializable
- object Union
- object Unions extends Serializable
- object ValidateCreation extends ValidateCreation
- object ValidateEffect extends ValidateEffect
- object ValidateInterpretation extends ValidateInterpretation
- object WriterCreation extends WriterCreation
- object WriterEffect extends WriterEffect
- object WriterInterpretation extends WriterInterpretation
- object all extends ReaderEffect with WriterEffect with StateEffect with EvalEffect with OptionEffect with ListEffect with EitherEffect with ValidateEffect with ChooseEffect with SafeEffect with MemoEffect with Batch with EffInterpretation with EffCreation with EffImplicits
- object batch extends Batch
- object choose extends ChooseCreation with ChooseInterpretation
- object create extends ReaderCreation with WriterCreation with StateCreation with EvalCreation with OptionCreation with ListCreation with EitherCreation with ValidateCreation with ChooseCreation with FutureCreation with MemoCreation with EffCreation with SafeCreation
- object eff extends EffCreation with EffInterpretation
- object either extends EitherCreation with EitherInterpretation with EitherImplicits
- object eval extends EvalCreation with EvalInterpretation
- object future extends FutureCreation with FutureInterpretation
- object interpret extends Interpret with Batch
- object list extends ListCreation with ListInterpretation
- object memo extends MemoCreation with MemoInterpretation
- object option extends OptionCreation with OptionInterpretation
- object reader extends ReaderCreation with ReaderInterpretation
- object safe extends SafeCreation with SafeInterpretation
- object state extends StateCreation with StateInterpretation with StateImplicits
- object validate extends ValidateCreation with ValidateInterpretation
- object writer extends WriterCreation with WriterInterpretation