module HaskellWorks.Polysemy.Control.Concurrent.STM
  ( TVar,
    atomically,
    STM.orElse,
    STM.retry,
    STM.check,
    STM.throwSTM,
    STM.catchSTM,
  ) where

import           Control.Concurrent.STM        (STM, TVar)
import qualified Control.Concurrent.STM        as STM
import           Control.Monad.IO.Class        (MonadIO (..))
import           HaskellWorks.Polysemy.Prelude
import           Polysemy

atomically :: forall a r m. ()
  => MonadIO m
  => Member (Embed m) r
  => STM a
  -> Sem r a
atomically :: forall a (r :: EffectRow) (m :: * -> *).
(MonadIO m, Member (Embed m) r) =>
STM a -> Sem r a
atomically STM a
m =
  m a -> Sem r a
forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed (m a -> Sem r a) -> m a -> Sem r a
forall a b. (a -> b) -> a -> b
$ IO a -> m a
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> m a) -> IO a -> m a
forall a b. (a -> b) -> a -> b
$ STM a -> IO a
forall a. STM a -> IO a
STM.atomically STM a
m