interpret

Type Members

trait Loop[M[_], R, A, B] extends AnyRef

Generalisation of Recurse and StateRecurse
Generalisation of Recurse and StateRecurse

Definition Classes
Interpret
trait Recurse[M[_], R, A] 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

Definition Classes
Interpret
trait SideEffect[T[_]] extends AnyRef

Definition Classes
Interpret
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[M |: R, A] returns an A, this one can be combined with the last state value to produce a B

Definition Classes
Interpret
trait Translate[T[_], U] extends AnyRef

trait for translating one effect into other ones in the same stack
trait for translating one effect into other ones in the same stack

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 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: Member[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: Member[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, S](pure: (A) ⇒ Eff[R, B], loop: Loop[M, R, A, Eff[R, B]])(effects: Eff[R, A])(implicit m: Member[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, S](pure: (A) ⇒ B)(loop: Loop[M, R, A, Eff[R, B]])(effects: Eff[R, A])(implicit m: Member[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 M |: R stack
interpret the effect M in the M |: 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, S](pure: (A) ⇒ Eff[U, B], loop: Loop[M, R, A, Eff[U, B]])(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, S](pure: (A) ⇒ B)(loop: Loop[M, R, A, Eff[U, B]])(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 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
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: NaturalTransformation[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
transform an effect into another one using a natural transformation

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
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 Doc: package eff

object interpret extends Interpret

Type Members

trait Loop[M[_], R, A, B] extends AnyRef

trait Recurse[M[_], R, A] extends AnyRef

trait SideEffect[T[_]] extends AnyRef

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

trait Translate[T[_], U] extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

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 intercept[R, M[_], A, B](pure: (A) ⇒ Eff[R, B], recurse: Recurse[M, R, B])(effects: Eff[R, A])(implicit m: Member[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: Member[M, R]): Eff[R, B]

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

def interceptLoop1[R, M[_], A, B, S](pure: (A) ⇒ B)(loop: Loop[M, R, A, Eff[R, B]])(effects: Eff[R, A])(implicit m: Member[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, S](pure: (A) ⇒ Eff[U, B], loop: Loop[M, R, A, Eff[U, B]])(effects: Eff[R, A])(implicit m: Aux[M, R, U]): Eff[U, B]

def interpretLoop1[R, U, M[_], A, B, S](pure: (A) ⇒ B)(loop: Loop[M, R, A, Eff[U, B]])(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 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: NaturalTransformation[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]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from Interpret

Inherited from AnyRef

Inherited from Any

Ungrouped