Packages

object all extends ReaderEffect with WriterEffect with StateEffect with EvalEffect with OptionEffect with ListEffect with EitherEffect with ValidateEffect with ChooseEffect with SafeEffect with MemoEffect with Batch with EffInterpretation with EffCreation with EffImplicits

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. all
  2. EffImplicits
  3. EffCreation
  4. EffInterpretation
  5. Batch
  6. MemoEffect
  7. MemoInterpretation
  8. MemoCreation
  9. MemoTypes
  10. SafeEffect
  11. SafeInterpretation
  12. SafeCreation
  13. SafeTypes
  14. ChooseEffect
  15. ChooseInterpretation
  16. ChooseCreation
  17. ValidateEffect
  18. ValidateInterpretation
  19. ValidateCreation
  20. EitherEffect
  21. EitherInterpretation
  22. EitherCreation
  23. ListEffect
  24. ListInterpretation
  25. ListCreation
  26. OptionEffect
  27. OptionInterpretation
  28. OptionCreation
  29. EvalEffect
  30. EvalInterpretation
  31. EvalCreation
  32. EvalTypes
  33. StateEffect
  34. StateInterpretation
  35. StateCreation
  36. WriterEffect
  37. WriterInterpretation
  38. WriterCreation
  39. ReaderEffect
  40. ReaderInterpretation
  41. ReaderCreation
  42. AnyRef
  43. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type Out[A] = (EitherEffect.ThrowableEither[A], List[Throwable])
    Definition Classes
    SafeInterpretation
  2. type ThrowableEither[A] = Either[Throwable, A]
    Definition Classes
    EitherCreation
  3. type _Choose[R] = Member[Choose, R]
    Definition Classes
    ChooseCreation
  4. type _Eval[R] = Member[Eval, R]
    Definition Classes
    EvalTypes
  5. type _List[R] = Member[List, R]
    Definition Classes
    ListCreation
  6. type _Memo[R] = Member[Memoized, R]
    Definition Classes
    MemoTypes
  7. type _Option[R] = Member[Option, R]
    Definition Classes
    OptionCreation
  8. type _Safe[R] = Member[Safe, R]
    Definition Classes
    SafeTypes
  9. type _ThrowableEither[R] = Member[ThrowableEither, R]
    Definition Classes
    EitherCreation
  10. type _choose[R] = MemberIn[Choose, R]
    Definition Classes
    ChooseCreation
  11. type _eval[R] = MemberIn[Eval, R]
    Definition Classes
    EvalTypes
  12. type _list[R] = MemberIn[List, R]
    Definition Classes
    ListCreation
  13. type _memo[R] = MemberIn[Memoized, R]
    Definition Classes
    MemoTypes
  14. type _option[R] = MemberIn[Option, R]
    Definition Classes
    OptionCreation
  15. type _safe[R] = MemberIn[Safe, R]
    Definition Classes
    SafeTypes
  16. type _throwableEither[R] = MemberIn[ThrowableEither, R]
    Definition Classes
    EitherCreation

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def EffApplicative[R]: Applicative[[β$6$]Eff[R, β$6$]]
    Definition Classes
    EffImplicits
  5. implicit final def EffMonad[R]: Monad[[β$4$]Eff[R, β$4$]]
    Definition Classes
    EffImplicits
  6. def EitherApplicative[E](implicit s: Semigroup[E]): Applicative[[β$33$]Either[E, β$33$]]
    Definition Classes
    EitherInterpretation
  7. def EvalFold[A](f: (A) ⇒ Eval[Unit]): RightFold[A, Eval[Unit]]
    Definition Classes
    WriterInterpretation
  8. def IntoMonoidFold[M, A](f: (A) ⇒ M)(implicit arg0: Monoid[M]): RightFold[A, M]
    Definition Classes
    WriterInterpretation
  9. implicit def ListFold[A]: RightFold[A, List[A]]
    Definition Classes
    WriterInterpretation
  10. def MonoidFold[A](implicit arg0: Monoid[A]): RightFold[A, A]
    Definition Classes
    WriterInterpretation
  11. 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
  12. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  13. def ask[R, T](implicit member: |=[[β$0$]Kleisli[[A]A, T, β$0$], R]): Eff[R, T]

    get the environment

    get the environment

    Definition Classes
    ReaderCreation
  14. def attempt[R, A](action: Eff[R, A])(implicit m: /=[Safe, R]): Eff[R, Either[Throwable, A]]

    try to execute an action an report any issue

    try to execute an action an report any issue

    Definition Classes
    SafeInterpretation
  15. def attemptEither[R, E, A](effect: Eff[R, A])(implicit member: /=[[β$12$]Either[E, β$12$], R]): Eff[R, Either[E, A]]

    catch possible left values

    catch possible left values

    Definition Classes
    EitherInterpretation
  16. def attemptEval[R, U, A](effect: Eff[R, A])(implicit m: Aux[Eval, R, U]): Eff[U, Either[Throwable, A]]
    Definition Classes
    EvalInterpretation
  17. def attemptSafe[R, A](effect: Eff[R, A])(implicit m: /=[Safe, R]): Eff[R, (EitherEffect.ThrowableEither[A], List[Throwable])]

    Attempt to execute a safe action including finalizers

    Attempt to execute a safe action including finalizers

    Definition Classes
    SafeInterpretation
  18. def batch[R, T[_], A](eff: Eff[R, A])(implicit batchable: Batchable[T], m: /=[T, R]): Eff[R, A]
    Definition Classes
    Batch
  19. def bracket[R, A, B, C](acquire: Eff[R, A])(use: (A) ⇒ Eff[R, B])(release: (A) ⇒ Eff[R, C])(implicit m: /=[Safe, R]): Eff[R, B]

    get a resource A and use it.

    get a resource A and use it. Call the release function whether an exception is thrown or not when using the resource

    NOTE: Eff interpreters are independent so if there is an effect short-circuiting all computations inside 'use', like Option or Either then the release function will not be called. If you want to make sure that the release function is always called "at the end of the world and whatever happens" you need to call Eff.bracketLast

    Definition Classes
    SafeInterpretation
  20. 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
  21. def catchLeft[R, E, A](effect: Eff[R, A])(handle: (E) ⇒ Eff[R, A])(implicit member: /=[[β$13$]Either[E, β$13$], R]): Eff[R, A]

    catch and handle a possible left value

    catch and handle a possible left value

    Definition Classes
    EitherInterpretation
  22. def catchLeftCombine[R, E, A](effect: Eff[R, A])(handle: (E) ⇒ Eff[R, A])(implicit member: /=[[β$15$]Either[E, β$15$], R], s: Semigroup[E]): Eff[R, A]

    catch and handle a possible left value.

    catch and handle a possible left value. The value is the combination of all failures in case of an applicative

    Definition Classes
    EitherInterpretation
  23. def catchNonFatalThrowable[R, A](a: ⇒ A)(implicit member: |=[[β$7$]Either[Throwable, β$7$], R]): Eff[R, A]

    create an Either effect from a value possibly throwing a Throwable

    create an Either effect from a value possibly throwing a Throwable

    Definition Classes
    EitherCreation
  24. def catchThrowable[R, A, B](action: Eff[R, A], pureValue: (A) ⇒ B, onThrowable: (Throwable) ⇒ Eff[R, B])(implicit m: /=[Safe, R]): Eff[R, B]

    evaluate first action possibly having error effects

    evaluate first action possibly having error effects

    Execute a second action if the first one is not successful, based on the error

    Definition Classes
    SafeInterpretation
  25. def catchWrong[R, E, A](effect: Eff[R, A])(handle: (E) ⇒ Eff[R, A])(implicit member: <=[[β$12$]Validate[E, β$12$], R]): Eff[R, A]

    catch and handle possible wrong values

    catch and handle possible wrong values

    Definition Classes
    ValidateInterpretation
  26. def chooseFrom[R, A](as: List[A])(implicit arg0: _choose[R]): Eff[R, A]
    Definition Classes
    ChooseCreation
  27. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  28. 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
  29. def correct[R, E, A](a: A)(implicit m: |=[[β$4$]Validate[E, β$4$], R]): Eff[R, A]

    create a correct value

    create a correct value

    Definition Classes
    ValidateCreation
  30. def defer[R, A](eff: ⇒ Eval[Eff[R, A]])(implicit arg0: _eval[R]): Eff[R, A]
    Definition Classes
    EvalCreation
  31. def delay[R, A](a: ⇒ A)(implicit arg0: _eval[R]): Eff[R, A]
    Definition Classes
    EvalCreation
  32. 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
  33. 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
  34. 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
  35. 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
  36. final val effApplicativeUnsafe: Applicative[[β$2$]Eff[AnyRef, β$2$]]
    Definition Classes
    EffImplicits
  37. 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
  38. 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
  39. def empty[R, A](implicit arg0: _list[R]): Eff[R, A]

    create a list effect with no values

    create a list effect with no values

    Definition Classes
    ListCreation
  40. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  41. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  42. def eval[R, A](a: Eval[A])(implicit arg0: _safe[R]): Eff[R, A]
    Definition Classes
    SafeCreation
  43. def evalState[R, U, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[β$19$]StateT[Eval, S, β$19$], 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
  44. def evalStateZero[R, U, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[β$18$]StateT[Eval, S, β$18$], R, U]): Eff[U, A]

    run a state effect, with a Monoidal state

    run a state effect, with a Monoidal state

    Definition Classes
    StateInterpretation
  45. def exception[R, A](t: Throwable)(implicit arg0: _safe[R]): Eff[R, A]
    Definition Classes
    SafeCreation
  46. def execSafe[R, U, A](r: Eff[R, A])(implicit m: Aux[Safe, R, U]): Eff[U, EitherEffect.ThrowableEither[A]]

    run a safe effect but drop the finalizer errors

    run a safe effect but drop the finalizer errors

    Definition Classes
    SafeInterpretation
  47. def execState[R, U, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[β$21$]StateT[Eval, S, β$21$], 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
  48. def execStateZero[R, U, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[β$20$]StateT[Eval, S, β$20$], 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
  49. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  50. def finalizerException[R](t: Throwable)(implicit arg0: _safe[R]): Eff[R, Unit]
    Definition Classes
    SafeCreation
  51. 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
  52. 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
  53. def fromCatchNonFatal[R, E, A](a: ⇒ A)(onThrowable: (Throwable) ⇒ E)(implicit member: |=[[β$6$]Either[E, β$6$], R]): Eff[R, A]

    create an Either effect from a value possibly throwing an exception

    create an Either effect from a value possibly throwing an exception

    Definition Classes
    EitherCreation
  54. def fromEither[R, E, A](Either: Either[E, A])(implicit member: |=[[β$1$]Either[E, β$1$], R]): Eff[R, A]

    create an Either effect from a single Either value

    create an Either effect from a single Either value

    Definition Classes
    EitherCreation
  55. def fromList[R, A](as: List[A])(implicit arg0: _list[R]): Eff[R, A]

    create a list effect from a list of values

    create a list effect from a list of values

    Definition Classes
    ListCreation
  56. def fromOption[R, A](o: Option[A])(implicit arg0: _option[R]): Eff[R, A]

    create an Option effect from a single Option value

    create an Option effect from a single Option value

    Definition Classes
    OptionCreation
  57. def get[R, S](implicit member: |=[[β$2$]StateT[Eval, S, β$2$], R]): Eff[R, S]

    get the current state value

    get the current state value

    Definition Classes
    StateCreation
  58. def getCache[R](implicit arg0: _memo[R]): Eff[R, Cache]
    Definition Classes
    MemoCreation
  59. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  60. def gets[R, S, T](f: (S) ⇒ T)(implicit member: |=[[β$4$]StateT[Eval, S, β$4$], 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
  61. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  62. def ignoreException[R, E <: Throwable, A](action: Eff[R, A])(implicit arg0: ClassTag[E], m: /=[Safe, R]): Eff[R, Unit]

    ignore one possible exception that could be thrown

    ignore one possible exception that could be thrown

    Definition Classes
    SafeInterpretation
  63. 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
  64. 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
  65. 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
  66. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  67. def left[R, E, A](e: E)(implicit member: |=[[β$2$]Either[E, β$2$], R]): Eff[R, A]

    create a failed value

    create a failed value

    Definition Classes
    EitherCreation
  68. def lensState[TS, SS, U, T, S, A](state: Eff[TS, A], getter: (S) ⇒ T, setter: (S, T) ⇒ S)(implicit ts: Aux[[β$26$]StateT[Eval, T, β$26$], TS, U], ss: Aux[[β$27$]StateT[Eval, S, β$27$], 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
  69. def local[R, T, U](f: (T) ⇒ U)(implicit member: |=[[β$1$]Kleisli[[A]A, T, β$1$], R]): Eff[R, U]

    modify the environment

    modify the environment

    Definition Classes
    ReaderCreation
  70. def localEither[R, E, A](e: Eff[R, A])(modify: (E) ⇒ E)(implicit m: /=[[β$30$]Either[E, β$30$], R]): Eff[R, A]

    Update the error value, the stack of the Eff computation stays the same

    Update the error value, the stack of the Eff computation stays the same

    Definition Classes
    EitherInterpretation
  71. def localKleisli[R, T, U, F[_]](f: (T) ⇒ F[U])(implicit member: |=[[γ$3$]Kleisli[F, T, γ$3$], R]): Eff[R, U]

    modify the environment using a Kleisli[F, T, ?]

    modify the environment using a Kleisli[F, T, ?]

    Definition Classes
    ReaderCreation
  72. def localReader[R, T, A](e: Eff[R, A])(modify: (T) ⇒ T)(implicit r: /=[[β$17$]Kleisli[[A]A, T, β$17$], R]): Eff[R, A]

    Update the read value, the stack of the Eff computation stays the same

    Update the read value, the stack of the Eff computation stays the same

    Definition Classes
    ReaderInterpretation
  73. def localState[R, S, A](e: Eff[R, A])(modify: (S) ⇒ S)(implicit s: /=[[β$32$]StateT[Eval, S, β$32$], R]): Eff[R, A]

    Update the state value, the stack of the Eff computation stays the same

    Update the state value, the stack of the Eff computation stays the same

    Definition Classes
    StateInterpretation
  74. def memoize[R, A](key: AnyRef, a: ⇒ A)(implicit arg0: _memo[R]): Eff[R, A]
    Definition Classes
    MemoCreation
  75. 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
  76. def modify[R, S](f: (S) ⇒ S)(implicit member: |=[[β$6$]StateT[Eval, S, β$6$], R]): Eff[R, Unit]

    modify the current state value

    modify the current state value

    Definition Classes
    StateCreation
  77. implicit final val monadErrorEval: MonadError[Eval, Throwable]

    the monad error instance for Eval is useful for using detach on Eff[Fx1[Eval], A]

    the monad error instance for Eval is useful for using detach on Eff[Fx1[Eval], A]

    Definition Classes
    EvalInterpretation
  78. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  79. def none[R, A](implicit arg0: _option[R]): Eff[R, A]

    no value returned

    no value returned

    Definition Classes
    OptionCreation
  80. final def notify(): Unit
    Definition Classes
    AnyRef
  81. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  82. def now[R, A](a: A)(implicit arg0: _eval[R]): Eff[R, A]
    Definition Classes
    EvalCreation
  83. def optionEither[R, E, A](option: Option[A], e: E)(implicit member: |=[[β$0$]Either[E, β$0$], R]): Eff[R, A]

    create an Either effect from a single Option value

    create an Either effect from a single Option value

    Definition Classes
    EitherCreation
  84. def otherwise[R, A](action: Eff[R, A], onThrowable: Eff[R, A])(implicit m: /=[Safe, R]): Eff[R, A]

    evaluate first action possibly having exceptions

    evaluate first action possibly having exceptions

    Execute a second action if the first one is not successful

    Definition Classes
    SafeInterpretation
  85. def plus[R, A](a1: Eff[R, A], a2: Eff[R, A])(implicit arg0: _choose[R]): Eff[R, A]
    Definition Classes
    ChooseCreation
  86. def protect[R, A](a: ⇒ A)(implicit arg0: _safe[R]): Eff[R, A]
    Definition Classes
    SafeCreation
  87. def pure[R, A](a: A): Eff[R, A]

    create a pure value

    create a pure value

    Definition Classes
    EffCreation
  88. def put[R, S](s: S)(implicit member: |=[[β$0$]StateT[Eval, S, β$0$], R]): Eff[R, Unit]

    store a new state value

    store a new state value

    Definition Classes
    StateCreation
  89. def recoverThrowable[R, A, B](action: Eff[R, A], pureValue: (A) ⇒ B, onThrowable: PartialFunction[Throwable, Eff[R, B]])(implicit m: /=[Safe, R]): Eff[R, B]

    evaluate first action possibly having error effects

    evaluate first action possibly having error effects

    Execute a second action if the first one is not successful and second is defined for the error

    Definition Classes
    SafeInterpretation
  90. def right[R, E, A](a: A)(implicit member: |=[[β$4$]Either[E, β$4$], R]): Eff[R, A]

    create a correct value

    create a correct value

    Definition Classes
    EitherCreation
  91. 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
  92. def runChoose[R, U, A, F[_]](r: Eff[R, A])(implicit arg0: Alternative[F], m: Aux[Choose, R, U]): Eff[U, F[A]]
    Definition Classes
    ChooseInterpretation
  93. def runEither[R, U, E, A](effect: Eff[R, A])(implicit m: Aux[[β$8$]Either[E, β$8$], R, U]): Eff[U, Either[E, A]]

    run the Either effect, yielding E Either A

    run the Either effect, yielding E Either A

    Definition Classes
    EitherInterpretation
  94. def runEitherCatchLeft[R, U, E, A](r: Eff[R, A])(handle: (E) ⇒ Eff[U, A])(implicit m: Aux[[β$14$]Either[E, β$14$], R, U]): Eff[U, A]

    run the Either effect, handling E (with effects) and yielding A

    run the Either effect, handling E (with effects) and yielding A

    Definition Classes
    EitherInterpretation
  95. def runEitherCombine[R, U, E, A](effect: Eff[R, A])(implicit m: Aux[[β$9$]Either[E, β$9$], R, U], s: Semigroup[E]): Eff[U, Either[E, A]]

    run the Either effect, yielding E Either A and combine all Es

    run the Either effect, yielding E Either A and combine all Es

    Definition Classes
    EitherInterpretation
  96. def runEval[R, U, A](effect: Eff[R, A])(implicit m: Aux[Eval, R, U]): Eff[U, A]
    Definition Classes
    EvalInterpretation
  97. def runFutureMemo[R, U, A](cache: Cache)(effect: Eff[R, A])(implicit m: Aux[Memoized, R, U], future: |=[TimedFuture, U]): Eff[U, A]
    Definition Classes
    MemoInterpretation
  98. def runKleisli[R, U, S, A, F[_]](env: S)(e: Eff[R, A])(implicit mx: Aux[[γ$7$]Kleisli[F, S, γ$7$], R, U], m: |=[F, U]): Eff[U, A]

    interpret the Kleisli effect by providing an environment when required and translating the resulting target effect into the same stack

    interpret the Kleisli effect by providing an environment when required and translating the resulting target effect into the same stack

    Definition Classes
    ReaderInterpretation
  99. def runList[R, U, A](effect: Eff[R, A])(implicit m: Aux[List, R, U]): Eff[U, List[A]]

    run an effect stack starting with a list effect

    run an effect stack starting with a list effect

    Definition Classes
    ListInterpretation
  100. def runMap[R, U, E, L, A](effect: Eff[R, A])(map: (E) ⇒ L)(implicit arg0: Semigroup[L], m: Aux[[β$10$]Validate[E, β$10$], R, U]): Eff[U, Either[L, A]]

    run the validate effect, yielding a list of failures Either A

    run the validate effect, yielding a list of failures Either A

    Definition Classes
    ValidateInterpretation
  101. def runMemo[R, U, A](cache: Cache)(effect: Eff[R, A])(implicit m: Aux[Memoized, R, U], eval: |=[Eval, U]): Eff[U, A]
    Definition Classes
    MemoInterpretation
  102. def runNel[R, U, E, A](r: Eff[R, A])(implicit m: Aux[[β$9$]Validate[E, β$9$], R, U]): Eff[U, Either[NonEmptyList[E], A]]

    run the validate effect, yielding a non-empty list of failures Either A

    run the validate effect, yielding a non-empty list of failures Either A

    Definition Classes
    ValidateInterpretation
  103. def runOption[R, U, A](effect: Eff[R, A])(implicit m: Aux[Option, R, U]): Eff[U, Option[A]]

    Interpret the Option effect

    Interpret the Option effect

    Stop all computations if None is present once

    Definition Classes
    OptionInterpretation
  104. 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
  105. def runReader[R, U, A, B](env: A)(effect: Eff[R, B])(implicit m: Aux[[β$5$]Kleisli[[A]A, A, β$5$], R, U]): Eff[U, B]

    interpret the Reader effect by providing an environment when required

    interpret the Reader effect by providing an environment when required

    Definition Classes
    ReaderInterpretation
  106. def runSafe[R, U, A](effect: Eff[R, A])(implicit m: Aux[Safe, R, U]): Eff[U, (EitherEffect.ThrowableEither[A], List[Throwable])]

    Run a safe effect

    Run a safe effect

    Collect finalizer exceptions if any

    Definition Classes
    SafeInterpretation
  107. def runState[R, U, S1, A](initial: S1)(w: Eff[R, A])(implicit m: Aux[[β$23$]StateT[Eval, S1, β$23$], 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
  108. def runStateZero[R, U, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[β$22$]StateT[Eval, S, β$22$], 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
  109. def runValidatedNel[R, U, E, A](r: Eff[R, A])(implicit m: Aux[[β$8$]Validate[E, β$8$], R, U]): Eff[U, ValidatedNel[E, A]]

    run the validate effect, yielding a ValidatedNel

    run the validate effect, yielding a ValidatedNel

    Definition Classes
    ValidateInterpretation
  110. def runWriter[R, U, O, A, B](w: Eff[R, A])(implicit m: Aux[[β$2$]WriterT[[A]A, O, β$2$], R, U]): Eff[U, (A, List[O])]

    run a writer effect and return the list of written values

    run a writer effect and return the list of written values

    This uses a ListBuffer internally to append values

    Definition Classes
    WriterInterpretation
  111. def runWriterEval[R, U, O, A](w: Eff[R, A])(f: (O) ⇒ Eval[Unit])(implicit m: Aux[[β$7$]WriterT[[A]A, O, β$7$], R, U], ev: |=[Eval, U]): Eff[U, A]
    Definition Classes
    WriterInterpretation
  112. def runWriterFold[R, U, O, A, B](w: Eff[R, A])(fold: RightFold[O, B])(implicit m: Aux[[β$3$]WriterT[[A]A, O, β$3$], R, U]): Eff[U, (A, B)]

    More general fold of runWriter where we can use a fold to accumulate values in a mutable buffer

    More general fold of runWriter where we can use a fold to accumulate values in a mutable buffer

    Definition Classes
    WriterInterpretation
  113. def runWriterIntoMonoid[R, U, O, M, A](w: Eff[R, A])(f: (O) ⇒ M)(implicit m: Aux[[β$9$]WriterT[[A]A, O, β$9$], R, U], M: Monoid[M]): Eff[U, (A, M)]
    Definition Classes
    WriterInterpretation
  114. def runWriterMonoid[R, U, O, A](w: Eff[R, A])(implicit m: Aux[[β$8$]WriterT[[A]A, O, β$8$], R, U], O: Monoid[O]): Eff[U, (A, O)]
    Definition Classes
    WriterInterpretation
  115. def runWriterUnsafe[R, U, O, A](w: Eff[R, A])(f: (O) ⇒ Unit)(implicit m: Aux[[β$5$]WriterT[[A]A, O, β$5$], R, U]): Eff[U, A]

    Run a side-effecting fold

    Run a side-effecting fold

    Definition Classes
    WriterInterpretation
  116. def safeInterpreter[R, A](last: Option[(Eff[R, Unit], /=[Safe, R])]): Interpreter[Safe, R, A, Out[A]]
    Definition Classes
    SafeInterpretation
  117. def safeInterpreter[R, A]: Interpreter[Safe, R, A, Out[A]]
    Definition Classes
    SafeInterpretation
  118. def safeMemo[R, A](key: AnyRef, cache: Cache, e: Eff[R, A])(implicit safe: /=[Safe, R]): Eff[R, A]

    Memoize safe effects using a cache

    Memoize safe effects using a cache

    if this method is called with the same key the previous value will be returned

    Definition Classes
    SafeInterpretation
  119. 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
  120. 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
  121. def singleton[R, A](a: A)(implicit arg0: _list[R]): Eff[R, A]

    create a list effect from a single value

    create a list effect from a single value

    Definition Classes
    ListCreation
  122. def some[R, A](a: A)(implicit arg0: _option[R]): Eff[R, A]

    a value is returned

    a value is returned

    Definition Classes
    OptionCreation
  123. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  124. def tell[R, O](o: O)(implicit member: |=[[β$0$]WriterT[[A]A, O, β$0$], R]): Eff[R, Unit]

    write a given value

    write a given value

    Definition Classes
    WriterCreation
  125. def thenFinally[R, A](effect: Eff[R, A], last: Eff[R, Unit])(implicit m: /=[Safe, R]): Eff[R, A]

    evaluate first action possibly having error effects execute a second action whether the first is successful or not but keep track of finalizer exceptions

    evaluate first action possibly having error effects execute a second action whether the first is successful or not but keep track of finalizer exceptions

    Definition Classes
    SafeInterpretation
  126. def toString(): String
    Definition Classes
    AnyRef → Any
  127. def translateEither[R, U, E1, E2, A](r: Eff[R, A], getter: (E1) ⇒ E2)(implicit sr: Aux[[β$27$]Either[E1, β$27$], R, U], br: |=[[β$28$]Either[E2, β$28$], U]): Eff[U, A]

    Translate an error effect to another one in the same stack a computation over a "bigger" error (for the full application)

    Translate an error effect to another one in the same stack a computation over a "bigger" error (for the full application)

    Definition Classes
    EitherInterpretation
  128. def translateReader[R, U, S, B, A](e: Eff[R, A], getter: (B) ⇒ S)(implicit sr: Aux[[β$9$]Kleisli[[A]A, S, β$9$], R, U], br: |=[[β$10$]Kleisli[[A]A, B, β$10$], U]): Eff[U, A]

    Interpret a Reader effect by using another Reader effect in the same stack

    Interpret a Reader effect by using another Reader effect in the same stack

    Definition Classes
    ReaderInterpretation
  129. 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
  130. def unit[R]: Eff[R, Unit]

    create an Eff value for ()

    create an Eff value for ()

    Definition Classes
    EffCreation
  131. def validateCheck[R, E](condition: Boolean, e: E)(implicit m: |=[[β$6$]Validate[E, β$6$], R]): Eff[R, Unit]

    check a correct condition

    check a correct condition

    Definition Classes
    ValidateCreation
  132. def validateEither[R, E, A](either: Either[E, A])(implicit m: |=[[β$1$]Validate[E, β$1$], R]): Eff[R, Unit]

    create an Validate effect from a single Either value

    create an Validate effect from a single Either value

    Definition Classes
    ValidateCreation
  133. def validateOption[R, E, A](option: Option[A], e: E)(implicit m: |=[[β$0$]Validate[E, β$0$], R]): Eff[R, Unit]

    create an Validate effect from a single Option value

    create an Validate effect from a single Option value

    Definition Classes
    ValidateCreation
  134. def validateValue[R, E, A](condition: Boolean, a: A, e: E)(implicit m: |=[[β$7$]Validate[E, β$7$], R]): Eff[R, A]

    check a correct value

    check a correct value

    Definition Classes
    ValidateCreation
  135. def values[R, A](as: A*)(implicit arg0: _list[R]): Eff[R, A]

    create a list effect from a list of values

    create a list effect from a list of values

    Definition Classes
    ListCreation
  136. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  137. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  138. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  139. def whenFailed[R, A](action: Eff[R, A], onThrowable: (Throwable) ⇒ Eff[R, A])(implicit m: /=[Safe, R]): Eff[R, A]

    evaluate first action possibly throwing exceptions

    evaluate first action possibly throwing exceptions

    Execute a second action if the first one is not successful, based on the exception

    The final value type is the same as the original type

    Definition Classes
    SafeInterpretation
  140. 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
  141. def whenThrowable[R, A](action: Eff[R, A], onThrowable: PartialFunction[Throwable, Eff[R, A]])(implicit m: /=[Safe, R]): Eff[R, A]

    evaluate first action possibly throwing exceptions

    evaluate first action possibly throwing exceptions

    Execute a second action if the first one is not successful and second is defined for the error

    The final value type is the same as the original type

    Definition Classes
    SafeInterpretation
  142. def wrong[R, E](e: E)(implicit m: |=[[β$2$]Validate[E, β$2$], R]): Eff[R, Unit]

    create a failed value

    create a failed value

    Definition Classes
    ValidateCreation
  143. def zero[R, A](implicit arg0: _choose[R]): Eff[R, A]
    Definition Classes
    ChooseCreation
  144. def zoomEither[SR, BR, U, E1, E2, A](r: Eff[SR, A], getter: (E1) ⇒ E2)(implicit sr: Aux[[β$21$]Either[E1, β$21$], SR, U], br: Aux[[β$22$]Either[E2, β$22$], BR, U]): Eff[BR, A]

    Modify the type of the read value

    Modify the type of the read value

    This changes the stack of the Eff computation

    Definition Classes
    EitherInterpretation
  145. def zoomReader[R1, R2, U, S, T, A](e: Eff[R1, A])(f: (T) ⇒ S)(implicit readerS: Aux[[β$13$]Kleisli[[A]A, S, β$13$], R1, U], readerT: Aux[[β$14$]Kleisli[[A]A, T, β$14$], R2, U]): Eff[R2, A]

    Modify the type of the read value

    Modify the type of the read value

    This changes the stack of the Eff computation

    Definition Classes
    ReaderInterpretation

Inherited from EffImplicits

Inherited from EffCreation

Inherited from EffInterpretation

Inherited from Batch

Inherited from MemoEffect

Inherited from MemoInterpretation

Inherited from MemoCreation

Inherited from MemoTypes

Inherited from SafeEffect

Inherited from SafeInterpretation

Inherited from SafeCreation

Inherited from SafeTypes

Inherited from ChooseEffect

Inherited from ChooseInterpretation

Inherited from ChooseCreation

Inherited from ValidateEffect

Inherited from ValidateInterpretation

Inherited from ValidateCreation

Inherited from EitherEffect

Inherited from EitherInterpretation

Inherited from EitherCreation

Inherited from ListEffect

Inherited from ListInterpretation

Inherited from ListCreation

Inherited from OptionEffect

Inherited from OptionInterpretation

Inherited from OptionCreation

Inherited from EvalEffect

Inherited from EvalInterpretation

Inherited from EvalCreation

Inherited from EvalTypes

Inherited from StateEffect

Inherited from StateInterpretation

Inherited from StateCreation

Inherited from WriterEffect

Inherited from WriterInterpretation

Inherited from WriterCreation

Inherited from ReaderEffect

Inherited from ReaderInterpretation

Inherited from ReaderCreation

Inherited from AnyRef

Inherited from Any

Ungrouped