ZSTM

object ZSTM
Companion:
class
class Object
trait Matchable
class Any
ZSTM.type

Type members

Classlikes

final class AccessMPartiallyApplied[R](dummy: Boolean) extends AnyVal
final class AccessPartiallyApplied[R](dummy: Boolean) extends AnyVal
final class IfM[R, E](b: ZSTM[R, E, Boolean])
final class ServiceWithPartiallyApplied[Service](dummy: Boolean) extends AnyVal
final class UnlessM[R, E](b: ZSTM[R, E, Boolean])
final class UpdateService[-R, +E, +A, M](self: ZSTM[R, E, A])
final class WhenM[R, E](b: ZSTM[R, E, Boolean])

Value members

Concrete methods

def absolve[R, E, A](z: ZSTM[R, E, Either[E, A]]): ZSTM[R, E, A]

Submerges the error case of an Either into the STM. The inverse operation of STM.either.

Submerges the error case of an Either into the STM. The inverse operation of STM.either.

Accesses the environment of the transaction.

Accesses the environment of the transaction.

Accesses the environment of the transaction to perform a transaction.

Accesses the environment of the transaction to perform a transaction.

def atomically[R, E, A](stm: ZSTM[R, E, A]): ZIO[R, E, A]

Atomically performs a batch of operations in a single transaction.

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.

Checks the condition, and if it's true, returns unit, otherwise, retries.

def collect[R, E, A, B, Collection <: (Iterable)](in: Collection[A])(f: A => ZSTM[R, Option[E], B])(implicit bf: BuildFrom[Collection[A], B, Collection[B]]): ZSTM[R, E, Collection[B]]

Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases.

Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases.

def collectAll[R, E, A, Collection <: (Iterable)](in: Collection[ZSTM[R, E, A]])(implicit bf: BuildFrom[Collection[ZSTM[R, E, A]], A, Collection[A]]): ZSTM[R, E, Collection[A]]

Collects all the transactional effects in a collection, returning a single transactional effect that produces a collection of values.

Collects all the transactional effects in a collection, returning a single transactional effect that produces a collection of values.

def collectAll[R, E, A](in: Set[ZSTM[R, E, A]]): ZSTM[R, E, Set[A]]

Collects all the transactional effects in a set, returning a single transactional effect that produces a set of values.

Collects all the transactional effects in a set, returning a single transactional effect that produces a set of values.

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 collectFirst[R, E, A, B](as: Iterable[A])(f: A => ZSTM[R, E, Option[B]]): ZSTM[R, E, Option[B]]

Collects the first element of the Iterable[A] for which the effectual function f returns Some.

Collects the first element of the Iterable[A] for which the effectual function f returns Some.

def cond[E, A](predicate: Boolean, result: => A, error: => E): STM[E, A]

Similar to Either.cond, evaluate the predicate, return the given A as success if predicate returns true, and the given E as error otherwise

Similar to Either.cond, evaluate the predicate, return the given A as success if predicate returns true, and the given E as error otherwise

def die(t: => Throwable): USTM[Nothing]

Kills the fiber running the effect.

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.

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.

Returns a value modelled on provided exit status.

def environment[R]: URSTM[R, R]

Retrieves the environment inside an stm.

Retrieves the environment inside an stm.

def exists[R, E, A](as: Iterable[A])(f: A => ZSTM[R, E, Boolean]): ZSTM[R, E, Boolean]

Determines whether any element of the Iterable[A] satisfies the effectual predicate f.

Determines whether any element of the Iterable[A] satisfies the effectual predicate f.

def fail[E](e: => E): STM[E, Nothing]

Returns a value that models failure in the transaction.

Returns a value that models failure in the transaction.

def filter[R, E, A, Collection <: (Iterable)](as: Collection[A])(f: A => ZSTM[R, E, Boolean])(implicit bf: BuildFrom[Collection[A], A, Collection[A]]): ZSTM[R, E, Collection[A]]

Filters the collection using the specified effectual predicate.

Filters the collection using the specified effectual predicate.

def filter[R, E, A](as: Set[A])(f: A => ZSTM[R, E, Boolean]): ZSTM[R, E, Set[A]]

Filters the set using the specified effectual predicate.

Filters the set using the specified effectual predicate.

def filterNot[R, E, A, Collection <: (Iterable)](as: Collection[A])(f: A => ZSTM[R, E, Boolean])(implicit bf: BuildFrom[Collection[A], A, Collection[A]]): ZSTM[R, E, Collection[A]]

Filters the collection using the specified effectual predicate, removing all elements that satisfy the predicate.

Filters the collection using the specified effectual predicate, removing all elements that satisfy the predicate.

def filterNot[R, E, A](as: Set[A])(f: A => ZSTM[R, E, Boolean]): ZSTM[R, E, Set[A]]

Filters the set using the specified effectual predicate, removing all elements that satisfy the predicate.

Filters the set using the specified effectual predicate, removing all elements that satisfy the predicate.

def first[A]: ZSTM[(A, Any), Nothing, A]

Returns an effectful function that extracts out the first element of a tuple.

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.

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.

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.

Folds an Iterable[A] using an effectual function f, working sequentially from right to left.

def forall[R, E, A](as: Iterable[A])(f: A => ZSTM[R, E, Boolean]): ZSTM[R, E, Boolean]

Determines whether all elements of the Iterable[A] satisfy the effectual predicate f.

Determines whether all elements of the Iterable[A] satisfy the effectual predicate f.

def foreach[R, E, A, B, Collection <: (Iterable)](in: Collection[A])(f: A => ZSTM[R, E, B])(implicit bf: BuildFrom[Collection[A], B, Collection[B]]): ZSTM[R, E, Collection[B]]

Applies the function f to each element of the Collection[A] and returns a transactional effect that produces a new Collection[B].

Applies the function f to each element of the Collection[A] and returns a transactional effect that produces a new Collection[B].

def foreach[R, E, A, B](in: Set[A])(f: A => ZSTM[R, E, B]): ZSTM[R, E, Set[B]]

Applies the function f to each element of the Set[A] and returns a transactional effect that produces a new Set[B].

Applies the function f to each element of the Set[A] and returns a transactional effect that produces a new Set[B].

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 the Iterable[A] and returns a transactional effect that produces Unit.

Applies the function f to each element of the Iterable[A] and returns a transactional effect that produces Unit.

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 a STM.

Lifts an Either into a STM.

def fromFunction[R, A](f: R => A): URSTM[R, A]

Lifts a function R => A into a URSTM[R, A].

Lifts a function R => A into a URSTM[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.

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[Option[Nothing], A]

Lifts an Option into a STM.

Lifts an Option into a STM.

def fromTry[A](a: => Try[A]): TaskSTM[A]

Lifts a Try into a STM.

Lifts a Try into a STM.

def identity[R]: URSTM[R, R]

Returns the identity effectful function, which performs no effects

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 of b is true and onFalse otherwise.

Runs onTrue if the result of b is true and onFalse otherwise.

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. The moral equivalent of:

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.

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. The moral equivalent of:

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. The moral equivalent of:

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](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.

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.

Sequentially zips the specified effects using the specified combiner function.

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.

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.

Merges an Iterable[ZSTM] to a single ZSTM, working sequentially.

def partial[A](a: => A): STM[Throwable, A]

Creates an STM value from a partial (but pure) function.

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, (Iterable[E], Iterable[B])]

Feeds elements of type A to a function f that returns an effect. Collects all successes and failures in a tupled fashion.

Feeds elements of type A to a function f 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 single ZSTM, working sequentially.

Reduces an Iterable[ZSTM] to a single ZSTM, 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. If 0 or negative numbers are given, an empty Iterable will return.

Replicates the given effect n times. If 0 or negative numbers are given, an empty Iterable will return.

def replicateM[R, E, A](n: Int)(transaction: ZSTM[R, E, A]): ZSTM[R, E, Iterable[A]]

Performs this transaction the specified number of times and collects the results.

Performs this transaction the specified number of times and collects the results.

def replicateM_[R, E, A](n: Int)(transaction: ZSTM[R, E, A]): ZSTM[R, E, Unit]

Performs this transaction the specified number of times, discarding the results.

Performs this transaction the specified number of times, discarding the results.

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. If there is no value, then the specified error will be raised.

Requires that the given ZSTM[R, E, Option[A]] contain a value. If there is no value, then the specified error will be raised.

def right[A](a: => A): USTM[Either[Nothing, A]]

Returns an effect with the value on the right part.

Returns an effect with the value on the right part.

def second[A]: URSTM[(Any, A), A]

Returns an effectful function that extracts out the second element of a tuple.

Returns an effectful function that extracts out the second element of a tuple.

def service[A : Tag]: ZSTM[Has[A], Nothing, A]

Accesses the specified service in the environment of the effect.

Accesses the specified service in the environment of the effect.

Effectfully accesses the specified service in the environment of the effect.

Effectfully accesses the specified service in the environment of the effect.

def services[A : Tag, B : Tag]: ZSTM[Has[A] & Has[B], Nothing, (A, B)]

Accesses the specified services in the environment of the effect.

Accesses the specified services in the environment of the effect.

def services[A : Tag, B : Tag, C : Tag]: ZSTM[Has[A] & Has[B] & Has[C], Nothing, (A, B, C)]

Accesses the specified services in the environment of the effect.

Accesses the specified services in the environment of the effect.

def services[A : Tag, B : Tag, C : Tag, D : Tag]: ZSTM[Has[A] & Has[B] & Has[C] & Has[D], Nothing, (A, B, C, D)]

Accesses the specified services in the environment of the effect.

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.

Returns an effect with the optional value.

def succeed[A](a: => A): USTM[A]

Returns an STM effect that succeeds with the specified value.

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.

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.

Returns an effectful function that merely swaps the elements in a Tuple2.

def unless[R, E](b: => Boolean)(stm: => ZSTM[R, E, Any]): ZSTM[R, E, Unit]

The moral equivalent of if (!p) exp

The moral equivalent of if (!p) exp

def unlessM[R, E](b: ZSTM[R, E, Boolean]): UnlessM[R, E]

The moral equivalent of if (!p) exp when p has side-effects

The moral equivalent of if (!p) exp when p has side-effects

def validate[R, E, A, B, Collection <: (Iterable)](in: Collection[A])(f: A => ZSTM[R, E, B])(implicit bf: BuildFrom[Collection[A], B, Collection[B]], ev: CanFail[E]): ZSTM[R, ::[E], Collection[B]]

Feeds elements of type A to f and accumulates all errors in error channel or successes in success channel.

Feeds elements of type A to f 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 validate[R, E, A, B](in: NonEmptyChunk[A])(f: A => ZSTM[R, E, B])(implicit ev: CanFail[E]): ZSTM[R, ::[E], NonEmptyChunk[B]]

Feeds elements of type A to f and accumulates all errors in error channel or successes in success channel.

Feeds elements of type A to f 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, Collection <: (Iterable)](in: Collection[A])(f: A => ZSTM[R, E, B])(implicit bf: BuildFrom[Collection[A], E, Collection[E]], ev: CanFail[E]): ZSTM[R, Collection[E], B]

Feeds elements of type A to f until it succeeds. Returns first success or the accumulation of all errors.

Feeds elements of type A to f until it succeeds. Returns first success or the accumulation of all errors.

def when[R, E](b: => Boolean)(stm: => ZSTM[R, E, Any]): ZSTM[R, E, Unit]

The moral equivalent of if (p) exp

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.

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.

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]): WhenM[R, E]

The moral equivalent of if (p) exp when p has side-effects

The moral equivalent of if (p) exp when p has side-effects

Concrete fields

Returns the fiber id of the fiber committing the transaction.

Returns the fiber id of the fiber committing the transaction.

val none: USTM[Option[Nothing]]

Returns an effect with the empty value.

Returns an effect with the empty value.

val retry: USTM[Nothing]

Abort and retry the whole transaction when any of the underlying transactional variables have changed.

Abort and retry the whole transaction when any of the underlying transactional variables have changed.

val unit: USTM[Unit]

Returns an STM effect that succeeds with Unit.

Returns an STM effect that succeeds with Unit.