object Interpret extends Interpret
- Alphabetic
- By Inheritance
- Interpret
- Interpret
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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
- Definition Classes
- Interpret
-
type
of[F[_], G[_]] = AnyRef { type l[A] = F[G[A]] }
- Definition Classes
- Interpret
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]
- Definition Classes
- Interpret
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
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
INTERPRET IN THE SAME STACK
- Definition Classes
- Interpret
-
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
simpler version of intercept where the pure value is just mapped to another type
- Definition Classes
- Interpret
-
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
- Definition Classes
- Interpret
-
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]
- Definition Classes
- Interpret
-
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
Intercept the values for one effect and transform them into other values for the same effect
- Definition Classes
- Interpret
-
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
Intercept the values for one effect, emitting new values for the same effect inside a monad which is interleaved in
- Definition Classes
- Interpret
-
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]
- Definition Classes
- Interpret
-
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]
- Definition Classes
- Interpret
-
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
interpret the effect M in the R stack
- Definition Classes
- Interpret
-
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
simpler version of interpret where the pure value is just mapped to another type
- Definition Classes
- Interpret
-
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
- Definition Classes
- Interpret
-
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]
- Definition Classes
- Interpret
-
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
interpret the effect M in the M |: R stack, keeping track of some state
- Definition Classes
- Interpret
-
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
simpler version of interpret1 where the pure value is just mapped to another type
- Definition Classes
- Interpret
-
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
- Definition Classes
- Interpret
-
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]
- Definition Classes
- Interpret
-
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
interpret an effect by running side-effects
- Definition Classes
- Interpret
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
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
transform an effect into another one using a natural transformation, leaving the rest of the stack untouched
- Definition Classes
- Interpret
-
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
Translate one effect of the stack into some of the other effects in the stack
- Definition Classes
- Interpret
-
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
Translate one effect of the stack into other effects in a larger stack
- Definition Classes
- Interpret
-
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
Translate one effect of the stack into some of the other effects in the stack Using a natural transformation
- Definition Classes
- Interpret
-
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( ... ) @native()