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

-- | Lifted 'STM.TMVar' operations.
module Control.Concurrent.STM.TMVar.Lifted
  ( TMVar
  , newTMVar
  , newEmptyTMVar
  , newTMVarIO
  , newEmptyTMVarIO
  , takeTMVar
  , tryTakeTMVar
  , putTMVar
  , tryPutTMVar
  , readTMVar
  , tryReadTMVar
  , swapTMVar
  , isEmptyTMVar
  , mkWeakTMVar
  ) where

import Control.Monad.Base (MonadBase(..))
import Control.Monad.STM (STM)
import Control.Concurrent.STM.TMVar (TMVar)
import qualified Control.Concurrent.STM.TMVar as STM
import System.Mem.Weak (Weak)

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

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

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

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

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

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

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

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

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

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

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

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

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