trait
Interpret extends AnyRef
Type Members
-
trait
Loop[M[_], R <: Effects, A, B] extends AnyRef
-
trait
Recurse[M[_], R, A] extends AnyRef
-
trait
StateRecurse[M[_], A, B] extends AnyRef
Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
final
def
asInstanceOf[T0]: T0
-
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
interpret[R <: Effects, M[_], A, B](pure: (A) ⇒ Eff[R, B], recurse: Recurse[M, R, B])(effects: Eff[|:[M, R], A]): Eff[R, B]
-
def
interpret1[R <: Effects, M[_], A, B](pure: (A) ⇒ B)(recurse: Recurse[M, R, B])(effects: Eff[|:[M, R], A]): Eff[R, B]
-
def
interpretLoop[R <: Effects, M[_], A, B, S](pure: (A) ⇒ Eff[R, B], loop: Loop[M, R, A, Eff[R, B]])(effects: Eff[|:[M, R], A]): Eff[R, B]
-
def
interpretLoop1[R <: Effects, M[_], A, B, S](pure: (A) ⇒ B)(loop: Loop[M, R, A, Eff[R, B]])(effects: Eff[|:[M, R], A]): Eff[R, B]
-
def
interpretState[R <: Effects, M[_], A, B](pure: (A) ⇒ Eff[R, B], recurse: StateRecurse[M, A, B])(effects: Eff[|:[M, R], A]): Eff[R, B]
-
def
interpretState1[R <: Effects, M[_], A, B](pure: (A) ⇒ B)(recurse: StateRecurse[M, A, B])(effects: Eff[|:[M, R], A]): Eff[R, B]
-
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
-
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 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:
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)