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.  def EffApplicative[R]: Applicative[[β$4$]Eff[R, β$4$]]

   Definition Classes

   EffImplicits

5.  implicit final def EffMonad[R]: Monad[[β$0$]Eff[R, β$0$]] with BindRecʹ[[β$1$]Eff[R, β$1$]]

   Monad implementation for the Eff[R, ?] type

   Monad implementation for the Eff[R, ?] type

   Definition Classes

   EffImplicits

6.  implicit def ListFold[A]: FoldId[A, List[A]]

   Definition Classes

   WriterInterpretation

7.  def MonoidFold[A](implicit arg0: Monoid[A]): FoldId[A, A]

   Definition Classes

   WriterInterpretation

8.  def UnsafeFold[A](f: (A) ⇒ Unit): FoldId[A, Unit]

   Definition Classes

   WriterInterpretation

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

10.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

11.  def attempt[R, A](action: Eff[R, A])(implicit m: /=[Safe, R]): Eff[R, \/[Throwable, A]]

    try to execute an action an report any issue

    try to execute an action an report any issue

    Definition Classes

    SafeInterpretation

12.  def attemptEval[R, U, A](r: Eff[R, A])(implicit m: Aux[Eval, R, U]): Eff[U, \/[Throwable, A]]

    Definition Classes

    EvalInterpretation

13.  def attemptSafe[R, A](r: Eff[R, A])(implicit m: /=[Safe, R]): Eff[R, (\/[Throwable, A], List[Throwable])]

    Attempt to execute a safe action including finalizers

    Attempt to execute a safe action including finalizers

    Definition Classes

    SafeInterpretation

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

    Definition Classes

    SafeInterpretation

15.  def catchLeft[R, E, A](r: Eff[R, A])(handle: (E) ⇒ Eff[R, A])(implicit member: <=[[β$10$]\/[E, β$10$], R]): Eff[R, A]

    catch and handle a possible -\/ value

    catch and handle a possible -\/ value

    Definition Classes

    DisjunctionInterpretation

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

17.  def clone(): AnyRef

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

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

    Definition Classes

    EvalCreation

20.  def detach[M[_], A](eff: Eff[Fx1[M], A])(implicit arg0: Monad[M], bindRec: BindRecʹ[M]): M[A]

    peel-off the only present effect

    peel-off the only present effect

    Definition Classes

    EffInterpretation

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

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

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

    Definition Classes

    AnyRef

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

    Definition Classes

    AnyRef → Any

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

    Definition Classes

    SafeCreation

26.  def evalState[R, U, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[β$18$]IndexedStateT[[X]X, S, S, β$18$], 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

27.  def evalStateZero[R, U, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[β$17$]IndexedStateT[[X]X, S, S, β$17$], R, U]): Eff[U, A]

    run a state effect, with a Monoidal state

    run a state effect, with a Monoidal state

    Definition Classes

    StateInterpretation

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

    Definition Classes

    SafeCreation

29.  def execSafe[R, U, A](r: Eff[R, A])(implicit m: Aux[Safe, R, U]): Eff[U, \/[Throwable, A]]

    run a safe effect but drop the finalizer errors

    run a safe effect but drop the finalizer errors

    Definition Classes

    SafeInterpretation

30.  def execState[R, U, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[β$20$]IndexedStateT[[X]X, S, S, β$20$], 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

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

32.  def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

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

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

    Definition Classes

    SafeCreation

34.  def flatTraverseA[R, F[_], A, B](fs: F[A])(f: (A) ⇒ Eff[R, F[B]])(implicit FT: Traverse[F], FM: Bind[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

35.  def fromDisjunction[R, E, A](disjunction: \/[E, A])(implicit member: |=[[β$1$]\/[E, β$1$], R]): Eff[R, A]

    create an \/ effect from a single \/ value

    create an \/ effect from a single \/ value

    Definition Classes

    DisjunctionCreation

36.  def get[R, S](implicit member: |=[[β$2$]IndexedStateT[[X]X, S, S, β$2$], R]): Eff[R, S]

    get the current state value

    get the current state value

    Definition Classes

    StateCreation

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

    Definition Classes

    AnyRef → Any

38.  def gets[R, S, T](f: (S) ⇒ T)(implicit member: |=[[β$4$]IndexedStateT[[X]X, S, 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

39.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

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

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

42.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

43.  def left[R, E, A](e: E)(implicit member: |=[[β$2$]\/[E, β$2$], R]): Eff[R, A]

    create a failed value

    create a failed value

    Definition Classes

    DisjunctionCreation

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

45.  def localDisjunction[SR, BR, U, E1, E2, A](r: Eff[SR, A], getter: (E1) ⇒ E2)(implicit sr: Aux[[β$13$]\/[E1, β$13$], SR, U], br: Aux[[β$14$]\/[E2, β$14$], BR, U]): Eff[BR, A]

    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

    DisjunctionInterpretation

46.  def modify[R, S](f: (S) ⇒ S)(implicit member: |=[[β$6$]IndexedStateT[[X]X, S, S, β$6$], R]): Eff[R, Unit]

    modify the current state value

    modify the current state value

    Definition Classes

    StateCreation

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

    Definition Classes

    AnyRef

48.  final def notify(): Unit

    Definition Classes

    AnyRef

49.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

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

    Definition Classes

    EvalCreation

51.  def optionDisjunction[R, E, A](option: Option[A], e: E)(implicit member: |=[[β$0$]\/[E, β$0$], R]): Eff[R, A]

    create an \/ effect from a single Option value

    create an \/ effect from a single Option value

    Definition Classes

    DisjunctionCreation

52.  def otherwise[R, A](action: Eff[R, A], onThrowable: Eff[R, A])(implicit m: /=[Safe, R]): Eff[R, A]

    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

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

    Definition Classes

    SafeCreation

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

    create a pure value

    create a pure value

    Definition Classes

    EffCreation

55.  def put[R, S](s: S)(implicit member: |=[[β$0$]IndexedStateT[[X]X, S, S, β$0$], R]): Eff[R, Unit]

    store a new state value

    store a new state value

    Definition Classes

    StateCreation

56.  def right[R, E, A](a: A)(implicit member: |=[[β$4$]\/[E, β$4$], R]): Eff[R, A]

    create a correct value

    create a correct value

    Definition Classes

    DisjunctionCreation

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

58.  def runDisjunction[R, U, E, A](r: Eff[R, A])(implicit m: Aux[[β$6$]\/[E, β$6$], R, U]): Eff[U, \/[E, A]]

    run the disjunction effect, yielding E \/ A

    run the disjunction effect, yielding E \/ A

    Definition Classes

    DisjunctionInterpretation

59.  def runEither[R, U, E, A](r: Eff[R, A])(implicit m: Aux[[β$9$]\/[E, β$9$], R, U]): Eff[U, Either[E, A]]

    run the disjunction effect, yielding Either[E, A]

    run the disjunction effect, yielding Either[E, A]

    Definition Classes

    DisjunctionInterpretation

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

    Definition Classes

    EvalInterpretation

61.  def runLocalDisjunction[R, U, E1, E2, A](r: Eff[R, A], getter: (E1) ⇒ E2)(implicit sr: Aux[[β$19$]\/[E1, β$19$], R, U], br: |=[[β$20$]\/[E2, β$20$], 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

    DisjunctionInterpretation

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

63.  def runSafe[R, U, A](r: Eff[R, A])(implicit m: Aux[Safe, R, U]): Eff[U, (\/[Throwable, A], List[Throwable])]

    Run a safe effect

    Run a safe effect

    Collect finalizer exceptions if any

    Definition Classes

    SafeInterpretation

64.  def runState[R, U, S1, A](initial: S1)(w: Eff[R, A])(implicit m: Aux[[β$22$]IndexedStateT[[X]X, S1, S1, β$22$], 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

65.  def runStateZero[R, U, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[β$21$]IndexedStateT[[X]X, S, S, β$21$], 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

66.  def runWriter[R, U, O, A, B](w: Eff[R, A])(implicit m: Aux[[β$2$]WriterT[[X]X, 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

67.  def runWriterFold[R, U, O, A, B](w: Eff[R, A])(fold: FoldId[O, B])(implicit m: Aux[[β$3$]WriterT[[X]X, 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

68.  def runWriterUnsafe[R, U, O, A](w: Eff[R, A])(f: (O) ⇒ Unit)(implicit m: Aux[[β$7$]WriterT[[X]X, O, β$7$], R, U]): Eff[U, A]

    Run a side-effecting fold

    Run a side-effecting fold

    Definition Classes

    WriterInterpretation

69.  def safeLoop[R, U, A]: Loop[Safe, R, A, Eff[U, (\/[Throwable, A], Vector[Throwable])], Eff[U, Unit]]

    Definition Classes

    SafeInterpretation

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

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

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

    Definition Classes

    AnyRef

73.  def tell[R, O](o: O)(implicit member: |=[[β$0$]WriterT[[X]X, O, β$0$], R]): Eff[R, Unit]

    write a given value

    write a given value

    Definition Classes

    WriterCreation

74.  def thenFinally[R, A](action: Eff[R, A], last: Eff[R, Unit])(implicit m: _Safe[R]): Eff[R, A]

    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

75.  def toString(): String

    Definition Classes

    AnyRef → Any

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

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

    create an Eff value for ()

    create an Eff value for ()

    Definition Classes

    EffCreation

78.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

81.  def whenFailed[R, A](action: Eff[R, A], onThrowable: (Throwable) ⇒ Eff[R, A])(implicit m: /=[Safe, R]): Eff[R, A]

    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