ZSTM

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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.

final def asInstanceOf[T0]: T0

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

Atomically performs a batch of operations in a single transaction.

def attempt[A](a: ⇒ A): STM[Throwable, A]

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

def check[R](p: ⇒ Boolean): URSTM[R, Unit]

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

def clone(): AnyRef

def collect[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ ZSTM[R, Option[E], B])(implicit bf: zio.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.

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.

def collectAll[R, E, A, Collection[+Element] <: Iterable[Element]](in: Collection[ZSTM[R, E, A]])(implicit bf: zio.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.

def collectAllDiscard[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.

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.

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

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, ZEnvironment[R]]

Retrieves the environment inside an stm.

def environmentWith[R]: EnvironmentWithPartiallyApplied[R]

Accesses the environment of the transaction to perform a transaction.

def environmentWithSTM[R]: EnvironmentWithSTMPartiallyApplied[R]

Accesses the environment of the transaction to perform a transaction.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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.

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

Returns a value that models failure in the transaction.

val fiberId: USTM[FiberId]

Returns the fiber id of the fiber committing the transaction.

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.

def filter[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ ZSTM[R, E, Boolean])(implicit bf: zio.BuildFrom[Collection[A], A, Collection[A]]): ZSTM[R, E, Collection[A]]

Filters the collection using the specified effectual 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.

def filterNot[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ ZSTM[R, E, Boolean])(implicit bf: zio.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.

def finalize(): Unit

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

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

def foreach[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ ZSTM[R, E, B])(implicit bf: zio.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].

def foreachDiscard[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.

def fromEither[E, A](e: ⇒ Either[E, A]): STM[E, A]

Lifts an Either into a STM.

def fromOption[A](v: ⇒ Option[A]): STM[Option[Nothing], A]

Lifts an Option into a STM.

def fromTry[A](a: ⇒ Try[A]): TaskSTM[A]

Lifts a Try into a STM.

final def getClass(): Class[_]

def hashCode(): Int

def ifSTM[R, E](b: ZSTM[R, E, Boolean]): IfSTM[R, E]

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

lazy val interrupt: USTM[Nothing]

Interrupts the fiber running the effect.

def interruptAs(fiberId: ⇒ FiberId): USTM[Nothing]

Interrupts the fiber running the effect with the specified fiber id.

final def isInstanceOf[T0]: Boolean

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.

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.

var s  = initial
var as = List.empty[A]

while (cont(s)) {
  as = body(s) :: as
  s  = inc(s)
}

as.reverse

def loopDiscard[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.

var s = initial

while (cont(s)) {
  body(s)
  s = inc(s)
}

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

val none: USTM[Option[Nothing]]

Returns an effect with the empty value.

final def notify(): Unit

final def notifyAll(): Unit

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.

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.

def replicate[R, E, A](n: Int)(tx: ZSTM[R, E, A]): Iterable[ZSTM[R, E, A]]

Replicates the given effect n times.

def replicateSTM[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.

def replicateSTMDiscard[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.

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 service[A](implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A]): ZSTM[A, Nothing, A]

Accesses the specified service in the environment of the effect.

def serviceAt[Service]: ServiceAtPartiallyApplied[Service]

Accesses the service corresponding to the specified key in the environment.

def serviceWith[Service]: ServiceWithPartiallyApplied[Service]

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

def serviceWithSTM[Service]: ServiceWithSTMPartiallyApplied[Service]

Effectfully accesses the specified service 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.

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

val unit: USTM[Unit]

Returns an STM effect that succeeds with Unit.

def unless[R, E, A](b: ⇒ Boolean)(stm: ⇒ ZSTM[R, E, A]): ZSTM[R, E, Option[A]]

The moral equivalent of if (!p) exp

def unlessSTM[R, E](b: ZSTM[R, E, Boolean]): UnlessSTM[R, E]

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

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.

def validate[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ ZSTM[R, E, B])(implicit bf: zio.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.

def validateFirst[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ ZSTM[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], E, Collection[E]], ev: CanFail[E]): ZSTM[R, Collection[E], B]

Feeds elements of type A to f until it succeeds.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def when[R, E, A](b: ⇒ Boolean)(stm: ⇒ ZSTM[R, E, A]): ZSTM[R, E, Option[A]]

The moral equivalent of if (p) exp

def whenCase[R, E, A, B](a: ⇒ A)(pf: PartialFunction[A, ZSTM[R, E, B]]): ZSTM[R, E, Option[B]]

Runs an effect when the supplied PartialFunction matches for the given value, otherwise does nothing.

def whenCaseSTM[R, E, A, B](a: ZSTM[R, E, A])(pf: PartialFunction[A, ZSTM[R, E, B]]): ZSTM[R, E, Option[B]]

Runs an effect when the supplied PartialFunction matches for the given effectful value, otherwise does nothing.

def whenSTM[R, E](b: ZSTM[R, E, Boolean]): WhenSTM[R, E]

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

def access[R]: EnvironmentWithPartiallyApplied[R]

Accesses the environment of the transaction.

def accessM[R]: EnvironmentWithSTMPartiallyApplied[R]

Accesses the environment of the transaction to perform a transaction.

def accessSTM[R]: EnvironmentWithSTMPartiallyApplied[R]

Accesses the environment of the transaction to perform a transaction.

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.

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.

def fromFunction[R, A](f: (ZEnvironment[R]) ⇒ A): URSTM[R, A]

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

def fromFunctionM[R, E, A](f: (ZEnvironment[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 ifM[R, E](b: ZSTM[R, E, Boolean]): IfSTM[R, E]

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

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.

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 partial[A](a: ⇒ A): STM[Throwable, A]

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

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.

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.

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.

def services[A, B, C, D](implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], arg2: zio.Tag[B], arg3: IsNotIntersection[B], arg4: zio.Tag[C], arg5: IsNotIntersection[C], arg6: zio.Tag[D], arg7: IsNotIntersection[D]): ZSTM[A with B with C with 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: IsNotIntersection[A], arg2: zio.Tag[B], arg3: IsNotIntersection[B], arg4: zio.Tag[C], arg5: IsNotIntersection[C]): ZSTM[A with B with 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: IsNotIntersection[A], arg2: zio.Tag[B], arg3: IsNotIntersection[B]): ZSTM[A with B, Nothing, (A, B)]

Accesses the specified services in the environment of the effect.

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

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

def whenCaseM[R, E, A, B](a: ZSTM[R, E, A])(pf: PartialFunction[A, ZSTM[R, E, B]]): ZSTM[R, E, Option[B]]

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

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