object all extends ReaderEffect with WriterEffect with StateEffect with EvalEffect with OptionEffect with ListEffect with EitherEffect with ValidateEffect with ChooseEffect with SafeEffect with MemoEffect with Batch with EffInterpretation with EffCreation with EffImplicits
- Source
- package.scala
- Alphabetic
- By Inheritance
- all
- EffImplicits
- EffCreation
- EffInterpretation
- Batch
- MemoEffect
- MemoInterpretation
- MemoCreation
- MemoTypes
- SafeEffect
- SafeInterpretation
- SafeCreation
- SafeTypes
- ChooseEffect
- ChooseInterpretation
- ChooseCreation
- ValidateEffect
- ValidateInterpretation
- ValidateCreation
- EitherEffect
- EitherInterpretation
- EitherCreation
- ListEffect
- ListInterpretation
- ListCreation
- OptionEffect
- OptionInterpretation
- OptionCreation
- EvalEffect
- EvalInterpretation
- EvalCreation
- EvalTypes
- StateEffect
- StateInterpretation
- StateCreation
- WriterEffect
- WriterInterpretation
- WriterCreation
- ReaderEffect
- ReaderInterpretation
- ReaderCreation
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
type
Out[A] = (EitherEffect.ThrowableEither[A], List[Throwable])
- Definition Classes
- SafeInterpretation
-
type
ThrowableEither[A] = Either[Throwable, A]
- Definition Classes
- EitherCreation
-
type
_Choose[R] = Member[Choose, R]
- Definition Classes
- ChooseCreation
-
type
_Eval[R] = Member[Eval, R]
- Definition Classes
- EvalTypes
-
type
_List[R] = Member[List, R]
- Definition Classes
- ListCreation
-
type
_Memo[R] = Member[Memoized, R]
- Definition Classes
- MemoTypes
-
type
_Option[R] = Member[Option, R]
- Definition Classes
- OptionCreation
-
type
_Safe[R] = Member[Safe, R]
- Definition Classes
- SafeTypes
-
type
_ThrowableEither[R] = Member[ThrowableEither, R]
- Definition Classes
- EitherCreation
-
type
_choose[R] = MemberIn[Choose, R]
- Definition Classes
- ChooseCreation
-
type
_eval[R] = MemberIn[Eval, R]
- Definition Classes
- EvalTypes
-
type
_list[R] = MemberIn[List, R]
- Definition Classes
- ListCreation
-
type
_memo[R] = MemberIn[Memoized, R]
- Definition Classes
- MemoTypes
-
type
_option[R] = MemberIn[Option, R]
- Definition Classes
- OptionCreation
-
type
_safe[R] = MemberIn[Safe, R]
- Definition Classes
- SafeTypes
-
type
_throwableEither[R] = MemberIn[ThrowableEither, R]
- Definition Classes
- EitherCreation
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
-
final
def
EffApplicative[R]: Applicative[[β$8$]Eff[R, β$8$]]
- Definition Classes
- EffImplicits
-
implicit final
def
EffMonad[R]: Monad[[β$6$]Eff[R, β$6$]]
- Definition Classes
- EffImplicits
-
def
EitherApplicative[E](implicit s: Semigroup[E]): Applicative[[β$33$]Either[E, β$33$]]
- Definition Classes
- EitherInterpretation
-
def
EvalFold[A](f: (A) ⇒ Eval[Unit]): RightFold[A, Eval[Unit]]
- Definition Classes
- WriterInterpretation
-
def
IntoMonoidFold[M, A](f: (A) ⇒ M)(implicit arg0: Monoid[M]): RightFold[A, M]
- Definition Classes
- WriterInterpretation
-
implicit
def
ListFold[A]: RightFold[A, List[A]]
- Definition Classes
- WriterInterpretation
-
def
MonoidFold[A](implicit arg0: Monoid[A]): RightFold[A, A]
- 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
ask[R, T](implicit member: |=[[β$0$]Kleisli[[A]A, T, β$0$], R]): Eff[R, T]
get the environment
get the environment
- Definition Classes
- ReaderCreation
-
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
attemptEither[R, E, A](effect: Eff[R, A])(implicit member: /=[[β$11$]Either[E, β$11$], R]): Eff[R, Either[E, A]]
catch possible left values
catch possible left values
- Definition Classes
- EitherInterpretation
-
def
attemptEval[R, U, A](effect: Eff[R, A])(implicit m: Aux[Eval, R, U]): Eff[U, Either[Throwable, A]]
- Definition Classes
- EvalInterpretation
-
def
attemptSafe[R, A](effect: 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
-
def
batch[R, T[_], A](eff: Eff[R, A])(implicit batchable: Batchable[T], m: /=[T, R]): Eff[R, A]
- Definition Classes
- Batch
-
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
-
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
-
def
catchAllWrongs[R, E, A](effect: Eff[R, A])(handle: (NonEmptyList[E]) ⇒ Eff[R, A])(implicit member: <=[[β$23$]Validate[E, β$23$], R]): Eff[R, A]
catch and handle all wrong values
catch and handle all wrong values
- Definition Classes
- ValidateInterpretation
-
def
catchFirstWrong[R, E, A](effect: Eff[R, A])(handle: (E) ⇒ Eff[R, A])(implicit member: <=[[β$21$]Validate[E, β$21$], R]): Eff[R, A]
catch and handle the first wrong value
catch and handle the first wrong value
- Definition Classes
- ValidateInterpretation
-
def
catchLastWrong[R, E, A](effect: Eff[R, A])(handle: (E) ⇒ Eff[R, A])(implicit member: <=[[β$22$]Validate[E, β$22$], R]): Eff[R, A]
catch and handle the last wrong value
catch and handle the last wrong value
- Definition Classes
- ValidateInterpretation
-
def
catchLeft[R, E, A](effect: Eff[R, A])(handle: (E) ⇒ Eff[R, A])(implicit member: /=[[β$12$]Either[E, β$12$], R]): Eff[R, A]
catch and handle a possible left value
catch and handle a possible left value
- Definition Classes
- EitherInterpretation
-
def
catchLeftCombine[R, E, A](effect: Eff[R, A])(handle: (E) ⇒ Eff[R, A])(implicit member: /=[[β$14$]Either[E, β$14$], 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
-
def
catchNonFatalThrowable[R, A](a: ⇒ A)(implicit member: |=[ThrowableEither, 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
-
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
-
def
catchWrongs[R, E, A, S[_]](effect: Eff[R, A])(handle: (S[E]) ⇒ Eff[R, A])(implicit arg0: Applicative[S], member: <=[[β$19$]Validate[E, β$19$], R], semi: Semigroup[S[E]]): Eff[R, A]
catch and handle possible wrong values
catch and handle possible wrong values
- Definition Classes
- ValidateInterpretation
-
def
chooseFrom[R, A](as: List[A])(implicit arg0: _choose[R]): Eff[R, A]
- Definition Classes
- ChooseCreation
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
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
correct[R, E, A](a: A)(implicit m: |=[[β$5$]Validate[E, β$5$], R]): Eff[R, A]
create a correct value
create a correct value
- Definition Classes
- ValidateCreation
-
def
defer[R, A](eff: ⇒ Eval[Eff[R, A]])(implicit arg0: _eval[R]): Eff[R, A]
- Definition Classes
- EvalCreation
-
def
delay[R, A](a: ⇒ A)(implicit arg0: _eval[R]): Eff[R, A]
- Definition Classes
- EvalCreation
-
def
detach[M[_], A, E](eff: Eff[Fx1[M], A])(implicit monad: MonadError[M, E]): M[A]
peel-off the only present effect
peel-off the only present effect
- Definition Classes
- EffInterpretation
-
def
detach[M[_], R, A, E](eff: Eff[R, A])(implicit monad: MonadError[M, E], m: Aux[M, R, NoFx]): M[A]
peel-off the only present effect
peel-off the only present effect
- Definition Classes
- EffInterpretation
-
def
detachA[M[_], A, E](eff: Eff[Fx1[M], A])(implicit monad: MonadError[M, E], 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
detachA[M[_], R, A, E](eff: Eff[R, A])(implicit monad: MonadError[M, E], applicative: Applicative[M], member: Aux[M, R, NoFx]): 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
-
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
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
eval[R, A](a: Eval[A])(implicit arg0: _safe[R]): Eff[R, A]
- Definition Classes
- SafeCreation
-
def
evalState[R, U, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[β$19$]IndexedStateT[Eval, S, 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
-
def
evalStateZero[R, U, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[β$18$]IndexedStateT[Eval, S, 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
-
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, EitherEffect.ThrowableEither[A]]
run a safe effect but drop the finalizer errors
run a safe effect but drop the finalizer errors
- Definition Classes
- SafeInterpretation
-
def
execState[R, U, S, A](initial: S)(w: Eff[R, A])(implicit m: Aux[[β$21$]IndexedStateT[Eval, S, 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
-
def
execStateZero[R, U, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[β$20$]IndexedStateT[Eval, S, 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
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
finalizerException[R](t: Throwable)(implicit arg0: _safe[R]): Eff[R, Unit]
- Definition Classes
- SafeCreation
-
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
-
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
-
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
-
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
-
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
-
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
-
def
get[R, S](implicit member: |=[[β$2$]IndexedStateT[Eval, S, S, β$2$], R]): Eff[R, S]
get the current state value
get the current state value
- Definition Classes
- StateCreation
-
def
getCache[R](implicit arg0: _memo[R]): Eff[R, Cache]
- Definition Classes
- MemoCreation
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
gets[R, S, T](f: (S) ⇒ T)(implicit member: |=[[β$4$]IndexedStateT[Eval, 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
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
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, A, B](value: A, continuation: Continuation[R, A, B], map: (B) ⇒ B): Eff[R, B]
create a delayed impure value
create a delayed impure value
- Definition Classes
- EffCreation
-
def
impure[R, A, B](value: A, continuation: Continuation[R, A, B]): Eff[R, B]
create a delayed impure value
create a delayed impure value
- Definition Classes
- EffCreation
-
def
impure[R, X, A](union: Union[R, X], continuation: Continuation[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
-
def
intoState[TS, SS, U1, U2, T, S, A](state: Eff[TS, A], getter: (S) ⇒ T, setter: (S, T) ⇒ S)(implicit ts: Aux[[β$28$]IndexedStateT[Eval, T, T, β$28$], TS, U1], ss: Aux[[β$29$]IndexedStateT[Eval, S, S, β$29$], SS, U2], into: IntoPoly[U1, U2]): Eff[SS, A]
General lifting of a state effect into another from one stack to another.
General lifting of a state effect into another from one stack to another. This will require a type annotation
- Definition Classes
- StateInterpretation
-
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
- EitherCreation
-
def
lensState[TS, SS, U, T, S, A](state: Eff[TS, A], getter: (S) ⇒ T, setter: (S, T) ⇒ S)(implicit ts: Aux[[β$26$]IndexedStateT[Eval, T, T, β$26$], TS, U], ss: Aux[[β$27$]IndexedStateT[Eval, 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
-
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
-
def
localEither[R, E, A](e: Eff[R, A])(modify: (E) ⇒ E)(implicit m: /=[[β$30$]Either[E, β$30$], 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
-
def
localKleisli[R, T, U, F[_]](f: (T) ⇒ F[U])(implicit member: |=[[γ$3$]Kleisli[F, T, γ$3$], R]): Eff[R, U]
modify the environment using a Kleisli[F, T, *]
modify the environment using a Kleisli[F, T, *]
- Definition Classes
- ReaderCreation
-
def
localReader[R, T, A](e: Eff[R, A])(modify: (T) ⇒ T)(implicit r: /=[[β$17$]Kleisli[[A]A, T, β$17$], 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
-
def
localState[R, S, A](e: Eff[R, A])(modify: (S) ⇒ S)(implicit s: /=[[β$34$]IndexedStateT[Eval, S, S, β$34$], 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
-
def
memoize[R, A](key: AnyRef, a: ⇒ A)(implicit arg0: _memo[R]): Eff[R, A]
- Definition Classes
- MemoCreation
-
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
-
def
modify[R, S](f: (S) ⇒ S)(implicit member: |=[[β$6$]IndexedStateT[Eval, S, S, β$6$], R]): Eff[R, Unit]
modify the current state value
modify the current state value
- Definition Classes
- StateCreation
-
implicit final
val
monadErrorEval: MonadError[Eval, Throwable]
the monad error instance for Eval is useful for using detach on Eff[Fx1[Eval], A]
the monad error instance for Eval is useful for using detach on Eff[Fx1[Eval], A]
- Definition Classes
- EvalInterpretation
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
none[R, A](implicit arg0: _option[R]): Eff[R, A]
no value returned
no value returned
- Definition Classes
- OptionCreation
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
now[R, A](a: A)(implicit arg0: _eval[R]): Eff[R, A]
- Definition Classes
- EvalCreation
-
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
-
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
-
def
plus[R, A](a1: ⇒ Eff[R, A], a2: ⇒ Eff[R, A])(implicit arg0: _choose[R]): Eff[R, A]
- Definition Classes
- ChooseCreation
-
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
put[R, S](s: S)(implicit member: |=[[β$0$]IndexedStateT[Eval, S, S, β$0$], R]): Eff[R, Unit]
store a new state value
store a new state value
- Definition Classes
- StateCreation
-
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
-
def
retryUntil[R, A](e: Eff[R, A], condition: (A) ⇒ Boolean, durations: List[FiniteDuration], waitFor: (FiniteDuration) ⇒ Eff[R, Unit]): Eff[R, A]
- 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
- EitherCreation
-
def
run[A](eff: Eff[NoFx, A]): A
base runner for an Eff value having no effects at all the execution is trampolined using Eval
base runner for an Eff value having no effects at all the execution is trampolined using Eval
- Definition Classes
- EffInterpretation
-
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
-
def
runEither[R, U, E, A](effect: Eff[R, A])(implicit m: Aux[[β$7$]Either[E, β$7$], 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
-
def
runEitherCatchLeft[R, U, E, A](r: Eff[R, A])(handle: (E) ⇒ Eff[U, A])(implicit m: Aux[[β$13$]Either[E, β$13$], R, U]): Eff[U, A]
run the Either effect, handling E (with effects) and yielding A
run the Either effect, handling E (with effects) and yielding A
- Definition Classes
- EitherInterpretation
-
def
runEitherCombine[R, U, E, A](effect: Eff[R, A])(implicit m: Aux[[β$8$]Either[E, β$8$], 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
-
def
runEval[R, U, A](effect: Eff[R, A])(implicit m: Aux[Eval, R, U]): Eff[U, A]
- Definition Classes
- EvalInterpretation
-
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
-
def
runIorMap[R, U, E, L, A](effect: Eff[R, A])(map: (E) ⇒ L)(implicit arg0: Semigroup[L], m: Aux[[β$16$]Validate[E, β$16$], R, U]): Eff[U, Ior[L, A]]
run the validate effect, yielding a list of failures or A or both
run the validate effect, yielding a list of failures or A or both
- Definition Classes
- ValidateInterpretation
-
def
runIorNel[R, U, E, A](r: Eff[R, A])(implicit m: Aux[[β$15$]Validate[E, β$15$], R, U]): Eff[U, IorNel[E, A]]
run the validate effect, yielding a non-empty list of failures or A or both
run the validate effect, yielding a non-empty list of failures or A or both
- Definition Classes
- ValidateInterpretation
-
def
runKleisli[R, U, S, A, F[_]](env: S)(e: Eff[R, A])(implicit mx: Aux[[γ$7$]Kleisli[F, S, γ$7$], R, U], m: |=[F, U]): Eff[U, A]
interpret the Kleisli effect by providing an environment when required and translating the resulting target effect into the same stack
interpret the Kleisli effect by providing an environment when required and translating the resulting target effect into the same stack
- Definition Classes
- ReaderInterpretation
-
def
runList[R, U, A](effect: 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
-
def
runMap[R, U, E, L, A](effect: Eff[R, A])(map: (E) ⇒ L)(implicit arg0: Semigroup[L], m: Aux[[β$14$]Validate[E, β$14$], 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
-
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
-
def
runNel[R, U, E, A](r: Eff[R, A])(implicit m: Aux[[β$13$]Validate[E, β$13$], 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
-
def
runOption[R, U, A](effect: 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
-
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
runReader[R, U, A, B](env: A)(effect: Eff[R, B])(implicit m: Aux[[β$5$]Kleisli[[A]A, A, β$5$], 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
-
def
runSafe[R, U, A](effect: 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
-
def
runState[R, U, S1, A](initial: S1)(w: Eff[R, A])(implicit m: Aux[[β$23$]IndexedStateT[Eval, S1, 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
-
def
runStateZero[R, U, S, A](w: Eff[R, A])(implicit arg0: Monoid[S], m: Aux[[β$22$]IndexedStateT[Eval, S, 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
-
def
runValidatedNel[R, U, E, A](r: Eff[R, A])(implicit m: Aux[[β$12$]Validate[E, β$12$], R, U]): Eff[U, ValidatedNel[E, A]]
run the validate effect, yielding a ValidatedNel
run the validate effect, yielding a ValidatedNel
- Definition Classes
- ValidateInterpretation
-
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
-
def
runWriterEval[R, U, O, A](w: Eff[R, A])(f: (O) ⇒ Eval[Unit])(implicit m: Aux[[β$7$]WriterT[[A]A, O, β$7$], R, U], ev: |=[Eval, U]): Eff[U, A]
- Definition Classes
- WriterInterpretation
-
def
runWriterFold[R, U, O, A, B](w: Eff[R, A])(fold: RightFold[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
-
def
runWriterIntoMonoid[R, U, O, M, A](w: Eff[R, A])(f: (O) ⇒ M)(implicit m: Aux[[β$9$]WriterT[[A]A, O, β$9$], R, U], M: Monoid[M]): Eff[U, (A, M)]
- Definition Classes
- WriterInterpretation
-
def
runWriterMonoid[R, U, O, A](w: Eff[R, A])(implicit m: Aux[[β$8$]WriterT[[A]A, O, β$8$], R, U], O: Monoid[O]): Eff[U, (A, O)]
- Definition Classes
- WriterInterpretation
-
def
runWriterUnsafe[R, U, O, A](w: Eff[R, A])(f: (O) ⇒ Unit)(implicit m: Aux[[β$5$]WriterT[[A]A, O, β$5$], R, U]): Eff[U, A]
Run a side-effecting fold
Run a side-effecting fold
- Definition Classes
- WriterInterpretation
-
def
safeInterpreter[R, A](last: Option[(Eff[R, Unit], /=[Safe, R])]): Interpreter[Safe, R, A, Out[A]]
- Definition Classes
- SafeInterpretation
-
def
safeInterpreter[R, A]: Interpreter[Safe, R, A, Out[A]]
- Definition Classes
- SafeInterpretation
-
def
safeMemo[R, A](key: AnyRef, cache: Cache, e: Eff[R, A])(implicit safe: /=[Safe, R]): Eff[R, A]
Memoize safe effects using a cache
Memoize safe effects using a cache
if this method is called with the same key the previous value will be returned
- 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
-
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
-
def
some[R, A](a: A)(implicit arg0: _option[R]): Eff[R, A]
a value is returned
a value is returned
- Definition Classes
- OptionCreation
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
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
-
def
thenFinally[R, A](effect: 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
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
translateEither[R, U, E1, E2, A](r: Eff[R, A], getter: (E1) ⇒ E2)(implicit sr: Aux[[β$27$]Either[E1, β$27$], R, U], br: |=[[β$28$]Either[E2, β$28$], 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
-
def
translateReader[R, U, S, B, A](e: Eff[R, A], getter: (B) ⇒ S)(implicit sr: Aux[[β$9$]Kleisli[[A]A, S, β$9$], R, U], br: |=[[β$10$]Kleisli[[A]A, B, β$10$], 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
-
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
-
def
validateCheck[R, E](condition: Boolean, e: ⇒ E)(implicit m: |=[[β$10$]Validate[E, β$10$], R]): Eff[R, Unit]
check a correct condition
check a correct condition
- Definition Classes
- ValidateCreation
-
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
-
def
validateIor[R, E, A](ior: Ior[E, A])(implicit m: |=[[β$2$]Validate[E, β$2$], R]): Eff[R, Unit]
create an Validate effect from a single Ior value
create an Validate effect from a single Ior value
- Definition Classes
- ValidateCreation
-
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
-
def
validateValue[R, E, A](condition: Boolean, a: ⇒ A, e: ⇒ E)(implicit m: |=[[β$11$]Validate[E, β$11$], R]): Eff[R, A]
check a correct value
check a correct value
- Definition Classes
- ValidateCreation
-
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
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
warning[R, E, A](a: A, e: E)(implicit m: |=[[β$9$]Validate[E, β$9$], R]): Eff[R, A]
create a correct value with warning
create a correct value with warning
- Definition Classes
- ValidateCreation
-
def
warning[R, E](e: E)(implicit m: |=[[β$7$]Validate[E, β$7$], R]): Eff[R, Unit]
create a pure warning
create a pure warning
- Definition Classes
- ValidateCreation
-
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
-
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
-
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
-
def
wrong[R, E](e: E)(implicit m: |=[[β$3$]Validate[E, β$3$], R]): Eff[R, Unit]
create a failed value
create a failed value
- Definition Classes
- ValidateCreation
-
def
zero[R, A](implicit arg0: _choose[R]): Eff[R, A]
- Definition Classes
- ChooseCreation
-
def
zoomEither[SR, BR, U1, U2, E1, E2, A](r: Eff[SR, A], getter: (E1) ⇒ E2)(implicit sr: Aux[[β$21$]Either[E1, β$21$], SR, U1], br: Aux[[β$22$]Either[E2, β$22$], BR, U2], into: IntoPoly[U1, U2]): 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
-
def
zoomReader[R1, R2, U, S, T, A](e: Eff[R1, A])(f: (T) ⇒ S)(implicit readerS: Aux[[β$13$]Kleisli[[A]A, S, β$13$], R1, U], readerT: Aux[[β$14$]Kleisli[[A]A, T, β$14$], 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
Deprecated Value Members
-
def
catchWrong[R, E, A](effect: Eff[R, A])(handle: (E) ⇒ Eff[R, A])(implicit member: <=[[β$24$]Validate[E, β$24$], R]): Eff[R, A]
catch and handle possible wrong values
catch and handle possible wrong values
- Definition Classes
- ValidateInterpretation
- Annotations
- @deprecated
- Deprecated
(Since version 5.4.2) Use catchFirstWrong or more general catchWrongs instead
-
final
def
effApplicativeUnsafe: Applicative[[β$3$]Eff[AnyRef, β$3$]]
- Definition Classes
- EffImplicits
- Annotations
- @deprecated
- Deprecated
(Since version ) use EffApplicative
-
final
def
effMonadUnsafe: Monad[[β$0$]Eff[AnyRef, β$0$]]
- Definition Classes
- EffImplicits
- Annotations
- @deprecated
- Deprecated
(Since version ) use EffMonad