Packages

final class ZSTM[-R, +E, +A] extends AnyVal

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 <- sender.get
      _       <- STM.check(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/

Self Type
ZSTM[R, E, A]
Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZSTM
  2. AnyVal
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

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

    A symbolic alias for orDie.

  2. final def !=(arg0: Any): Boolean
    Definition Classes
    Any
  3. final def ##: Int
    Definition Classes
    Any
  4. def &&&[R1 <: R, E1 >: E, B](that: ZSTM[R1, E1, B]): ZSTM[R1, E1, (A, B)]

    Alias for <*> and zip.

  5. def ***[R1, E1 >: E, B](that: ZSTM[R1, E1, B]): ZSTM[(R, R1), E1, (A, B)]

    Splits the environment, providing the first part to this effect and the second part to that effect.

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

  7. def +++[R1, B, E1 >: E](that: ZSTM[R1, E1, B]): ZSTM[Either[R, R1], E1, Either[A, B]]

    Depending on provided environment, returns either this one or the other effect lifted in Left or Right, respectively.

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

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

    Sequentially zips this value with the specified one.

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

    A symbolic alias for orElseEither.

  11. def <<<[R1, E1 >: E](that: ZSTM[R1, E1, R]): ZSTM[R1, E1, A]

    Propagates self environment to that.

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

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

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

  14. final def ==(arg0: Any): Boolean
    Definition Classes
    Any
  15. def >>=[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.

  16. def >>>[E1 >: E, B](that: ZSTM[A, E1, B]): ZSTM[R, E1, B]

    Propagates the given environment to self.

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

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

  18. def andThen[E1 >: E, B](that: ZSTM[A, E1, B]): ZSTM[R, E1, B]

    Named alias for >>>.

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

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

  20. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  21. def asSome: ZSTM[R, E, Option[A]]

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

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

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

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

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

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

    Simultaneously filters and maps the value produced by this effect.

  26. def collectM[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.

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

  27. def commit: ZIO[R, E, A]

    Commits this transaction atomically.

  28. def commitEither: ZIO[R, E, A]

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

  29. def compose[R1, E1 >: E](that: ZSTM[R1, E1, R]): ZSTM[R1, E1, A]

    Named alias for <<<.

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

    Converts the failure channel into an Either.

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

    Executes the specified finalization transaction whether or not this effect succeeds.

    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.

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

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

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

    Dies with specified Throwable if the predicate fails.

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

  35. def filterOrElse[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.

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

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

    Fails with e if the predicate fails.

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

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

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

    Flattens out a nested STM effect.

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

  42. def flip(implicit ev: CanFail[E]): ZSTM[R, A, E]

    Flips the success and failure channels of this transactional effect.

    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.

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

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

  45. def foldM[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.

  46. def get[B](implicit ev1: <:<[E, Nothing], ev2: <:<[A, Option[B]]): ZSTM[R, Option[Nothing], B]

    Unwraps the optional success of this effect, but can fail with None value.

  47. def getClass(): Class[_ <: AnyVal]
    Definition Classes
    AnyVal → Any
  48. 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.

  49. def ignore: URSTM[R, Unit]

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

  50. def isFailure: ZSTM[R, Nothing, Boolean]

    Returns whether this transactional effect is a failure.

  51. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  52. def isSuccess: ZSTM[R, Nothing, Boolean]

    Returns whether this transactional effect is a success.

  53. def left[B, C](implicit ev: <:<[A, Either[B, C]]): ZSTM[R, Option[E], B]

    Returns a successful effect if the value is Left, or fails with the error None.

  54. def leftOrFail[B, C, E1 >: E](e: => E1)(implicit ev: <:<[A, Either[B, C]]): ZSTM[R, E1, B]

    Returns a successful effect if the value is Left, or fails with the error e.

  55. def leftOrFailException[B, C, E1 >: NoSuchElementException](implicit ev: <:<[A, Either[B, C]], ev2: <:<[E, E1]): ZSTM[R, E1, B]

    Returns a successful effect if the value is Left, or fails with a java.util.NoSuchElementException.

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

    Maps the value produced by the effect.

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

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

    Maps from one error type to another.

  59. def mapPartial[B](f: (A) => B)(implicit ev: <:<[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.

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

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

    Requires the option produced by this value to be None.

  62. def onFirst[R1 <: R]: ZSTM[R1, E, (A, R1)]

    Propagates the success value to the first element of a tuple, but passes the effect input R along unmodified as the second element of the tuple.

  63. def onLeft[C]: ZSTM[Either[R, C], E, Either[A, C]]

    Returns this effect if environment is on the left, otherwise returns whatever is on the right unmodified.

    Returns this effect if environment is on the left, otherwise returns whatever is on the right unmodified. Note that the result is lifted in either.

  64. def onRight[C]: ZSTM[Either[C, R], E, Either[C, A]]

    Returns this effect if environment is on the right, otherwise returns whatever is on the left unmodified.

    Returns this effect if environment is on the right, otherwise returns whatever is on the left unmodified. Note that the result is lifted in either.

  65. def onSecond[R1 <: R]: ZSTM[R1, E, (R1, A)]

    Propagates the success value to the second element of a tuple, but passes the effect input R along unmodified as the first element of the tuple.

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

    Converts the failure channel into an Option.

  67. def optional[E1](implicit ev: <:<[E, Option[E1]]): ZSTM[R, E1, Option[A]]

    Converts an option on errors into an option on values.

  68. def orDie(implicit ev1: <:<[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.

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

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

    Named alias for <>.

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

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

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

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

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

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

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

    Named alias for <|>.

  76. def provide(r: R): STM[E, A]

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

  77. def provideSome[R0](f: (R0) => R): ZSTM[R0, E, A]

    Provides some of the environment required to run this effect, leaving the remainder R0.

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

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

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

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

  81. def rejectM[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.

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

    Repeats this STM effect until its result satisfies the specified predicate.

    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.

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

    Repeats this STM effect while its result satisfies the specified predicate.

    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.

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

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

  86. def right[B, C](implicit ev: <:<[A, Either[B, C]]): ZSTM[R, Option[E], C]

    Returns a successful effect if the value is Right, or fails with the error None.

  87. def rightOrFail[B, C, E1 >: E](e: => E1)(implicit ev: <:<[A, Either[B, C]]): ZSTM[R, E1, C]

    Returns a successful effect if the value is Right, or fails with the given error 'e'.

  88. def rightOrFailException[B, C, E1 >: NoSuchElementException](implicit ev: <:<[A, Either[B, C]], ev2: <:<[E, E1]): ZSTM[R, E1, C]

    Returns a successful effect if the value is Right, or fails with a java.util.NoSuchElementException.

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

    Converts an option on values into an option on errors.

  90. def someOrElse[B](default: => B)(implicit ev: <:<[A, Option[B]]): ZSTM[R, E, B]

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

  91. def someOrElseM[B, R1 <: R, E1 >: E](default: ZSTM[R1, E1, B])(implicit ev: <:<[A, Option[B]]): ZSTM[R1, E1, B]

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

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

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

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

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

    "Peeks" at the success of transactional effect.

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

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

  98. def toString(): String
    Definition Classes
    Any
  99. def unit: ZSTM[R, E, Unit]

    Maps the success value of this effect to unit.

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

    The moral equivalent of if (!p) exp

  101. def unlessM[R1 <: R, E1 >: E](b: ZSTM[R1, E1, Boolean]): ZSTM[R1, E1, Unit]

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

  102. final def updateService[M]: UpdateService[R, E, A, M]

    Updates a service in the environment of this effect.

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

    The moral equivalent of if (p) exp

  104. def whenM[R1 <: R, E1 >: E](b: ZSTM[R1, E1, Boolean]): ZSTM[R1, E1, Unit]

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

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

    Same as retryUntil.

  106. def zip[R1 <: R, E1 >: E, B](that: => ZSTM[R1, E1, B]): ZSTM[R1, E1, (A, B)]

    Named alias for <*>.

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

    Named alias for <*.

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

    Named alias for *>.

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

  110. def |||[R1, E1 >: E, A1 >: A](that: ZSTM[R1, E1, A1]): ZSTM[Either[R, R1], E1, A1]

    Depending on provided environment returns either this one or the other effect.

Deprecated Value Members

  1. def bimap[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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use mapBoth

  2. def forever: ZSTM[R, E, Nothing]

    Repeats this effect forever (until the first error).

    Repeats this effect forever (until the first error). WARNING: forever uses a busy loop to repeat the effect and will consume a thread until it fails. This is because STM describes a single atomic transaction, and so must either complete, retry or fail a transaction before yielding back to the ZIO Runtime. - Ensure repeating the STM effect will eventually fail. - Consider using the Blocking thread pool for execution of the transaction.

    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.2) Repeating until failure doesn't make sense in the context of STM because it will always roll back the transaction

Inherited from AnyVal

Inherited from Any

Ungrouped