packages feed

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)