object all extends WriterEffect with EvalEffect with DisjunctionEffect with SafeEffect with EffInterpretation with EffCreation with EffImplicits
- Alphabetic
- By Inheritance
- all
- EffImplicits
- EffCreation
- EffInterpretation
- SafeEffect
- SafeInterpretation
- SafeCreation
- SafeTypes
- DisjunctionEffect
- DisjunctionInterpretation
- DisjunctionCreation
- EvalEffect
- EvalInterpretation
- EvalCreation
- EvalTypes
- WriterEffect
- WriterInterpretation
- WriterCreation
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- type Eval[A] = Name[A]
- Definition Classes
- EvalTypes
- type ThrowableOr[A] = Either[Throwable, A]
- Definition Classes
- DisjunctionCreation
- type _Eval[R] = Member[Eval, R]
- Definition Classes
- EvalTypes
- type _Safe[R] = MemberInOut[Safe, R]
- Definition Classes
- SafeTypes
- type _ThrowableOr[R] = Member[ThrowableOr, R]
- Definition Classes
- DisjunctionCreation
- type _eval[R] = MemberIn[Eval, R]
- Definition Classes
- EvalTypes
- type _safe[R] = MemberIn[Safe, R]
- Definition Classes
- SafeTypes
- type _throwableOr[R] = MemberIn[ThrowableOr, R]
- Definition Classes
- DisjunctionCreation
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def EffApplicative[R]: Applicative[[β$2$]Eff[R, β$2$]]
- Definition Classes
- EffImplicits
- 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
- implicit def ListFold[A]: FoldId[A, List[A]]
- Definition Classes
- WriterInterpretation
- def MonoidFold[A](implicit arg0: Monoid[A]): FoldId[A, A]
- Definition Classes
- WriterInterpretation
- def UnsafeFold[A](f: (A) => Unit): FoldId[A, Unit]
- Definition Classes
- WriterInterpretation
- 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
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- 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
- def attemptEval[R, U, A](r: Eff[R, A])(implicit m: Aux[Eval, R, U]): Eff[U, Either[Throwable, A]]
- Definition Classes
- EvalInterpretation
- 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
- 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
- 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
- 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
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @IntrinsicCandidate()
- 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
- def delay[R, A](a: => A)(implicit arg0: _eval[R]): Eff[R, A]
- Definition Classes
- EvalCreation
- 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
- 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
- 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
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def eval[R, A](a: Name[A])(implicit arg0: _safe[R]): Eff[R, A]
- Definition Classes
- SafeCreation
- def exception[R, A](t: Throwable)(implicit arg0: _safe[R]): Eff[R, A]
- Definition Classes
- SafeCreation
- 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
- def finalizerException[R](t: Throwable)(implicit arg0: _safe[R]): Eff[R, Unit]
- Definition Classes
- SafeCreation
- 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
- 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
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
- 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
- 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
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- 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
- implicit def naturalInto[R, U](into: IntoPoly[R, U]): ~>[[β$4$]Eff[R, β$4$], [β$5$]Eff[U, β$5$]]
- Definition Classes
- EffImplicits
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
- def now[R, A](a: A)(implicit arg0: _eval[R]): Eff[R, A]
- Definition Classes
- EvalCreation
- 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
- 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
- def protect[R, A](a: => A)(implicit arg0: _safe[R]): Eff[R, A]
- Definition Classes
- SafeCreation
- def pure[R, A](a: A): Eff[R, A]
create a pure value
create a pure value
- Definition Classes
- EffCreation
- 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
- 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
- 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
- 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
- def runEval[R, U, A](r: Eff[R, A])(implicit m: Aux[Eval, R, U]): Eff[U, A]
- Definition Classes
- EvalInterpretation
- 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
- 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
- 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
- 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
- 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
- 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
- def safeLoop[R, U, A]: Loop[Safe, R, A, Eff[U, (Either[Throwable, A], Vector[Throwable])], Eff[U, Unit]]
- Definition Classes
- SafeInterpretation
- 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
- 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
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- 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
- 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
- def toString(): String
- Definition Classes
- AnyRef → Any
- 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
- def unit[R]: Eff[R, Unit]
create an Eff value for ()
create an Eff value for ()
- Definition Classes
- EffCreation
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- 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
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated