{-# LANGUAGE UnicodeSyntax #-}
{-# LANGUAGE FlexibleContexts #-}

-- | Lifted 'TChan' operations.
module Control.Concurrent.STM.TChan.Lifted
  ( TChan
  , newTChan
  , newTChanIO
  , newBroadcastTChan
  , newBroadcastTChanIO
  , dupTChan
  , cloneTChan
  , readTChan
  , tryReadTChan
  , peekTChan
  , tryPeekTChan
  , writeTChan
  , unGetTChan
  , isEmptyTChan
  ) where

import Control.Monad.Base (MonadBase(..))
import Control.Monad.STM (STM)
import Control.Concurrent.STM.TChan (TChan)
import qualified Control.Concurrent.STM.TChan as STM

-- | A lifted version of 'STM.newTChan'.
newTChan ∷ MonadBase STM μ ⇒ μ (TChan α)
newTChan :: forall (μ :: * -> *) α. MonadBase STM μ => μ (TChan α)
newTChan = forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall a. STM (TChan a)
STM.newTChan
{-# INLINE newTChan #-}

-- | A lifted version of 'STM.newTChanIO'.
newTChanIO ∷ MonadBase IO μ ⇒ μ (TChan α)
newTChanIO :: forall (μ :: * -> *) α. MonadBase IO μ => μ (TChan α)
newTChanIO = forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall a. IO (TChan a)
STM.newTChanIO
{-# INLINE newTChanIO #-}

-- | A lifted version of 'STM.newBroadcastTChan'.
newBroadcastTChan ∷ MonadBase STM μ ⇒ μ (TChan α)
newBroadcastTChan :: forall (μ :: * -> *) α. MonadBase STM μ => μ (TChan α)
newBroadcastTChan = forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall a. STM (TChan a)
STM.newBroadcastTChan
{-# INLINE newBroadcastTChan #-}

-- | A lifted version of 'STM.newBroadcastTChanIO'.
newBroadcastTChanIO ∷ MonadBase IO μ ⇒ μ (TChan α)
newBroadcastTChanIO :: forall (μ :: * -> *) α. MonadBase IO μ => μ (TChan α)
newBroadcastTChanIO = forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall a. IO (TChan a)
STM.newBroadcastTChanIO
{-# INLINE newBroadcastTChanIO #-}

-- | A lifted version of 'STM.dupTChan'.
dupTChan ∷ MonadBase STM μ ⇒ TChan α → μ (TChan α)
dupTChan :: forall (μ :: * -> *) α. MonadBase STM μ => TChan α -> μ (TChan α)
dupTChan = forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TChan a -> STM (TChan a)
STM.dupTChan
{-# INLINE dupTChan #-}

-- | A lifted version of 'STM.cloneTChan'.
cloneTChan ∷ MonadBase STM μ ⇒ TChan α → μ (TChan α)
cloneTChan :: forall (μ :: * -> *) α. MonadBase STM μ => TChan α -> μ (TChan α)
cloneTChan = forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TChan a -> STM (TChan a)
STM.cloneTChan
{-# INLINE cloneTChan #-}

-- | A lifted version of 'STM.readTChan'.
readTChan ∷ MonadBase STM μ ⇒ TChan α → μ α
readTChan :: forall (μ :: * -> *) α. MonadBase STM μ => TChan α -> μ α
readTChan = forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TChan a -> STM a
STM.readTChan
{-# INLINE readTChan #-}

-- | A lifted version of 'STM.tryReadTChan'.
tryReadTChan ∷ MonadBase STM μ ⇒ TChan α → μ (Maybe α)
tryReadTChan :: forall (μ :: * -> *) α. MonadBase STM μ => TChan α -> μ (Maybe α)
tryReadTChan = forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TChan a -> STM (Maybe a)
STM.tryReadTChan
{-# INLINE tryReadTChan #-}

-- | A lifted version of 'STM.peekTChan'.
peekTChan ∷ MonadBase STM μ ⇒ TChan α → μ α
peekTChan :: forall (μ :: * -> *) α. MonadBase STM μ => TChan α -> μ α
peekTChan = forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TChan a -> STM a
STM.peekTChan
{-# INLINE peekTChan #-}

-- | A lifted version of 'STM.tryPeekTChan'.
tryPeekTChan ∷ MonadBase STM μ ⇒ TChan α → μ (Maybe α)
tryPeekTChan :: forall (μ :: * -> *) α. MonadBase STM μ => TChan α -> μ (Maybe α)
tryPeekTChan = forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TChan a -> STM (Maybe a)
STM.tryPeekTChan
{-# INLINE tryPeekTChan #-}

-- | A lifted version of 'STM.writeTChan'.
writeTChan ∷ MonadBase STM μ ⇒ TChan α → α → μ ()
writeTChan :: forall (μ :: * -> *) α. MonadBase STM μ => TChan α -> α -> μ ()
writeTChan = (forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TChan a -> a -> STM ()
STM.writeTChan
{-# INLINE writeTChan #-}

-- | A lifted version of 'STM.unGetTChan'.
unGetTChan ∷ MonadBase STM μ ⇒ TChan α → α → μ ()
unGetTChan :: forall (μ :: * -> *) α. MonadBase STM μ => TChan α -> α -> μ ()
unGetTChan = (forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TChan a -> a -> STM ()
STM.unGetTChan
{-# INLINE unGetTChan #-}

-- | A lifted version of 'STM.isEmptyTChan'.
isEmptyTChan ∷ MonadBase STM μ ⇒ TChan α → μ Bool
isEmptyTChan :: forall (μ :: * -> *) α. MonadBase STM μ => TChan α -> μ Bool
isEmptyTChan = forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. TChan a -> STM Bool
STM.isEmptyTChan
{-# INLINE isEmptyTChan #-}