create

Type members

Inherited types

type ThrowableEither[A] = Either[Throwable, A]
Inherited from
EitherCreation
type _Choose[R] = Member[[T] =>> Choose[T], R]
Inherited from
ChooseCreation
type _Eval[R] = Member[[A] =>> Eval[A], R]
Inherited from
EvalTypes
type _Future[R] = Member[[A] =>> TimedFuture[A], R]
Inherited from
FutureTypes
type _List[R] = Member[List, R]
Inherited from
ListCreation
type _Memo[R] = Member[[A] =>> Memoized[A], R]
Inherited from
MemoTypes
type _Option[R] = Member[[A] =>> Option[A], R]
Inherited from
OptionCreation
type _Safe[R] = Member[[A] =>> Safe[A], R]
Inherited from
SafeTypes
type _choose[R] = MemberIn[[T] =>> Choose[T], R]
Inherited from
ChooseCreation
type _eval[R] = MemberIn[[A] =>> Eval[A], R]
Inherited from
EvalTypes
type _future[R] = MemberIn[[A] =>> TimedFuture[A], R]
Inherited from
FutureTypes
type _list[R] = MemberIn[List, R]
Inherited from
ListCreation
type _memo[R] = MemberIn[[A] =>> Memoized[A], R]
Inherited from
MemoTypes
type _option[R] = MemberIn[[A] =>> Option[A], R]
Inherited from
OptionCreation
type _safe[R] = MemberIn[[A] =>> Safe[A], R]
Inherited from
SafeTypes

Value members

Inherited methods

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

Inherited from
EffCreation
def ask[R, T](implicit member: MemberIn[[_] =>> Reader[T, _$1], R]): Eff[R, T]

get the environment

get the environment

Inherited from
ReaderCreation
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

Inherited from
EffCreation
def catchNonFatalThrowable[R, A](a: => A)(implicit member: MemberIn[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

Inherited from
EitherCreation
def chooseFrom[R, A](as: List[A])(implicit evidence$3: _choose[R]): Eff[R, A]
Inherited from
ChooseCreation
def collapse[R, M[_], A](r: Eff[R, M[A]])(implicit m: MemberIn[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

Inherited from
EffCreation
def correct[R, E, A](a: A)(implicit m: MemberIn[[_] =>> Validate[E, _$10], R]): Eff[R, A]

create a correct value

create a correct value

Inherited from
ValidateCreation
def defer[R, A](eff: => Eval[Eff[R, A]])(implicit evidence$3: _eval[R]): Eff[R, A]
Inherited from
EvalCreation
def delay[R, A](a: => A)(implicit evidence$2: _eval[R]): Eff[R, A]
Inherited from
EvalCreation
def empty[R, A](implicit evidence$1: _list[R]): Eff[R, A]

create a list effect with no values

create a list effect with no values

Inherited from
ListCreation
def eval[R, A](a: Eval[A])(implicit evidence$2: _safe[R]): Eff[R, A]
Inherited from
SafeCreation
def exception[R, A](t: Throwable)(implicit evidence$3: _safe[R]): Eff[R, A]
Inherited from
SafeCreation
def finalizerException[R](t: Throwable)(implicit evidence$4: _safe[R]): Eff[R, Unit]
Inherited from
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

Inherited from
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

Inherited from
EffCreation
def fromCatchNonFatal[R, E, A](a: => A)(onThrowable: Throwable => E)(implicit member: MemberIn[[_] =>> Either[E, _$7], 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

Inherited from
EitherCreation
def fromEither[R, E, A](Either: Either[E, A])(implicit member: MemberIn[[_] =>> Either[E, _$2], R]): Eff[R, A]

create an Either effect from a single Either value

create an Either effect from a single Either value

Inherited from
EitherCreation
final def fromFuture[R, A](c: => Future[A], timeout: Option[FiniteDuration])(implicit evidence$2: _future[R]): Eff[R, A]
Inherited from
FutureCreation
final def fromFutureWithExecutors[R, A](c: (Scheduler, ExecutionContext) => Future[A], timeout: Option[FiniteDuration])(implicit evidence$1: _future[R]): Eff[R, A]
Inherited from
FutureCreation
def fromList[R, A](as: List[A])(implicit evidence$4: _list[R]): Eff[R, A]

create a list effect from a list of values

create a list effect from a list of values

Inherited from
ListCreation
def fromOption[R, A](o: Option[A])(implicit evidence$1: _option[R]): Eff[R, A]

create an Option effect from a single Option value

create an Option effect from a single Option value

Inherited from
OptionCreation
final def futureDefer[R, A](a: => Future[A], timeout: Option[FiniteDuration])(implicit evidence$7: _future[R]): Eff[R, A]
Inherited from
FutureCreation
final def futureDelay[R, A](a: => A, timeout: Option[FiniteDuration])(implicit evidence$5: _future[R]): Eff[R, A]
Inherited from
FutureCreation
final def futureFail[R, A](t: Throwable)(implicit evidence$3: _future[R]): Eff[R, A]
Inherited from
FutureCreation
final def futureFork[R, A](a: => A, ec: ExecutionContext, timeout: Option[FiniteDuration])(implicit evidence$6: _future[R]): Eff[R, A]
Inherited from
FutureCreation
final def futureFromEither[R, A](e: Either[Throwable, A])(implicit evidence$4: _future[R]): Eff[R, A]
Inherited from
FutureCreation
def get[R, S](implicit member: MemberIn[[_] =>> State[S, _$3], R]): Eff[R, S]

get the current state value

get the current state value

Inherited from
StateCreation
def getCache[R](implicit evidence$2: _memo[R]): Eff[R, Cache]
Inherited from
MemoCreation
def gets[R, S, T](f: S => T)(implicit member: MemberIn[[_] =>> State[S, _$5], 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

Inherited from
StateCreation
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

Inherited from
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

Inherited from
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

Inherited from
EffCreation
def left[R, E, A](e: E)(implicit member: MemberIn[[_] =>> Either[E, _$3], R]): Eff[R, A]

create a failed value

create a failed value

Inherited from
EitherCreation
def local[R, T, U](f: T => U)(implicit member: MemberIn[[_] =>> Reader[T, _$2], R]): Eff[R, U]

modify the environment

modify the environment

Inherited from
ReaderCreation
def localKleisli[R, T, U, F[_]](f: T => F[U])(implicit member: MemberIn[[_] =>> Kleisli[F, T, _$5], R]): Eff[R, U]

modify the environment using a Kleisli[F, T, *]

modify the environment using a Kleisli[F, T, *]

Inherited from
ReaderCreation
def memoize[R, A](key: AnyRef, a: => A)(implicit evidence$1: _memo[R]): Eff[R, A]
Inherited from
MemoCreation
def modify[R, S](f: S => S)(implicit member: MemberIn[[_] =>> State[S, _$7], R]): Eff[R, Unit]

modify the current state value

modify the current state value

Inherited from
StateCreation
def none[R, A](implicit evidence$2: _option[R]): Eff[R, A]

no value returned

no value returned

Inherited from
OptionCreation
def now[R, A](a: A)(implicit evidence$1: _eval[R]): Eff[R, A]
Inherited from
EvalCreation
def optionEither[R, E, A](option: Option[A], e: => E)(implicit member: MemberIn[[_] =>> Either[E, _$1], R]): Eff[R, A]

create an Either effect from a single Option value

create an Either effect from a single Option value

Inherited from
EitherCreation
def plus[R, A](a1: => Eff[R, A], a2: => Eff[R, A])(implicit evidence$2: _choose[R]): Eff[R, A]
Inherited from
ChooseCreation
def protect[R, A](a: => A)(implicit evidence$1: _safe[R]): Eff[R, A]
Inherited from
SafeCreation
def pure[R, A](a: A): Eff[R, A]

create a pure value

create a pure value

Inherited from
EffCreation
def put[R, S](s: S)(implicit member: MemberIn[[_] =>> State[S, _$1], R]): Eff[R, Unit]

store a new state value

store a new state value

Inherited from
StateCreation
def retryUntil[R, A](e: Eff[R, A], condition: A => Boolean, durations: List[FiniteDuration], waitFor: FiniteDuration => Eff[R, Unit]): Eff[R, A]
Inherited from
EffCreation
def retryUntil[R, A](e: Eff[R, A], condition: A => Boolean, durations: List[FiniteDuration])(implicit evidence$8: _future[R]): Eff[R, A]
Inherited from
FutureCreation
def right[R, E, A](a: A)(implicit member: MemberIn[[_] =>> Either[E, _$5], R]): Eff[R, A]

create a correct value

create a correct value

Inherited from
EitherCreation
def send[T[_], R, V](tv: T[V])(implicit member: MemberIn[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

Inherited from
EffCreation
def sequenceA[R, F[_], A](fs: F[Eff[R, A]])(implicit evidence$2: 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

Inherited from
EffCreation
def singleton[R, A](a: A)(implicit evidence$2: _list[R]): Eff[R, A]

create a list effect from a single value

create a list effect from a single value

Inherited from
ListCreation
def some[R, A](a: A)(implicit evidence$3: _option[R]): Eff[R, A]

a value is returned

a value is returned

Inherited from
OptionCreation
def tell[R, O](o: O)(implicit member: MemberIn[[_] =>> Writer[O, _$1], R]): Eff[R, Unit]

write a given value

write a given value

Inherited from
WriterCreation
def traverseA[R, F[_], A, B](fs: F[A])(f: A => Eff[R, B])(implicit evidence$1: 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

Inherited from
EffCreation
def unit[R]: Eff[R, Unit]

create an Eff value for ()

create an Eff value for ()

Inherited from
EffCreation
def validateCheck[R, E](condition: Boolean, e: => E)(implicit m: MemberIn[[_] =>> Validate[E, _$15], R]): Eff[R, Unit]

check a correct condition

check a correct condition

Inherited from
ValidateCreation
def validateEither[R, E, A](either: Either[E, A])(implicit m: MemberIn[[_] =>> Validate[E, _$3], R]): Eff[R, Unit]

create an Validate effect from a single Either value

create an Validate effect from a single Either value

Inherited from
ValidateCreation
def validateIor[R, E, A](ior: Ior[E, A])(implicit m: MemberIn[[_] =>> Validate[E, _$5], R]): Eff[R, Unit]

create an Validate effect from a single Ior value

create an Validate effect from a single Ior value

Inherited from
ValidateCreation
def validateOption[R, E, A](option: Option[A], e: => E)(implicit m: MemberIn[[_] =>> Validate[E, _$1], R]): Eff[R, Unit]

create an Validate effect from a single Option value

create an Validate effect from a single Option value

Inherited from
ValidateCreation
def validateValue[R, E, A](condition: Boolean, a: => A, e: => E)(implicit m: MemberIn[[_] =>> Validate[E, _$16], R]): Eff[R, A]

check a correct value

check a correct value

Inherited from
ValidateCreation
def values[R, A](as: A*)(implicit evidence$3: _list[R]): Eff[R, A]

create a list effect from a list of values

create a list effect from a list of values

Inherited from
ListCreation
def waitFor[R](duration: FiniteDuration)(implicit evidence$9: _future[R]): Eff[R, Unit]
Inherited from
FutureCreation
def warning[R, E, A](a: A, e: E)(implicit m: MemberIn[[_] =>> Validate[E, _$14], R]): Eff[R, A]

create a correct value with warning

create a correct value with warning

Inherited from
ValidateCreation
def warning[R, E](e: E)(implicit m: MemberIn[[_] =>> Validate[E, _$12], R]): Eff[R, Unit]

create a pure warning

create a pure warning

Inherited from
ValidateCreation
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)

Inherited from
EffCreation
def wrong[R, E](e: E)(implicit m: MemberIn[[_] =>> Validate[E, _$8], R]): Eff[R, Unit]

create a failed value

create a failed value

Inherited from
ValidateCreation
def zero[R, A](implicit evidence$1: _choose[R]): Eff[R, A]
Inherited from
ChooseCreation