hoare-0.2.0.0: lib/Control/Concurrent/Channel/Split.hs
-- | "Control.Concurrent.Channel" with newtypes for producer and consumer sides.
module Control.Concurrent.Channel.Split(
Reader (..),
Writer (..),
TBCQReader,
TBCQWriter,
TCSReader,
TCSWriter,
End (..),
C.OverwriteResult (..),
split,
closeChannel,
isClosedChannel,
isEmptyChannel,
isFullChannel,
readChannel,
drainChannel,
writeChannel,
overwriteChannel,
writeChannel',
evalWriteChannel,
evalWriteChannel',
overwriteChannel',
evalOverwriteChannel,
evalOverwriteChannel',
consumeChannel,
consumeChannelBatches,
consumeChannelBatches',
stateConsumeChannel,
stateConsumeChannelBatches,
stateConsumeChannelBatches',
feedChannel,
evalFeedChannel,
pipeline,
pipeline_
) where
import Control.Concurrent.STM
import Control.Concurrent.Channel qualified as C
import Control.Concurrent.TBCQueue
import Control.Concurrent.TCSlot
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 TBCQReader = Reader TBCQueue
type TBCQWriter = Writer TBCQueue
type TCSReader = Reader TCSlot
type TCSWriter = Writer TCSlot
-- | Operations that either side of a channel can do.
class End e where
unEnd :: e c a -> c a
instance End Reader where
unEnd = unReader
instance End Writer where
unEnd = unWriter
closeChannel :: (End e, C.Channel c) => e c a -> STM ()
closeChannel = C.closeChannel . unEnd
isClosedChannel :: (End e, C.Channel c) => e c a -> STM Bool
isClosedChannel = C.isClosedChannel . unEnd
isEmptyChannel :: (End e, C.Channel c) => e c a -> STM Bool
isEmptyChannel = C.isEmptyChannel . unEnd
isFullChannel :: (End e, C.Channel c) => e c a -> STM Bool
isFullChannel = C.isFullChannel . unEnd
readChannel :: (C.Channel c) => Reader c a -> STM (Maybe a)
readChannel = C.readChannel . unReader
drainChannel :: (C.Channel c) => Reader c a -> STM [a]
drainChannel = C.drainChannel . unReader
writeChannel :: (C.Channel c) => Writer c a -> a -> STM Bool
writeChannel = C.writeChannel . unWriter
overwriteChannel :: (C.Channel c) => Writer c a -> a -> STM (C.OverwriteResult a)
overwriteChannel = C.overwriteChannel . unWriter
writeChannel' :: (C.Channel c) => Writer c a -> a -> STM ()
writeChannel' = C.writeChannel' . unWriter
evalWriteChannel :: (C.Channel c, NFData a) => Writer c a -> a -> IO Bool
evalWriteChannel = C.evalWriteChannel . unWriter
evalWriteChannel' :: (C.Channel c, NFData a) => Writer c a -> a -> IO ()
evalWriteChannel' = C.evalWriteChannel' . unWriter
overwriteChannel' :: (C.Channel c) => Writer c a -> a -> STM (Maybe a)
overwriteChannel' = C.overwriteChannel' . unWriter
evalOverwriteChannel :: (C.Channel c, NFData a) => Writer c a -> a -> IO (C.OverwriteResult a)
evalOverwriteChannel = C.evalOverwriteChannel . unWriter
evalOverwriteChannel' :: (C.Channel c, NFData a) => Writer c a -> a -> IO (Maybe a)
evalOverwriteChannel' = C.evalOverwriteChannel' . unWriter
consumeChannel :: (C.Channel c) => Reader c a -> (a -> IO ()) -> IO ()
consumeChannel = C.consumeChannel . unReader
consumeChannelBatches :: (C.Channel c) => Reader c a -> ([a] -> IO ()) -> IO ()
consumeChannelBatches = C.consumeChannelBatches . unReader
consumeChannelBatches' :: (C.Channel c) => Reader c a -> (a -> IO ()) -> IO ()
consumeChannelBatches' = C.consumeChannelBatches' . unReader
stateConsumeChannel :: (C.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO s
stateConsumeChannel = C.stateConsumeChannel . unReader
stateConsumeChannelBatches :: (C.Channel c) => Reader c a -> s -> (s -> [a] -> IO s) -> IO s
stateConsumeChannelBatches = C.stateConsumeChannelBatches . unReader
stateConsumeChannelBatches' :: (C.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO s
stateConsumeChannelBatches' = C.stateConsumeChannelBatches' . unReader
feedChannel :: (C.Channel c) => Writer c a -> IO (Maybe a) -> IO ()
feedChannel = C.feedChannel . unWriter
evalFeedChannel :: (C.Channel c, NFData a) => Writer c a -> IO (Maybe a) -> IO ()
evalFeedChannel = C.evalFeedChannel . unWriter
-- | Create a channel with the given action,
-- then give its writer to the producer and its reader to the consumer.
pipeline :: (C.Channel c) => IO (c a) -> (Writer c a -> IO x) -> (Reader c a -> IO y) -> IO (x, y)
pipeline new producer consumer = C.pipeline new (producer . Writer) (consumer . Reader)
pipeline_ :: (C.Channel c) => IO (c a) -> (Writer c a -> IO x) -> (Reader c a -> IO y) -> IO ()
pipeline_ new producer consumer = C.pipeline_ new (producer . Writer) (consumer . Reader)