Interpret

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:

"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

Linear Supertypes

AnyRef, Any

Known Subclasses

Interpret, interpret

Type Members

trait StateRecurse[M[_], A, B] extends AnyRef

Helper trait for computations which might produce several M[X] in a stack of effects and which need to keep some state around
Helper trait for computations which might produce several M[X] in a stack of effects and which need to keep some state around
This is typically the case for Writer or State which need to keep some state S after each evaluation Evaluating the effect M[X] might use the previous S value as shown in the apply method
Finally when the Eff[R, A] returns an A, this one can be combined with the last state value to produce a B
type of[F[_], G[_]] = AnyRef { type l[A] = F[G[A]] }

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def augment[R, T[_], O[_], A](eff: Eff[R, A])(w: Augment[T, O])(implicit m: MemberInOut[T, R]): Eff[prepend[O, R], A]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def intercept[R, M[_], A, B](pure: (A) ⇒ Eff[R, B], recurse: Recurse[M, R, B])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]

INTERPRET IN THE SAME STACK
def intercept1[R, M[_], A, B](pure: (A) ⇒ B)(recurse: Recurse[M, R, B])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]

simpler version of intercept where the pure value is just mapped to another type
def interceptLoop[R, M[_], A, B](pure: (A) ⇒ Eff[R, B], loop: Loop[M, R, A, Eff[R, B], Eff[R, Unit]])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]

intercept an effect and interpret it in the same stack.
intercept an effect and interpret it in the same stack. This method is stack-safe
def interceptLoop1[R, M[_], A, B](pure: (A) ⇒ B)(loop: Loop[M, R, A, Eff[R, B], Eff[R, Unit]])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]
def interceptNat[R, T[_], A](effects: Eff[R, A])(nat: ~>[T, T])(implicit m: MemberInOut[T, R]): Eff[R, A]

Intercept the values for one effect and transform them into other values for the same effect
def interceptNatM[R, T[_], F[_], A](effects: Eff[R, A], nat: ~>[T, [A]T[F[A]]])(implicit m: MemberInOut[T, R], FT: Traverse[F], FM: Monad[F]): Eff[R, F[A]]

Intercept the values for one effect, emitting new values for the same effect inside a monad which is interleaved in
def interceptStatelessLoop[R, M[_], A, B](pure: (A) ⇒ Eff[R, B], loop: StatelessLoop[M, R, A, Eff[R, B], Eff[R, Unit]])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]
def interceptStatelessLoop1[R, M[_], A, B](pure: (A) ⇒ B)(loop: StatelessLoop[M, R, A, Eff[R, B], Eff[R, Unit]])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]
def interpret[R, U, M[_], A, B](pure: (A) ⇒ Eff[U, B], recurse: Recurse[M, U, B])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

interpret the effect M in the R stack
def interpret1[R, U, M[_], A, B](pure: (A) ⇒ B)(recurse: Recurse[M, U, B])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

simpler version of interpret where the pure value is just mapped to another type
def interpretLoop[R, U, M[_], A, B](pure: (A) ⇒ Eff[U, B], loop: Loop[M, R, A, Eff[U, B], Eff[U, Unit]])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

generalization of interpret and interpretState
generalization of interpret and interpretState
This method contains a loop which is stack-safe
def interpretLoop1[R, U, M[_], A, B](pure: (A) ⇒ B)(loop: Loop[M, R, A, Eff[U, B], Eff[U, Unit]])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]
def interpretState[R, U, M[_], A, B](pure: (A) ⇒ Eff[U, B], recurse: StateRecurse[M, A, B])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

interpret the effect M in the M |: R stack, keeping track of some state
def interpretState1[R, U, M[_], A, B](pure: (A) ⇒ B)(recurse: StateRecurse[M, A, B])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

simpler version of interpret1 where the pure value is just mapped to another type
def interpretStatelessLoop[R, U, M[_], A, B](pure: (A) ⇒ Eff[U, B], loop: StatelessLoop[M, R, A, Eff[U, B], Eff[U, Unit]])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

generalization of interpret
generalization of interpret
This method contains a loop which is stack-safe
def interpretStatelessLoop1[R, U, M[_], A, B](pure: (A) ⇒ B)(loop: StatelessLoop[M, R, A, Eff[U, B], Eff[U, Unit]])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]
def interpretUnsafe[R, U, T[_], A](effects: Eff[R, A])(sideEffect: SideEffect[T])(implicit m: Aux[T, R, U]): Eff[U, A]

interpret an effect by running side-effects
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def transform[SR, BR, U, TS[_], TB[_], A](r: Eff[SR, A], nat: ~>[TS, TB])(implicit sr: Aux[TS, SR, U], br: Aux[TB, BR, U]): Eff[BR, A]

transform an effect into another one using a natural transformation, leaving the rest of the stack untouched
def translate[R, U, T[_], A](effects: Eff[R, A])(tr: Translate[T, U])(implicit m: Aux[T, R, U]): Eff[U, A]

Translate one effect of the stack into some of the other effects in the stack
def translateInto[R, T[_], U, A](eff: Eff[R, A])(translate: Translate[T, U])(implicit m: MemberInOut[T, R], into: IntoPoly[R, U]): Eff[U, A]

Translate one effect of the stack into other effects in a larger stack
def translateNat[R, U, T[_], A](effects: Eff[R, A])(nat: ~>[T, [β$0$]Eff[U, β$0$]])(implicit m: Aux[T, R, U]): Eff[U, A]

Translate one effect of the stack into some of the other effects in the stack Using a natural transformation
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object Interpret | package eff

trait Interpret extends AnyRef

Type Members

trait StateRecurse[M[_], A, B] extends AnyRef

type of[F[_], G[_]] = AnyRef { type l[A] = F[G[A]] }

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def augment[R, T[_], O[_], A](eff: Eff[R, A])(w: Augment[T, O])(implicit m: MemberInOut[T, R]): Eff[prepend[O, R], A]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def intercept[R, M[_], A, B](pure: (A) ⇒ Eff[R, B], recurse: Recurse[M, R, B])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]

def intercept1[R, M[_], A, B](pure: (A) ⇒ B)(recurse: Recurse[M, R, B])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]

def interceptLoop[R, M[_], A, B](pure: (A) ⇒ Eff[R, B], loop: Loop[M, R, A, Eff[R, B], Eff[R, Unit]])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]

def interceptLoop1[R, M[_], A, B](pure: (A) ⇒ B)(loop: Loop[M, R, A, Eff[R, B], Eff[R, Unit]])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]

def interceptNat[R, T[_], A](effects: Eff[R, A])(nat: ~>[T, T])(implicit m: MemberInOut[T, R]): Eff[R, A]

def interceptNatM[R, T[_], F[_], A](effects: Eff[R, A], nat: ~>[T, [A]T[F[A]]])(implicit m: MemberInOut[T, R], FT: Traverse[F], FM: Monad[F]): Eff[R, F[A]]

def interceptStatelessLoop[R, M[_], A, B](pure: (A) ⇒ Eff[R, B], loop: StatelessLoop[M, R, A, Eff[R, B], Eff[R, Unit]])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]

def interceptStatelessLoop1[R, M[_], A, B](pure: (A) ⇒ B)(loop: StatelessLoop[M, R, A, Eff[R, B], Eff[R, Unit]])(effects: Eff[R, A])(implicit m: /=[M, R]): Eff[R, B]

def interpret[R, U, M[_], A, B](pure: (A) ⇒ Eff[U, B], recurse: Recurse[M, U, B])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

def interpret1[R, U, M[_], A, B](pure: (A) ⇒ B)(recurse: Recurse[M, U, B])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

def interpretLoop[R, U, M[_], A, B](pure: (A) ⇒ Eff[U, B], loop: Loop[M, R, A, Eff[U, B], Eff[U, Unit]])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

def interpretLoop1[R, U, M[_], A, B](pure: (A) ⇒ B)(loop: Loop[M, R, A, Eff[U, B], Eff[U, Unit]])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

def interpretState[R, U, M[_], A, B](pure: (A) ⇒ Eff[U, B], recurse: StateRecurse[M, A, B])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

def interpretState1[R, U, M[_], A, B](pure: (A) ⇒ B)(recurse: StateRecurse[M, A, B])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

def interpretStatelessLoop[R, U, M[_], A, B](pure: (A) ⇒ Eff[U, B], loop: StatelessLoop[M, R, A, Eff[U, B], Eff[U, Unit]])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

def interpretStatelessLoop1[R, U, M[_], A, B](pure: (A) ⇒ B)(loop: StatelessLoop[M, R, A, Eff[U, B], Eff[U, Unit]])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

def interpretUnsafe[R, U, T[_], A](effects: Eff[R, A])(sideEffect: SideEffect[T])(implicit m: Aux[T, R, U]): Eff[U, A]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def transform[SR, BR, U, TS[_], TB[_], A](r: Eff[SR, A], nat: ~>[TS, TB])(implicit sr: Aux[TS, SR, U], br: Aux[TB, BR, U]): Eff[BR, A]

def translate[R, U, T[_], A](effects: Eff[R, A])(tr: Translate[T, U])(implicit m: Aux[T, R, U]): Eff[U, A]

def translateInto[R, T[_], U, A](eff: Eff[R, A])(translate: Translate[T, U])(implicit m: MemberInOut[T, R], into: IntoPoly[R, U]): Eff[U, A]

def translateNat[R, U, T[_], A](effects: Eff[R, A])(nat: ~>[T, [β$0$]Eff[U, β$0$]])(implicit m: Aux[T, R, U]): Eff[U, A]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped