Îõ³h$+ó)éØ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW "(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 X if the supplied   is empty.stmReturns X 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) Trustworthy3pstm< 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 X 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 Y if the * was empty, or Z 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 X if it was successful, or [ 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.6stm'Non-blocking write of a new value to a *' Puts if empty. Replaces if populated.7stmCheck whether a given * is empty.8stmMake a \ pointer to a *<, using the second argument as a finalizer to run when the * is garbage-collected.*+,-./012345678*+-,./136450278"(c) The University of Glasgow 2012/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 returns a new instance of :<stmIO version of ;*. This is useful for creating top-level :s using  , because using   inside   isn't possible.=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.@stm*Efficiently read the entire contents of a :+ into a list. This function never retries.AstmGet the next value from the TQueue8 without removing it, retrying if the channel is empty.Bstm A version of A+ which does not retry. Instead it returns Nothing if no value is available.CstmÉPut a data item back onto a channel, where it will be the next item read.DstmReturns X if the supplied : is empty. :;<=>?@ABCD :;<>?@AB=CD"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) TrustworthyǹFstmMutate the contents of a  . N.B., this version is non-strict.GstmStrict version of F.HstmLike Gõ but the function is a simple state transition that can return a side value which is passed on as the result of the  .IstmSwap the contents of a   for a new value.JstmMake a \ pointer to a  8, using the second argument as a finalizer to run when   is garbage-collected  FGHIJ FGHIJ"(c) The University of Glasgow 2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy3>ÀÁ ¬Kstm6TArray is a transactional array, supporting the usual ] 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).KK"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) TrustworthyÇ!óNstm6Check that the boolean condition is true and, if not,  .In other words, check b = unless b retry.Qstm N N "(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM)Safe"±É  !"#$%&'(*+,-./012345678:;<=>?@ABCDFGHIJKN"(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Safe-Inferred3)šRstmRî is a transactional semaphore. It holds a certain number of units, and units may be acquired or released by T and U respectively. When the R is empty, T blocks. Note that RÐ has no concept of fairness, and there is no guarantee that threads blocked in Tô will be unblocked in the same order; in fact they will all be unblocked at the same time and will fight over the R . Hence RŠ is not suitable if you expect there to be a high number of threads contending for the resource. However, like other STM abstractions, R is composable.SstmConstruct new R with an initial counter value.ÀA positive initial counter value denotes availability of units T can acquire.ðThe initial counter value can be negative which denotes a resource "debt" that requires a respective amount of U operations to counter-balance.TstmWait on R (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).Ustm Signal a R (aka V operation).âThis operation adds/releases a unit back to the semaphore (i.e. increments the internal counter).VstmMulti-signal a RêThis operation adds/releases multiple units back to the semaphore (i.e. increments the internal counter). signalTSem == signalTSemN 1RSTUVRSTUV Safe)Ú^stm_stm `ab^cdef_gè              !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij kl kmhin opqrs          ô"stm-2.5.1.0-5xqBZrmC0OFG0lyFqOMc3gControl.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 writeTMVar isEmptyTMVar mkWeakTMVar $fEqTMVarTQueue newTQueue newTQueueIO writeTQueue readTQueue tryReadTQueue flushTQueue peekTQueue tryPeekTQueue unGetTQueue isEmptyTQueue $fEqTQueue modifyTVar modifyTVar' stateTVarswapTVar mkWeakTVarTArray$fMArrayTArrayeSTM $fEqTArraycheck $fMonoidSTM$fSemigroupSTM $fMonadFixSTMTSemnewTSemwaitTSem signalTSem signalTSemN$fEqTSemghc-prim GHC.TypesTrue GHC.MaybeNothingJustFalseGHC.WeakWeak array-0.5.4.0Data.Array.BaseMArray