Îõ³h$+v){Õ      !"#$%&'()*+,-./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.stmçPut 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) Trustworthy3dstm< 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.&stmÉPut 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) Trustworthy3¤ 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.BstmÉPut 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).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"DÈ  !"#$%&'(*+,-./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 OêThis operation adds/releases multiple units back to the semaphore (i.e. increments the internal counter). signalTSem == signalTSemN 1OPQRSOPQRS Safe)l[stm\stm ]^_[`abc\då              !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg hi hjefk lmnop          ñ"stm-2.5.0.2-1MXxbuJRxWyEQEuEMeCZzKControl.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.BaseMArray