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

-- | Lifted 'TQueue' operations.
module Control.Concurrent.STM.TQueue.Lifted
  ( TQueue
  , newTQueue
  , newTQueueIO
  , readTQueue
  , tryReadTQueue
  , peekTQueue
  , tryPeekTQueue
  , flushTQueue
  , writeTQueue
  , unGetTQueue
  , isEmptyTQueue
  ) where

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

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

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

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

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

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

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

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

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

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

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