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](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)(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])(`evidence$3`: _choose[R]): Eff[R, A]
Inherited from
ChooseCreation
def collapse[R, M[_], A](r: Eff[R, M[A]])(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)(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]])(`evidence$3`: _eval[R]): Eff[R, A]
Inherited from
EvalCreation
def delay[R, A](a: => A)(`evidence$2`: _eval[R]): Eff[R, A]
Inherited from
EvalCreation
def empty[R, A](`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])(`evidence$2`: _safe[R]): Eff[R, A]
Inherited from
SafeCreation
def exception[R, A](t: Throwable)(`evidence$3`: _safe[R]): Eff[R, A]
Inherited from
SafeCreation
def finalizerException[R](t: Throwable)(`evidence$4`: _safe[R]): Eff[R, Unit]
Inherited from
SafeCreation
def flatSequenceA[R, F[_], A](fs: F[Eff[R, F[A]]])(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]])(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)(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])(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])(`evidence$2`: _future[R]): Eff[R, A]
Inherited from
FutureCreation
final def fromFutureWithExecutors[R, A](c: (Scheduler, ExecutionContext) => Future[A], timeout: Option[FiniteDuration])(`evidence$1`: _future[R]): Eff[R, A]
Inherited from
FutureCreation
def fromList[R, A](as: List[A])(`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])(`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])(`evidence$7`: _future[R]): Eff[R, A]
Inherited from
FutureCreation
final def futureDelay[R, A](a: => A, timeout: Option[FiniteDuration])(`evidence$5`: _future[R]): Eff[R, A]
Inherited from
FutureCreation
final def futureFail[R, A](t: Throwable)(`evidence$3`: _future[R]): Eff[R, A]
Inherited from
FutureCreation
final def futureFork[R, A](a: => A, ec: ExecutionContext, timeout: Option[FiniteDuration])(`evidence$6`: _future[R]): Eff[R, A]
Inherited from
FutureCreation
final def futureFromEither[R, A](e: Either[Throwable, A])(`evidence$4`: _future[R]): Eff[R, A]
Inherited from
FutureCreation
def get[R, S](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](`evidence$2`: _memo[R]): Eff[R, Cache]
Inherited from
MemoCreation
def gets[R, S, T](f: S => T)(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)(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)(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])(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)(`evidence$1`: _memo[R]): Eff[R, A]
Inherited from
MemoCreation
def modify[R, S](f: S => S)(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](`evidence$2`: _option[R]): Eff[R, A]

no value returned

no value returned

Inherited from
OptionCreation
def now[R, A](a: A)(`evidence$1`: _eval[R]): Eff[R, A]
Inherited from
EvalCreation
def optionEither[R, E, A](option: Option[A], e: => E)(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])(`evidence$2`: _choose[R]): Eff[R, A]
Inherited from
ChooseCreation
def protect[R, A](a: => A)(`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)(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])(`evidence$8`: _future[R]): Eff[R, A]
Inherited from
FutureCreation
def right[R, E, A](a: A)(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])(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]])(`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)(`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)(`evidence$3`: _option[R]): Eff[R, A]

a value is returned

a value is returned

Inherited from
OptionCreation
def tell[R, O](o: O)(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])(`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)(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])(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])(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)(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)(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*)(`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)(`evidence$9`: _future[R]): Eff[R, Unit]
Inherited from
FutureCreation
def warning[R, E, A](a: A, e: E)(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)(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)(m: MemberIn[[_] =>> Validate[E, _$8], R]): Eff[R, Unit]

create a failed value

create a failed value

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