úÎÌvÈQI      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH*non-portable (GHC STM, DeriveDataTypeable) provisionalwren@community.haskell.org Trustworthy TMQueue3 is an abstract type representing a closeable FIFO  queue. $Build and returns a new instance of TMQueue. IO version of . This is useful for creating  top-level TMQueues using I, because using  J inside I isn' t possible. Read the next value from the TMQueue, retrying if the queue & is empty (and not closed). We return Nothing immediately if  the queue is closed and empty.  A version of " which does not retry. Instead it  returns  Just Nothing& if the queue is open but no value is  available; it still returns Nothing if the queue is closed  and empty. Get the next value from the TMQueue without removing it, ! retrying if the queue is empty.  A version of " which does not retry. Instead it  returns  Just Nothing& if the queue is open but no value is  available; it still returns Nothing if the queue is closed  and empty. Write a value to a TMQueue". If the queue is closed then the " value is silently discarded. Use   to determine 3 if the queue is closed before writing, as needed. =Put a data item back onto a queue, where it will be the next > item read. If the queue is closed then the value is silently  discarded; you can use  to circumvent this in certain  circumstances.  Closes the TMQueue!, preventing any further writes. Returns True if the supplied TMQueue has been closed. Returns True if the supplied TMQueue is empty. K   K *non-portable (GHC STM, DeriveDataTypeable) provisionalwren@community.haskell.org Trustworthy TBMQueue6 is an abstract type representing a bounded closeable  FIFO queue. $Build and returns a new instance of TBMQueue with the given  capacity. N.B.1, we do not verify the capacity is positive, but  if it is non-positive then  will always retry and   will always be true. IO version of  . This is useful for creating  top-level TBMQueues using I, because using  J inside I isn' t possible. Read the next value from the TBMQueue, retrying if the queue & is empty (and not closed). We return Nothing immediately if  the queue is closed and empty.  A version of " which does not retry. Instead it  returns  Just Nothing& if the queue is open but no value is  available; it still returns Nothing if the queue is closed  and empty. Get the next value from the TBMQueue without removing it, ! retrying if the queue is empty.  A version of " which does not retry. Instead it  returns  Just Nothing& if the queue is open but no value is  available; it still returns Nothing if the queue is closed  and empty. Write a value to a TBMQueue!, retrying if the queue is full. > If the queue is closed then the value is silently discarded.  Use % to determine if the queue is closed  before writing, as needed.  A version of  which does not retry. Returns Just  True( if the value was successfully written,  Just False if it 4 could not be written (but the queue was open), and Nothing 3 if it was discarded (i.e., the queue was closed). =Put a data item back onto a queue, where it will be the next > item read. If the queue is closed then the value is silently  discarded; you can use  to circumvent this in certain  circumstances. N.B.,, this could allow the queue to temporarily ? become longer than the specified limit, which is necessary to 3 ensure that the item is indeed the next one read.  Closes the TBMQueue!, preventing any further writes. Returns True if the supplied TBMQueue has been closed. Returns True if the supplied TBMQueue is empty (i.e., has  no elements). N.B., a TBMQueue can be both `empty' and  `full': at the same time, if the initial limit was non-positive. Returns True if the supplied TBMQueue is full (i.e., is  over its limit). N.B., a TBMQueue can be both `empty' and  `full': at the same time, if the initial limit was non-positive.  N.B., a TBMQueue% may still be full after reading, if  ( was used to go over the initial limit. This is equivalent to: liftM (<= 0) estimateFreeSlotsTBMQueue >Estimate the number of free slots. If the result is positive,  then it's a minimum bound; if it's non-positive then it' s exact. ? It will only be negative if the initial limit was negative or  if ( was used to go over the initial limit. >This function always contends with writers, but only contends . with readers when it has to; compare against . 9Return the exact number of free slots. The result can be 2 negative if the initial limit was negative or if  ( was used to go over the initial limit. =This function always contends with both readers and writers;  compare against .  L    L *non-portable (GHC STM, DeriveDataTypeable) provisionalwren@community.haskell.org TrustworthyTMChan3 is an abstract type representing a closeable FIFO  channel. $Build and returns a new instance of TMChan. IO version of . This is useful for creating  top-level TMChans using I, because using  J inside I isn' t possible. Like M.  Since: 2.1.0 IO version of .  Since: 2.1.0 ! Duplicate a TMChan*: the duplicate channel begins empty, but ? data written to either channel from then on will be available A from both, and closing one copy will close them all. Hence this C creates a kind of broadcast channel, where data written by anyone  is seen by everyone else. "Read the next value from the TMChan, retrying if the channel & is empty (and not closed). We return Nothing immediately if " the channel is closed and empty. # A version of "" which does not retry. Instead it  returns  Just Nothing( if the channel is open but no value is  available; it still returns Nothing if the channel is closed  and empty. $Get the next value from the TMChan without removing it, # retrying if the channel is empty. % A version of $" which does not retry. Instead it  returns  Just Nothing( if the channel is open but no value is  available; it still returns Nothing if the channel is closed  and empty. &Write a value to a TMChan$. If the channel is closed then the " value is silently discarded. Use ) to determine 5 if the channel is closed before writing, as needed. '?Put a data item back onto a channel, where it will be the next @ item read. If the channel is closed then the value is silently  discarded; you can use $ to circumvent this in certain  circumstances. ( Closes the TMChan!, preventing any further writes. )Returns True if the supplied TMChan has been closed. *Returns True if the supplied TMChan is empty. N !"#$%&'()* !"#$%&'()*! "#$%&'()*N !"#$%&'()**non-portable (GHC STM, DeriveDataTypeable) provisionalwren@community.haskell.org Trustworthy+TBMChan6 is an abstract type representing a bounded closeable  FIFO channel. ,$Build and returns a new instance of TBMChan with the given  capacity. N.B.1, we do not verify the capacity is positive, but  if it is non-positive then 2 will always retry and  8 will always be true. -IO version of ,. This is useful for creating  top-level TBMChans using I, because using  J inside I isn' t possible. .Read the next value from the TBMChan, retrying if the channel & is empty (and not closed). We return Nothing immediately if " the channel is closed and empty. / A version of ." which does not retry. Instead it  returns  Just Nothing( if the channel is open but no value is  available; it still returns Nothing if the channel is closed  and empty. 0Get the next value from the TBMChan without removing it, # retrying if the channel is empty. 1 A version of 0" which does not retry. Instead it  returns  Just Nothing( if the channel is open but no value is  available; it still returns Nothing if the channel is closed  and empty. 2Write a value to a TBMChan#, retrying if the channel is full. @ If the channel is closed then the value is silently discarded.  Use 6' to determine if the channel is closed  before writing, as needed. 3 A version of 2 which does not retry. Returns Just  True( if the value was successfully written,  Just False if it 6 could not be written (but the channel was open), and Nothing 5 if it was discarded (i.e., the channel was closed). 4?Put a data item back onto a channel, where it will be the next @ item read. If the channel is closed then the value is silently  discarded; you can use 0 to circumvent this in certain  circumstances. N.B.., this could allow the channel to temporarily ? become longer than the specified limit, which is necessary to 3 ensure that the item is indeed the next one read. 5 Closes the TBMChan!, preventing any further writes. 6Returns True if the supplied TBMChan has been closed. 7Returns True if the supplied TBMChan is empty (i.e., has  no elements). N.B., a TBMChan can be both `empty' and  `full': at the same time, if the initial limit was non-positive. 8Returns True if the supplied TBMChan is full (i.e., is  over its limit). N.B., a TBMChan can be both `empty' and  `full': at the same time, if the initial limit was non-positive.  N.B., a TBMChan% may still be full after reading, if  4( was used to go over the initial limit. This is equivalent to: liftM (<= 0) estimateFreeSlotsTBMChan 9>Estimate the number of free slots. If the result is positive,  then it's a minimum bound; if it's non-positive then it' s exact. ? It will only be negative if the initial limit was negative or  if 4( was used to go over the initial limit. >This function always contends with writers, but only contends . with readers when it has to; compare against :. :9Return the exact number of free slots. The result can be 2 negative if the initial limit was negative or if 4 ( was used to go over the initial limit. =This function always contends with both readers and writers;  compare against 9. +O,-./0123456789:+,-./0123456789:+,-./0123456789:+O,-./0123456789:*non-portable (GHC STM, DeriveDataTypeable) provisionalwren@community.haskell.org Trustworthy;TBChan1 is an abstract type representing a bounded FIFO  channel. <$Build and returns a new instance of TBChan with the given  capacity. N.B.1, we do not verify the capacity is positive, but  if it is non-positive then B will always retry and  F will always be true. =IO version of <. This is useful for creating  top-level TBChans using I, because using  J inside I isn' t possible. >Read the next value from the TBChan, retrying if the channel  is empty. ? A version of >" which does not retry. Instead it  returns Nothing if no value is available. @Get the next value from the TBChan without removing it, # retrying if the channel is empty. A A version of @" which does not retry. Instead it  returns Nothing if no value is available. BWrite a value to a TBChan#, retrying if the channel is full. C A version of B which does not retry. Returns True , if the value was successfully written, and False otherwise. D?Put a data item back onto a channel, where it will be the next  item read. N.B.., this could allow the channel to temporarily ? become longer than the specified limit, which is necessary to 3 ensure that the item is indeed the next one read. EReturns True if the supplied TBChan is empty (i.e., has  no elements). N.B., a TBChan can be both `empty' and  `full': at the same time, if the initial limit was non-positive. FReturns True if the supplied TBChan is full (i.e., is over  its limit). N.B., a TBChan can be both `empty' and `full' : at the same time, if the initial limit was non-positive. N.B.,  a TBChan% may still be full after reading, if D was $ used to go over the initial limit. This is equivalent to: liftM (<= 0) estimateFreeSlotsTBMChan G>Estimate the number of free slots. If the result is positive,  then it's a minimum bound; if it's non-positive then it' s exact. ? It will only be negative if the initial limit was negative or  if D( was used to go over the initial limit. >This function always contends with writers, but only contends . with readers when it has to; compare against H. H9Return the exact number of free slots. The result can be 2 negative if the initial limit was negative or if D ( was used to go over the initial limit. =This function always contends with both readers and writers;  compare against G. ;P<=>?@ABCDEFGH;<=>?@ABCDEFGH;<=>?@ABCDEFGH;P<=>?@ABCDEFGHQ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQORSTUV"1AWstm-chans-3.0.0Control.Concurrent.STM.TMQueueControl.Concurrent.STM.TBMQueueControl.Concurrent.STM.TMChanControl.Concurrent.STM.TBMChanControl.Concurrent.STM.TBChanTMQueue newTMQueue newTMQueueIO readTMQueuetryReadTMQueue peekTMQueuetryPeekTMQueue writeTMQueue unGetTMQueue closeTMQueueisClosedTMQueueisEmptyTMQueueTBMQueue newTBMQueue newTBMQueueIO readTBMQueuetryReadTBMQueue peekTBMQueuetryPeekTBMQueue writeTBMQueuetryWriteTBMQueue unGetTBMQueue closeTBMQueueisClosedTBMQueueisEmptyTBMQueueisFullTBMQueueestimateFreeSlotsTBMQueuefreeSlotsTBMQueueTMChan newTMChan newTMChanIOnewBroadcastTMChannewBroadcastTMChanIO dupTMChan readTMChan tryReadTMChan peekTMChan tryPeekTMChan writeTMChan unGetTMChan closeTMChanisClosedTMChan isEmptyTMChanTBMChan newTBMChan newTBMChanIO readTBMChantryReadTBMChan peekTBMChantryPeekTBMChan writeTBMChantryWriteTBMChan unGetTBMChan closeTBMChanisClosedTBMChanisEmptyTBMChan isFullTBMChanestimateFreeSlotsTBMChanfreeSlotsTBMChanTBChan newTBChan newTBChanIO readTBChan tryReadTBChan peekTBChan tryPeekTBChan writeTBChantryWriteTBChan unGetTBChan isEmptyTBChan isFullTBChanestimateFreeSlotsTBChanfreeSlotsTBChanbaseGHC.IOunsafePerformIO GHC.Conc.Sync atomically stm-2.4.2Control.Concurrent.STM.TChannewBroadcastTChan