object ZSTM
- Alphabetic
- By Inheritance
- ZSTM
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- final class AccessMPartiallyApplied[R] extends AnyVal
- final class AccessPartiallyApplied[R] extends AnyVal
- final class IfM[R, E] extends AnyRef
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 absolve[R, E, A](z: ZSTM[R, E, Either[E, A]]): ZSTM[R, E, A]
Submerges the error case of an
Either
into theSTM
.Submerges the error case of an
Either
into theSTM
. The inverse operation ofSTM.either
. - def access[R]: AccessPartiallyApplied[R]
Accesses the environment of the transaction.
- def accessM[R]: AccessMPartiallyApplied[R]
Accesses the environment of the transaction to perform a transaction.
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def atomically[R, E, A](stm: ZSTM[R, E, A]): ZIO[R, E, A]
Atomically performs a batch of operations in a single transaction.
- def check[R](p: => Boolean): URSTM[R, Unit]
Checks the condition, and if it's true, returns unit, otherwise, retries.
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collectAll[R, E, A](in: Chunk[ZSTM[R, E, A]]): ZSTM[R, E, Chunk[A]]
Collects all the transactional effects in a list, returning a single transactional effect that produces a chunk of values.
- def collectAll[R, E, A](in: Iterable[ZSTM[R, E, A]]): ZSTM[R, E, List[A]]
Collects all the transactional effects in a list, returning a single transactional effect that produces a list of values.
- def collectAll_[R, E, A](in: Chunk[ZSTM[R, E, A]]): ZSTM[R, E, Unit]
Collects all the transactional effects, returning a single transactional effect that produces
Unit
.Collects all the transactional effects, returning a single transactional effect that produces
Unit
.Equivalent to
collectAll(i).unit
, but without the cost of building the chunk of results. - def collectAll_[R, E, A](in: Iterable[ZSTM[R, E, A]]): ZSTM[R, E, Unit]
Collects all the transactional effects, returning a single transactional effect that produces
Unit
.Collects all the transactional effects, returning a single transactional effect that produces
Unit
.Equivalent to
collectAll(i).unit
, but without the cost of building the list of results. - def die(t: => Throwable): USTM[Nothing]
Kills the fiber running the effect.
- def dieMessage(m: => String): USTM[Nothing]
Kills the fiber running the effect with a
RuntimeException
that contains the specified message. - def done[R, E, A](exit: => TExit[E, A]): ZSTM[R, E, A]
Returns a value modelled on provided exit status.
- def environment[R]: URSTM[R, R]
Retrieves the environment inside an stm.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def fail[E](e: => E): STM[E, Nothing]
Returns a value that models failure in the transaction.
- val fiberId: USTM[Id]
Returns the fiber id of the fiber committing the transaction.
- def filter[R, E, A](as: Iterable[A])(f: (A) => ZSTM[R, E, Boolean]): ZSTM[R, E, List[A]]
Filters the collection using the specified effectual predicate.
- def filterNot[R, E, A](as: Iterable[A])(f: (A) => ZSTM[R, E, Boolean]): ZSTM[R, E, List[A]]
Filters the collection using the specified effectual predicate, removing all elements that satisfy the predicate.
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def first[A, B]: ZSTM[(A, B), Nothing, A]
Returns an effectful function that extracts out the first element of a tuple.
- def flatten[R, E, A](tx: ZSTM[R, E, ZSTM[R, E, A]]): ZSTM[R, E, A]
Returns an effect that first executes the outer effect, and then executes the inner effect, returning the value from the inner effect, and effectively flattening a nested effect.
- def foldLeft[R, E, S, A](in: Iterable[A])(zero: S)(f: (S, A) => ZSTM[R, E, S]): ZSTM[R, E, S]
Folds an Iterable[A] using an effectual function f, working sequentially from left to right.
- def foldRight[R, E, S, A](in: Iterable[A])(zero: S)(f: (A, S) => ZSTM[R, E, S]): ZSTM[R, E, S]
Folds an Iterable[A] using an effectual function f, working sequentially from right to left.
- def foreach[R, E, A, B](in: Chunk[A])(f: (A) => ZSTM[R, E, B]): ZSTM[R, E, Chunk[B]]
Applies the function
f
to each element of theChunk[A]
and returns a transactional effect that produces a newChunk[B]
. - def foreach[R, E, A, B](in: Iterable[A])(f: (A) => ZSTM[R, E, B]): ZSTM[R, E, List[B]]
Applies the function
f
to each element of theIterable[A]
and returns a transactional effect that produces a newList[B]
. - def foreach_[R, E, A](in: Chunk[A])(f: (A) => ZSTM[R, E, Any]): ZSTM[R, E, Unit]
Applies the function
f
to each element of theChunk[A]
and returns a transactional effect that producesUnit
.Applies the function
f
to each element of theChunk[A]
and returns a transactional effect that producesUnit
.Equivalent to
foreach(as)(f).unit
, but without the cost of building the chunk of results. - def foreach_[R, E, A](in: Iterable[A])(f: (A) => ZSTM[R, E, Any]): ZSTM[R, E, Unit]
Applies the function
f
to each element of theIterable[A]
and returns a transactional effect that producesUnit
.Applies the function
f
to each element of theIterable[A]
and returns a transactional effect that producesUnit
.Equivalent to
foreach(as)(f).unit
, but without the cost of building the list of results. - def fromEither[E, A](e: => Either[E, A]): STM[E, A]
Lifts an
Either
into aSTM
. - def fromFunction[R, A](f: (R) => A): URSTM[R, A]
Lifts a function
R => A
into aURSTM[R, A]
. - def fromFunctionM[R, E, A](f: (R) => STM[E, A]): ZSTM[R, E, A]
Lifts an effectful function whose effect requires no environment into an effect that requires the input to the function.
- def fromOption[A](v: => Option[A]): STM[Unit, A]
Lifts an
Option
into aSTM
. - def fromTry[A](a: => Try[A]): TaskSTM[A]
Lifts a
Try
into aSTM
. - final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def identity[R]: URSTM[R, R]
Returns the identity effectful function, which performs no effects
- def ifM[R, E](b: ZSTM[R, E, Boolean]): IfM[R, E]
Runs
onTrue
if the result ofb
istrue
andonFalse
otherwise. - final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def iterate[R, E, S](initial: S)(cont: (S) => Boolean)(body: (S) => ZSTM[R, E, S]): ZSTM[R, E, S]
Iterates with the specified transactional function.
Iterates with the specified transactional function. The moral equivalent of:
var s = initial while (cont(s)) { s = body(s) } s
- def left[A](a: => A): USTM[Either[A, Nothing]]
Returns an effect with the value on the left part.
- def loop[R, E, A, S](initial: S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZSTM[R, E, A]): ZSTM[R, E, List[A]]
Loops with the specified transactional function, collecting the results into a list.
Loops with the specified transactional function, collecting the results into a list. The moral equivalent of:
var s = initial var as = List.empty[A] while (cont(s)) { as = body(s) :: as s = inc(s) } as.reverse
- def loop_[R, E, S](initial: S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZSTM[R, E, Any]): ZSTM[R, E, Unit]
Loops with the specified transactional function purely for its transactional effects.
Loops with the specified transactional function purely for its transactional effects. The moral equivalent of:
var s = initial while (cont(s)) { body(s) s = inc(s) }
- def mapN[R, E, A, B, C, D, F](tx1: ZSTM[R, E, A], tx2: ZSTM[R, E, B], tx3: ZSTM[R, E, C], tx4: ZSTM[R, E, D])(f: (A, B, C, D) => F): ZSTM[R, E, F]
Sequentially zips the specified effects using the specified combiner function.
- def mapN[R, E, A, B, C, D](tx1: ZSTM[R, E, A], tx2: ZSTM[R, E, B], tx3: ZSTM[R, E, C])(f: (A, B, C) => D): ZSTM[R, E, D]
Sequentially zips the specified effects using the specified combiner function.
- def mapN[R, E, A, B, C](tx1: ZSTM[R, E, A], tx2: ZSTM[R, E, B])(f: (A, B) => C): ZSTM[R, E, C]
Sequentially zips the specified effects using the specified combiner function.
- def mergeAll[R, E, A, B](in: Iterable[ZSTM[R, E, A]])(zero: B)(f: (B, A) => B): ZSTM[R, E, B]
Merges an
Iterable[ZSTM]
to a single ZSTM, working sequentially. - final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- val none: USTM[Option[Nothing]]
Returns an effect wth the empty value.
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def partial[A](a: => A): STM[Throwable, A]
Creates an
STM
value from a partial (but pure) function. - def partition[R, E, A, B](in: Iterable[A])(f: (A) => ZSTM[R, E, B])(implicit ev: CanFail[E]): ZSTM[R, Nothing, (List[E], List[B])]
Feeds elements of type
A
to a functionf
that returns an effect.Feeds elements of type
A
to a functionf
that returns an effect. Collects all successes and failures in a tupled fashion. - def reduceAll[R, R1 <: R, E, A](a: ZSTM[R, E, A], as: Iterable[ZSTM[R1, E, A]])(f: (A, A) => A): ZSTM[R1, E, A]
Reduces an
Iterable[ZSTM]
to a singleZSTM
, working sequentially. - def replicate[R, E, A](n: Int)(tx: ZSTM[R, E, A]): Iterable[ZSTM[R, E, A]]
Replicates the given effect n times.
Replicates the given effect n times. If 0 or negative numbers are given, an empty
Iterable
will return. - def require[R, E, A](error: => E): (ZSTM[R, E, Option[A]]) => ZSTM[R, E, A]
Requires that the given
ZSTM[R, E, Option[A]]
contain a value.Requires that the given
ZSTM[R, E, Option[A]]
contain a value. If there is no value, then the specified error will be raised. - val retry: USTM[Nothing]
Abort and retry the whole transaction when any of the underlying transactional variables have changed.
- def right[A](a: => A): USTM[Either[Nothing, A]]
Returns an effect with the value on the right part.
- def second[A, B]: URSTM[(A, B), B]
Returns an effectful function that extracts out the second element of a tuple.
- def service[A](implicit arg0: zio.Tag[A]): ZSTM[Has[A], Nothing, A]
Accesses the specified service in the environment of the effect.
- def services[A, B, C, D](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C], arg3: zio.Tag[D]): ZSTM[Has[A] with Has[B] with Has[C] with Has[D], Nothing, (A, B, C, D)]
Accesses the specified services in the environment of the effect.
- def services[A, B, C](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C]): ZSTM[Has[A] with Has[B] with Has[C], Nothing, (A, B, C)]
Accesses the specified services in the environment of the effect.
- def services[A, B](implicit arg0: zio.Tag[A], arg1: zio.Tag[B]): ZSTM[Has[A] with Has[B], Nothing, (A, B)]
Accesses the specified services in the environment of the effect.
- def some[A](a: => A): USTM[Option[A]]
Returns an effect with the optional value.
- def succeed[A](a: => A): USTM[A]
Returns an
STM
effect that succeeds with the specified value. - def suspend[R, E, A](stm: => ZSTM[R, E, A]): ZSTM[R, E, A]
Suspends creation of the specified transaction lazily.
- def swap[A, B]: URSTM[(A, B), (B, A)]
Returns an effectful function that merely swaps the elements in a
Tuple2
. - final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- val unit: USTM[Unit]
Returns an
STM
effect that succeeds withUnit
. - def unless[R, E](b: => Boolean)(stm: => ZSTM[R, E, Any]): ZSTM[R, E, Unit]
The moral equivalent of
if (!p) exp
- def unlessM[R, E](b: ZSTM[R, E, Boolean])(stm: => ZSTM[R, E, Any]): ZSTM[R, E, Unit]
The moral equivalent of
if (!p) exp
whenp
has side-effects - def validate[R, E, A, B](in: Iterable[A])(f: (A) => ZSTM[R, E, B])(implicit ev: CanFail[E]): ZSTM[R, ::[E], List[B]]
Feeds elements of type
A
tof
and accumulates all errors in error channel or successes in success channel.Feeds elements of type
A
tof
and accumulates all errors in error channel or successes in success channel.This combinator is lossy meaning that if there are errors all successes will be lost. To retain all information please use partition.
- def validateFirst[R, E, A, B](in: Iterable[A])(f: (A) => ZSTM[R, E, B])(implicit ev: CanFail[E]): ZSTM[R, List[E], B]
Feeds elements of type
A
tof
until it succeeds.Feeds elements of type
A
tof
until it succeeds. Returns first success or the accumulation of all errors. - final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- 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]) @native()
- def when[R, E](b: => Boolean)(stm: => ZSTM[R, E, Any]): ZSTM[R, E, Unit]
The moral equivalent of
if (p) exp
- def whenCase[R, E, A](a: => A)(pf: PartialFunction[A, ZSTM[R, E, Any]]): ZSTM[R, E, Unit]
Runs an effect when the supplied
PartialFunction
matches for the given value, otherwise does nothing. - def whenCaseM[R, E, A](a: ZSTM[R, E, A])(pf: PartialFunction[A, ZSTM[R, E, Any]]): ZSTM[R, E, Unit]
Runs an effect when the supplied
PartialFunction
matches for the given effectful value, otherwise does nothing. - def whenM[R, E](b: ZSTM[R, E, Boolean])(stm: => ZSTM[R, E, Any]): ZSTM[R, E, Unit]
The moral equivalent of
if (p) exp
whenp
has side-effects