Safe Haskell | Safe |
---|---|
Language | Haskell98 |
Asynchronous communication between pipes
- newtype Input a = Input {}
- newtype Output a = Output {}
- fromInput :: MonadIO m => Input a -> Producer' a m ()
- toOutput :: MonadIO m => Output a -> Consumer' a m ()
- spawn :: Buffer a -> IO (Output a, Input a)
- spawn' :: Buffer a -> IO (Output a, Input a, STM ())
- data Buffer a
- unbounded :: Buffer a
- bounded :: Int -> Buffer a
- latest :: a -> Buffer a
- newest :: Int -> Buffer a
- module Control.Concurrent
- module Control.Concurrent.STM
- module System.Mem
Inputs and Outputs
newtype Input a
newtype Output a
Pipe utilities
Actors
spawn :: Buffer a -> IO (Output a, Input a)
Spawn a mailbox using the specified Buffer
to store messages
- fails and returns
False
if the mailbox is sealed, otherwise it: - retries if the mailbox is full, or:
- adds a message to the mailbox and returns
True
.
- retrieves a message from the mailbox wrapped in
Just
if the mailbox is not empty, otherwise it: - retries if the mailbox is not sealed, or:
- fails and returns
Nothing
.
If either the Input
or Output
is garbage collected the mailbox will
become sealed.
spawn' :: Buffer a -> IO (Output a, Input a, STM ())
Like spawn
, but also returns an action to manually seal
the mailbox
early:
(output, input, seal) <- spawn' buffer ...
Use the seal
action to allow early cleanup of readers and writers to the
mailbox without waiting for the next garbage collection cycle.
Like Bounded
, but send
never fails (the buffer is never full).
Instead, old elements are discard to make room for new elements
Re-exports
Control.Concurrent
re-exports forkIO
, although I recommend using the
async
library instead.
Control.Concurrent.STM
re-exports atomically
and STM
.
System.Mem
re-exports performGC
.
module Control.Concurrent
module Control.Concurrent.STM
module System.Mem