module MonadVar.Instances.STRef where

import           MonadVar.Classes
import           MonadVar.Default
import           Control.Monad.ST
import           Data.STRef

instance MonadNew   (ST s) (STRef s) where
  new :: a -> ST s (STRef s a)
new = a -> ST s (STRef s a)
forall a s. a -> ST s (STRef s a)
newSTRef
  {-# INLINE new #-}

instance MonadRead  (ST s) (STRef s) where
  read :: STRef s a -> ST s a
read = STRef s a -> ST s a
forall s a. STRef s a -> ST s a
readSTRef
  {-# INLINE read #-}

instance MonadWrite (ST s) (STRef s) where
  write :: STRef s a -> a -> ST s ()
write = STRef s a -> a -> ST s ()
forall s a. STRef s a -> a -> ST s ()
writeSTRef
  {-# INLINE write #-}

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

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

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

instance ST s ~ st_s => MonadMutateM_ st_s (ST s) (STRef s) where
  mutateM_ :: STRef s a -> (a -> st_s a) -> ST s ()
mutateM_ = STRef s a -> (a -> st_s a) -> ST s ()
forall (m :: * -> *) (v :: * -> *) a.
(MonadRead m v, MonadWrite m v) =>
v a -> (a -> m a) -> m ()
defaultReadWriteMutateM_
  {-# INLINE mutateM_ #-}

instance ST s ~ st_s => MonadMutateM  st_s (ST s) (STRef s) where
  mutateM :: STRef s a -> (a -> st_s (a, b)) -> ST s b
mutateM = STRef s a -> (a -> st_s (a, b)) -> ST s b
forall (m :: * -> *) (v :: * -> *) a b.
(MonadRead m v, MonadWrite m v) =>
v a -> (a -> m (a, b)) -> m b
defaultReadWriteMutateM
  {-# INLINE mutateM #-}