Type Members

1.  final class STM[+E, +A] extends AnyVal

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

   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/

2.  final class TArray[A] extends AnyVal

   Wraps array of TRef and adds methods for convenience.

   Wraps array of TRef and adds methods for convenience. Caution: most of methods are not stack-safe.

3.  class TMap[K, V] extends AnyRef

   Transactional map implemented on top of TRef and TArray.

   Transactional map implemented on top of TRef and TArray. Resolves conflicts via chaining.

4.  final class TPromise[E, A] extends AnyVal
5.  class TQueue[A] extends AnyRef
6.  class TRef[A] extends AnyRef

   A variable that can be modified as part of a transactional effect.

7.  final class TSemaphore extends AnyVal
8.  final class TSet[A] extends AnyVal

   Transactional set implemented on top of TMap.