content: {-# LANGUAGE CPP #-}
  -- | Lifted version of "Control.Concurrent.STM"
  --
  -- @since 0.2.1.0
  module UnliftIO.STM
    ( -- * Core
      STM.STM
    , atomically
    , retrySTM
    , checkSTM
    , STM.orElse
  
      -- * TVar
    , STM.TVar
    , newTVarIO
    , readTVarIO
    , STM.newTVar
    , STM.readTVar
    , STM.writeTVar
    , STM.modifyTVar
    , STM.modifyTVar'
    , STM.stateTVar
    , STM.swapTVar
    , registerDelay
    , mkWeakTVar
  
      -- * TMVar
    , STM.TMVar
    , STM.newTMVar
    , STM.newEmptyTMVar
    , newTMVarIO
    , newEmptyTMVarIO
    , STM.takeTMVar
    , STM.putTMVar
    , STM.readTMVar
  #if MIN_VERSION_stm(2, 5, 1)
    , STM.writeTMVar
  #endif
    , STM.tryReadTMVar
    , STM.swapTMVar
    , STM.tryTakeTMVar
    , STM.tryPutTMVar
    , STM.isEmptyTMVar
    , mkWeakTMVar
  
      -- * TChan
    , STM.TChan
    , STM.newTChan
    , newTChanIO
    , STM.newBroadcastTChan
    , newBroadcastTChanIO
    , STM.dupTChan
    , STM.cloneTChan
    , STM.readTChan
    , STM.tryReadTChan
    , STM.peekTChan
    , STM.tryPeekTChan
    , STM.writeTChan
    , STM.unGetTChan
    , STM.isEmptyTChan
  
      -- * TQueue
    , STM.TQueue
    , STM.newTQueue
    , newTQueueIO
    , STM.readTQueue
    , STM.tryReadTQueue
    , STM.peekTQueue
    , STM.tryPeekTQueue
    , STM.writeTQueue
    , STM.unGetTQueue
    , STM.isEmptyTQueue
  
      -- * TBQueue
    , STM.TBQueue
    , STM.newTBQueue
    , newTBQueueIO
    , STM.readTBQueue
    , STM.tryReadTBQueue
    , STM.flushTBQueue
    , STM.peekTBQueue
    , STM.tryPeekTBQueue
    , STM.writeTBQueue
    , STM.unGetTBQueue
    , STM.lengthTBQueue
    , STM.isEmptyTBQueue
    , STM.isFullTBQueue
    ) where
  
  import Control.Concurrent.STM (STM, TVar, TMVar, TChan, TQueue, TBQueue)
  import qualified Control.Concurrent.STM as STM
  import Control.Monad.IO.Unlift
  import System.Mem.Weak (Weak)
  #if MIN_VERSION_base(4, 8, 0)
  import GHC.Natural (Natural)
  #else
  import Numeric.Natural (Natural)
  #endif
  
  -- | Lifted version of 'STM.atomically'
  --
  -- @since 0.2.1.0
  atomically :: MonadIO m => STM a -> m a
  atomically = liftIO . STM.atomically
  
  -- | Renamed 'STM.retry' for unqualified export
  --
  -- @since 0.2.1.0
  retrySTM :: STM a
  retrySTM = STM.retry
  
  -- | Renamed 'STM.check' for unqualified export
  --
  -- @since 0.2.1.0
  checkSTM :: Bool -> STM ()
  checkSTM = STM.check
  
  -- | Lifted version of 'STM.newTVarIO'
  --
  -- @since 0.2.1.0
  newTVarIO :: MonadIO m => a -> m (TVar a)
  newTVarIO = liftIO . STM.newTVarIO
  
  -- | Lifted version of 'STM.readTVarIO'
  --
  -- @since 0.2.1.0
  readTVarIO :: MonadIO m => TVar a -> m a
  readTVarIO = liftIO . STM.readTVarIO
  
  -- | Lifted version of 'STM.registerDelay'
  --
  -- @since 0.2.1.0
  registerDelay :: MonadIO m => Int -> m (TVar Bool)
  registerDelay = liftIO . STM.registerDelay
  
  -- | Lifted version of 'STM.mkWeakTVar'
  --
  -- @since 0.2.1.0
  mkWeakTVar :: MonadUnliftIO m => TVar a -> m () -> m (Weak (TVar a))
  mkWeakTVar var final = withRunInIO $ \run -> STM.mkWeakTVar var (run final)
  
  -- | Lifted version of 'STM.newTMVarIO'
  --
  -- @since 0.2.1.0
  newTMVarIO :: MonadIO m => a -> m (TMVar a)
  newTMVarIO = liftIO . STM.newTMVarIO
  
  -- | Lifted version of 'STM.newEmptyTMVarIO'
  --
  -- @since 0.2.1.0
  newEmptyTMVarIO :: MonadIO m => m (TMVar a)
  newEmptyTMVarIO = liftIO STM.newEmptyTMVarIO
  
  -- | Lifted version of 'STM.mkWeakTMVar'
  --
  -- @since 0.2.1.0
  mkWeakTMVar :: MonadUnliftIO m => TMVar a -> m () -> m (Weak (TMVar a))
  mkWeakTMVar var final = withRunInIO $ \run -> STM.mkWeakTMVar var (run final)
  
  -- | Lifted version of 'STM.newTChanIO'
  --
  -- @since 0.2.1.0
  newTChanIO :: MonadIO m => m (TChan a)
  newTChanIO = liftIO STM.newTChanIO
  
  -- | Lifted version of 'STM.newBroadcastTChanIO'
  --
  -- @since 0.2.1.0
  newBroadcastTChanIO :: MonadIO m => m (TChan a)
  newBroadcastTChanIO = liftIO STM.newBroadcastTChanIO
  
  -- | Lifted version of 'STM.newTQueueIO'
  --
  -- @since 0.2.1.0
  newTQueueIO :: MonadIO m => m (TQueue a)
  newTQueueIO = liftIO STM.newTQueueIO
  
  -- | Lifted version of 'STM.newTBQueueIO'
  --
  -- @since 0.2.1.0
  #if MIN_VERSION_stm(2, 5, 0)
  newTBQueueIO :: MonadIO m => Natural -> m (TBQueue a)
  #else
  newTBQueueIO :: MonadIO m => Int -> m (TBQueue a)
  #endif
  newTBQueueIO = liftIO . STM.newTBQueueIO
  