Object

org.atnos.eff

all

Related Doc: package eff

Permalink

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

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

Type Members

  1. type ThrowableEither[A] = Either[Throwable, A]

    Permalink
    Definition Classes
    EitherCreation
  2. type _Async[R] = Member[Async, R]

    Permalink
    Definition Classes
    AsyncCreation
  3. type _Choose[R] = Member[Choose, R]

    Permalink
    Definition Classes
    ChooseCreation
  4. type _Eval[R] = Member[Eval, R]

    Permalink
    Definition Classes
    EvalTypes
  5. type _List[R] = Member[List, R]

    Permalink
    Definition Classes
    ListCreation
  6. type _Option[R] = Member[Option, R]

    Permalink
    Definition Classes
    OptionCreation
  7. type _Safe[R] = Member[Safe, R]

    Permalink
    Definition Classes
    SafeTypes
  8. type _ThrowableEither[R] = Member[ThrowableEither, R]

    Permalink
    Definition Classes
    EitherCreation
  9. type _async[R] = MemberIn[Async, R]

    Permalink
    Definition Classes
    AsyncCreation
  10. type _choose[R] = MemberIn[Choose, R]

    Permalink
    Definition Classes
    ChooseCreation
  11. type _eval[R] = MemberIn[Eval, R]

    Permalink
    Definition Classes
    EvalTypes
  12. type _list[R] = MemberIn[List, R]

    Permalink
    Definition Classes
    ListCreation
  13. type _option[R] = MemberIn[Option, R]

    Permalink
    Definition Classes
    OptionCreation
  14. type _safe[R] = MemberIn[Safe, R]

    Permalink
    Definition Classes
    SafeTypes
  15. type _throwableEither[R] = MemberIn[ThrowableEither, R]

    Permalink
    Definition Classes
    EitherCreation

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  4. def EffApplicative[R]: Applicative[[β$2$]Eff[R, β$2$]]

    Permalink
    Definition Classes
    EffImplicits
  5. implicit final def EffMonad[R]: Monad[[β$0$]Eff[R, β$0$]]

    Permalink

    Monad implementation for the Eff[R, ?] type

    Monad implementation for the Eff[R, ?] type

    Definition Classes
    EffImplicits
  6. def EitherApplicative[E](implicit s: Semigroup[E]): Applicative[[β$11$]Either[E, β$11$]]

    Permalink
    Definition Classes
    EitherInterpretation
  7. def EvalFold[A](f: (A) ⇒ Eval[Unit]): LeftFold[A, Eval[Unit]]

    Permalink
    Definition Classes
    WriterInterpretation
  8. implicit def ListFold[A]: LeftFold[A, List[A]]

    Permalink
    Definition Classes
    WriterInterpretation
  9. def MonoidFold[A](implicit arg0: Monoid[A]): LeftFold[A, A]

    Permalink
    Definition Classes
    WriterInterpretation
  10. def UnsafeFold[A](f: (A) ⇒ Unit): LeftFold[A, Unit]

    Permalink
    Definition Classes
    WriterInterpretation
  11. def ap[R, A, B](a: Eff[R, A])(f: Eff[R, (A) ⇒ B]): Eff[R, B]

    Permalink

    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

    Permalink
    Definition Classes
    Any
  13. def ask[R, T](implicit member: |=[[β$0$]Kleisli[[A]A, T, β$0$], R]): Eff[R, T]

    Permalink

    get the environment

    get the environment

    Definition Classes
    ReaderCreation
  14. def async[R, A](subscribe: Subscribe[A], timeout: Option[FiniteDuration] = None)(implicit arg0: _async[R]): Eff[R, A]

    Permalink
    Definition Classes
    AsyncCreation
  15. def asyncDelay[R, A](a: ⇒ A, timeout: Option[FiniteDuration] = None)(implicit arg0: _async[R]): Eff[R, A]

    Permalink
    Definition Classes
    AsyncCreation
  16. def asyncFail[R, A](t: Throwable)(implicit arg0: _async[R]): Eff[R, A]

    Permalink
    Definition Classes
    AsyncCreation
  17. def asyncFork[R, A](a: ⇒ A, timeout: Option[FiniteDuration] = None)(implicit arg0: _async[R]): Eff[R, A]

    Permalink
    Definition Classes
    AsyncCreation
  18. def asyncNow[R, A](a: A)(implicit arg0: _async[R]): Eff[R, A]

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

    Permalink

    try to execute an action an report any issue

    try to execute an action an report any issue

    Definition Classes
    SafeInterpretation
  20. def attemptEval[R, U, A](r: Eff[R, A])(implicit m: Aux[Eval, R, U]): Eff[U, Either[Throwable, A]]

    Permalink
    Definition Classes
    EvalInterpretation
  21. def attemptSafe[R, A](r: Eff[R, A])(implicit m: /=[Safe, R]): Eff[R, (EitherEffect.ThrowableEither[A], List[Throwable])]

    Permalink

    Attempt to execute a safe action including finalizers

    Attempt to execute a safe action including finalizers

    Definition Classes
    SafeInterpretation
  22. def batch[R, T[_], A](eff: Eff[R, A])(implicit batchable: Batchable[T], m: /=[T, R]): Eff[R, A]

    Permalink
    Definition Classes
    Batch
  23. def bracket[R, A, B, C](acquire: Eff[R, A])(step: (A) ⇒ Eff[R, B])(release: (A) ⇒ Eff[R, C])(implicit m: /=[Safe, R]): Eff[R, B]

    Permalink
    Definition Classes
    SafeInterpretation
  24. def catchLeft[R, E, A](r: Eff[R, A])(handle: (E) ⇒ Eff[R, A])(implicit member: /=[[β$16$]Either[E, β$16$], R]): Eff[R, A]

    Permalink

    catch and handle a possible left value

    catch and handle a possible left value

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

    Permalink

    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
  26. def catchNonFatalThrowable[R, A](a: ⇒ A)(implicit member: |=[[β$7$]Either[Throwable, β$7$], R]): Eff[R, A]

    Permalink

    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
  27. def catchThrowable[R, A, B](action: Eff[R, A], pureValue: (A) ⇒ B, onThrowable: (Throwable) ⇒ Eff[R, B])(implicit m: /=[Safe, R]): Eff[R, B]

    Permalink

    evaluate 1 action possibly having error effects

    evaluate 1 action possibly having error effects

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

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

    Permalink

    catch and handle possible wrong values

    catch and handle possible wrong values

    Definition Classes
    ValidateInterpretation
  29. def chooseFrom[R, A](as: List[A])(implicit arg0: _choose[R]): Eff[R, A]

    Permalink
    Definition Classes
    ChooseCreation
  30. def clone(): AnyRef

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

    Permalink

    use the internal effect as one of the stack effects

    use the internal effect as one of the stack effects

    Definition Classes
    EffCreation
  32. def correct[R, E, A](a: A)(implicit m: |=[[β$4$]Validate[E, β$4$], R]): Eff[R, A]

    Permalink

    create a correct value

    create a correct value

    Definition Classes
    ValidateCreation
  33. def defer[R, A](eff: ⇒ Eval[Eff[R, A]])(implicit arg0: _eval[R]): Eff[R, A]

    Permalink
    Definition Classes
    EvalCreation
  34. def delay[R, A](a: ⇒ A)(implicit arg0: _eval[R]): Eff[R, A]

    Permalink
    Definition Classes
    EvalCreation
  35. def detach[M[_], A](eff: Eff[Fx1[M], A])(implicit arg0: Monad[M]): M[A]

    Permalink

    peel-off the only present effect

    peel-off the only present effect

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

    Permalink

    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
  37. def effInto[R, U, A](e: Eff[R, A])(implicit f: IntoPoly[R, U]): Eff[U, A]

    Permalink

    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. def empty[R, A](implicit arg0: _list[R]): Eff[R, A]

    Permalink

    create a list effect with no values

    create a list effect with no values

    Definition Classes
    ListCreation
  39. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  40. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  41. def eval[R, A](a: Eval[A])(implicit arg0: _safe[R]): Eff[R, A]

    Permalink
    Definition Classes
    SafeCreation
  42. def evalState[R, U, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[β$18$]StateT[Eval, S, β$18$], R, U]): Eff[U, A]

    Permalink

    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
  43. def evalStateZero[R, U, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[β$17$]StateT[Eval, S, β$17$], R, U]): Eff[U, A]

    Permalink

    run a state effect, with a Monoidal state

    run a state effect, with a Monoidal state

    Definition Classes
    StateInterpretation
  44. def exception[R, A](t: Throwable)(implicit arg0: _safe[R]): Eff[R, A]

    Permalink
    Definition Classes
    SafeCreation
  45. def execSafe[R, U, A](r: Eff[R, A])(implicit m: Aux[Safe, R, U]): Eff[U, EitherEffect.ThrowableEither[A]]

    Permalink

    run a safe effect but drop the finalizer errors

    run a safe effect but drop the finalizer errors

    Definition Classes
    SafeInterpretation
  46. def execState[R, U, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[β$20$]StateT[Eval, S, β$20$], R, U]): Eff[U, S]

    Permalink

    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
  47. def execStateZero[R, U, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[β$19$]StateT[Eval, S, β$19$], R, U]): Eff[U, S]

    Permalink

    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
  48. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  49. def finalizerException[R](t: Throwable)(implicit arg0: _safe[R]): Eff[R, Unit]

    Permalink
    Definition Classes
    SafeCreation
  50. def flatSequenceA[R, F[_], A](fs: F[Eff[R, F[A]]])(implicit FT: Traverse[F], FM: FlatMap[F]): Eff[R, F[A]]

    Permalink

    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
  51. 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]]

    Permalink

    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
  52. def fork[R, A](a: ⇒ Async[A], timeout: Option[FiniteDuration] = None)(implicit arg0: _async[R]): Eff[R, A]

    Permalink
    Definition Classes
    AsyncCreation
  53. def fromCatchNonFatal[R, E, A](a: ⇒ A)(onThrowable: (Throwable) ⇒ E)(implicit member: |=[[β$6$]Either[E, β$6$], R]): Eff[R, A]

    Permalink

    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]

    Permalink

    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]

    Permalink

    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]

    Permalink

    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]

    Permalink

    get the current state value

    get the current state value

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

    Permalink
    Definition Classes
    AnyRef → Any
  59. def gets[R, S, T](f: (S) ⇒ T)(implicit member: |=[[β$4$]StateT[Eval, S, β$4$], R]): Eff[R, T]

    Permalink

    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
  60. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  61. def ignoreException[R, E <: Throwable, A](action: Eff[R, A])(implicit arg0: ClassTag[E], m: /=[Safe, R]): Eff[R, Unit]

    Permalink

    ignore one possible exception that could be thrown

    ignore one possible exception that could be thrown

    Definition Classes
    SafeInterpretation
  62. def impure[R, X, A](union: Union[R, X], continuation: Arrs[R, X, A]): Eff[R, A]

    Permalink

    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
  63. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  64. def left[R, E, A](e: E)(implicit member: |=[[β$2$]Either[E, β$2$], R]): Eff[R, A]

    Permalink

    create a failed value

    create a failed value

    Definition Classes
    EitherCreation
  65. 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]

    Permalink

    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
  66. def local[R, T, U](f: (T) ⇒ U)(implicit member: |=[[β$1$]Kleisli[[A]A, T, β$1$], R]): Eff[R, U]

    Permalink

    modify the environment

    modify the environment

    Definition Classes
    ReaderCreation
  67. def localEither[SR, BR, U, E1, E2, A](r: Eff[SR, A], getter: (E1) ⇒ E2)(implicit sr: Aux[[β$22$]Either[E1, β$22$], SR, U], br: Aux[[β$23$]Either[E2, β$23$], BR, U]): Eff[BR, A]

    Permalink

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

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

    Definition Classes
    EitherInterpretation
  68. def localReader[R, U, S, B, A](e: Eff[R, A], getter: (B) ⇒ S)(implicit sr: Aux[[β$6$]Kleisli[[A]A, S, β$6$], R, U], br: |=[[β$7$]Kleisli[[A]A, B, β$7$], U]): Eff[U, A]

    Permalink

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

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

    Definition Classes
    ReaderInterpretation
  69. def modify[R, S](f: (S) ⇒ S)(implicit member: |=[[β$6$]StateT[Eval, S, β$6$], R]): Eff[R, Unit]

    Permalink

    modify the current state value

    modify the current state value

    Definition Classes
    StateCreation
  70. def modifyReader[R1, R2, U, S, T, A](e: Eff[R1, A])(f: (T) ⇒ S)(implicit readerS: Aux[[β$10$]Kleisli[[A]A, S, β$10$], R1, U], readerT: Aux[[β$11$]Kleisli[[A]A, T, β$11$], R2, U]): Eff[R2, A]

    Permalink

    Modify the read value

    Modify the read value

    Definition Classes
    ReaderInterpretation
  71. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  72. def none[R, A](implicit arg0: _option[R]): Eff[R, A]

    Permalink

    no value returned

    no value returned

    Definition Classes
    OptionCreation
  73. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  74. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  75. def now[R, A](a: A)(implicit arg0: _eval[R]): Eff[R, A]

    Permalink
    Definition Classes
    EvalCreation
  76. def optionEither[R, E, A](option: Option[A], e: E)(implicit member: |=[[β$0$]Either[E, β$0$], R]): Eff[R, A]

    Permalink

    create an Either effect from a single Option value

    create an Either effect from a single Option value

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

    Permalink

    evaluate 1 action possibly having error effects

    evaluate 1 action possibly having error effects

    Execute a second action if the first one is not successful

    Definition Classes
    SafeInterpretation
  78. def plus[R, A](a1: Eff[R, A], a2: Eff[R, A])(implicit arg0: _choose[R]): Eff[R, A]

    Permalink
    Definition Classes
    ChooseCreation
  79. def protect[R, A](a: ⇒ A)(implicit arg0: _safe[R]): Eff[R, A]

    Permalink
    Definition Classes
    SafeCreation
  80. def pure[R, A](a: A): Eff[R, A]

    Permalink

    create a pure value

    create a pure value

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

    Permalink

    store a new state value

    store a new state value

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

    Permalink

    create a correct value

    create a correct value

    Definition Classes
    EitherCreation
  83. def run[A](eff: Eff[NoFx, A]): A

    Permalink

    base runner for an Eff value having no effects at all

    base runner for an Eff value having no effects at all

    This runner can only return the value in Pure because it doesn't known how to interpret the effects in Impure

    Definition Classes
    EffInterpretation
  84. def runChoose[R, U, A, F[_]](r: Eff[R, A])(implicit arg0: Alternative[F], m: Aux[Choose, R, U]): Eff[U, F[A]]

    Permalink
    Definition Classes
    ChooseInterpretation
  85. def runEither[R, U, E, A](r: Eff[R, A])(implicit m: Aux[[β$8$]Either[E, β$8$], R, U]): Eff[U, Either[E, A]]

    Permalink

    run the Either effect, yielding E Either A

    run the Either effect, yielding E Either A

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

    Permalink

    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
  87. def runEval[R, U, A](r: Eff[R, A])(implicit m: Aux[Eval, R, U]): Eff[U, A]

    Permalink
    Definition Classes
    EvalInterpretation
  88. def runList[R, U, A](effects: Eff[R, A])(implicit m: Aux[List, R, U]): Eff[U, List[A]]

    Permalink

    run an effect stack starting with a list effect

    run an effect stack starting with a list effect

    Definition Classes
    ListInterpretation
  89. def runLocalEither[R, U, E1, E2, A](r: Eff[R, A], getter: (E1) ⇒ E2)(implicit sr: Aux[[β$28$]Either[E1, β$28$], R, U], br: |=[[β$29$]Either[E2, β$29$], U]): Eff[U, A]

    Permalink

    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
  90. def runMap[R, U, E, L, A](r: Eff[R, A])(map: (E) ⇒ L)(implicit arg0: Semigroup[L], m: Aux[[β$10$]Validate[E, β$10$], R, U]): Eff[U, Either[L, A]]

    Permalink

    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
  91. 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]]

    Permalink

    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
  92. def runOption[R, U, A](r: Eff[R, A])(implicit m: Aux[Option, R, U]): Eff[U, Option[A]]

    Permalink

    Interpret the Option effect

    Interpret the Option effect

    Stop all computations if None is present once

    Definition Classes
    OptionInterpretation
  93. def runPure[R, A](eff: Eff[R, A]): Option[A]

    Permalink

    get the pure value if there is no effect

    get the pure value if there is no effect

    Definition Classes
    EffInterpretation
  94. def runReader[R, U, A, B](env: A)(r: Eff[R, B])(implicit m: Aux[[β$3$]Kleisli[[A]A, A, β$3$], R, U]): Eff[U, B]

    Permalink

    interpret the Reader effect by providing an environment when required

    interpret the Reader effect by providing an environment when required

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

    Permalink

    Run a safe effect

    Run a safe effect

    Collect finalizer exceptions if any

    Definition Classes
    SafeInterpretation
  96. def runState[R, U, S1, A](initial: S1)(w: Eff[R, A])(implicit m: Aux[[β$22$]StateT[Eval, S1, β$22$], R, U]): Eff[U, (A, S1)]

    Permalink

    run a state effect, with an initial value

    run a state effect, with an initial value

    Definition Classes
    StateInterpretation
  97. def runStateZero[R, U, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[β$21$]StateT[Eval, S, β$21$], R, U]): Eff[U, (A, S)]

    Permalink

    run a state effect, with an initial value

    run a state effect, with an initial value

    Definition Classes
    StateInterpretation
  98. def runValidatedNel[R, U, E, A](r: Eff[R, A])(implicit m: Aux[[β$8$]Validate[E, β$8$], R, U]): Eff[U, ValidatedNel[E, A]]

    Permalink

    run the validate effect, yielding a ValidatedNel

    run the validate effect, yielding a ValidatedNel

    Definition Classes
    ValidateInterpretation
  99. 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])]

    Permalink

    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
  100. def runWriterEval[R, U, O, A](w: Eff[R, A])(f: (O) ⇒ Eval[Unit])(implicit m: Aux[[β$8$]WriterT[[A]A, O, β$8$], R, U], ev: |=[Eval, U]): Eff[U, A]

    Permalink
    Definition Classes
    WriterInterpretation
  101. def runWriterFold[R, U, O, A, B](w: Eff[R, A])(fold: LeftFold[O, B])(implicit m: Aux[[β$3$]WriterT[[A]A, O, β$3$], R, U]): Eff[U, (A, B)]

    Permalink

    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
  102. def runWriterUnsafe[R, U, O, A](w: Eff[R, A])(f: (O) ⇒ Unit)(implicit m: Aux[[β$7$]WriterT[[A]A, O, β$7$], R, U]): Eff[U, A]

    Permalink

    Run a side-effecting fold

    Run a side-effecting fold

    Definition Classes
    WriterInterpretation
  103. def safeLoop[R, U, A]: Loop[Safe, R, A, Eff[U, (Either[Throwable, A], Vector[Throwable])], Eff[U, Unit]]

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

    Permalink

    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
  105. def sequenceA[R, F[_], A](fs: F[Eff[R, A]])(implicit arg0: Traverse[F]): Eff[R, F[A]]

    Permalink

    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
  106. def singleton[R, A](a: A)(implicit arg0: _list[R]): Eff[R, A]

    Permalink

    create a list effect from a single value

    create a list effect from a single value

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

    Permalink

    a value is returned

    a value is returned

    Definition Classes
    OptionCreation
  108. def subscribe[R, A](c: Subscribe[A], timeout: Option[FiniteDuration] = None)(implicit arg0: _async[R]): Eff[R, A]

    Permalink
    Definition Classes
    AsyncCreation
  109. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  110. def tell[R, O](o: O)(implicit member: |=[[β$0$]WriterT[[A]A, O, β$0$], R]): Eff[R, Unit]

    Permalink

    write a given value

    write a given value

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

    Permalink

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

    evaluate 1 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
  112. def toString(): String

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

    Permalink

    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
  114. def unit[R]: Eff[R, Unit]

    Permalink

    create an Eff value for ()

    create an Eff value for ()

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

    Permalink

    check a correct condition

    check a correct condition

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

    Permalink

    create an Validate effect from a single Either value

    create an Validate effect from a single Either value

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

    Permalink

    create an Validate effect from a single Option value

    create an Validate effect from a single Option value

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

    Permalink

    check a correct value

    check a correct value

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

    Permalink

    create a list effect from a list of values

    create a list effect from a list of values

    Definition Classes
    ListCreation
  120. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  121. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  122. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  123. def whenFailed[R, A](action: Eff[R, A], onThrowable: (Throwable) ⇒ Eff[R, A])(implicit m: /=[Safe, R]): Eff[R, A]

    Permalink

    evaluate 1 action possibly throwing exceptions

    evaluate 1 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
  124. def wrong[R, E](e: E)(implicit m: |=[[β$2$]Validate[E, β$2$], R]): Eff[R, Unit]

    Permalink

    create a failed value

    create a failed value

    Definition Classes
    ValidateCreation
  125. def zero[R, A](implicit arg0: _choose[R]): Eff[R, A]

    Permalink
    Definition Classes
    ChooseCreation

Inherited from EffImplicits

Inherited from EffCreation

Inherited from EffInterpretation

Inherited from Batch

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 AsyncEffect

Inherited from AsyncCreation

Inherited from AnyRef

Inherited from Any

Ungrouped