h"+)      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST "(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy3 stm 9 is an abstract type representing a bounded FIFO channel.stm%Builds and returns a new instance of  .stmIO version of *. This is useful for creating top-level  s using  , because using  atomically inside   isn't possible.stmWrite a value to a  ; blocks if the queue is full.stmRead the next value from the  .stm A version of + which does not retry. Instead it returns Nothing if no value is available.stm*Efficiently read the entire contents of a  + into a list. This function never retries.stmGet the next value from the TBQueue8 without removing it, retrying if the channel is empty.stm A version of + which does not retry. Instead it returns Nothing if no value is available.stmPut a data item back onto a channel, where it will be the next item read. Blocks if the queue is full.stmReturn the length of a  .stmReturns U if the supplied   is empty.stmReturns U if the supplied   is full.stm-maximum number of elements the queue can hold  "(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy3>stm< is an abstract type representing an unbounded FIFO channel.stm#Build and return a new instance of stmIO version of *. This is useful for creating top-level s using  , because using   inside   isn't possible.stmCreate a write-only . More precisely, ! will   even after items have been written to the channel. The only way to read a broadcast channel is to duplicate it with %.6Consider a server that broadcasts messages to clients: serve :: TChan Message -> Client -> IO loop serve broadcastChan client = do myChan <- dupTChan broadcastChan forever $ do message <- readTChan myChan send client messageThe problem with using  to create the broadcast channel is that if it is only written to and never read, items will pile up in memory. By using  to create the broadcast channel, items can be garbage collected after clients have seen them.stmIO version of . stmWrite a value to a .!stmRead the next value from the ."stm A version of !+ which does not retry. Instead it returns Nothing if no value is available.#stmGet the next value from the TChan8 without removing it, retrying if the channel is empty.$stm A version of #+ which does not retry. Instead it returns Nothing if no value is available.%stm Duplicate a : the duplicate channel begins empty, but data written to either channel from then on will be available from both. Hence this creates a kind of broadcast channel, where data written by anyone is seen by everyone else.&stmPut a data item back onto a channel, where it will be the next item read.'stmReturns U if the supplied  is empty.(stmClone a : similar to dupTChan, but the cloned channel starts with the same content available as the original channel. !"#$%&'(%(!"#$ &'"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy3*stmA * is a synchronising variable, used for communication between concurrent threads. It can be thought of as a box, which may be empty or full.+stm Create a *# which contains the supplied value.,stmIO version of +*. This is useful for creating top-level *s using  , because using   inside   isn't possible.-stm Create a * which is initially empty..stmIO version of -*. This is useful for creating top-level *s using  , because using   inside   isn't possible./stmReturn the contents of the * . If the *+ is currently empty, the transaction will   . After a /, the * is left empty.0stm A version of / that does not  . The 0 function returns V if the * was empty, or W a if the * was full with contents a . After 0, the * is left empty.1stmPut a value into a * . If the * is currently full, 1 will  .2stm A version of 1 that does not  . The 2% function attempts to put the value a into the * , returning U if it was successful, or X otherwise.3stmThis is a combination of / and 1#; ie. it takes the value from the *%, puts it back, and also returns it.4stm A version of 3+ which does not retry. Instead it returns Nothing if no value is available.5stmSwap the contents of a * for a new value.6stmCheck whether a given * is empty.7stmMake a Y pointer to a *<, using the second argument as a finalizer to run when the * is garbage-collected.*+,-./01234567*+-,./13450267"(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy3B 9stm9< is an abstract type representing an unbounded FIFO channel.:stm$Build and returns a new instance of 9;stmIO version of :*. This is useful for creating top-level 9s using  , because using   inside   isn't possible.<stmWrite a value to a 9.=stmRead the next value from the 9.>stm A version of =+ which does not retry. Instead it returns Nothing if no value is available.?stm*Efficiently read the entire contents of a 9+ into a list. This function never retries.@stmGet the next value from the TQueue8 without removing it, retrying if the channel is empty.Astm A version of @+ which does not retry. Instead it returns Nothing if no value is available.BstmPut a data item back onto a channel, where it will be the next item read.CstmReturns U if the supplied 9 is empty. 9:;<=>?@ABC 9:;=>?@A Jstm6TArray is a transactional array, supporting the usual Z interface for mutable arrays.It is currently implemented as Array ix (TVar e), but it may be replaced by a more efficient implementation in the future (the interface will remain the same, however).[stmLike  replicateM= but uses an accumulator to prevent stack overflows. Unlike  replicateM the returned list is in reversed order. This doesn't matter though since this function is only used to create arrays with identical elements.JJ"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy"Mstm6Check that the boolean condition is true and, if not,  .In other words, check b = unless b retry.Nstm M M "(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM)Safe"  !"#$%&'(*+,-./012345679:;<=>?@ABCEFGHIJM"(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Safe-Inferred3)OstmO is a transactional semaphore. It holds a certain number of units, and units may be acquired or released by Q and R respectively. When the O is empty, Q blocks. Note that O has no concept of fairness, and there is no guarantee that threads blocked in Q will be unblocked in the same order; in fact they will all be unblocked at the same time and will fight over the O . Hence O is not suitable if you expect there to be a high number of threads contending for the resource. However, like other STM abstractions, O is composable.PstmConstruct new O with an initial counter value.A positive initial counter value denotes availability of units Q can acquire.The initial counter value can be negative which denotes a resource "debt" that requires a respective amount of R operations to counter-balance.QstmWait on O (aka P operation).This operation acquires a unit from the semaphore (i.e. decreases the internal counter) and blocks (via  5) if no units are available (i.e. if the counter is not positive).Rstm Signal a O (aka V operation).This operation adds/releases a unit back to the semaphore (i.e. increments the internal counter).SstmMulti-signal a OThis operation adds/releases multiple units back to the semaphore (i.e. increments the internal counter). signalTSem == signalTSemN 1OPQRSOPQRS Safe)\stm]stm ^_`\abcd]e              !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg hi hjefk lmnopq           stm-2.5.0.0Control.Concurrent.STM.TVarControl.Monad.STMControl.Concurrent.STM.TBQueueControl.Concurrent.STM.TChanControl.Concurrent.STM.TMVarControl.Concurrent.STM.TQueueControl.Concurrent.STM.TArrayControl.Concurrent.STM.TSemSystem.IO.UnsafeunsafePerformIOControl.Concurrent.STMControl.Sequential.STMbase GHC.Conc.IO registerDelay GHC.Conc.Sync writeTVarreadTVar readTVarIO newTVarIOnewTVarcatchSTMthrowSTMorElseretry atomicallySTMTVarTBQueue newTBQueue newTBQueueIO writeTBQueue readTBQueuetryReadTBQueue flushTBQueue peekTBQueuetryPeekTBQueue unGetTBQueue lengthTBQueueisEmptyTBQueue isFullTBQueue $fEqTBQueueTChannewTChan newTChanIOnewBroadcastTChannewBroadcastTChanIO writeTChan readTChan tryReadTChan peekTChan tryPeekTChandupTChan unGetTChan isEmptyTChan cloneTChan $fEqTChanTMVarnewTMVar newTMVarIO newEmptyTMVarnewEmptyTMVarIO takeTMVar tryTakeTMVarputTMVar tryPutTMVar readTMVar tryReadTMVar swapTMVar isEmptyTMVar mkWeakTMVar $fEqTMVarTQueue newTQueue newTQueueIO writeTQueue readTQueue tryReadTQueue flushTQueue peekTQueue tryPeekTQueue unGetTQueue isEmptyTQueue $fEqTQueue modifyTVar modifyTVar' stateTVarswapTVar mkWeakTVarTArray$fMArrayTArrayeSTM $fEqTArraycheck $fMonadFixSTMTSemnewTSemwaitTSem signalTSem signalTSemN$fEqTSemghc-prim GHC.TypesTrue GHC.MaybeNothingJustFalseGHC.WeakWeak array-0.5.4.0Data.Array.BaseMArrayrep