ZSTM

zio.stm.ZSTM
See theZSTM companion object
sealed trait ZSTM[-R, +E, +A] extends Serializable

STM[E, A] represents an effect that can be performed transactionally, resulting in a failure E or a value A.

def transfer(receiver: TRef[Int],
             sender: TRef[Int], much: Int): UIO[Int] =
 STM.atomically {
   for {
     balance = much)
     _       <- receiver.update(_ + much)
     _       <- sender.update(_ - much)
     newAmnt <- receiver.get
   } yield newAmnt
 }

 val action: UIO[Int] =
   for {
     t <- STM.atomically(TRef.make(0).zip(TRef.make(20000)))
     (receiver, sender) = t
     balance <- transfer(receiver, sender, 1000)
   } yield balance

Software Transactional Memory is a technique which allows composition of arbitrary atomic operations. It is the software analog of transactions in database systems.

The API is lifted directly from the Haskell package Control.Concurrent.STM although the implementation does not resemble the Haskell one at all. http://hackage.haskell.org/package/stm-2.5.0.0/docs/Control-Concurrent-STM.html

STM in Haskell was introduced in: Composable memory transactions, by Tim Harris, Simon Marlow, Simon Peyton Jones, and Maurice Herlihy, in ACM Conference on Principles and Practice of Parallel Programming 2005. https://www.microsoft.com/en-us/research/publication/composable-memory-transactions/

See also: Lock Free Data Structures using STMs in Haskell, by Anthony Discolo, Tim Harris, Simon Marlow, Simon Peyton Jones, Satnam Singh) FLOPS 2006: Eighth International Symposium on Functional and Logic Programming, Fuji Susono, JAPAN, April 2006 https://www.microsoft.com/en-us/research/publication/lock-free-data-structures-using-stms-in-haskell/

Attributes

Companion
object
Source
ZSTM.scala
Graph
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
ZSTM[R, E, A]

Members list

Value members

Concrete methods

final def !(implicit ev: E <:< Throwable, ev2: CanFail[E]): ZSTM[R, Nothing, A]

A symbolic alias for orDie.

A symbolic alias for orDie.

Attributes

Source
ZSTM.scala
def *>[R1 <: R, E1 >: E, B](that: => ZSTM[R1, E1, B]): ZSTM[R1, E1, B]

Sequentially zips this value with the specified one, discarding the first element of the tuple.

Sequentially zips this value with the specified one, discarding the first element of the tuple.

Attributes

Source
ZSTM.scala
def <*[R1 <: R, E1 >: E, B](that: => ZSTM[R1, E1, B]): ZSTM[R1, E1, A]

Sequentially zips this value with the specified one, discarding the second element of the tuple.

Sequentially zips this value with the specified one, discarding the second element of the tuple.

Attributes

Source
ZSTM.scala
def <*>[R1 <: R, E1 >: E, B](that: => ZSTM[R1, E1, B])(implicit zippable: Zippable[A, B]): ZSTM[R1, E1, zippable.Out]

Sequentially zips this value with the specified one.

Sequentially zips this value with the specified one.

Attributes

Source
ZSTM.scala
def <+>[R1 <: R, E1, B](that: => ZSTM[R1, E1, B]): ZSTM[R1, E1, Either[A, B]]

A symbolic alias for orElseEither.

A symbolic alias for orElseEither.

Attributes

Source
ZSTM.scala
def <>[R1 <: R, E1, A1 >: A](that: => ZSTM[R1, E1, A1]): ZSTM[R1, E1, A1]

Tries this effect first, and if it fails or retries, tries the other effect.

Tries this effect first, and if it fails or retries, tries the other effect.

Attributes

Source
ZSTM.scala
def <|>[R1 <: R, E1 >: E, A1 >: A](that: => ZSTM[R1, E1, A1]): ZSTM[R1, E1, A1]

Tries this effect first, and if it enters retry, then it tries the other effect. This is an equivalent of haskell's orElse.

Tries this effect first, and if it enters retry, then it tries the other effect. This is an equivalent of haskell's orElse.

Attributes

Source
ZSTM.scala
def absolve[E1 >: E, B](implicit ev: A <:< Either[E1, B]): ZSTM[R, E1, B]

Returns an effect that submerges the error case of an Either into the STM. The inverse operation of STM.either.

Returns an effect that submerges the error case of an Either into the STM. The inverse operation of STM.either.

Attributes

Source
ZSTM.scala
def as[B](b: => B): ZSTM[R, E, B]

Maps the success value of this effect to the specified constant value.

Maps the success value of this effect to the specified constant value.

Attributes

Source
ZSTM.scala
def asSome: ZSTM[R, E, Option[A]]

Maps the success value of this effect to an optional value.

Maps the success value of this effect to an optional value.

Attributes

Source
ZSTM.scala
def asSomeError: ZSTM[R, Option[E], A]

Maps the error value of this effect to an optional value.

Maps the error value of this effect to an optional value.

Attributes

Source
ZSTM.scala
def catchAll[R1 <: R, E2, A1 >: A](h: E => ZSTM[R1, E2, A1])(implicit ev: CanFail[E]): ZSTM[R1, E2, A1]

Recovers from all errors.

Recovers from all errors.

Attributes

Source
ZSTM.scala
def catchSome[R1 <: R, E1 >: E, A1 >: A](pf: PartialFunction[E, ZSTM[R1, E1, A1]])(implicit ev: CanFail[E]): ZSTM[R1, E1, A1]

Recovers from some or all of the error cases.

Recovers from some or all of the error cases.

Attributes

Source
ZSTM.scala
def collect[B](pf: PartialFunction[A, B]): ZSTM[R, E, B]

Simultaneously filters and maps the value produced by this effect.

Simultaneously filters and maps the value produced by this effect.

Attributes

Source
ZSTM.scala
def collectSTM[R1 <: R, E1 >: E, B](pf: PartialFunction[A, ZSTM[R1, E1, B]]): ZSTM[R1, E1, B]

Simultaneously filters and flatMaps the value produced by this effect. Continues on the effect returned from pf.

Simultaneously filters and flatMaps the value produced by this effect. Continues on the effect returned from pf.

Attributes

Source
ZSTM.scala
def commit(implicit trace: Trace): ZIO[R, E, A]

Commits this transaction atomically.

Commits this transaction atomically.

Attributes

Source
ZSTM.scala
def commitEither(implicit trace: Trace): ZIO[R, E, A]

Commits this transaction atomically, regardless of whether the transaction is a success or a failure.

Commits this transaction atomically, regardless of whether the transaction is a success or a failure.

Attributes

Source
ZSTM.scala
def either(implicit ev: CanFail[E]): URSTM[R, Either[E, A]]

Converts the failure channel into an Either.

Converts the failure channel into an Either.

Attributes

Source
ZSTM.scala
def ensuring[R1 <: R](finalizer: ZSTM[R1, Nothing, Any]): ZSTM[R1, E, A]

Executes the specified finalization transaction whether or not this effect succeeds. Note that as with all STM transactions, if the full transaction fails, everything will be rolled back.

Executes the specified finalization transaction whether or not this effect succeeds. Note that as with all STM transactions, if the full transaction fails, everything will be rolled back.

Attributes

Source
ZSTM.scala
def eventually(implicit ev: CanFail[E]): URSTM[R, A]

Returns an effect that ignores errors and runs repeatedly until it eventually succeeds.

Returns an effect that ignores errors and runs repeatedly until it eventually succeeds.

Attributes

Source
ZSTM.scala
def filterOrDie(p: A => Boolean)(t: => Throwable): ZSTM[R, E, A]

Dies with specified Throwable if the predicate fails.

Dies with specified Throwable if the predicate fails.

Attributes

Source
ZSTM.scala
def filterOrDieMessage(p: A => Boolean)(msg: => String): ZSTM[R, E, A]

Dies with a java.lang.RuntimeException having the specified text message if the predicate fails.

Dies with a java.lang.RuntimeException having the specified text message if the predicate fails.

Attributes

Source
ZSTM.scala
def filterOrElse[R1 <: R, E1 >: E, A1 >: A](p: A => Boolean)(zstm: => ZSTM[R1, E1, A1]): ZSTM[R1, E1, A1]

Supplies zstm if the predicate fails.

Supplies zstm if the predicate fails.

Attributes

Source
ZSTM.scala
def filterOrElseWith[R1 <: R, E1 >: E, A1 >: A](p: A => Boolean)(f: A => ZSTM[R1, E1, A1]): ZSTM[R1, E1, A1]

Applies f if the predicate fails.

Applies f if the predicate fails.

Attributes

Source
ZSTM.scala
def filterOrFail[E1 >: E](p: A => Boolean)(e: => E1): ZSTM[R, E1, A]

Fails with e if the predicate fails.

Fails with e if the predicate fails.

Attributes

Source
ZSTM.scala
def flatMap[R1 <: R, E1 >: E, B](f: A => ZSTM[R1, E1, B]): ZSTM[R1, E1, B]

Feeds the value produced by this effect to the specified function, and then runs the returned effect as well to produce its results.

Feeds the value produced by this effect to the specified function, and then runs the returned effect as well to produce its results.

Attributes

Source
ZSTM.scala
def flatMapError[R1 <: R, E2](f: E => ZSTM[R1, Nothing, E2])(implicit ev: CanFail[E]): ZSTM[R1, E2, A]

Creates a composite effect that represents this effect followed by another one that may depend on the error produced by this one.

Creates a composite effect that represents this effect followed by another one that may depend on the error produced by this one.

Attributes

Source
ZSTM.scala
def flatten[R1 <: R, E1 >: E, B](implicit ev: A <:< ZSTM[R1, E1, B]): ZSTM[R1, E1, B]

Flattens out a nested STM effect.

Flattens out a nested STM effect.

Attributes

Source
ZSTM.scala
def flattenErrorOption[E1, E2 <: E1](default: => E2)(implicit ev: E <:< Option[E1]): ZSTM[R, E1, A]

Unwraps the optional error, defaulting to the provided value.

Unwraps the optional error, defaulting to the provided value.

Attributes

Source
ZSTM.scala
def flip: ZSTM[R, A, E]

Flips the success and failure channels of this transactional effect. This allows you to use all methods on the error channel, possibly before flipping back.

Flips the success and failure channels of this transactional effect. This allows you to use all methods on the error channel, possibly before flipping back.

Attributes

Source
ZSTM.scala
def flipWith[R1, A1, E1](f: (ZSTM[R, A, E]) => ZSTM[R1, A1, E1]): ZSTM[R1, E1, A1]

Swaps the error/value parameters, applies the function f and flips the parameters back

Swaps the error/value parameters, applies the function f and flips the parameters back

Attributes

Source
ZSTM.scala
def fold[B](f: E => B, g: A => B)(implicit ev: CanFail[E]): URSTM[R, B]

Folds over the STM effect, handling both failure and success, but not retry.

Folds over the STM effect, handling both failure and success, but not retry.

Attributes

Source
ZSTM.scala
def foldSTM[R1 <: R, E1, B](f: E => ZSTM[R1, E1, B], g: A => ZSTM[R1, E1, B])(implicit ev: CanFail[E]): ZSTM[R1, E1, B]

Effectfully folds over the STM effect, handling both failure and success.

Effectfully folds over the STM effect, handling both failure and success.

Attributes

Source
ZSTM.scala
def head[B](implicit ev: A <:< List[B]): ZSTM[R, Option[E], B]

Returns a successful effect with the head of the list if the list is non-empty or fails with the error None if the list is empty.

Returns a successful effect with the head of the list if the list is non-empty or fails with the error None if the list is empty.

Attributes

Source
ZSTM.scala
def ignore: URSTM[R, Unit]

Returns a new effect that ignores the success or failure of this effect.

Returns a new effect that ignores the success or failure of this effect.

Attributes

Source
ZSTM.scala
def isFailure: ZSTM[R, Nothing, Boolean]

Returns whether this transactional effect is a failure.

Returns whether this transactional effect is a failure.

Attributes

Source
ZSTM.scala
def isSuccess: ZSTM[R, Nothing, Boolean]

Returns whether this transactional effect is a success.

Returns whether this transactional effect is a success.

Attributes

Source
ZSTM.scala
def left[B, C](implicit ev: IsSubtypeOfOutput[A, Either[B, C]]): ZSTM[R, Either[E, C], B]

"Zooms in" on the value in the Left side of an Either, moving the possibility that the value is a Right to the error channel.

"Zooms in" on the value in the Left side of an Either, moving the possibility that the value is a Right to the error channel.

Attributes

Source
ZSTM.scala
def map[B](f: A => B): ZSTM[R, E, B]

Maps the value produced by the effect.

Maps the value produced by the effect.

Attributes

Source
ZSTM.scala
def mapAttempt[B](f: A => B)(implicit ev: IsSubtypeOfError[E, Throwable]): ZSTM[R, Throwable, B]

Maps the value produced by the effect with the specified function that may throw exceptions but is otherwise pure, translating any thrown exceptions into typed failed effects.

Maps the value produced by the effect with the specified function that may throw exceptions but is otherwise pure, translating any thrown exceptions into typed failed effects.

Attributes

Source
ZSTM.scala
def mapBoth[E2, B](f: E => E2, g: A => B)(implicit ev: CanFail[E]): ZSTM[R, E2, B]

Returns an STM effect whose failure and success channels have been mapped by the specified pair of functions, f and g.

Returns an STM effect whose failure and success channels have been mapped by the specified pair of functions, f and g.

Attributes

Source
ZSTM.scala
def mapError[E1](f: E => E1)(implicit ev: CanFail[E]): ZSTM[R, E1, A]

Maps from one error type to another.

Maps from one error type to another.

Attributes

Source
ZSTM.scala
def merge[A1 >: A](implicit ev1: E <:< A1, ev2: CanFail[E]): URSTM[R, A1]

Returns a new effect where the error channel has been merged into the success channel to their common combined type.

Returns a new effect where the error channel has been merged into the success channel to their common combined type.

Attributes

Source
ZSTM.scala
def none[B](implicit ev: A <:< Option[B]): ZSTM[R, Option[E], Unit]

Requires the option produced by this value to be None.

Requires the option produced by this value to be None.

Attributes

Source
ZSTM.scala
def option(implicit ev: CanFail[E]): URSTM[R, Option[A]]

Converts the failure channel into an Option.

Converts the failure channel into an Option.

Attributes

Source
ZSTM.scala
def orDie(implicit ev1: IsSubtypeOfError[E, Throwable], ev2: CanFail[E]): URSTM[R, A]

Translates STM effect failure into death of the fiber, making all failures unchecked and not a part of the type of the effect.

Translates STM effect failure into death of the fiber, making all failures unchecked and not a part of the type of the effect.

Attributes

Source
ZSTM.scala
def orDieWith(f: E => Throwable)(implicit ev: CanFail[E]): URSTM[R, A]

Keeps none of the errors, and terminates the fiber running the STM effect with them, using the specified function to convert the E into a Throwable.

Keeps none of the errors, and terminates the fiber running the STM effect with them, using the specified function to convert the E into a Throwable.

Attributes

Source
ZSTM.scala
def orElse[R1 <: R, E1, A1 >: A](that: => ZSTM[R1, E1, A1]): ZSTM[R1, E1, A1]

Named alias for &lt;.

Named alias for &lt;.

Attributes

Source
ZSTM.scala
def orElseEither[R1 <: R, E1, B](that: => ZSTM[R1, E1, B]): ZSTM[R1, E1, Either[A, B]]

Returns a transactional effect that will produce the value of this effect in left side, unless it fails or retries, in which case, it will produce the value of the specified effect in right side.

Returns a transactional effect that will produce the value of this effect in left side, unless it fails or retries, in which case, it will produce the value of the specified effect in right side.

Attributes

Source
ZSTM.scala
def orElseFail[E1](e1: => E1): ZSTM[R, E1, A]

Tries this effect first, and if it fails or retries, fails with the specified error.

Tries this effect first, and if it fails or retries, fails with the specified error.

Attributes

Source
ZSTM.scala
def orElseOptional[R1 <: R, E1, A1 >: A](that: => ZSTM[R1, Option[E1], A1])(implicit ev: E <:< Option[E1]): ZSTM[R1, Option[E1], A1]

Returns an effect that will produce the value of this effect, unless it fails with the None value, in which case it will produce the value of the specified effect.

Returns an effect that will produce the value of this effect, unless it fails with the None value, in which case it will produce the value of the specified effect.

Attributes

Source
ZSTM.scala
def orElseSucceed[A1 >: A](a1: => A1): URSTM[R, A1]

Tries this effect first, and if it fails or retries, succeeds with the specified value.

Tries this effect first, and if it fails or retries, succeeds with the specified value.

Attributes

Source
ZSTM.scala
def orTry[R1 <: R, E1 >: E, A1 >: A](that: => ZSTM[R1, E1, A1]): ZSTM[R1, E1, A1]

Named alias for ``.

Named alias for ``.

Attributes

Source
ZSTM.scala
def provideEnvironment(r: ZEnvironment[R]): STM[E, A]

Provides the transaction its required environment, which eliminates its dependency on R.

Provides the transaction its required environment, which eliminates its dependency on R.

Attributes

Source
ZSTM.scala
def provideSomeEnvironment[R0](f: (ZEnvironment[R0]) => ZEnvironment[R]): ZSTM[R0, E, A]

Transforms the environment being provided to this effect with the specified function.

Transforms the environment being provided to this effect with the specified function.

Attributes

Source
ZSTM.scala
def refineOrDie[E1](pf: PartialFunction[E, E1])(implicit ev1: IsSubtypeOfError[E, Throwable], ev2: CanFail[E]): ZSTM[R, E1, A]

Keeps some of the errors, and terminates the fiber with the rest.

Keeps some of the errors, and terminates the fiber with the rest.

Attributes

Source
ZSTM.scala
def refineOrDieWith[E1](pf: PartialFunction[E, E1])(f: E => Throwable)(implicit ev: CanFail[E]): ZSTM[R, E1, A]

Keeps some of the errors, and terminates the fiber with the rest, using the specified function to convert the E into a Throwable.

Keeps some of the errors, and terminates the fiber with the rest, using the specified function to convert the E into a Throwable.

Attributes

Source
ZSTM.scala
def reject[E1 >: E](pf: PartialFunction[A, E1]): ZSTM[R, E1, A]

Fail with the returned value if the PartialFunction matches, otherwise continue with our held value.

Fail with the returned value if the PartialFunction matches, otherwise continue with our held value.

Attributes

Source
ZSTM.scala
def rejectSTM[R1 <: R, E1 >: E](pf: PartialFunction[A, ZSTM[R1, E1, E1]]): ZSTM[R1, E1, A]

Continue with the returned computation if the PartialFunction matches, translating the successful match into a failure, otherwise continue with our held value.

Continue with the returned computation if the PartialFunction matches, translating the successful match into a failure, otherwise continue with our held value.

Attributes

Source
ZSTM.scala
def repeatUntil(f: A => Boolean): ZSTM[R, E, A]

Repeats this STM effect until its result satisfies the specified predicate. '''WARNING''': repeatUntil uses a busy loop to repeat the effect and will consume a thread until it completes (it cannot yield). This is because STM describes a single atomic transaction which must either complete, retry or fail a transaction before yielding back to the ZIO Runtime.

Repeats this STM effect until its result satisfies the specified predicate. '''WARNING''': repeatUntil uses a busy loop to repeat the effect and will consume a thread until it completes (it cannot yield). This is because STM describes a single atomic transaction which must either complete, retry or fail a transaction before yielding back to the ZIO Runtime.

  • Use retryUntil instead if you don't need to maintain transaction state for repeats.
  • Ensure repeating the STM effect will eventually satisfy the predicate.
  • Consider using the Blocking thread pool for execution of the transaction.

Attributes

Source
ZSTM.scala
def repeatWhile(f: A => Boolean): ZSTM[R, E, A]

Repeats this STM effect while its result satisfies the specified predicate. '''WARNING''': repeatWhile uses a busy loop to repeat the effect and will consume a thread until it completes (it cannot yield). This is because STM describes a single atomic transaction which must either complete, retry or fail a transaction before yielding back to the ZIO Runtime.

Repeats this STM effect while its result satisfies the specified predicate. '''WARNING''': repeatWhile uses a busy loop to repeat the effect and will consume a thread until it completes (it cannot yield). This is because STM describes a single atomic transaction which must either complete, retry or fail a transaction before yielding back to the ZIO Runtime.

  • Use retryWhile instead if you don't need to maintain transaction state for repeats.
  • Ensure repeating the STM effect will eventually not satisfy the predicate.
  • Consider using the Blocking thread pool for execution of the transaction.

Attributes

Source
ZSTM.scala
def retryUntil(f: A => Boolean): ZSTM[R, E, A]

Filters the value produced by this effect, retrying the transaction until the predicate returns true for the value.

Filters the value produced by this effect, retrying the transaction until the predicate returns true for the value.

Attributes

Source
ZSTM.scala
def retryWhile(f: A => Boolean): ZSTM[R, E, A]

Filters the value produced by this effect, retrying the transaction while the predicate returns true for the value.

Filters the value produced by this effect, retrying the transaction while the predicate returns true for the value.

Attributes

Source
ZSTM.scala
final def right[B, C](implicit ev: IsSubtypeOfOutput[A, Either[B, C]]): ZSTM[R, Either[B, E], C]

"Zooms in" on the value in the Right side of an Either, moving the possibility that the value is a Left to the error channel.

"Zooms in" on the value in the Right side of an Either, moving the possibility that the value is a Left to the error channel.

Attributes

Source
ZSTM.scala
def some[B](implicit ev: A <:< Option[B]): ZSTM[R, Option[E], B]

Converts an option on values into an option on errors.

Converts an option on values into an option on errors.

Attributes

Source
ZSTM.scala
def someOrElse[B, C](default: => C)(implicit ev0: A <:< Option[B], ev1: C <:< B): ZSTM[R, E, B]

Extracts the optional value, or returns the given 'default'.

Extracts the optional value, or returns the given 'default'.

Attributes

Source
ZSTM.scala
def someOrElseSTM[B, R1 <: R, E1 >: E, C](default: ZSTM[R1, E1, C])(implicit ev0: A <:< Option[B], ev1: C <:< B): ZSTM[R1, E1, B]

Extracts the optional value, or executes the effect 'default'.

Extracts the optional value, or executes the effect 'default'.

Attributes

Source
ZSTM.scala
def someOrFail[B, E1 >: E](e: => E1)(implicit ev: A <:< Option[B]): ZSTM[R, E1, B]

Extracts the optional value, or fails with the given error 'e'.

Extracts the optional value, or fails with the given error 'e'.

Attributes

Source
ZSTM.scala
def someOrFailException[B, E1 >: E](implicit ev: A <:< Option[B], ev2: NoSuchElementException <:< E1): ZSTM[R, E1, B]

Extracts the optional value, or fails with a java.util.NoSuchElementException

Extracts the optional value, or fails with a java.util.NoSuchElementException

Attributes

Source
ZSTM.scala
def summarized[R1 <: R, E1 >: E, B, C](summary: ZSTM[R1, E1, B])(f: (B, B) => C): ZSTM[R1, E1, (C, A)]

Summarizes a STM effect by computing a provided value before and after execution, and then combining the values to produce a summary, together with the result of execution.

Summarizes a STM effect by computing a provided value before and after execution, and then combining the values to produce a summary, together with the result of execution.

Attributes

Source
ZSTM.scala
def tap[R1 <: R, E1 >: E](f: A => ZSTM[R1, E1, Any]): ZSTM[R1, E1, A]

"Peeks" at the success of transactional effect.

"Peeks" at the success of transactional effect.

Attributes

Source
ZSTM.scala
def tapBoth[R1 <: R, E1 >: E](f: E => ZSTM[R1, E1, Any], g: A => ZSTM[R1, E1, Any])(implicit ev: CanFail[E]): ZSTM[R1, E1, A]

"Peeks" at both sides of an transactional effect.

"Peeks" at both sides of an transactional effect.

Attributes

Source
ZSTM.scala
def tapError[R1 <: R, E1 >: E](f: E => ZSTM[R1, E1, Any])(implicit ev: CanFail[E]): ZSTM[R1, E1, A]

"Peeks" at the error of the transactional effect.

"Peeks" at the error of the transactional effect.

Attributes

Source
ZSTM.scala
def unit: ZSTM[R, E, Unit]

Maps the success value of this effect to unit.

Maps the success value of this effect to unit.

Attributes

Source
ZSTM.scala
final def unleft[E1, B](implicit ev: IsSubtypeOfError[E, Either[E1, B]]): ZSTM[R, E1, Either[A, B]]

Converts a ZSTM[R, Either[E, B], A] into a ZSTM[R, E, Either[A, B]]. The inverse of left.

Converts a ZSTM[R, Either[E, B], A] into a ZSTM[R, E, Either[A, B]]. The inverse of left.

Attributes

Source
ZSTM.scala
def unless(b: => Boolean): ZSTM[R, E, Option[A]]

The moral equivalent of if (!p) exp

The moral equivalent of if (!p) exp

Attributes

Source
ZSTM.scala
def unlessSTM[R1 <: R, E1 >: E](b: ZSTM[R1, E1, Boolean]): ZSTM[R1, E1, Option[A]]

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

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

Attributes

Source
ZSTM.scala
final def unright[E1, B](implicit ev: IsSubtypeOfError[E, Either[B, E1]]): ZSTM[R, E1, Either[B, A]]

Converts a ZSTM[R, Either[B, E], A] into a ZSTM[R, E, Either[B, A]]. The inverse of right.

Converts a ZSTM[R, Either[B, E], A] into a ZSTM[R, E, Either[B, A]]. The inverse of right.

Attributes

Source
ZSTM.scala
def unsome[E1](implicit ev: E <:< Option[E1]): ZSTM[R, E1, Option[A]]

Converts an option on errors into an option on values.

Converts an option on errors into an option on values.

Attributes

Source
ZSTM.scala
def updateService[M]: UpdateService[R, E, A, M]

Updates a service in the environment of this effect.

Updates a service in the environment of this effect.

Attributes

Source
ZSTM.scala
final def updateServiceAt[Service]: UpdateServiceAt[R, E, A, Service]

Updates a service at the specified key in the environment of this effect.

Updates a service at the specified key in the environment of this effect.

Attributes

Source
ZSTM.scala
def when(b: => Boolean): ZSTM[R, E, Option[A]]

The moral equivalent of if (p) exp

The moral equivalent of if (p) exp

Attributes

Source
ZSTM.scala
def whenSTM[R1 <: R, E1 >: E](b: ZSTM[R1, E1, Boolean]): ZSTM[R1, E1, Option[A]]

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

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

Attributes

Source
ZSTM.scala
def withFilter(f: A => Boolean): ZSTM[R, E, A]

Same as retryUntil.

Same as retryUntil.

Attributes

Source
ZSTM.scala
def zip[R1 <: R, E1 >: E, B](that: => ZSTM[R1, E1, B])(implicit zippable: Zippable[A, B]): ZSTM[R1, E1, zippable.Out]

Named alias for ``.

Named alias for ``.

Attributes

Source
ZSTM.scala
def zipLeft[R1 <: R, E1 >: E, B](that: => ZSTM[R1, E1, B]): ZSTM[R1, E1, A]

Named alias for &lt;*.

Named alias for &lt;*.

Attributes

Source
ZSTM.scala
def zipRight[R1 <: R, E1 >: E, B](that: => ZSTM[R1, E1, B]): ZSTM[R1, E1, B]

Named alias for *>.

Named alias for *>.

Attributes

Source
ZSTM.scala
def zipWith[R1 <: R, E1 >: E, B, C](that: => ZSTM[R1, E1, B])(f: (A, B) => C): ZSTM[R1, E1, C]

Sequentially zips this value with the specified one, combining the values using the specified combiner function.

Sequentially zips this value with the specified one, combining the values using the specified combiner function.

Attributes

Source
ZSTM.scala

Deprecated methods

def tag: Int

Attributes

Deprecated
[Since version 2.1.8] use pattern-matching on types instead
Source
ZSTM.scala