object Eff extends EffCreation with EffInterpretation with EffImplicits
- Source
- Eff.scala
- Alphabetic
- By Inheritance
- Eff
- EffImplicits
- EffInterpretation
- EffCreation
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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[[β$8$]Eff[R, β$8$]]
- Definition Classes
- EffImplicits
-
implicit final
def
EffMonad[R]: Monad[[β$6$]Eff[R, β$6$]]
- 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[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
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
-
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
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] )
-
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
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
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
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
pure[R, A](a: A): Eff[R, A]
create a pure value
create a pure value
- Definition Classes
- EffCreation
-
def
retryUntil[R, A](e: Eff[R, A], condition: (A) ⇒ Boolean, durations: List[FiniteDuration], waitFor: (FiniteDuration) ⇒ Eff[R, Unit]): Eff[R, A]
- 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( ... ) @native()
-
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
Deprecated Value Members
-
final
def
effApplicativeUnsafe: Applicative[[β$3$]Eff[AnyRef, β$3$]]
- Definition Classes
- EffImplicits
- Annotations
- @deprecated
- Deprecated
(Since version ) use EffApplicative
-
final
def
effMonadUnsafe: Monad[[β$0$]Eff[AnyRef, β$0$]]
- Definition Classes
- EffImplicits
- Annotations
- @deprecated
- Deprecated
(Since version ) use EffMonad