Packages

object ZSTM extends Serializable

Linear Supertypes
Serializable, Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZSTM
  2. Serializable
  3. Serializable
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. final class AccessPartiallyApplied[R] extends AnyVal
  2. final class AccessSTMPartiallyApplied[R] extends AnyVal
  3. final class IfSTM[R, E] extends AnyRef
  4. final class ServiceAtPartiallyApplied[Service] extends AnyVal
  5. final class ServiceWithPartiallyApplied[Service] extends AnyVal
  6. final class UnlessSTM[R, E] extends AnyRef
  7. final class UpdateService[-R, +E, +A, M] extends AnyRef
  8. final class UpdateServiceAt[-R, +E, +A, Service] extends AnyVal
  9. final class WhenSTM[R, E] extends AnyRef

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. 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.

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

  5. def access[R]: AccessPartiallyApplied[R]

    Accesses the environment of the transaction.

  6. def accessSTM[R]: AccessSTMPartiallyApplied[R]

    Accesses the environment of the transaction to perform a transaction.

  7. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  8. 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.

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

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

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

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

  11. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  12. 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.

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

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

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

    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.

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

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

  18. def die(t: ⇒ Throwable): USTM[Nothing]

    Kills the fiber running the effect.

  19. def dieMessage(m: ⇒ String): USTM[Nothing]

    Kills the fiber running the effect with a RuntimeException that contains the specified message.

  20. def done[R, E, A](exit: ⇒ TExit[E, A]): ZSTM[R, E, A]

    Returns a value modelled on provided exit status.

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

    Retrieves the environment inside an stm.

  22. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  23. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  24. 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.

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

    Returns a value that models failure in the transaction.

  26. val fiberId: USTM[FiberId]

    Returns the fiber id of the fiber committing the transaction.

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

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

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

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

  31. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  32. 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.

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

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

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

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

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

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

    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.

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

    Lifts an Either into a STM.

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

    Lifts an Option into a STM.

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

    Lifts a Try into a STM.

  42. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  43. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  44. def ifSTM[R, E](b: ZSTM[R, E, Boolean]): IfSTM[R, E]

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

  45. lazy val interrupt: USTM[Nothing]

    Interrupts the fiber running the effect.

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

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

  47. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  48. 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
  49. def left[A](a: ⇒ A): USTM[Either[A, Nothing]]

    Returns an effect with the value on the left part.

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

    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)
}
  52. 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.

  53. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  54. val none: USTM[Option[Nothing]]

    Returns an effect with the empty value.

  55. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  56. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  57. 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.

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

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

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

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

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

  62. val retry: USTM[Nothing]

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

  63. def right[A](a: ⇒ A): USTM[Either[Nothing, A]]

    Returns an effect with the value on the right part.

  64. def service[A](implicit arg0: zio.Tag[A]): ZSTM[Has[A], Nothing, A]

    Accesses the specified service in the environment of the effect.

  65. def serviceAt[Service]: ServiceAtPartiallyApplied[Service]

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

  66. def serviceWith[Service]: ServiceWithPartiallyApplied[Service]

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

  67. def some[A](a: ⇒ A): USTM[Option[A]]

    Returns an effect with the optional value.

  68. def succeed[A](a: ⇒ A): USTM[A]

    Returns an STM effect that succeeds with the specified value.

  69. def suspend[R, E, A](stm: ⇒ ZSTM[R, E, A]): ZSTM[R, E, A]

    Suspends creation of the specified transaction lazily.

  70. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  71. def toString(): String
    Definition Classes
    AnyRef → Any
  72. val unit: USTM[Unit]

    Returns an STM effect that succeeds with Unit.

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

    The moral equivalent of if (!p) exp

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

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

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

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

    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.

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

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

  78. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  79. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  80. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  81. def when[R, E, A](b: ⇒ Boolean)(stm: ⇒ ZSTM[R, E, A]): ZSTM[R, E, Option[A]]

    The moral equivalent of if (p) exp

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

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

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

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

Deprecated Value Members

  1. def accessM[R]: AccessSTMPartiallyApplied[R]

    Accesses the environment of the transaction to perform a transaction.

    Accesses the environment of the transaction to perform a transaction.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use accessSTM

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectAllDiscard

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use foreachDiscard

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use access

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use accessSTM

  6. def ifM[R, E](b: ZSTM[R, E, Boolean]): IfSTM[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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use ifSTM

  7. 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)
}
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use loopDiscard

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use attempt

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use replicateSTM

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use replicateSTMDiscard

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use someOrFail

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

    Accesses the specified services in the environment of the effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

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

    Accesses the specified services in the environment of the effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

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

    Accesses the specified services in the environment of the effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

  18. def unlessM[R, E](b: ZSTM[R, E, Boolean]): UnlessSTM[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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use unlessSTM

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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use whenCaseSTM

  20. def whenM[R, E](b: ZSTM[R, E, Boolean]): WhenSTM[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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use whenSTM

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped