module MonadVar.Instances.TVar where

import           MonadVar.Prelude
import           MonadVar.Classes
import           MonadVar.Default
import           Control.Concurrent.STM

instance MonadNew   STM TVar where
  new :: a -> STM (TVar a)
new = a -> STM (TVar a)
forall a. a -> STM (TVar a)
newTVar
  {-# INLINE new #-}

instance MonadRead  STM TVar where
  read :: TVar a -> STM a
read = TVar a -> STM a
forall a. TVar a -> STM a
readTVar
  {-# INLINE read #-}

instance MonadWrite STM TVar where
  write :: TVar a -> a -> STM ()
write = TVar a -> a -> STM ()
forall a. TVar a -> a -> STM ()
writeTVar
  {-# INLINE write #-}

instance MonadSwap  STM TVar where
  swap :: TVar a -> a -> STM a
swap = TVar a -> a -> STM a
forall (m :: * -> *) (v :: * -> *) a.
(MonadRead m v, MonadWrite m v) =>
v a -> a -> m a
defaultReadWriteSwap
  {-# INLINE swap #-}

instance MonadMutate_ STM TVar where
  mutate_ :: TVar a -> (a -> a) -> STM ()
mutate_ = TVar a -> (a -> a) -> STM ()
forall (m :: * -> *) (v :: * -> *) a.
(MonadRead m v, MonadWrite m v) =>
v a -> (a -> a) -> m ()
defaultReadWriteMutate_
  {-# INLINE mutate_ #-}

instance MonadMutate  STM TVar where
  mutate :: TVar a -> (a -> (a, b)) -> STM b
mutate = TVar a -> (a -> (a, b)) -> STM b
forall (m :: * -> *) (v :: * -> *) a b.
(MonadRead m v, MonadWrite m v) =>
v a -> (a -> (a, b)) -> m b
defaultReadWriteMutate
  {-# INLINE mutate #-}

instance STM ~ stm => MonadMutateM_ stm STM TVar where
  mutateM_ :: TVar a -> (a -> stm a) -> STM ()
mutateM_ = TVar a -> (a -> stm a) -> STM ()
forall (m :: * -> *) (v :: * -> *) a.
(MonadRead m v, MonadWrite m v) =>
v a -> (a -> m a) -> m ()
defaultReadWriteMutateM_
  {-# INLINE mutateM_ #-}

instance STM ~ stm => MonadMutateM  stm STM TVar where
  mutateM :: TVar a -> (a -> stm (a, b)) -> STM b
mutateM = TVar a -> (a -> stm (a, b)) -> STM b
forall (m :: * -> *) (v :: * -> *) a b.
(MonadRead m v, MonadWrite m v) =>
v a -> (a -> m (a, b)) -> m b
defaultReadWriteMutateM
  {-# INLINE mutateM #-}

instance MonadNew   IO TVar where
  new :: a -> IO (TVar a)
new = a -> IO (TVar a)
forall a. a -> IO (TVar a)
newTVarIO
  {-# INLINE new #-}

instance MonadRead  IO TVar where
  read :: TVar a -> IO a
read = TVar a -> IO a
forall a. TVar a -> IO a
readTVarIO
  {-# INLINE read #-}

instance MonadWrite IO TVar where
  write :: TVar a -> a -> IO ()
write = STM () -> IO ()
forall a. STM a -> IO a
atomically (STM () -> IO ())
-> (TVar a -> a -> STM ()) -> TVar a -> a -> IO ()
forall c d a b. (c -> d) -> (a -> b -> c) -> a -> b -> d
.* TVar a -> a -> STM ()
forall a. TVar a -> a -> STM ()
writeTVar
  {-# INLINE write #-}

instance MonadSwap  IO TVar where
  swap :: TVar a -> a -> IO a
swap = STM a -> IO a
forall a. STM a -> IO a
atomically (STM a -> IO a) -> (TVar a -> a -> STM a) -> TVar a -> a -> IO a
forall c d a b. (c -> d) -> (a -> b -> c) -> a -> b -> d
.* TVar a -> a -> STM a
forall (m :: * -> *) (v :: * -> *) a.
MonadSwap m v =>
v a -> a -> m a
swap
  {-# INLINE swap #-}