packages feed

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)