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[[β$11$]Either[E, β$11$]]

   Definition Classes

   EitherInterpretation

7.  def EvalFold[A](f: (A) ⇒ Eval[Unit]): LeftFold[A, Eval[Unit]]

   Definition Classes

   WriterInterpretation

8.  implicit def ListFold[A]: LeftFold[A, List[A]]

   Definition Classes

   WriterInterpretation

9.  def MonoidFold[A](implicit arg0: Monoid[A]): LeftFold[A, A]

   Definition Classes

   WriterInterpretation

10.  def UnsafeFold[A](f: (A) ⇒ Unit): LeftFold[A, Unit]

    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 attemptEval[R, U, A](r: Eff[R, A])(implicit m: Aux[Eval, R, U]): Eff[U, Either[Throwable, A]]

    Definition Classes

    EvalInterpretation

16.  def attemptSafe[R, A](r: 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

17.  def batch[R, T[_], A](eff: Eff[R, A])(implicit batchable: Batchable[T], m: /=[T, R]): Eff[R, A]

    Definition Classes

    Batch

18.  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

19.  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

20.  def catchLeft[R, E, A](r: Eff[R, A])(handle: (E) ⇒ Eff[R, A])(implicit member: /=[[β$16$]Either[E, β$16$], R]): Eff[R, A]

    catch and handle a possible left value

    catch and handle a possible left value

    Definition Classes

    EitherInterpretation

21.  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]

    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

22.  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

23.  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

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

    catch and handle possible wrong values

    catch and handle possible wrong values

    Definition Classes

    ValidateInterpretation

25.  def chooseFrom[R, A](as: List[A])(implicit arg0: _choose[R]): Eff[R, A]

    Definition Classes

    ChooseCreation

26.  def clone(): AnyRef

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

27.  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

28.  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

29.  def defer[R, A](eff: ⇒ Eval[Eff[R, A]])(implicit arg0: _eval[R]): Eff[R, A]

    Definition Classes

    EvalCreation

30.  def delay[R, A](a: ⇒ A)(implicit arg0: _eval[R]): Eff[R, A]

    Definition Classes

    EvalCreation

31.  def detach[M[_], A](eff: Eff[Fx1[M], A])(implicit arg0: Monad[M]): M[A]

    peel-off the only present effect

    peel-off the only present effect

    Definition Classes

    EffInterpretation

32.  def detachA[M[_], A](eff: Eff[Fx1[M], A])(implicit monad: Monad[M], 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

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

    Definition Classes

    EffImplicits

34.  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

35.  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

36.  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

37.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

38.  def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

39.  def eval[R, A](a: Eval[A])(implicit arg0: _safe[R]): Eff[R, A]

    Definition Classes

    SafeCreation

40.  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

41.  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

42.  def exception[R, A](t: Throwable)(implicit arg0: _safe[R]): Eff[R, A]

    Definition Classes

    SafeCreation

43.  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

44.  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

45.  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

46.  def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

47.  def finalizerException[R](t: Throwable)(implicit arg0: _safe[R]): Eff[R, Unit]

    Definition Classes

    SafeCreation

48.  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

49.  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

50.  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

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

52.  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

53.  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

54.  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

55.  def getCache[R](implicit arg0: _memo[R]): Eff[R, Cache]

    Definition Classes

    MemoCreation

56.  final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

57.  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

58.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

59.  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

60.  def impure[R, X, A](union: Union[R, X], continuation: Arrs[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

61.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

62.  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

63.  def lensState[TS, SS, U, T, S, A](state: Eff[TS, A], getter: (S) ⇒ T, setter: (S, T) ⇒ S)(implicit ts: Aux[[β$27$]StateT[Eval, T, β$27$], TS, U], ss: Aux[[β$28$]StateT[Eval, S, β$28$], 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

64.  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

65.  def localEither[R, E, A](e: Eff[R, A])(modify: (E) ⇒ E)(implicit m: /=[[β$31$]Either[E, β$31$], 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

66.  def localReader[R, T, A](e: Eff[R, A])(modify: (T) ⇒ T)(implicit r: /=[[β$14$]Kleisli[[A]A, T, β$14$], 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

67.  def localState[R, S, A](e: Eff[R, A])(modify: (S) ⇒ S)(implicit s: /=[[β$33$]StateT[Eval, S, β$33$], 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

68.  def memoize[R, A](key: AnyRef, a: ⇒ A)(implicit arg0: _memo[R]): Eff[R, A]

    Definition Classes

    MemoCreation

69.  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

70.  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

71.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

72.  def none[R, A](implicit arg0: _option[R]): Eff[R, A]

    no value returned

    no value returned

    Definition Classes

    OptionCreation

73.  final def notify(): Unit

    Definition Classes

    AnyRef

74.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

75.  def now[R, A](a: A)(implicit arg0: _eval[R]): Eff[R, A]

    Definition Classes

    EvalCreation

76.  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

77.  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

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

    Definition Classes

    ChooseCreation

79.  def protect[R, A](a: ⇒ A)(implicit arg0: _safe[R]): Eff[R, A]

    Definition Classes

    SafeCreation

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

    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]

    store a new state value

    store a new state value

    Definition Classes

    StateCreation

82.  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

83.  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

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

    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

85.  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

86.  def runEither[R, U, E, A](r: 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

87.  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]]

    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

88.  def runEval[R, U, A](r: Eff[R, A])(implicit m: Aux[Eval, R, U]): Eff[U, A]

    Definition Classes

    EvalInterpretation

89.  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

90.  def runList[R, U, A](effects: 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

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

    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

92.  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

93.  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

94.  def runOption[R, U, A](r: 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

95.  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

96.  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]

    interpret the Reader effect by providing an environment when required

    interpret the Reader effect by providing an environment when required

    Definition Classes

    ReaderInterpretation

97.  def runSafe[R, U, A](r: 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

98.  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

99.  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

100.  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

101.  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

102.  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]

     Definition Classes

     WriterInterpretation

103.  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)]

     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

104.  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]

     Run a side-effecting fold

     Run a side-effecting fold

     Definition Classes

     WriterInterpretation

105.  def safeLoop[R, U, A]: Loop[Safe, R, A, Eff[U, (Either[Throwable, A], Vector[Throwable])], Eff[U, Unit]]

     Definition Classes

     SafeInterpretation

106.  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

107.  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

108.  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

109.  def some[R, A](a: A)(implicit arg0: _option[R]): Eff[R, A]

     a value is returned

     a value is returned

     Definition Classes

     OptionCreation

110.  final def synchronized[T0](arg0: ⇒ T0): T0

     Definition Classes

     AnyRef

111.  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

112.  def thenFinally[R, A](action: 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

113.  def toString(): String

     Definition Classes

     AnyRef → Any

114.  def translateEither[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]

     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

115.  def translateReader[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]

     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

116.  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

117.  def unit[R]: Eff[R, Unit]

     create an Eff value for ()

     create an Eff value for ()

     Definition Classes

     EffCreation

118.  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

119.  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

120.  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

121.  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

122.  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

123.  final def wait(): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

125.  final def wait(arg0: Long): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

126.  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

127.  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

128.  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

129.  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

130.  def zero[R, A](implicit arg0: _choose[R]): Eff[R, A]

     Definition Classes

     ChooseCreation

131.  def zoomEither[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]

     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

132.  def zoomReader[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]

     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