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
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 stacksafe behaviour when running on a large list of effects (in list.traverse(f) for example).
There are different types of supported interpreters:
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