Eff

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 EffApplicative[R]: Applicative[[β$6$]Eff[R, β$6$]]

Definition Classes
EffImplicits
implicit final def EffMonad[R]: Monad[[β$4$]Eff[R, β$4$]]

Definition Classes
EffImplicits
def ap[R, A, B](a: Eff[R, A])(f: Eff[R, (A) ⇒ B]): Eff[R, B]

apply a function to an Eff value using the applicative instance
apply a function to an Eff value using the applicative instance

Definition Classes
EffCreation
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bracketLast[R, A, B, C](acquire: Eff[R, A])(use: (A) ⇒ Eff[R, B])(release: (A) ⇒ Eff[R, C]): Eff[R, B]

bracket an action with one last action to execute at the end of the program
bracket an action with one last action to execute at the end of the program

Definition Classes
EffCreation
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collapse[R, M[_], A](r: Eff[R, M[A]])(implicit m: |=[M, R]): Eff[R, A]

use the internal effect as one of the stack effects
use the internal effect as one of the stack effects

Definition Classes
EffCreation
def detach[M[_], A, E](eff: Eff[Fx1[M], A])(implicit monad: MonadError[M, E]): M[A]

peel-off the only present effect
peel-off the only present effect

Definition Classes
EffInterpretation
def detach[M[_], R, A, E](eff: Eff[R, A])(implicit monad: MonadError[M, E], m: Aux[M, R, NoFx]): M[A]

peel-off the only present effect
peel-off the only present effect

Definition Classes
EffInterpretation
def detachA[M[_], A, E](eff: Eff[Fx1[M], A])(implicit monad: MonadError[M, E], applicative: Applicative[M]): M[A]

peel-off the only present effect, using an Applicative instance where possible
peel-off the only present effect, using an Applicative instance where possible

Definition Classes
EffInterpretation
def detachA[M[_], R, A, E](eff: Eff[R, A])(implicit monad: MonadError[M, E], applicative: Applicative[M], member: Aux[M, R, NoFx]): M[A]

peel-off the only present effect, using an Applicative instance where possible
peel-off the only present effect, using an Applicative instance where possible

Definition Classes
EffInterpretation
final val effApplicativeUnsafe: Applicative[[β$2$]Eff[AnyRef, β$2$]]

Definition Classes
EffImplicits
def effInto[R, U, A](e: Eff[R, A])(implicit f: IntoPoly[R, U]): Eff[U, A]

An Eff[R, A] value can be transformed into an Eff[U, A] value provided that all the effects in R are also in U
An Eff[R, A] value can be transformed into an Eff[U, A] value provided that all the effects in R are also in U

Definition Classes
EffInterpretation
final val effMonadUnsafe: Monad[[β$0$]Eff[AnyRef, β$0$]]

Monad implementation for the Eff[R, ?] type
Monad implementation for the Eff[R, ?] type

Definition Classes
EffImplicits
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] )
def flatSequenceA[R, F[_], A](fs: F[Eff[R, F[A]]])(implicit FT: Traverse[F], FM: FlatMap[F]): Eff[R, F[A]]

use the applicative instance of Eff to sequence a list of values, then flatten it
use the applicative instance of Eff to sequence a list of values, then flatten it

Definition Classes
EffCreation
def flatTraverseA[R, F[_], A, B](fs: F[A])(f: (A) ⇒ Eff[R, F[B]])(implicit FT: Traverse[F], FM: FlatMap[F]): Eff[R, F[B]]

use the applicative instance of Eff to traverse a list of values, then flatten it
use the applicative instance of Eff to traverse a list of values, then flatten it

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

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def impure[R, A, B](value: A, continuation: Continuation[R, A, B], map: (B) ⇒ B): Eff[R, B]

create a delayed impure value
create a delayed impure value

Definition Classes
EffCreation
def impure[R, A, B](value: A, continuation: Continuation[R, A, B]): Eff[R, B]

create a delayed impure value
create a delayed impure value

Definition Classes
EffCreation
def impure[R, X, A](union: Union[R, X], continuation: Continuation[R, X, A]): Eff[R, A]

create a impure value from an union of effects and a continuation
create a impure value from an union of effects and a continuation

Definition Classes
EffCreation
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def memoizeEffect[R, M[_], A](e: Eff[R, A], cache: Cache, key: AnyRef)(implicit member: /=[M, R], cached: SequenceCached[M]): Eff[R, A]

Memoize an effect using a cache
Memoize an effect using a cache
all the consecutive effects M[X] leading to the computation of Eff[R, A] will be cached in the cache and retrieved from there if the Eff[R, A] computation is executed again

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def pure[R, A](a: A): Eff[R, A]

create a pure value
create a pure value

Definition Classes
EffCreation
def run[A](eff: Eff[NoFx, A]): A

base runner for an Eff value having no effects at all the execution is trampolined using Eval
base runner for an Eff value having no effects at all the execution is trampolined using Eval

Definition Classes
EffInterpretation
def runPure[R, A](eff: Eff[R, A]): Option[A]

get the pure value if there is no effect
get the pure value if there is no effect

Definition Classes
EffInterpretation
def send[T[_], R, V](tv: T[V])(implicit member: |=[T, R]): Eff[R, V]

create an Eff[R, A] value from an effectful value of type T[V] provided that T is one of the effects of R
create an Eff[R, A] value from an effectful value of type T[V] provided that T is one of the effects of R

Definition Classes
EffCreation
def sequenceA[R, F[_], A](fs: F[Eff[R, A]])(implicit arg0: Traverse[F]): Eff[R, F[A]]

use the applicative instance of Eff to sequence a list of values
use the applicative instance of Eff to sequence a list of values

Definition Classes
EffCreation
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def traverseA[R, F[_], A, B](fs: F[A])(f: (A) ⇒ Eff[R, B])(implicit arg0: Traverse[F]): Eff[R, F[B]]

use the applicative instance of Eff to traverse a list of values
use the applicative instance of Eff to traverse a list of values

Definition Classes
EffCreation
def unit[R]: Eff[R, Unit]

create an Eff value for ()
create an Eff value for ()

Definition Classes
EffCreation
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( ... )
def whenStopped[R, A](e: Eff[R, A], action: Last[R]): Eff[R, A]

attach a clean-up action to the continuation (if any)
attach a clean-up action to the continuation (if any)

Definition Classes
EffCreation

Related Docs: trait Eff | package eff

object Eff extends EffCreation with EffInterpretation with EffImplicits

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def EffApplicative[R]: Applicative[[β$6$]Eff[R, β$6$]]

implicit final def EffMonad[R]: Monad[[β$4$]Eff[R, β$4$]]

def ap[R, A, B](a: Eff[R, A])(f: Eff[R, (A) ⇒ B]): Eff[R, B]

final def asInstanceOf[T0]: T0

def bracketLast[R, A, B, C](acquire: Eff[R, A])(use: (A) ⇒ Eff[R, B])(release: (A) ⇒ Eff[R, C]): Eff[R, B]

def clone(): AnyRef

def collapse[R, M[_], A](r: Eff[R, M[A]])(implicit m: |=[M, R]): Eff[R, A]

def detach[M[_], A, E](eff: Eff[Fx1[M], A])(implicit monad: MonadError[M, E]): M[A]

def detach[M[_], R, A, E](eff: Eff[R, A])(implicit monad: MonadError[M, E], m: Aux[M, R, NoFx]): M[A]

def detachA[M[_], A, E](eff: Eff[Fx1[M], A])(implicit monad: MonadError[M, E], applicative: Applicative[M]): M[A]

def detachA[M[_], R, A, E](eff: Eff[R, A])(implicit monad: MonadError[M, E], applicative: Applicative[M], member: Aux[M, R, NoFx]): M[A]

final val effApplicativeUnsafe: Applicative[[β$2$]Eff[AnyRef, β$2$]]

def effInto[R, U, A](e: Eff[R, A])(implicit f: IntoPoly[R, U]): Eff[U, A]

final val effMonadUnsafe: Monad[[β$0$]Eff[AnyRef, β$0$]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatSequenceA[R, F[_], A](fs: F[Eff[R, F[A]]])(implicit FT: Traverse[F], FM: FlatMap[F]): Eff[R, F[A]]

def flatTraverseA[R, F[_], A, B](fs: F[A])(f: (A) ⇒ Eff[R, F[B]])(implicit FT: Traverse[F], FM: FlatMap[F]): Eff[R, F[B]]

final def getClass(): Class[_]

def hashCode(): Int

def impure[R, A, B](value: A, continuation: Continuation[R, A, B], map: (B) ⇒ B): Eff[R, B]

def impure[R, A, B](value: A, continuation: Continuation[R, A, B]): Eff[R, B]

def impure[R, X, A](union: Union[R, X], continuation: Continuation[R, X, A]): Eff[R, A]

final def isInstanceOf[T0]: Boolean

def memoizeEffect[R, M[_], A](e: Eff[R, A], cache: Cache, key: AnyRef)(implicit member: /=[M, R], cached: SequenceCached[M]): Eff[R, A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pure[R, A](a: A): Eff[R, A]

def run[A](eff: Eff[NoFx, A]): A

def runPure[R, A](eff: Eff[R, A]): Option[A]

def send[T[_], R, V](tv: T[V])(implicit member: |=[T, R]): Eff[R, V]

def sequenceA[R, F[_], A](fs: F[Eff[R, A]])(implicit arg0: Traverse[F]): Eff[R, F[A]]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def traverseA[R, F[_], A, B](fs: F[A])(f: (A) ⇒ Eff[R, B])(implicit arg0: Traverse[F]): Eff[R, F[B]]

def unit[R]: Eff[R, Unit]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def whenStopped[R, A](e: Eff[R, A], action: Last[R]): Eff[R, A]

Inherited from EffImplicits

Inherited from EffInterpretation

Inherited from EffCreation

Inherited from AnyRef

Inherited from Any

Ungrouped