Îõ³h,+6)'Ø      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW "(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy8ÞÝ stm 9 is an abstract type representing a bounded FIFO channel.%Builds and returns a new instance of  .IO version of *. This is useful for creating top-level  s using  , because using  atomically 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.stm*Efficiently read the entire contents of a  + into a list. This function never retries.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.ç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  .Returns X if the supplied   is empty.stmReturns X if the supplied   is full.stm2The maximum number of elements the queue can hold.-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) Trustworthy8_< 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.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 .!Write a value to a ."Read 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.& 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.'ÉPut a data item back onto a channel, where it will be the next item read.(Returns 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) Trustworthy8Ì<+A +Œ is a synchronising variable, used for communication between concurrent threads. It can be thought of as a box, which may be empty or full., Create a +# which contains the supplied value.-IO version of ,*. This is useful for creating top-level +s using  , because using  inside   isn't possible.. Create a + which is initially empty./IO version of .*. This is useful for creating top-level +s using  , because using  inside   isn't possible.0Return the contents of the + . If the ++ is currently empty, the transaction will  . After a 0, the + is left empty.1 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.2Put a value into a + . If the + is currently full, 2 will .3 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.4This 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.6Swap the contents of a + for a new value.7stm'Non-blocking write of a new value to a +' Puts if empty. Replaces if populated.8Check whether a given + is empty.9stmMake a \ pointer to a +<, using the second argument as a finalizer to run when the + is garbage-collected.89./,-24603517++,.-/0247561389"(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy8ž ;stm;< 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.Astm*Efficiently read the entire contents of a ;+ into a list. This function never retries.BGet the next value from the TQueue8 without removing it, retrying if the channel is empty.C A version of B+ which does not retry. Instead it returns Nothing if no value is available.DÉPut a data item back onto a channel, where it will be the next item read.EReturns X if the supplied ; is empty. AE<=B?C@D>; ;<=?@ABC>DE"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) TrustworthyÌIGstmMutate 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  KGHIJ  GHIJ K"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Trustworthy̨Lstm6Check 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 8ÃÅÆÇÌ!8NN0 is a transactional array, supporting the usual ] interface for mutable arrays."It is conceptually implemented as Array i (TVar e).OWrites 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!ëÊ   )&( $"%#'!89./,-24603517AE<=B?C@D>KGHIJLN +;"(c) The University of Glasgow 2012/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires STM) Safe-Inferred8(Ö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 1SUVTRRSTUV Safe)_stm`stm abcde`_fghé !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmlnijopqrstiju          östm-2.5.3.1-8983Control.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.STM ghc-internalGHC.Internal.Conc.SyncTVarSTM atomicallyretryorElsethrowSTMcatchSTMnewTVar newTVarIO readTVarIOreadTVar writeTVarGHC.Internal.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.TypesTrueGHC.Internal.MaybeNothingJustFalseGHC.Internal.WeakWeakarray-0.5.8.0-b385Data.Array.BaseMArrayIO