úÎ…øòR      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ SafeRSTUVWXYZ[\]^_`a RTWXYZ[\]^RSTUVWXYZ[\]^_`a"(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy+ 9 is an abstract type representing a bounded FIFO channel.$Build and returns a new instance of IO version of *. This is useful for creating top-level s using  , because using   inside   isn't possible.Write a value to a ; blocks if the queue is full.Read the next value from the . A version of + which does not retry. Instead it returns Nothing if no value is available.Get the next value from the TBQueue8 without removing it, retrying if the channel is empty. A version of + which does not retry. Instead it returns Nothing if no value is available.gPut a data item back onto a channel, where it will be the next item read. Blocks if the queue is full.Returns b if the supplied  is empty.Returns b if the supplied  is full. c-maximum number of elements the queue can hold   c"(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy+ < is an abstract type representing an unbounded FIFO channel.$Build and returns a new instance of IO version of *. This is useful for creating top-level s using  , because using   inside   isn't possible.Write a value to a .Read the next value from the .  A version of + which does not retry. Instead it returns Nothing if no value is available.!Get the next value from the TQueue8 without removing it, retrying if the channel is empty." A version of !+ which does not retry. Instead it returns Nothing if no value is available.#IPut a data item back onto a channel, where it will be the next item read.$Returns b if the supplied  is empty. d !"#$%  !"#$  !"#$ d !"#$%"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy+&&< is an abstract type representing an unbounded FIFO channel.'#Build and return a new instance of &(IO version of '*. This is useful for creating top-level &s using  , because using   inside   isn't possible.)Create a write-only &. More precisely, , will  x even after items have been written to the channel. The only way to read a broadcast channel is to duplicate it with 0.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.*IO version of ).+Write a value to a &.,Read the next value from the &.- A version of ,+ which does not retry. Instead it returns Nothing if no value is available..Get the next value from the TChan8 without removing it, retrying if the channel is empty./ A version of .+ which does not retry. Instead it returns Nothing if no value is available.0 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.1IPut a data item back onto a channel, where it will be the next item read.2Returns b if the supplied & is empty.3Clone a &n: similar to dupTChan, but the cloned channel starts with the same content available as the original channel.efgh&i'()*+,-./0123&'()*+,-./0123&'()*03,-./+12efgh&i'()*+,-./0123"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy+<5A 5Œ is a synchronising variable, used for communication between concurrent threads. It can be thought of as a box, which may be empty or full.6 Create a 5# which contains the supplied value.7IO version of 6*. This is useful for creating top-level 5s using  , because using   inside   isn't possible.8 Create a 5 which is initially empty.9IO version of 8*. This is useful for creating top-level 5s using  , because using   inside   isn't possible.:Return the contents of the 5 . If the 5+ is currently empty, the transaction will   . After a :, the 5 is left empty.; A version of : that does not  . The ; function returns j if the 5 was empty, or k a if the 5 was full with contents a . After ;, the 5 is left empty.<Put a value into a 5 . If the 5 is currently full, < will  .= A version of < that does not  . The =% function attempts to put the value a into the 5 , returning b if it was successful, or l otherwise.>This is a combination of : and <#; ie. it takes the value from the 5%, puts it back, and also returns it.? A version of >+ which does not retry. Instead it returns Nothing if no value is available.@Swap the contents of a 5 for a new value.ACheck whether a given 5 is empty.BMake a m pointer to a 5<, using the second argument as a finalizer to run when the 5 is garbage-collected.5n6789:;<=>?@AB56789:;<=>?@AB56879:<>?@;=AB5n6789:;<=>?@AB"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy<DMutate the contents of a . N.B., this version is non-strict.EStrict version of D.FSwap the contents of a  for a new value.GMake a m pointer to a 8, using the second argument as a finalizer to run when  is garbage-collectedDEFG DEFG DEFGDEFG"(c) The University of Glasgow 2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy+357H6TArray is a transactional array, supporting the usual o interface for mutable arrays.It is currently implemented as Array ix (TVar e)z, but it may be replaced by a more efficient implementation in the future (the interface will remain the same, however).pLike  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.HqpIHHHqpI"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy<rsKtL  K  K rsKtL "(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM)SafeF  !"#$&'()*+,-./012356789:;<=>?@ABDEFGHK"(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM)Safe+MMn is a transactional semaphore. It holds a certain number of units, and units may be acquired or released by O and P respectively. When the M is empty, O blocks. Note that MP has no concept of fairness, and there is no guarantee that threads blocked in Ot will be unblocked in the same order; in fact they will all be unblocked at the same time and will fight over the M . Hence MŠ is not suitable if you expect there to be a high number of threads contending for the resource. However, like other STM abstractions, M is composable.MuNOPMNOPMNOPMuNOPv                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a     b         c d efgh+ijkl6 mn mofgp qrEstuvXwwx]yChXYRyvniZhC9Q8D3M7IoMControl.Concurrent.STM.TVarControl.Monad.STMControl.Concurrent.STM.TBQueueControl.Concurrent.STM.TQueueControl.Concurrent.STM.TChanControl.Concurrent.STM.TMVarControl.Concurrent.STM.TArrayControl.Concurrent.STM.TSemControl.Sequential.STMSystem.IO.UnsafeunsafePerformIOControl.Concurrent.STMbase GHC.Conc.IO registerDelay GHC.Conc.Sync writeTVarreadTVar readTVarIO newTVarIOnewTVaralwaysalwaysSucceedscatchSTMthrowSTMorElseretry atomicallySTMTVarTBQueue newTBQueue newTBQueueIO writeTBQueue readTBQueuetryReadTBQueue peekTBQueuetryPeekTBQueue unGetTBQueueisEmptyTBQueue isFullTBQueue $fEqTBQueueTQueue newTQueue newTQueueIO writeTQueue readTQueue tryReadTQueue peekTQueue tryPeekTQueue unGetTQueue isEmptyTQueue $fEqTQueueTChannewTChan newTChanIOnewBroadcastTChannewBroadcastTChanIO writeTChan readTChan tryReadTChan peekTChan tryPeekTChandupTChan unGetTChan isEmptyTChan cloneTChan $fEqTChanTMVarnewTMVar newTMVarIO newEmptyTMVarnewEmptyTMVarIO takeTMVar tryTakeTMVarputTMVar tryPutTMVar readTMVar tryReadTMVar swapTMVar isEmptyTMVar mkWeakTMVar $fEqTMVar modifyTVar modifyTVar'swapTVar mkWeakTVarTArray$fMArrayTArrayeSTM $fEqTArraycheck $fMonadFixSTMTSemnewTSemwaitTSem signalTSem$fEqTSemunSTM $fMonadSTM$fApplicativeSTM $fFunctorSTMghc-prim GHC.TypesTrueTListTNilTConsTVarListGHC.BaseNothingJustFalseGHC.WeakWeakarray_67iodizgJQIIxYVTp4emlAData.Array.BaseMArrayrepSTMretliftSTM