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

-- | Lifted 'TBQueue' operations.
module Control.Concurrent.STM.TBQueue.Lifted
  ( TBQueue
  , newTBQueue
  , newTBQueueIO
  , readTBQueue
  , tryReadTBQueue
  , peekTBQueue
  , tryPeekTBQueue
  , flushTBQueue
  , writeTBQueue
  , unGetTBQueue
  , isEmptyTBQueue
  , isFullTBQueue
  ) where

import Numeric.Natural (Natural)
import Control.Monad.Base (MonadBase(..))
import Control.Monad.STM (STM)
import Control.Concurrent.STM.TBQueue (TBQueue)
import qualified Control.Concurrent.STM.TBQueue as STM

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

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

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

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

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

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

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

-- | A lifted version of 'STM.writeTBQueue'.
writeTBQueue ∷ MonadBase STM μ ⇒ TBQueue α → α → μ ()
writeTBQueue :: forall (μ :: * -> *) α. MonadBase STM μ => TBQueue α -> α -> μ ()
writeTBQueue = (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. TBQueue a -> a -> STM ()
STM.writeTBQueue
{-# INLINE writeTBQueue #-}

-- | A lifted version of 'STM.unGetTBQueue'.
unGetTBQueue ∷ MonadBase STM μ ⇒ TBQueue α → α → μ ()
unGetTBQueue :: forall (μ :: * -> *) α. MonadBase STM μ => TBQueue α -> α -> μ ()
unGetTBQueue = (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. TBQueue a -> a -> STM ()
STM.unGetTBQueue
{-# INLINE unGetTBQueue #-}

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

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