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 <- 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]
- Alphabetic
- By Inheritance
- ZSTM
- Serializable
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Concrete Value Members
-
final
def
!(implicit ev: <:<[E, Throwable], ev2: CanFail[E]): ZSTM[R, Nothing, A]
A symbolic alias for
orDie
. -
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
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.
-
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.
-
def
<*>[R1 <: R, E1 >: E, B](that: ⇒ ZSTM[R1, E1, B])(implicit zippable: Zippable[A, B]): ZSTM[R1, E1, Out]
Sequentially zips this value with the specified one.
-
def
<+>[R1 <: R, E1, B](that: ⇒ ZSTM[R1, E1, B]): ZSTM[R1, E1, Either[A, B]]
A symbolic alias for
orElseEither
. -
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.
-
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.
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
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 theSTM
.Returns an effect that submerges the error case of an
Either
into theSTM
. The inverse operation ofSTM.either
. -
def
as[B](b: ⇒ B): ZSTM[R, E, B]
Maps the success value of this effect to the specified constant value.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
asSome: ZSTM[R, E, Option[A]]
Maps the success value of this effect to an optional value.
-
def
asSomeError: ZSTM[R, Option[E], A]
Maps the error value of this effect to an optional value.
-
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.
-
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.
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
collect[B](pf: PartialFunction[A, B]): ZSTM[R, E, B]
Simultaneously filters and maps the value produced by this effect.
-
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.
Simultaneously filters and flatMaps the value produced by this effect. Continues on the effect returned from pf.
-
def
commit(implicit trace: ZTraceElement): ZIO[R, E, A]
Commits this transaction atomically.
-
def
commitEither(implicit trace: ZTraceElement): ZIO[R, E, A]
Commits this transaction atomically, regardless of whether the transaction is a success or a failure.
-
def
either(implicit ev: CanFail[E]): URSTM[R, Either[E, A]]
Converts the failure channel into an
Either
. -
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.
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
eventually(implicit ev: CanFail[E]): URSTM[R, A]
Returns an effect that ignores errors and runs repeatedly until it eventually succeeds.
-
def
filterOrDie(p: (A) ⇒ Boolean)(t: ⇒ Throwable): ZSTM[R, E, A]
Dies with specified
Throwable
if the predicate fails. -
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.
-
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. -
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. -
def
filterOrFail[E1 >: E](p: (A) ⇒ Boolean)(e: ⇒ E1): ZSTM[R, E1, A]
Fails with
e
if the predicate fails. -
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
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.
-
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.
-
def
flatten[R1 <: R, E1 >: E, B](implicit ev: <:<[A, ZSTM[R1, E1, B]]): ZSTM[R1, E1, B]
Flattens out a nested
STM
effect. -
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.
-
def
flip: 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.
-
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 -
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. -
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. -
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
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. -
def
ignore: URSTM[R, Unit]
Returns a new effect that ignores the success or failure of this effect.
-
def
isFailure: ZSTM[R, Nothing, Boolean]
Returns whether this transactional effect is a failure.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
isSuccess: ZSTM[R, Nothing, Boolean]
Returns whether this transactional effect is a success.
-
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 anEither
, moving the possibility that the value is aRight
to the error channel. -
def
map[B](f: (A) ⇒ B): ZSTM[R, E, B]
Maps the value produced by the effect.
-
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.
-
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
andg
. -
def
mapError[E1](f: (E) ⇒ E1)(implicit ev: CanFail[E]): ZSTM[R, E1, A]
Maps from one error type to another.
-
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.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
none[B](implicit ev: <:<[A, Option[B]]): ZSTM[R, Option[E], Unit]
Requires the option produced by this value to be
None
. -
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
option(implicit ev: CanFail[E]): URSTM[R, Option[A]]
Converts the failure channel into an
Option
. -
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. -
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 theE
into aThrowable
. -
def
orElse[R1 <: R, E1, A1 >: A](that: ⇒ ZSTM[R1, E1, A1]): ZSTM[R1, E1, A1]
Named alias for
<>
. -
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.
-
def
orElseFail[E1](e1: ⇒ E1): ZSTM[R, E1, A]
Tries this effect first, and if it fails or retries, fails with the specified error.
-
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. -
def
orElseSucceed[A1 >: A](a1: ⇒ A1): URSTM[R, A1]
Tries this effect first, and if it fails or retries, succeeds with the specified value.
-
def
orTry[R1 <: R, E1 >: E, A1 >: A](that: ⇒ ZSTM[R1, E1, A1]): ZSTM[R1, E1, A1]
Named alias for
<|>
. -
def
provideEnvironment(r: ZEnvironment[R]): STM[E, A]
Provides the transaction its required environment, which eliminates its dependency on
R
. -
def
provideService[Service <: R](service: Service)(implicit tag: Tag[Service]): STM[E, A]
Provides the transaction with the single service it requires.
Provides the transaction with the single service it requires. If the transaction requires multiple services use
provideEnvironment
instead. -
def
provideSomeEnvironment[R0](f: (ZEnvironment[R0]) ⇒ ZEnvironment[R]): ZSTM[R0, E, A]
Transforms the environment being provided to this effect with the specified function.
-
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.
-
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 aThrowable
. -
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. -
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. -
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.
-
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.
-
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.
-
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.
-
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 anEither
, moving the possibility that the value is aLeft
to the error channel. -
def
some[B](implicit ev: <:<[A, Option[B]]): ZSTM[R, Option[E], B]
Converts an option on values into an option on errors.
-
def
someOrElse[B](default: ⇒ B)(implicit ev: <:<[A, Option[B]]): ZSTM[R, E, B]
Extracts the optional value, or returns the given 'default'.
-
def
someOrElseSTM[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'.
-
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'.
-
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
-
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. -
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
tap[R1 <: R, E1 >: E](f: (A) ⇒ ZSTM[R1, E1, Any]): ZSTM[R1, E1, A]
"Peeks" at the success of transactional effect.
-
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.
-
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.
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
unit: ZSTM[R, E, Unit]
Maps the success value of this effect to unit.
-
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 aZSTM[R, E, Either[A, B]]
.Converts a
ZSTM[R, Either[E, B], A]
into aZSTM[R, E, Either[A, B]]
. The inverse ofleft
. -
def
unless(b: ⇒ Boolean): ZSTM[R, E, Option[A]]
The moral equivalent of
if (!p) exp
-
def
unlessSTM[R1 <: R, E1 >: E](b: ZSTM[R1, E1, Boolean]): ZSTM[R1, E1, Option[A]]
The moral equivalent of
if (!p) exp
whenp
has side-effects -
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 aZSTM[R, E, Either[B, A]]
.Converts a
ZSTM[R, Either[B, E], A]
into aZSTM[R, E, Either[B, A]]
. The inverse ofright
. -
def
unsome[E1](implicit ev: <:<[E, Option[E1]]): ZSTM[R, E1, Option[A]]
Converts an option on errors into an option on values.
-
def
updateService[M]: UpdateService[R, E, A, M]
Updates a service in the environment of this effect.
-
final
def
updateServiceAt[Service]: UpdateServiceAt[R, E, A, Service]
Updates a service at the specified key in the environment of this effect.
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
when(b: ⇒ Boolean): ZSTM[R, E, Option[A]]
The moral equivalent of
if (p) exp
-
def
whenSTM[R1 <: R, E1 >: E](b: ZSTM[R1, E1, Boolean]): ZSTM[R1, E1, Option[A]]
The moral equivalent of
if (p) exp
whenp
has side-effects -
def
withFilter(f: (A) ⇒ Boolean): ZSTM[R, E, A]
Same as retryUntil.
-
def
zip[R1 <: R, E1 >: E, B](that: ⇒ ZSTM[R1, E1, B])(implicit zippable: Zippable[A, B]): ZSTM[R1, E1, Out]
Named alias for
<*>
. -
def
zipLeft[R1 <: R, E1 >: E, B](that: ⇒ ZSTM[R1, E1, B]): ZSTM[R1, E1, A]
Named alias for
<*
. -
def
zipRight[R1 <: R, E1 >: E, B](that: ⇒ ZSTM[R1, E1, B]): ZSTM[R1, E1, B]
Named alias for
*>
. -
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.
Deprecated Value Members
-
def
&&&[R1 <: R, E1 >: E, B](that: ZSTM[R1, E1, B])(implicit zippable: Zippable[A, B]): ZSTM[R1, E1, Out]
Alias for
<*>
andzip
.Alias for
<*>
andzip
.- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use zip
-
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.
Feeds the value produced by this effect to the specified function, and then runs the returned effect as well to produce its results.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use flatMap
-
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
andg
.Returns an
STM
effect whose failure and success channels have been mapped by the specified pair of functions,f
andg
.- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use mapBoth
-
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.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use collectSTM
-
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.- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use filterOrElse
-
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.Effectfully folds over the
STM
effect, handling both failure and success.- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use foldSTM
-
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.
Unwraps the optional success of this effect, but can fail with None value.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use some
-
def
mapPartial[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.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use mapAttempt
-
def
optional[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.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use unsome
-
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.Continue with the returned computation if the
PartialFunction
matches, translating the successful match into a failure, otherwise continue with our held value.- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use rejectSTM
-
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'.
Extracts the optional value, or executes the effect 'default'.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use someOrElseSTM
-
def
unlessM[R1 <: R, E1 >: E](b: ZSTM[R1, E1, Boolean]): ZSTM[R1, E1, Option[A]]
The moral equivalent of
if (!p) exp
whenp
has side-effectsThe moral equivalent of
if (!p) exp
whenp
has side-effects- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use unlessSTM
-
def
unoption[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.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use unsome
-
def
whenM[R1 <: R, E1 >: E](b: ZSTM[R1, E1, Boolean]): ZSTM[R1, E1, Option[A]]
The moral equivalent of
if (p) exp
whenp
has side-effectsThe moral equivalent of
if (p) exp
whenp
has side-effects- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use whenSTM