Îõ³h*,)ñØ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW 2.5.3.1 "(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy7Ý 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.stm2The maximum number of elements the queue can hold.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) Trustworthy7¿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.'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) Trustworthy7Ë×+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.0stmReturn the contents of the + . If the ++ is currently empty, the transaction will  . After a 0, the + is left empty.1stm A version of 0 that does not . The 1 function returns Y if the + was empty, or Z a if the + was full with contents a . After 1, the + is left empty.2stmPut a value into a + . If the + is currently full, 2 will .3stm A version of 2 that does not . The 3% function attempts to put the value a into the + , returning X if it was successful, or [ otherwise.4stmThis is a combination of 0 and 2#; ie. it takes the value from the +%, puts it back, and also returns it.5stm A version of 4+ which does not retry. Instead it returns Nothing if no value is available.6stmSwap the contents of a + for a new value.7stm'Non-blocking write of a new value to a +' Puts if empty. Replaces if populated.8stmCheck whether a given + is empty.9stmMake a \ pointer to a +<, using the second argument as a finalizer to run when the + is garbage-collected.+,.-/0247561389+,.-/0247561389"(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy7e ;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.Astm*Efficiently read the entire contents of a ;+ into a list. This function never retries.BstmGet the next value from the TQueue8 without removing it, retrying if the channel is empty.Cstm A version of B+ which does not retry. Instead it returns Nothing if no value is available.DstmÉPut a data item back onto a channel, where it will be the next item read.EstmReturns X if the supplied ; is empty. ;<=?@ABC>DE ;<=?@ABC>DE"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) TrustworthyËGstmMutate the contents of a . N.B., this version is non-strict.HstmStrict version of G.IstmLike Hõ but the function is a simple state transition that can return a side value which is passed on as the result of the .JstmSwap the contents of a  for a new value.KstmMake a \ pointer to a 8, using the second argument as a finalizer to run when  is garbage-collected  GHIJ K  GHIJ K"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) TrustworthyË mLstm6Check that the boolean condition is true and, if not, .In other words, check b = unless b retry.MstmLL"(c) The University of Glasgow 2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy 7ÂÄÅÆË"NstmN0 is a transactional array, supporting the usual ] interface for mutable arrays."It is conceptually implemented as Array i (TVar e).OstmWrites are slow in ^.NN "(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM)Safe"¸ÊL GHIJK+-,./0247561389 &)"#$%!'(;=DE N"(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Safe-Inferred7)¢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_cdefg`hé !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmlnijopqrstiju          ö"stm-2.5.3.1-ASkhOh3WoRQH1YciMkABVGControl.Concurrent.STM.TVarControl.Monad.STMControl.Concurrent.STM.TBQueueControl.Concurrent.STM.TChanControl.Concurrent.STM.TMVarControl.Concurrent.STM.TQueueControl.Concurrent.STM.TArrayControl.Concurrent.STM.TSemstmSystem.IO.UnsafeunsafePerformIOControl.Concurrent.STMControl.Sequential.STMbase GHC.Conc.SyncTVarSTM atomicallyretryorElsethrowSTMcatchSTMnewTVar newTVarIO readTVarIOreadTVar writeTVar GHC.Conc.IO registerDelayTBQueue newTBQueue newTBQueueIO writeTBQueue readTBQueuetryReadTBQueue flushTBQueue peekTBQueuetryPeekTBQueue unGetTBQueue lengthTBQueueisEmptyTBQueue isFullTBQueuecapacityTBQueue $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 mkWeakTVarcheck $fMonadFixSTMTArray$fMArrayTArrayeIO$fMArrayTArrayeSTM $fEqTArrayTSemnewTSemwaitTSem signalTSem signalTSemN$fEqTSemghc-prim GHC.TypesTrue GHC.MaybeNothingJustFalseGHC.WeakWeak array-0.5.5.0Data.Array.BaseMArrayIO