Interpret

Type Members

trait Loop[M[_], R <: Effects, 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 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

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

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

Definition Classes
Interpret
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]

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 <: Effects, M[_], A, B](pure: (A) ⇒ B)(recurse: StateRecurse[M, A, B])(effects: Eff[|:[M, R], A]): Eff[R, 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
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
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: trait Interpret | package eff

object Interpret extends Interpret

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: 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 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 Interpret

Inherited from AnyRef

Inherited from Any

Ungrouped