hoare-0.2.0.0: lib/Control/Concurrent/Channel/Endless/Split.hs
-- | "Control.Concurrent.Channel.Endless" with newtypes for producer and consumer sides.
module Control.Concurrent.Channel.Endless.Split(
Reader (..),
Writer (..),
TBQReader,
TBQWriter,
TMVReader,
TMVWriter,
split,
readChannel,
drainChannel,
writeChannel,
overwriteChannel,
evalWriteChannel,
evalOverwriteChannel,
consumeChannel,
consumeChannelBatches,
consumeChannelBatches',
stateConsumeChannel,
stateConsumeChannelBatches,
stateConsumeChannelBatches',
feedChannel,
evalFeedChannel,
pipeline,
pipeline_
) where
import Control.Concurrent.STM
import Control.Concurrent.Channel.Endless qualified as E
import Control.DeepSeq
-- | The consumer side of a channel @c@.
newtype Reader c a = Reader { unReader :: c a }
-- | The producer side of a channel @c@.
newtype Writer c a = Writer { unWriter :: c a }
-- | Give the producer and consumer sides of the given channel.
split :: c a -> (Writer c a, Reader c a)
split c = (Writer c, Reader c)
type TBQReader = Reader TBQueue
type TBQWriter = Writer TBQueue
type TMVReader = Reader TMVar
type TMVWriter = Writer TMVar
readChannel :: (E.Channel c) => Reader c a -> STM a
readChannel = E.readChannel . unReader
drainChannel :: (E.Channel c) => Reader c a -> STM [a]
drainChannel = E.drainChannel . unReader
writeChannel :: (E.Channel c) => Writer c a -> a -> STM ()
writeChannel = E.writeChannel . unWriter
overwriteChannel :: (E.Channel c) => Writer c a -> a -> STM (Maybe a)
overwriteChannel = E.overwriteChannel . unWriter
evalWriteChannel :: (E.Channel c, NFData a) => Writer c a -> a -> IO ()
evalWriteChannel = E.evalWriteChannel . unWriter
evalOverwriteChannel :: (E.Channel c, NFData a) => Writer c a -> a -> IO (Maybe a)
evalOverwriteChannel = E.evalOverwriteChannel . unWriter
consumeChannel :: (E.Channel c) => Reader c a -> (a -> IO ()) -> IO ()
consumeChannel = E.consumeChannel . unReader
consumeChannelBatches :: (E.Channel c) => Reader c a -> ([a] -> IO ()) -> IO ()
consumeChannelBatches = E.consumeChannelBatches . unReader
consumeChannelBatches' :: (E.Channel c) => Reader c a -> (a -> IO ()) -> IO ()
consumeChannelBatches' = E.consumeChannelBatches' . unReader
stateConsumeChannel :: (E.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO ()
stateConsumeChannel = E.stateConsumeChannel . unReader
stateConsumeChannelBatches :: (E.Channel c) => Reader c a -> s -> (s -> [a] -> IO s) -> IO ()
stateConsumeChannelBatches = E.stateConsumeChannelBatches . unReader
stateConsumeChannelBatches' :: (E.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO ()
stateConsumeChannelBatches' = E.stateConsumeChannelBatches' . unReader
feedChannel :: (E.Channel c) => Writer c a -> IO a -> IO ()
feedChannel = E.feedChannel . unWriter
evalFeedChannel :: (E.Channel c, NFData a) => Writer c a -> IO a -> IO ()
evalFeedChannel = E.evalFeedChannel . unWriter
-- | Create a channel with the given action,
-- then give its writer to the producer and its reader to the consumer.
pipeline :: IO (c a) -> (Writer c a -> IO x) -> (Reader c a -> IO y) -> IO (x, y)
pipeline new producer consumer = E.pipeline new (producer . Writer) (consumer . Reader)
pipeline_ :: IO (c a) -> (Writer c a -> IO x) -> (Reader c a -> IO y) -> IO ()
pipeline_ new producer consumer = E.pipeline_ new (producer . Writer) (consumer . Reader)