module Control.Concurrent.STM.TChan.Typed where
import Control.Concurrent.Chan.Scope (Scope (..), Writable, Readable)
import Control.Concurrent.STM.TChan (TChan)
import qualified Control.Concurrent.STM.TChan as TChan
import Control.Concurrent.STM (STM)
newtype TChanRW (scope :: Scope) a = TChanRW (TChan a)
readOnly :: Readable scope => TChanRW scope a -> TChanRW 'Read a
readOnly (TChanRW c) = TChanRW c
writeOnly :: Writable scope => TChanRW scope a -> TChanRW 'Write a
writeOnly (TChanRW c) = TChanRW c
allowReading :: Writable scope => TChanRW scope a -> TChanRW 'ReadWrite a
allowReading (TChanRW c) = TChanRW c
allowWriting :: Readable scope => TChanRW scope a -> TChanRW 'ReadWrite a
allowWriting (TChanRW c) = TChanRW c
newTChanRW :: STM (TChanRW 'ReadWrite a)
newTChanRW = TChanRW <$> TChan.newTChan
writeTChanRW :: Writable scope => TChanRW scope a -> a -> STM ()
writeTChanRW (TChanRW c) x = TChan.writeTChan c x
unGetTChanRW :: Writable scope => TChanRW scope a -> a -> STM ()
unGetTChanRW (TChanRW c) x = TChan.unGetTChan c x
isEmptyTChanRW :: Readable scope => TChanRW scope a -> STM Bool
isEmptyTChanRW (TChanRW c) = TChan.isEmptyTChan c
readTChanRW :: Readable scope => TChanRW scope a -> STM a
readTChanRW (TChanRW c) = TChan.readTChan c
tryReadTChanRW :: Readable scope => TChanRW scope a -> STM (Maybe a)
tryReadTChanRW (TChanRW c) = TChan.tryReadTChan c
peekTChanRW :: Readable scope => TChanRW scope a -> STM a
peekTChanRW (TChanRW c) = TChan.peekTChan c
tryPeekTChanRW :: Readable scope => TChanRW scope a -> STM (Maybe a)
tryPeekTChanRW (TChanRW c) = TChan.tryPeekTChan c
newBroadcastTChanRW :: STM (TChanRW 'Write a)
newBroadcastTChanRW = TChanRW <$> TChan.newBroadcastTChan
dupTChanRW :: Writable scopeIn
=> Readable scopeOut
=> TChanRW scopeIn a -> STM (TChanRW scopeOut a)
dupTChanRW (TChanRW c) = TChanRW <$> TChan.dupTChan c
cloneTChanRW :: Writable scopeIn
=> Readable scopeOut
=> TChanRW scopeIn a -> STM (TChanRW scopeOut a)
cloneTChanRW (TChanRW c) = TChanRW <$> TChan.cloneTChan c