Portability | non-portable (GHC STM, CPP) |
---|---|
Stability | provisional |
Maintainer | wren@community.haskell.org |
Safe Haskell | Trustworthy |
Deprecated: stm-chans >= 2.1 requires stm >= 2.4; so this module no longer does anything useful.
Compatibility layer for older versions of the stm
library.
Namely, we define tryReadTChan
, peekTChan
, and tryPeekTChan
which stm < 2.3.0
lacks. These implementations are less efficient
than the package versions due to the TChan
type being abstract.
However, this module uses Cabal-style CPP macros in order to use
the package versions when available.
Deprecated: 2.1.0 (will be removed in 3.0)
- data TChan a
- newTChan :: STM (TChan a)
- newTChanIO :: IO (TChan a)
- dupTChan :: TChan a -> STM (TChan a)
- newBroadcastTChan :: STM (TChan a)
- newBroadcastTChanIO :: IO (TChan a)
- readTChan :: TChan a -> STM a
- tryReadTChan :: TChan a -> STM (Maybe a)
- peekTChan :: TChan a -> STM a
- tryPeekTChan :: TChan a -> STM (Maybe a)
- unGetTChan :: TChan a -> a -> STM ()
- writeTChan :: TChan a -> a -> STM ()
- isEmptyTChan :: TChan a -> STM Bool
The TChan type
Creating TChans
newTChanIO :: IO (TChan a)
IO
version of newTChan
. This is useful for creating top-level
TChan
s using unsafePerformIO
, because using
atomically
inside unsafePerformIO
isn't
possible.
dupTChan :: TChan a -> STM (TChan a)
Duplicate a TChan
: 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.
newBroadcastTChan :: STM (TChan a)
Create a write-only TChan
. More precisely, readTChan
will retry
even after items have been written to the channel. The only way to read
a broadcast channel is to duplicate it with dupTChan
.
Consider 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 message
The problem with using newTChan
to create the broadcast channel is that if
it is only written to and never read, items will pile up in memory. By
using newBroadcastTChan
to create the broadcast channel, items can be
garbage collected after clients have seen them.
newBroadcastTChanIO :: IO (TChan a)
IO
version of newBroadcastTChan
.
Reading from TChans
tryReadTChan :: TChan a -> STM (Maybe a)
A version of readTChan
which does not retry. Instead it
returns Nothing
if no value is available.
Get the next value from the TChan
without removing it,
retrying if the channel is empty.
tryPeekTChan :: TChan a -> STM (Maybe a)
A version of peekTChan
which does not retry. Instead it
returns Nothing
if no value is available.
Writing to TChans
unGetTChan :: TChan a -> a -> STM ()
Put a data item back onto a channel, where it will be the next item read.
writeTChan :: TChan a -> a -> STM ()
Write a value to a TChan
.