Strict.hs

-- | Lifted "Data.IORef.Strict".
--
-- @since 2.4.0.0
module Effectful.Prim.IORef.Strict
  ( -- * Effect
    Prim

    -- ** Handlers
  , runPrim

    -- * IORef
  , IORef'
  , newIORef'
  , readIORef'
  , writeIORef'
  , modifyIORef'
  , atomicModifyIORef'
  , atomicWriteIORef'
  , mkWeakIORef'
  ) where

import Data.IORef.Strict (IORef')
import Data.IORef.Strict qualified as Ref
import System.Mem.Weak (Weak)

import Effectful
import Effectful.Dispatch.Static
import Effectful.Dispatch.Static.Primitive
import Effectful.Prim

-- | Lifted 'Ref.newIORef''.
newIORef' :: Prim :> es => a -> Eff es (IORef' a)
newIORef' = unsafeEff_ . Ref.newIORef'

-- | Lifted 'Ref.readIORef''.
readIORef' :: Prim :> es => IORef' a -> Eff es a
readIORef' = unsafeEff_ . Ref.readIORef'

-- | Lifted 'Ref.writeIORef''.
writeIORef' :: Prim :> es => IORef' a -> a -> Eff es ()
writeIORef' var = unsafeEff_ . Ref.writeIORef' var

-- | Lifted 'Ref.modifyIORef''.
modifyIORef' :: Prim :> es => IORef' a -> (a -> a) -> Eff es ()
modifyIORef' var = unsafeEff_ . Ref.modifyIORef' var

-- | Lifted 'Ref.atomicModifyIORef''.
atomicModifyIORef' :: Prim :> es => IORef' a -> (a -> (a, b)) -> Eff es b
atomicModifyIORef' var = unsafeEff_ . Ref.atomicModifyIORef' var

-- | Lifted 'Ref.atomicWriteIORef''.
atomicWriteIORef' :: Prim :> es => IORef' a -> a -> Eff es ()
atomicWriteIORef' var = unsafeEff_ . Ref.atomicWriteIORef' var

-- | Lifted 'Ref.mkWeakIORef''.
--
-- /Note:/ the finalizer will run a cloned environment, so any changes it makes
-- to thread local data will not be visible outside of it.
mkWeakIORef'
  :: (HasCallStack, Prim :> es)
  => IORef' a
  -> Eff es ()
  -> Eff es (Weak (IORef' a))
mkWeakIORef' var f = unsafeEff $ \es -> do
  -- The finalizer can run at any point and in any thread.
  Ref.mkWeakIORef' var . unEff f =<< cloneEnv es