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[[β$2$]Eff[R, β$2$]]

   Definition Classes

   EffImplicits

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

   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, Either[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, Either[Throwable, A]]

    Definition Classes

    EvalInterpretation

13.  def attemptSafe[R, A](r: Eff[R, A])(implicit m: /=[Safe, R]): Eff[R, (Either[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$]Either[E, β$10$], R]): Eff[R, A]

    catch and handle a possible Left value

    catch and handle a possible Left 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

    @native() @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]): 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], 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 exception[R, A](t: Throwable)(implicit arg0: _safe[R]): Eff[R, A]

    Definition Classes

    SafeCreation

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

    run a safe effect but drop the finalizer errors

    run a safe effect but drop the finalizer errors

    Definition Classes

    SafeInterpretation

28.  def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

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

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

    Definition Classes

    SafeCreation

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

31.  def fromDisjunction[R, E, A](disjunction: 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

    DisjunctionCreation

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

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

33.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

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

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

36.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

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

    DisjunctionCreation

38.  implicit def naturalInto[R, U](into: IntoPoly[R, U]): ~>[[β$4$]Eff[R, β$4$], [β$5$]Eff[U, β$5$]]

    Definition Classes

    EffImplicits

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

    Definition Classes

    AnyRef

40.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

41.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

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

    Definition Classes

    EvalCreation

43.  def optionDisjunction[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

    DisjunctionCreation

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

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

    Definition Classes

    SafeCreation

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

    create a pure value

    create a pure value

    Definition Classes

    EffCreation

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

    DisjunctionCreation

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

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

    run the disjunction effect, yielding E Either A

    run the disjunction effect, yielding E Either A

    Definition Classes

    DisjunctionInterpretation

50.  def runEither[R, U, E, A](r: Eff[R, A])(implicit m: Aux[[β$9$]Either[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

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

    Definition Classes

    EvalInterpretation

52.  def runLocalDisjunction[R, U, E1, E2, A](r: Eff[R, A], getter: (E1) ⇒ E2)(implicit sr: Aux[[β$13$]Either[E1, β$13$], R, U], br: |=[[β$14$]Either[E2, β$14$], 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

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

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

    Run a safe effect

    Run a safe effect

    Collect finalizer exceptions if any

    Definition Classes

    SafeInterpretation

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

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

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

    Run a side-effecting fold

    Run a side-effecting fold

    Definition Classes

    WriterInterpretation

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

    Definition Classes

    SafeInterpretation

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

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

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

    Definition Classes

    AnyRef

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

    write a given value

    write a given value

    Definition Classes

    WriterCreation

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

64.  def toString(): String

    Definition Classes

    AnyRef → Any

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

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

    create an Eff value for ()

    create an Eff value for ()

    Definition Classes

    EffCreation

67.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @native() @throws( ... )

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