StateEffect

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
implicit def TaggedStateMemberFirst[R <: Effects, Tg, A]: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, Effects.|:[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R], R]

Definition Classes
StateImplicits
implicit def TaggedStateMemberSuccessor[O[_], R <: Effects, U <: Effects, Tg, A](implicit m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, Effects.|:[O, R], Effects.|:[O, U]]

Definition Classes
StateImplicits1
implicit def TaggedStateMemberZero[Tg, A]: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, Effects.|:[[X]AnyRef { ... /* 2 definitions in type refinement */ }, NoEffect], NoEffect]

Definition Classes
StateImplicits
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 evalState[R <: Effects, U <: Effects, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[X]IndexedStateT[[X]X, S, S, X], R, U]): Eff[U, A]

run a state effect, with an initial value, return only the value
run a state effect, with an initial value, return only the value

Definition Classes
StateInterpretation
def evalStateTagged[R <: Effects, U <: Effects, T, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, A]

run a state effect, with an initial value, return only the value
run a state effect, with an initial value, return only the value

Definition Classes
StateInterpretation
def evalStateZero[R <: Effects, U <: Effects, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]IndexedStateT[[X]X, S, S, X], R, U]): Eff[U, A]

run a state effect, with a Monoidal state
run a state effect, with a Monoidal state

Definition Classes
StateInterpretation
def evalStateZeroTagged[R <: Effects, U <: Effects, T, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, A]

run a state effect, with a Monoidal state
run a state effect, with a Monoidal state

Definition Classes
StateInterpretation
def execState[R <: Effects, U <: Effects, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[X]IndexedStateT[[X]X, S, S, X], R, U]): Eff[U, S]

run a state effect, with an initial value, return only the state
run a state effect, with an initial value, return only the state

Definition Classes
StateInterpretation
def execStateTagged[R <: Effects, U <: Effects, T, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, S]

run a state effect, with an initial value, return only the state
run a state effect, with an initial value, return only the state

Definition Classes
StateInterpretation
def execStateZero[R <: Effects, U <: Effects, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]IndexedStateT[[X]X, S, S, X], R, U]): Eff[U, S]

run a state effect, with a monoidal state, return only the state
run a state effect, with a monoidal state, return only the state

Definition Classes
StateInterpretation
def execStateZeroTagged[R <: Effects, U <: Effects, T, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, S]

run a state effect, with a monoidal state, return only the state
run a state effect, with a monoidal state, return only the state

Definition Classes
StateInterpretation
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def get[R, S](implicit member: Member[[X]IndexedStateT[[X]X, S, S, X], R]): Eff[R, S]

get the current state value
get the current state value

Definition Classes
StateCreation
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getTagged[R, T, S](implicit member: Member[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R]): Eff[R, S]

get the current state value
get the current state value

Definition Classes
StateCreation
def gets[R, S, T](f: (S) ⇒ T)(implicit member: Member[[X]IndexedStateT[[X]X, S, S, X], R]): Eff[R, T]

get the current state value and map it with a function f
get the current state value and map it with a function f

Definition Classes
StateCreation
def getsTagged[R, U, S, T](f: (S) ⇒ T)(implicit member: Member[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R]): Eff[R, T]

get the current state value and map it with a function f
get the current state value and map it with a function f

Definition Classes
StateCreation
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lensState[TS, SS, U, T, S, A](state: Eff[TS, A], getter: (S) ⇒ T, setter: (S, T) ⇒ S)(implicit ts: Aux[[X]IndexedStateT[[X]X, T, T, X], TS, U], ss: Aux[[X]IndexedStateT[[X]X, S, S, X], SS, U]): Eff[SS, A]

Lift a computation over a "small" state (for a subsystem) into a computation over a "bigger" state (for the full application state)
Lift a computation over a "small" state (for a subsystem) into a computation over a "bigger" state (for the full application state)

Definition Classes
StateInterpretation
def modify[R, S](f: (S) ⇒ S)(implicit member: Member[[X]IndexedStateT[[X]X, S, S, X], R]): Eff[R, Unit]

modify the current state value
modify the current state value

Definition Classes
StateCreation
def modifyTagged[R, T, S](f: (S) ⇒ S)(implicit member: Member[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R]): Eff[R, Unit]

modify the current state value
modify the current state value

Definition Classes
StateCreation
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def put[R, S](s: S)(implicit member: Member[[X]IndexedStateT[[X]X, S, S, X], R]): Eff[R, Unit]

store a new state value
store a new state value

Definition Classes
StateCreation
def putTagged[R, T, S](s: S)(implicit member: Member[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R]): Eff[R, Unit]

store a new state value
store a new state value

Definition Classes
StateCreation
def runState[R <: Effects, U <: Effects, S1, A](initial: S1)(w: Eff[R, A])(implicit m: Aux[[X]IndexedStateT[[X]X, S1, S1, X], R, U]): Eff[U, (A, S1)]

run a state effect, with an initial value
run a state effect, with an initial value

Definition Classes
StateInterpretation
def runStateTagged[R <: Effects, U <: Effects, T, S1, A](initial: S1)(w: Eff[R, A])(implicit m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, (A, S1)]

run a tagged state effect, with an initial value
run a tagged state effect, with an initial value

Definition Classes
StateInterpretation
def runStateZero[R <: Effects, U <: Effects, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]IndexedStateT[[X]X, S, S, X], R, U]): Eff[U, (A, S)]

run a state effect, with an initial value
run a state effect, with an initial value

Definition Classes
StateInterpretation
def runStateZeroTagged[R <: Effects, U <: Effects, T, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, (A, S)]

run a state effect, with an initial value
run a state effect, with an initial value

Definition Classes
StateInterpretation
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 StateEffect | package eff

object StateEffect extends StateEffect

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit def TaggedStateMemberFirst[R <: Effects, Tg, A]: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, Effects.|:[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R], R]

implicit def TaggedStateMemberSuccessor[O[_], R <: Effects, U <: Effects, Tg, A](implicit m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, Effects.|:[O, R], Effects.|:[O, U]]

implicit def TaggedStateMemberZero[Tg, A]: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, Effects.|:[[X]AnyRef { ... /* 2 definitions in type refinement */ }, NoEffect], NoEffect]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evalState[R <: Effects, U <: Effects, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[X]IndexedStateT[[X]X, S, S, X], R, U]): Eff[U, A]

def evalStateTagged[R <: Effects, U <: Effects, T, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, A]

def evalStateZero[R <: Effects, U <: Effects, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]IndexedStateT[[X]X, S, S, X], R, U]): Eff[U, A]

def evalStateZeroTagged[R <: Effects, U <: Effects, T, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, A]

def execState[R <: Effects, U <: Effects, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[X]IndexedStateT[[X]X, S, S, X], R, U]): Eff[U, S]

def execStateTagged[R <: Effects, U <: Effects, T, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, S]

def execStateZero[R <: Effects, U <: Effects, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]IndexedStateT[[X]X, S, S, X], R, U]): Eff[U, S]

def execStateZeroTagged[R <: Effects, U <: Effects, T, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, S]

def finalize(): Unit

def get[R, S](implicit member: Member[[X]IndexedStateT[[X]X, S, S, X], R]): Eff[R, S]

final def getClass(): Class[_]

def getTagged[R, T, S](implicit member: Member[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R]): Eff[R, S]

def gets[R, S, T](f: (S) ⇒ T)(implicit member: Member[[X]IndexedStateT[[X]X, S, S, X], R]): Eff[R, T]

def getsTagged[R, U, S, T](f: (S) ⇒ T)(implicit member: Member[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R]): Eff[R, T]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def lensState[TS, SS, U, T, S, A](state: Eff[TS, A], getter: (S) ⇒ T, setter: (S, T) ⇒ S)(implicit ts: Aux[[X]IndexedStateT[[X]X, T, T, X], TS, U], ss: Aux[[X]IndexedStateT[[X]X, S, S, X], SS, U]): Eff[SS, A]

def modify[R, S](f: (S) ⇒ S)(implicit member: Member[[X]IndexedStateT[[X]X, S, S, X], R]): Eff[R, Unit]

def modifyTagged[R, T, S](f: (S) ⇒ S)(implicit member: Member[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R]): Eff[R, Unit]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def put[R, S](s: S)(implicit member: Member[[X]IndexedStateT[[X]X, S, S, X], R]): Eff[R, Unit]

def putTagged[R, T, S](s: S)(implicit member: Member[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R]): Eff[R, Unit]

def runState[R <: Effects, U <: Effects, S1, A](initial: S1)(w: Eff[R, A])(implicit m: Aux[[X]IndexedStateT[[X]X, S1, S1, X], R, U]): Eff[U, (A, S1)]

def runStateTagged[R <: Effects, U <: Effects, T, S1, A](initial: S1)(w: Eff[R, A])(implicit m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, (A, S1)]

def runStateZero[R <: Effects, U <: Effects, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]IndexedStateT[[X]X, S, S, X], R, U]): Eff[U, (A, S)]

def runStateZeroTagged[R <: Effects, U <: Effects, T, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement */ }, R, U]): Eff[U, (A, S)]

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 StateEffect

Inherited from StateImplicits

Inherited from StateImplicits1

Inherited from StateInterpretation

Inherited from StateCreation

Inherited from AnyRef

Inherited from Any

Ungrouped

implicit def TaggedStateMemberFirst[R <: Effects, Tg, A]: Aux[[X]AnyRef { ... /* 2 definitions in type refinement / }, Effects.|:[[X]AnyRef { ... / 2 definitions in type refinement */ }, R], R]

implicit def TaggedStateMemberSuccessor[O[_], R <: Effects, U <: Effects, Tg, A](implicit m: Aux[[X]AnyRef { ... /* 2 definitions in type refinement / }, R, U]): Aux[[X]AnyRef { ... / 2 definitions in type refinement */ }, Effects.|:[O, R], Effects.|:[O, U]]

implicit def TaggedStateMemberZero[Tg, A]: Aux[[X]AnyRef { ... /* 2 definitions in type refinement / }, Effects.|:[[X]AnyRef { ... / 2 definitions in type refinement */ }, NoEffect], NoEffect]