{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE UndecidableInstances #-}

{- |
Most definitions follow the RIO lib: https://hackage.haskell.org/package/rio-0.1.18.0/docs/RIO.html
The rest follow from orphans: https://hackage.haskell.org/package/rio-orphans-0.1.1.0/docs/src/RIO.Orphans.html
See LICENSE info in the README.
-}
module LittleRIO
  ( HasResourceMap (..)
  , HasStateRef (..)
  , HasWriteRef (..)
  , SimpleResourceEnv (..)
  , SimpleStateEnv (..)
  , SimpleWriteEnv (..)
  , SomeRef (..)
  , ResourceMap
  , RIO (..)
  , getStateRef
  , liftRIO
  , listenWriteRef
  , newSomeRef
  , mapRIO
  , modifySomeRef
  , modifyStateRef
  , passWriteRef
  , putStateRef
  , runSimpleResourceRIO
  , runSimpleStateRIO
  , runSimpleWriteRIO
  , runRIO
  , readSomeRef
  , resourceRIO
  , tellWriteRef
  , unliftRIO
  , withResourceMap
  , writeSomeRef
  ) where

import Control.Applicative (liftA2)
import Control.DeepSeq (NFData (..))
import Control.Monad.Catch (MonadCatch, MonadMask, MonadThrow)
import Control.Monad.IO.Class (MonadIO (..))
import Control.Monad.IO.Unlift (MonadUnliftIO (..), UnliftIO, askUnliftIO)
import Control.Monad.Primitive (PrimMonad (..))
import Control.Monad.Reader (MonadReader (..), ReaderT (..))
import Control.Monad.State (MonadState (..))
import Control.Monad.Trans.Resource (runResourceT)
import Control.Monad.Trans.Resource.Internal (MonadResource (..), ReleaseMap, ResourceT (..))
import Control.Monad.Writer (MonadWriter (..))
import Data.IORef (IORef, newIORef, readIORef, writeIORef)
import GHC.Generics (Generic)
import Lens.Micro (Lens', lens)
import Lens.Micro.Mtl (view)
import LittleLogger (LogActionWrapperM (..), MonadLogger)

newtype RIO env a = RIO { RIO env a -> ReaderT env IO a
unRIO :: ReaderT env IO a }
  deriving newtype (a -> RIO env b -> RIO env a
(a -> b) -> RIO env a -> RIO env b
(forall a b. (a -> b) -> RIO env a -> RIO env b)
-> (forall a b. a -> RIO env b -> RIO env a) -> Functor (RIO env)
forall a b. a -> RIO env b -> RIO env a
forall a b. (a -> b) -> RIO env a -> RIO env b
forall env a b. a -> RIO env b -> RIO env a
forall env a b. (a -> b) -> RIO env a -> RIO env b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> RIO env b -> RIO env a
$c<$ :: forall env a b. a -> RIO env b -> RIO env a
fmap :: (a -> b) -> RIO env a -> RIO env b
$cfmap :: forall env a b. (a -> b) -> RIO env a -> RIO env b
Functor, Functor (RIO env)
a -> RIO env a
Functor (RIO env)
-> (forall a. a -> RIO env a)
-> (forall a b. RIO env (a -> b) -> RIO env a -> RIO env b)
-> (forall a b c.
    (a -> b -> c) -> RIO env a -> RIO env b -> RIO env c)
-> (forall a b. RIO env a -> RIO env b -> RIO env b)
-> (forall a b. RIO env a -> RIO env b -> RIO env a)
-> Applicative (RIO env)
RIO env a -> RIO env b -> RIO env b
RIO env a -> RIO env b -> RIO env a
RIO env (a -> b) -> RIO env a -> RIO env b
(a -> b -> c) -> RIO env a -> RIO env b -> RIO env c
forall env. Functor (RIO env)
forall a. a -> RIO env a
forall env a. a -> RIO env a
forall a b. RIO env a -> RIO env b -> RIO env a
forall a b. RIO env a -> RIO env b -> RIO env b
forall a b. RIO env (a -> b) -> RIO env a -> RIO env b
forall env a b. RIO env a -> RIO env b -> RIO env a
forall env a b. RIO env a -> RIO env b -> RIO env b
forall env a b. RIO env (a -> b) -> RIO env a -> RIO env b
forall a b c. (a -> b -> c) -> RIO env a -> RIO env b -> RIO env c
forall env a b c.
(a -> b -> c) -> RIO env a -> RIO env b -> RIO env c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: RIO env a -> RIO env b -> RIO env a
$c<* :: forall env a b. RIO env a -> RIO env b -> RIO env a
*> :: RIO env a -> RIO env b -> RIO env b
$c*> :: forall env a b. RIO env a -> RIO env b -> RIO env b
liftA2 :: (a -> b -> c) -> RIO env a -> RIO env b -> RIO env c
$cliftA2 :: forall env a b c.
(a -> b -> c) -> RIO env a -> RIO env b -> RIO env c
<*> :: RIO env (a -> b) -> RIO env a -> RIO env b
$c<*> :: forall env a b. RIO env (a -> b) -> RIO env a -> RIO env b
pure :: a -> RIO env a
$cpure :: forall env a. a -> RIO env a
$cp1Applicative :: forall env. Functor (RIO env)
Applicative, Applicative (RIO env)
a -> RIO env a
Applicative (RIO env)
-> (forall a b. RIO env a -> (a -> RIO env b) -> RIO env b)
-> (forall a b. RIO env a -> RIO env b -> RIO env b)
-> (forall a. a -> RIO env a)
-> Monad (RIO env)
RIO env a -> (a -> RIO env b) -> RIO env b
RIO env a -> RIO env b -> RIO env b
forall env. Applicative (RIO env)
forall a. a -> RIO env a
forall env a. a -> RIO env a
forall a b. RIO env a -> RIO env b -> RIO env b
forall a b. RIO env a -> (a -> RIO env b) -> RIO env b
forall env a b. RIO env a -> RIO env b -> RIO env b
forall env a b. RIO env a -> (a -> RIO env b) -> RIO env b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> RIO env a
$creturn :: forall env a. a -> RIO env a
>> :: RIO env a -> RIO env b -> RIO env b
$c>> :: forall env a b. RIO env a -> RIO env b -> RIO env b
>>= :: RIO env a -> (a -> RIO env b) -> RIO env b
$c>>= :: forall env a b. RIO env a -> (a -> RIO env b) -> RIO env b
$cp1Monad :: forall env. Applicative (RIO env)
Monad, MonadReader env, Monad (RIO env)
Monad (RIO env)
-> (forall a. IO a -> RIO env a) -> MonadIO (RIO env)
IO a -> RIO env a
forall env. Monad (RIO env)
forall a. IO a -> RIO env a
forall env a. IO a -> RIO env a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> RIO env a
$cliftIO :: forall env a. IO a -> RIO env a
$cp1MonadIO :: forall env. Monad (RIO env)
MonadIO, Monad (RIO env)
e -> RIO env a
Monad (RIO env)
-> (forall e a. Exception e => e -> RIO env a)
-> MonadThrow (RIO env)
forall env. Monad (RIO env)
forall e a. Exception e => e -> RIO env a
forall env e a. Exception e => e -> RIO env a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: e -> RIO env a
$cthrowM :: forall env e a. Exception e => e -> RIO env a
$cp1MonadThrow :: forall env. Monad (RIO env)
MonadThrow, Monad (RIO env)
Monad (RIO env)
-> (forall a. String -> RIO env a) -> MonadFail (RIO env)
String -> RIO env a
forall env. Monad (RIO env)
forall a. String -> RIO env a
forall env a. String -> RIO env a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
fail :: String -> RIO env a
$cfail :: forall env a. String -> RIO env a
$cp1MonadFail :: forall env. Monad (RIO env)
MonadFail, MonadThrow (RIO env)
MonadThrow (RIO env)
-> (forall e a.
    Exception e =>
    RIO env a -> (e -> RIO env a) -> RIO env a)
-> MonadCatch (RIO env)
RIO env a -> (e -> RIO env a) -> RIO env a
forall env. MonadThrow (RIO env)
forall e a.
Exception e =>
RIO env a -> (e -> RIO env a) -> RIO env a
forall env e a.
Exception e =>
RIO env a -> (e -> RIO env a) -> RIO env a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: RIO env a -> (e -> RIO env a) -> RIO env a
$ccatch :: forall env e a.
Exception e =>
RIO env a -> (e -> RIO env a) -> RIO env a
$cp1MonadCatch :: forall env. MonadThrow (RIO env)
MonadCatch, MonadCatch (RIO env)
MonadCatch (RIO env)
-> (forall b.
    ((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b)
-> (forall b.
    ((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b)
-> (forall a b c.
    RIO env a
    -> (a -> ExitCase b -> RIO env c)
    -> (a -> RIO env b)
    -> RIO env (b, c))
-> MonadMask (RIO env)
RIO env a
-> (a -> ExitCase b -> RIO env c)
-> (a -> RIO env b)
-> RIO env (b, c)
((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b
((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b
forall env. MonadCatch (RIO env)
forall b.
((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b
forall env b.
((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b
forall a b c.
RIO env a
-> (a -> ExitCase b -> RIO env c)
-> (a -> RIO env b)
-> RIO env (b, c)
forall env a b c.
RIO env a
-> (a -> ExitCase b -> RIO env c)
-> (a -> RIO env b)
-> RIO env (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: RIO env a
-> (a -> ExitCase b -> RIO env c)
-> (a -> RIO env b)
-> RIO env (b, c)
$cgeneralBracket :: forall env a b c.
RIO env a
-> (a -> ExitCase b -> RIO env c)
-> (a -> RIO env b)
-> RIO env (b, c)
uninterruptibleMask :: ((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b
$cuninterruptibleMask :: forall env b.
((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b
mask :: ((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b
$cmask :: forall env b.
((forall a. RIO env a -> RIO env a) -> RIO env b) -> RIO env b
$cp1MonadMask :: forall env. MonadCatch (RIO env)
MonadMask, MonadIO (RIO env)
MonadIO (RIO env)
-> (forall b. ((forall a. RIO env a -> IO a) -> IO b) -> RIO env b)
-> MonadUnliftIO (RIO env)
((forall a. RIO env a -> IO a) -> IO b) -> RIO env b
forall env. MonadIO (RIO env)
forall b. ((forall a. RIO env a -> IO a) -> IO b) -> RIO env b
forall env b. ((forall a. RIO env a -> IO a) -> IO b) -> RIO env b
forall (m :: * -> *).
MonadIO m
-> (forall b. ((forall a. m a -> IO a) -> IO b) -> m b)
-> MonadUnliftIO m
withRunInIO :: ((forall a. RIO env a -> IO a) -> IO b) -> RIO env b
$cwithRunInIO :: forall env b. ((forall a. RIO env a -> IO a) -> IO b) -> RIO env b
$cp1MonadUnliftIO :: forall env. MonadIO (RIO env)
MonadUnliftIO)
  deriving Monad (RIO env)
Monad (RIO env)
-> (forall msg.
    ToLogStr msg =>
    Loc -> LogSource -> LogLevel -> msg -> RIO env ())
-> MonadLogger (RIO env)
Loc -> LogSource -> LogLevel -> msg -> RIO env ()
forall msg.
ToLogStr msg =>
Loc -> LogSource -> LogLevel -> msg -> RIO env ()
forall env. HasLogAction env => Monad (RIO env)
forall env msg.
(HasLogAction env, ToLogStr msg) =>
Loc -> LogSource -> LogLevel -> msg -> RIO env ()
forall (m :: * -> *).
Monad m
-> (forall msg.
    ToLogStr msg =>
    Loc -> LogSource -> LogLevel -> msg -> m ())
-> MonadLogger m
monadLoggerLog :: Loc -> LogSource -> LogLevel -> msg -> RIO env ()
$cmonadLoggerLog :: forall env msg.
(HasLogAction env, ToLogStr msg) =>
Loc -> LogSource -> LogLevel -> msg -> RIO env ()
$cp1MonadLogger :: forall env. HasLogAction env => Monad (RIO env)
MonadLogger via LogActionWrapperM env (RIO env)

instance Semigroup a => Semigroup (RIO env a) where
  <> :: RIO env a -> RIO env a -> RIO env a
(<>) = (a -> a -> a) -> RIO env a -> RIO env a -> RIO env a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Semigroup a => a -> a -> a
(<>)

instance Monoid a => Monoid (RIO env a) where
  mempty :: RIO env a
mempty = a -> RIO env a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Monoid a => a
mempty
  mappend :: RIO env a -> RIO env a -> RIO env a
mappend = RIO env a -> RIO env a -> RIO env a
forall a. Semigroup a => a -> a -> a
(<>)

instance PrimMonad (RIO env) where
  type PrimState (RIO env) = PrimState IO
  primitive :: (State# (PrimState (RIO env))
 -> (# State# (PrimState (RIO env)), a #))
-> RIO env a
primitive = ReaderT env IO a -> RIO env a
forall env a. ReaderT env IO a -> RIO env a
RIO (ReaderT env IO a -> RIO env a)
-> ((State# RealWorld -> (# State# RealWorld, a #))
    -> ReaderT env IO a)
-> (State# RealWorld -> (# State# RealWorld, a #))
-> RIO env a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (env -> IO a) -> ReaderT env IO a
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((env -> IO a) -> ReaderT env IO a)
-> ((State# RealWorld -> (# State# RealWorld, a #)) -> env -> IO a)
-> (State# RealWorld -> (# State# RealWorld, a #))
-> ReaderT env IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> env -> IO a
forall a b. a -> b -> a
const (IO a -> env -> IO a)
-> ((State# RealWorld -> (# State# RealWorld, a #)) -> IO a)
-> (State# RealWorld -> (# State# RealWorld, a #))
-> env
-> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
forall (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
primitive

mapRIO :: (env -> env') -> RIO env' a -> RIO env a
mapRIO :: (env -> env') -> RIO env' a -> RIO env a
mapRIO env -> env'
f RIO env' a
m = do
  env
env <- RIO env env
forall r (m :: * -> *). MonadReader r m => m r
ask
  let env' :: env'
env' = env -> env'
f env
env
  env' -> RIO env' a -> RIO env a
forall (m :: * -> *) env a. MonadIO m => env -> RIO env a -> m a
runRIO env'
env' RIO env' a
m

liftRIO :: (MonadIO m, MonadReader env m) => RIO env a -> m a
liftRIO :: RIO env a -> m a
liftRIO RIO env a
m = do
  env
env <- m env
forall r (m :: * -> *). MonadReader r m => m r
ask
  env -> RIO env a -> m a
forall (m :: * -> *) env a. MonadIO m => env -> RIO env a -> m a
runRIO env
env RIO env a
m

unliftRIO :: MonadIO m => env -> m (UnliftIO (RIO env))
unliftRIO :: env -> m (UnliftIO (RIO env))
unliftRIO env
env = IO (UnliftIO (RIO env)) -> m (UnliftIO (RIO env))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (env -> RIO env (UnliftIO (RIO env)) -> IO (UnliftIO (RIO env))
forall (m :: * -> *) env a. MonadIO m => env -> RIO env a -> m a
runRIO env
env RIO env (UnliftIO (RIO env))
forall (m :: * -> *). MonadUnliftIO m => m (UnliftIO m)
askUnliftIO)

runRIO :: MonadIO m => env -> RIO env a -> m a
runRIO :: env -> RIO env a -> m a
runRIO env
r RIO env a
m = IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ReaderT env IO a -> env -> IO a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (RIO env a -> ReaderT env IO a
forall env a. RIO env a -> ReaderT env IO a
unRIO RIO env a
m) env
r)

data SomeRef a = SomeRef !(IO a) !(a -> IO ())

instance NFData (SomeRef a) where
  rnf :: SomeRef a -> ()
rnf (SomeRef IO a
r a -> IO ()
w) = IO a -> () -> ()
seq IO a
r ((a -> IO ()) -> () -> ()
seq a -> IO ()
w ())

readSomeRef :: MonadIO m => SomeRef a -> m a
readSomeRef :: SomeRef a -> m a
readSomeRef (SomeRef IO a
x a -> IO ()
_) = IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO a
x

writeSomeRef :: MonadIO m => SomeRef a -> a -> m ()
writeSomeRef :: SomeRef a -> a -> m ()
writeSomeRef (SomeRef IO a
_ a -> IO ()
x) = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> (a -> IO ()) -> a -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> IO ()
x

modifySomeRef :: MonadIO m => SomeRef a -> (a -> a) -> m ()
modifySomeRef :: SomeRef a -> (a -> a) -> m ()
modifySomeRef (SomeRef IO a
read' a -> IO ()
write) a -> a
f = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a
read' IO a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> IO ()
write (a -> IO ()) -> (a -> a) -> a -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
f)

ioRefToSomeRef :: IORef a -> SomeRef a
ioRefToSomeRef :: IORef a -> SomeRef a
ioRefToSomeRef IORef a
ref = IO a -> (a -> IO ()) -> SomeRef a
forall a. IO a -> (a -> IO ()) -> SomeRef a
SomeRef (IORef a -> IO a
forall a. IORef a -> IO a
readIORef IORef a
ref) (IORef a -> a -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef a
ref)

newSomeRef :: MonadIO m => a -> m (SomeRef a)
newSomeRef :: a -> m (SomeRef a)
newSomeRef = IO (SomeRef a) -> m (SomeRef a)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (SomeRef a) -> m (SomeRef a))
-> (a -> IO (SomeRef a)) -> a -> m (SomeRef a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (IORef a -> SomeRef a) -> IO (IORef a) -> IO (SomeRef a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap IORef a -> SomeRef a
forall a. IORef a -> SomeRef a
ioRefToSomeRef (IO (IORef a) -> IO (SomeRef a))
-> (a -> IO (IORef a)) -> a -> IO (SomeRef a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> IO (IORef a)
forall a. a -> IO (IORef a)
newIORef

class HasStateRef st env | env -> st where
  stateRefL :: Lens' env (SomeRef st)

instance HasStateRef a (SomeRef a) where
  stateRefL :: (SomeRef a -> f (SomeRef a)) -> SomeRef a -> f (SomeRef a)
stateRefL = (SomeRef a -> f (SomeRef a)) -> SomeRef a -> f (SomeRef a)
forall a. a -> a
id

data SimpleStateEnv st env = SimpleStateEnv
  { SimpleStateEnv st env -> SomeRef st
sseRef :: !(SomeRef st)
  , SimpleStateEnv st env -> env
sseEnv :: !env
  } deriving stock (a -> SimpleStateEnv st b -> SimpleStateEnv st a
(a -> b) -> SimpleStateEnv st a -> SimpleStateEnv st b
(forall a b.
 (a -> b) -> SimpleStateEnv st a -> SimpleStateEnv st b)
-> (forall a b. a -> SimpleStateEnv st b -> SimpleStateEnv st a)
-> Functor (SimpleStateEnv st)
forall a b. a -> SimpleStateEnv st b -> SimpleStateEnv st a
forall a b. (a -> b) -> SimpleStateEnv st a -> SimpleStateEnv st b
forall st a b. a -> SimpleStateEnv st b -> SimpleStateEnv st a
forall st a b.
(a -> b) -> SimpleStateEnv st a -> SimpleStateEnv st b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> SimpleStateEnv st b -> SimpleStateEnv st a
$c<$ :: forall st a b. a -> SimpleStateEnv st b -> SimpleStateEnv st a
fmap :: (a -> b) -> SimpleStateEnv st a -> SimpleStateEnv st b
$cfmap :: forall st a b.
(a -> b) -> SimpleStateEnv st a -> SimpleStateEnv st b
Functor, SimpleStateEnv st a -> Bool
(a -> m) -> SimpleStateEnv st a -> m
(a -> b -> b) -> b -> SimpleStateEnv st a -> b
(forall m. Monoid m => SimpleStateEnv st m -> m)
-> (forall m a. Monoid m => (a -> m) -> SimpleStateEnv st a -> m)
-> (forall m a. Monoid m => (a -> m) -> SimpleStateEnv st a -> m)
-> (forall a b. (a -> b -> b) -> b -> SimpleStateEnv st a -> b)
-> (forall a b. (a -> b -> b) -> b -> SimpleStateEnv st a -> b)
-> (forall b a. (b -> a -> b) -> b -> SimpleStateEnv st a -> b)
-> (forall b a. (b -> a -> b) -> b -> SimpleStateEnv st a -> b)
-> (forall a. (a -> a -> a) -> SimpleStateEnv st a -> a)
-> (forall a. (a -> a -> a) -> SimpleStateEnv st a -> a)
-> (forall a. SimpleStateEnv st a -> [a])
-> (forall a. SimpleStateEnv st a -> Bool)
-> (forall a. SimpleStateEnv st a -> Int)
-> (forall a. Eq a => a -> SimpleStateEnv st a -> Bool)
-> (forall a. Ord a => SimpleStateEnv st a -> a)
-> (forall a. Ord a => SimpleStateEnv st a -> a)
-> (forall a. Num a => SimpleStateEnv st a -> a)
-> (forall a. Num a => SimpleStateEnv st a -> a)
-> Foldable (SimpleStateEnv st)
forall a. Eq a => a -> SimpleStateEnv st a -> Bool
forall a. Num a => SimpleStateEnv st a -> a
forall a. Ord a => SimpleStateEnv st a -> a
forall m. Monoid m => SimpleStateEnv st m -> m
forall a. SimpleStateEnv st a -> Bool
forall a. SimpleStateEnv st a -> Int
forall a. SimpleStateEnv st a -> [a]
forall a. (a -> a -> a) -> SimpleStateEnv st a -> a
forall st a. Eq a => a -> SimpleStateEnv st a -> Bool
forall st a. Num a => SimpleStateEnv st a -> a
forall st a. Ord a => SimpleStateEnv st a -> a
forall m a. Monoid m => (a -> m) -> SimpleStateEnv st a -> m
forall st m. Monoid m => SimpleStateEnv st m -> m
forall st a. SimpleStateEnv st a -> Bool
forall st a. SimpleStateEnv st a -> Int
forall st a. SimpleStateEnv st a -> [a]
forall b a. (b -> a -> b) -> b -> SimpleStateEnv st a -> b
forall a b. (a -> b -> b) -> b -> SimpleStateEnv st a -> b
forall st a. (a -> a -> a) -> SimpleStateEnv st a -> a
forall st m a. Monoid m => (a -> m) -> SimpleStateEnv st a -> m
forall st b a. (b -> a -> b) -> b -> SimpleStateEnv st a -> b
forall st a b. (a -> b -> b) -> b -> SimpleStateEnv st a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: SimpleStateEnv st a -> a
$cproduct :: forall st a. Num a => SimpleStateEnv st a -> a
sum :: SimpleStateEnv st a -> a
$csum :: forall st a. Num a => SimpleStateEnv st a -> a
minimum :: SimpleStateEnv st a -> a
$cminimum :: forall st a. Ord a => SimpleStateEnv st a -> a
maximum :: SimpleStateEnv st a -> a
$cmaximum :: forall st a. Ord a => SimpleStateEnv st a -> a
elem :: a -> SimpleStateEnv st a -> Bool
$celem :: forall st a. Eq a => a -> SimpleStateEnv st a -> Bool
length :: SimpleStateEnv st a -> Int
$clength :: forall st a. SimpleStateEnv st a -> Int
null :: SimpleStateEnv st a -> Bool
$cnull :: forall st a. SimpleStateEnv st a -> Bool
toList :: SimpleStateEnv st a -> [a]
$ctoList :: forall st a. SimpleStateEnv st a -> [a]
foldl1 :: (a -> a -> a) -> SimpleStateEnv st a -> a
$cfoldl1 :: forall st a. (a -> a -> a) -> SimpleStateEnv st a -> a
foldr1 :: (a -> a -> a) -> SimpleStateEnv st a -> a
$cfoldr1 :: forall st a. (a -> a -> a) -> SimpleStateEnv st a -> a
foldl' :: (b -> a -> b) -> b -> SimpleStateEnv st a -> b
$cfoldl' :: forall st b a. (b -> a -> b) -> b -> SimpleStateEnv st a -> b
foldl :: (b -> a -> b) -> b -> SimpleStateEnv st a -> b
$cfoldl :: forall st b a. (b -> a -> b) -> b -> SimpleStateEnv st a -> b
foldr' :: (a -> b -> b) -> b -> SimpleStateEnv st a -> b
$cfoldr' :: forall st a b. (a -> b -> b) -> b -> SimpleStateEnv st a -> b
foldr :: (a -> b -> b) -> b -> SimpleStateEnv st a -> b
$cfoldr :: forall st a b. (a -> b -> b) -> b -> SimpleStateEnv st a -> b
foldMap' :: (a -> m) -> SimpleStateEnv st a -> m
$cfoldMap' :: forall st m a. Monoid m => (a -> m) -> SimpleStateEnv st a -> m
foldMap :: (a -> m) -> SimpleStateEnv st a -> m
$cfoldMap :: forall st m a. Monoid m => (a -> m) -> SimpleStateEnv st a -> m
fold :: SimpleStateEnv st m -> m
$cfold :: forall st m. Monoid m => SimpleStateEnv st m -> m
Foldable, Functor (SimpleStateEnv st)
Foldable (SimpleStateEnv st)
Functor (SimpleStateEnv st)
-> Foldable (SimpleStateEnv st)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> SimpleStateEnv st a -> f (SimpleStateEnv st b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    SimpleStateEnv st (f a) -> f (SimpleStateEnv st a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SimpleStateEnv st a -> m (SimpleStateEnv st b))
-> (forall (m :: * -> *) a.
    Monad m =>
    SimpleStateEnv st (m a) -> m (SimpleStateEnv st a))
-> Traversable (SimpleStateEnv st)
(a -> f b) -> SimpleStateEnv st a -> f (SimpleStateEnv st b)
forall st. Functor (SimpleStateEnv st)
forall st. Foldable (SimpleStateEnv st)
forall st (m :: * -> *) a.
Monad m =>
SimpleStateEnv st (m a) -> m (SimpleStateEnv st a)
forall st (f :: * -> *) a.
Applicative f =>
SimpleStateEnv st (f a) -> f (SimpleStateEnv st a)
forall st (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SimpleStateEnv st a -> m (SimpleStateEnv st b)
forall st (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SimpleStateEnv st a -> f (SimpleStateEnv st b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
SimpleStateEnv st (m a) -> m (SimpleStateEnv st a)
forall (f :: * -> *) a.
Applicative f =>
SimpleStateEnv st (f a) -> f (SimpleStateEnv st a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SimpleStateEnv st a -> m (SimpleStateEnv st b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SimpleStateEnv st a -> f (SimpleStateEnv st b)
sequence :: SimpleStateEnv st (m a) -> m (SimpleStateEnv st a)
$csequence :: forall st (m :: * -> *) a.
Monad m =>
SimpleStateEnv st (m a) -> m (SimpleStateEnv st a)
mapM :: (a -> m b) -> SimpleStateEnv st a -> m (SimpleStateEnv st b)
$cmapM :: forall st (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SimpleStateEnv st a -> m (SimpleStateEnv st b)
sequenceA :: SimpleStateEnv st (f a) -> f (SimpleStateEnv st a)
$csequenceA :: forall st (f :: * -> *) a.
Applicative f =>
SimpleStateEnv st (f a) -> f (SimpleStateEnv st a)
traverse :: (a -> f b) -> SimpleStateEnv st a -> f (SimpleStateEnv st b)
$ctraverse :: forall st (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SimpleStateEnv st a -> f (SimpleStateEnv st b)
$cp2Traversable :: forall st. Foldable (SimpleStateEnv st)
$cp1Traversable :: forall st. Functor (SimpleStateEnv st)
Traversable, (forall x. SimpleStateEnv st env -> Rep (SimpleStateEnv st env) x)
-> (forall x.
    Rep (SimpleStateEnv st env) x -> SimpleStateEnv st env)
-> Generic (SimpleStateEnv st env)
forall x. Rep (SimpleStateEnv st env) x -> SimpleStateEnv st env
forall x. SimpleStateEnv st env -> Rep (SimpleStateEnv st env) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall st env x.
Rep (SimpleStateEnv st env) x -> SimpleStateEnv st env
forall st env x.
SimpleStateEnv st env -> Rep (SimpleStateEnv st env) x
$cto :: forall st env x.
Rep (SimpleStateEnv st env) x -> SimpleStateEnv st env
$cfrom :: forall st env x.
SimpleStateEnv st env -> Rep (SimpleStateEnv st env) x
Generic)
    deriving anyclass (SimpleStateEnv st env -> ()
(SimpleStateEnv st env -> ()) -> NFData (SimpleStateEnv st env)
forall a. (a -> ()) -> NFData a
forall st env. NFData env => SimpleStateEnv st env -> ()
rnf :: SimpleStateEnv st env -> ()
$crnf :: forall st env. NFData env => SimpleStateEnv st env -> ()
NFData)

instance HasStateRef st (SimpleStateEnv st env) where
  stateRefL :: (SomeRef st -> f (SomeRef st))
-> SimpleStateEnv st env -> f (SimpleStateEnv st env)
stateRefL = (SimpleStateEnv st env -> SomeRef st)
-> (SimpleStateEnv st env -> SomeRef st -> SimpleStateEnv st env)
-> Lens' (SimpleStateEnv st env) (SomeRef st)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens SimpleStateEnv st env -> SomeRef st
forall st env. SimpleStateEnv st env -> SomeRef st
sseRef (\(SimpleStateEnv SomeRef st
_ env
env) SomeRef st
st -> SomeRef st -> env -> SimpleStateEnv st env
forall st env. SomeRef st -> env -> SimpleStateEnv st env
SimpleStateEnv SomeRef st
st env
env)

runSimpleStateRIO :: MonadIO m => st -> env -> RIO (SimpleStateEnv st env) a -> m (a, st)
runSimpleStateRIO :: st -> env -> RIO (SimpleStateEnv st env) a -> m (a, st)
runSimpleStateRIO st
st env
env RIO (SimpleStateEnv st env) a
m = do
  SomeRef st
ref <- st -> m (SomeRef st)
forall (m :: * -> *) a. MonadIO m => a -> m (SomeRef a)
newSomeRef st
st
  a
a <- SimpleStateEnv st env -> RIO (SimpleStateEnv st env) a -> m a
forall (m :: * -> *) env a. MonadIO m => env -> RIO env a -> m a
runRIO (SomeRef st -> env -> SimpleStateEnv st env
forall st env. SomeRef st -> env -> SimpleStateEnv st env
SimpleStateEnv SomeRef st
ref env
env) RIO (SimpleStateEnv st env) a
m
  st
st' <- SomeRef st -> m st
forall (m :: * -> *) a. MonadIO m => SomeRef a -> m a
readSomeRef SomeRef st
ref
  (a, st) -> m (a, st)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a
a, st
st')

getStateRef :: (HasStateRef st env, MonadReader env m, MonadIO m) => m st
getStateRef :: m st
getStateRef = do
  SomeRef st
ref <- Getting (SomeRef st) env (SomeRef st) -> m (SomeRef st)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (SomeRef st) env (SomeRef st)
forall st env. HasStateRef st env => Lens' env (SomeRef st)
stateRefL
  IO st -> m st
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (SomeRef st -> IO st
forall (m :: * -> *) a. MonadIO m => SomeRef a -> m a
readSomeRef SomeRef st
ref)

putStateRef :: (HasStateRef st env, MonadReader env m, MonadIO m) => st -> m ()
putStateRef :: st -> m ()
putStateRef st
st = do
  SomeRef st
ref <- Getting (SomeRef st) env (SomeRef st) -> m (SomeRef st)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (SomeRef st) env (SomeRef st)
forall st env. HasStateRef st env => Lens' env (SomeRef st)
stateRefL
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (SomeRef st -> st -> IO ()
forall (m :: * -> *) a. MonadIO m => SomeRef a -> a -> m ()
writeSomeRef SomeRef st
ref st
st)

modifyStateRef :: (HasStateRef st env, MonadReader env m, MonadIO m) => (st -> st) -> m ()
modifyStateRef :: (st -> st) -> m ()
modifyStateRef st -> st
f = do
  SomeRef st
ref <- Getting (SomeRef st) env (SomeRef st) -> m (SomeRef st)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (SomeRef st) env (SomeRef st)
forall st env. HasStateRef st env => Lens' env (SomeRef st)
stateRefL
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (SomeRef st -> (st -> st) -> IO ()
forall (m :: * -> *) a. MonadIO m => SomeRef a -> (a -> a) -> m ()
modifySomeRef SomeRef st
ref st -> st
f)

instance HasStateRef st env => MonadState st (RIO env) where
  get :: RIO env st
get = RIO env st
forall st env (m :: * -> *).
(HasStateRef st env, MonadReader env m, MonadIO m) =>
m st
getStateRef
  put :: st -> RIO env ()
put = st -> RIO env ()
forall st env (m :: * -> *).
(HasStateRef st env, MonadReader env m, MonadIO m) =>
st -> m ()
putStateRef

class HasWriteRef w env | env -> w where
  writeRefL :: Lens' env (SomeRef w)

instance HasWriteRef a (SomeRef a) where
  writeRefL :: (SomeRef a -> f (SomeRef a)) -> SomeRef a -> f (SomeRef a)
writeRefL = (SomeRef a -> f (SomeRef a)) -> SomeRef a -> f (SomeRef a)
forall a. a -> a
id

data SimpleWriteEnv w env = SimpleWriteEnv
  { SimpleWriteEnv w env -> SomeRef w
sweRef :: !(SomeRef w)
  , SimpleWriteEnv w env -> env
sweEnv :: !env
  } deriving stock (a -> SimpleWriteEnv w b -> SimpleWriteEnv w a
(a -> b) -> SimpleWriteEnv w a -> SimpleWriteEnv w b
(forall a b. (a -> b) -> SimpleWriteEnv w a -> SimpleWriteEnv w b)
-> (forall a b. a -> SimpleWriteEnv w b -> SimpleWriteEnv w a)
-> Functor (SimpleWriteEnv w)
forall a b. a -> SimpleWriteEnv w b -> SimpleWriteEnv w a
forall a b. (a -> b) -> SimpleWriteEnv w a -> SimpleWriteEnv w b
forall w a b. a -> SimpleWriteEnv w b -> SimpleWriteEnv w a
forall w a b. (a -> b) -> SimpleWriteEnv w a -> SimpleWriteEnv w b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> SimpleWriteEnv w b -> SimpleWriteEnv w a
$c<$ :: forall w a b. a -> SimpleWriteEnv w b -> SimpleWriteEnv w a
fmap :: (a -> b) -> SimpleWriteEnv w a -> SimpleWriteEnv w b
$cfmap :: forall w a b. (a -> b) -> SimpleWriteEnv w a -> SimpleWriteEnv w b
Functor, SimpleWriteEnv w a -> Bool
(a -> m) -> SimpleWriteEnv w a -> m
(a -> b -> b) -> b -> SimpleWriteEnv w a -> b
(forall m. Monoid m => SimpleWriteEnv w m -> m)
-> (forall m a. Monoid m => (a -> m) -> SimpleWriteEnv w a -> m)
-> (forall m a. Monoid m => (a -> m) -> SimpleWriteEnv w a -> m)
-> (forall a b. (a -> b -> b) -> b -> SimpleWriteEnv w a -> b)
-> (forall a b. (a -> b -> b) -> b -> SimpleWriteEnv w a -> b)
-> (forall b a. (b -> a -> b) -> b -> SimpleWriteEnv w a -> b)
-> (forall b a. (b -> a -> b) -> b -> SimpleWriteEnv w a -> b)
-> (forall a. (a -> a -> a) -> SimpleWriteEnv w a -> a)
-> (forall a. (a -> a -> a) -> SimpleWriteEnv w a -> a)
-> (forall a. SimpleWriteEnv w a -> [a])
-> (forall a. SimpleWriteEnv w a -> Bool)
-> (forall a. SimpleWriteEnv w a -> Int)
-> (forall a. Eq a => a -> SimpleWriteEnv w a -> Bool)
-> (forall a. Ord a => SimpleWriteEnv w a -> a)
-> (forall a. Ord a => SimpleWriteEnv w a -> a)
-> (forall a. Num a => SimpleWriteEnv w a -> a)
-> (forall a. Num a => SimpleWriteEnv w a -> a)
-> Foldable (SimpleWriteEnv w)
forall a. Eq a => a -> SimpleWriteEnv w a -> Bool
forall a. Num a => SimpleWriteEnv w a -> a
forall a. Ord a => SimpleWriteEnv w a -> a
forall m. Monoid m => SimpleWriteEnv w m -> m
forall a. SimpleWriteEnv w a -> Bool
forall a. SimpleWriteEnv w a -> Int
forall a. SimpleWriteEnv w a -> [a]
forall a. (a -> a -> a) -> SimpleWriteEnv w a -> a
forall w a. Eq a => a -> SimpleWriteEnv w a -> Bool
forall w a. Num a => SimpleWriteEnv w a -> a
forall w a. Ord a => SimpleWriteEnv w a -> a
forall m a. Monoid m => (a -> m) -> SimpleWriteEnv w a -> m
forall w m. Monoid m => SimpleWriteEnv w m -> m
forall w a. SimpleWriteEnv w a -> Bool
forall w a. SimpleWriteEnv w a -> Int
forall w a. SimpleWriteEnv w a -> [a]
forall b a. (b -> a -> b) -> b -> SimpleWriteEnv w a -> b
forall a b. (a -> b -> b) -> b -> SimpleWriteEnv w a -> b
forall w a. (a -> a -> a) -> SimpleWriteEnv w a -> a
forall w m a. Monoid m => (a -> m) -> SimpleWriteEnv w a -> m
forall w b a. (b -> a -> b) -> b -> SimpleWriteEnv w a -> b
forall w a b. (a -> b -> b) -> b -> SimpleWriteEnv w a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: SimpleWriteEnv w a -> a
$cproduct :: forall w a. Num a => SimpleWriteEnv w a -> a
sum :: SimpleWriteEnv w a -> a
$csum :: forall w a. Num a => SimpleWriteEnv w a -> a
minimum :: SimpleWriteEnv w a -> a
$cminimum :: forall w a. Ord a => SimpleWriteEnv w a -> a
maximum :: SimpleWriteEnv w a -> a
$cmaximum :: forall w a. Ord a => SimpleWriteEnv w a -> a
elem :: a -> SimpleWriteEnv w a -> Bool
$celem :: forall w a. Eq a => a -> SimpleWriteEnv w a -> Bool
length :: SimpleWriteEnv w a -> Int
$clength :: forall w a. SimpleWriteEnv w a -> Int
null :: SimpleWriteEnv w a -> Bool
$cnull :: forall w a. SimpleWriteEnv w a -> Bool
toList :: SimpleWriteEnv w a -> [a]
$ctoList :: forall w a. SimpleWriteEnv w a -> [a]
foldl1 :: (a -> a -> a) -> SimpleWriteEnv w a -> a
$cfoldl1 :: forall w a. (a -> a -> a) -> SimpleWriteEnv w a -> a
foldr1 :: (a -> a -> a) -> SimpleWriteEnv w a -> a
$cfoldr1 :: forall w a. (a -> a -> a) -> SimpleWriteEnv w a -> a
foldl' :: (b -> a -> b) -> b -> SimpleWriteEnv w a -> b
$cfoldl' :: forall w b a. (b -> a -> b) -> b -> SimpleWriteEnv w a -> b
foldl :: (b -> a -> b) -> b -> SimpleWriteEnv w a -> b
$cfoldl :: forall w b a. (b -> a -> b) -> b -> SimpleWriteEnv w a -> b
foldr' :: (a -> b -> b) -> b -> SimpleWriteEnv w a -> b
$cfoldr' :: forall w a b. (a -> b -> b) -> b -> SimpleWriteEnv w a -> b
foldr :: (a -> b -> b) -> b -> SimpleWriteEnv w a -> b
$cfoldr :: forall w a b. (a -> b -> b) -> b -> SimpleWriteEnv w a -> b
foldMap' :: (a -> m) -> SimpleWriteEnv w a -> m
$cfoldMap' :: forall w m a. Monoid m => (a -> m) -> SimpleWriteEnv w a -> m
foldMap :: (a -> m) -> SimpleWriteEnv w a -> m
$cfoldMap :: forall w m a. Monoid m => (a -> m) -> SimpleWriteEnv w a -> m
fold :: SimpleWriteEnv w m -> m
$cfold :: forall w m. Monoid m => SimpleWriteEnv w m -> m
Foldable, Functor (SimpleWriteEnv w)
Foldable (SimpleWriteEnv w)
Functor (SimpleWriteEnv w)
-> Foldable (SimpleWriteEnv w)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> SimpleWriteEnv w a -> f (SimpleWriteEnv w b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    SimpleWriteEnv w (f a) -> f (SimpleWriteEnv w a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SimpleWriteEnv w a -> m (SimpleWriteEnv w b))
-> (forall (m :: * -> *) a.
    Monad m =>
    SimpleWriteEnv w (m a) -> m (SimpleWriteEnv w a))
-> Traversable (SimpleWriteEnv w)
(a -> f b) -> SimpleWriteEnv w a -> f (SimpleWriteEnv w b)
forall w. Functor (SimpleWriteEnv w)
forall w. Foldable (SimpleWriteEnv w)
forall w (m :: * -> *) a.
Monad m =>
SimpleWriteEnv w (m a) -> m (SimpleWriteEnv w a)
forall w (f :: * -> *) a.
Applicative f =>
SimpleWriteEnv w (f a) -> f (SimpleWriteEnv w a)
forall w (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SimpleWriteEnv w a -> m (SimpleWriteEnv w b)
forall w (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SimpleWriteEnv w a -> f (SimpleWriteEnv w b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
SimpleWriteEnv w (m a) -> m (SimpleWriteEnv w a)
forall (f :: * -> *) a.
Applicative f =>
SimpleWriteEnv w (f a) -> f (SimpleWriteEnv w a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SimpleWriteEnv w a -> m (SimpleWriteEnv w b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SimpleWriteEnv w a -> f (SimpleWriteEnv w b)
sequence :: SimpleWriteEnv w (m a) -> m (SimpleWriteEnv w a)
$csequence :: forall w (m :: * -> *) a.
Monad m =>
SimpleWriteEnv w (m a) -> m (SimpleWriteEnv w a)
mapM :: (a -> m b) -> SimpleWriteEnv w a -> m (SimpleWriteEnv w b)
$cmapM :: forall w (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SimpleWriteEnv w a -> m (SimpleWriteEnv w b)
sequenceA :: SimpleWriteEnv w (f a) -> f (SimpleWriteEnv w a)
$csequenceA :: forall w (f :: * -> *) a.
Applicative f =>
SimpleWriteEnv w (f a) -> f (SimpleWriteEnv w a)
traverse :: (a -> f b) -> SimpleWriteEnv w a -> f (SimpleWriteEnv w b)
$ctraverse :: forall w (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SimpleWriteEnv w a -> f (SimpleWriteEnv w b)
$cp2Traversable :: forall w. Foldable (SimpleWriteEnv w)
$cp1Traversable :: forall w. Functor (SimpleWriteEnv w)
Traversable, (forall x. SimpleWriteEnv w env -> Rep (SimpleWriteEnv w env) x)
-> (forall x. Rep (SimpleWriteEnv w env) x -> SimpleWriteEnv w env)
-> Generic (SimpleWriteEnv w env)
forall x. Rep (SimpleWriteEnv w env) x -> SimpleWriteEnv w env
forall x. SimpleWriteEnv w env -> Rep (SimpleWriteEnv w env) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall w env x.
Rep (SimpleWriteEnv w env) x -> SimpleWriteEnv w env
forall w env x.
SimpleWriteEnv w env -> Rep (SimpleWriteEnv w env) x
$cto :: forall w env x.
Rep (SimpleWriteEnv w env) x -> SimpleWriteEnv w env
$cfrom :: forall w env x.
SimpleWriteEnv w env -> Rep (SimpleWriteEnv w env) x
Generic)
    deriving anyclass (SimpleWriteEnv w env -> ()
(SimpleWriteEnv w env -> ()) -> NFData (SimpleWriteEnv w env)
forall a. (a -> ()) -> NFData a
forall w env. NFData env => SimpleWriteEnv w env -> ()
rnf :: SimpleWriteEnv w env -> ()
$crnf :: forall w env. NFData env => SimpleWriteEnv w env -> ()
NFData)

instance HasWriteRef w (SimpleWriteEnv w env) where
  writeRefL :: (SomeRef w -> f (SomeRef w))
-> SimpleWriteEnv w env -> f (SimpleWriteEnv w env)
writeRefL = (SimpleWriteEnv w env -> SomeRef w)
-> (SimpleWriteEnv w env -> SomeRef w -> SimpleWriteEnv w env)
-> Lens' (SimpleWriteEnv w env) (SomeRef w)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens SimpleWriteEnv w env -> SomeRef w
forall w env. SimpleWriteEnv w env -> SomeRef w
sweRef (\(SimpleWriteEnv SomeRef w
_ env
env) SomeRef w
w -> SomeRef w -> env -> SimpleWriteEnv w env
forall w env. SomeRef w -> env -> SimpleWriteEnv w env
SimpleWriteEnv SomeRef w
w env
env)

runSimpleWriteRIO :: (MonadIO m, Monoid w) => env -> RIO (SimpleWriteEnv w env) a -> m (a, w)
runSimpleWriteRIO :: env -> RIO (SimpleWriteEnv w env) a -> m (a, w)
runSimpleWriteRIO env
env RIO (SimpleWriteEnv w env) a
m = do
  SomeRef w
ref <- w -> m (SomeRef w)
forall (m :: * -> *) a. MonadIO m => a -> m (SomeRef a)
newSomeRef w
forall a. Monoid a => a
mempty
  a
a <- SimpleWriteEnv w env -> RIO (SimpleWriteEnv w env) a -> m a
forall (m :: * -> *) env a. MonadIO m => env -> RIO env a -> m a
runRIO (SomeRef w -> env -> SimpleWriteEnv w env
forall w env. SomeRef w -> env -> SimpleWriteEnv w env
SimpleWriteEnv SomeRef w
ref env
env) RIO (SimpleWriteEnv w env) a
m
  w
w <- SomeRef w -> m w
forall (m :: * -> *) a. MonadIO m => SomeRef a -> m a
readSomeRef SomeRef w
ref
  (a, w) -> m (a, w)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a
a, w
w)

tellWriteRef :: (HasWriteRef w env, MonadReader env m, MonadIO m, Semigroup w) => w -> m ()
tellWriteRef :: w -> m ()
tellWriteRef w
value = do
  SomeRef w
ref <- Getting (SomeRef w) env (SomeRef w) -> m (SomeRef w)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (SomeRef w) env (SomeRef w)
forall w env. HasWriteRef w env => Lens' env (SomeRef w)
writeRefL
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SomeRef w -> (w -> w) -> IO ()
forall (m :: * -> *) a. MonadIO m => SomeRef a -> (a -> a) -> m ()
modifySomeRef SomeRef w
ref (w -> w -> w
forall a. Semigroup a => a -> a -> a
<> w
value)

listenWriteRef :: (HasWriteRef w env, MonadReader env m, MonadIO m) => m a -> m (a, w)
listenWriteRef :: m a -> m (a, w)
listenWriteRef m a
action = do
  w
w1 <- Getting (SomeRef w) env (SomeRef w) -> m (SomeRef w)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (SomeRef w) env (SomeRef w)
forall w env. HasWriteRef w env => Lens' env (SomeRef w)
writeRefL m (SomeRef w) -> (SomeRef w -> m w) -> m w
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= IO w -> m w
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO w -> m w) -> (SomeRef w -> IO w) -> SomeRef w -> m w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SomeRef w -> IO w
forall (m :: * -> *) a. MonadIO m => SomeRef a -> m a
readSomeRef
  a
a <- m a
action
  w
w2 <- do
    SomeRef w
refEnv <- Getting (SomeRef w) env (SomeRef w) -> m (SomeRef w)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (SomeRef w) env (SomeRef w)
forall w env. HasWriteRef w env => Lens' env (SomeRef w)
writeRefL
    w
v <- IO w -> m w
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO w -> m w) -> IO w -> m w
forall a b. (a -> b) -> a -> b
$ SomeRef w -> IO w
forall (m :: * -> *) a. MonadIO m => SomeRef a -> m a
readSomeRef SomeRef w
refEnv
    ()
_ <- IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SomeRef w -> w -> IO ()
forall (m :: * -> *) a. MonadIO m => SomeRef a -> a -> m ()
writeSomeRef SomeRef w
refEnv w
w1
    w -> m w
forall (m :: * -> *) a. Monad m => a -> m a
return w
v
  (a, w) -> m (a, w)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, w
w2)

passWriteRef :: (HasWriteRef w env, MonadReader env m, MonadIO m) => m (a, w -> w) -> m a
passWriteRef :: m (a, w -> w) -> m a
passWriteRef m (a, w -> w)
action = do
  (a
a, w -> w
transF) <- m (a, w -> w)
action
  SomeRef w
ref <- Getting (SomeRef w) env (SomeRef w) -> m (SomeRef w)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (SomeRef w) env (SomeRef w)
forall w env. HasWriteRef w env => Lens' env (SomeRef w)
writeRefL
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SomeRef w -> (w -> w) -> IO ()
forall (m :: * -> *) a. MonadIO m => SomeRef a -> (a -> a) -> m ()
modifySomeRef SomeRef w
ref w -> w
transF
  a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
a

instance (Monoid w, HasWriteRef w env) => MonadWriter w (RIO env) where
  tell :: w -> RIO env ()
tell = w -> RIO env ()
forall w env (m :: * -> *).
(HasWriteRef w env, MonadReader env m, MonadIO m, Semigroup w) =>
w -> m ()
tellWriteRef
  listen :: RIO env a -> RIO env (a, w)
listen = RIO env a -> RIO env (a, w)
forall w env (m :: * -> *) a.
(HasWriteRef w env, MonadReader env m, MonadIO m) =>
m a -> m (a, w)
listenWriteRef
  pass :: RIO env (a, w -> w) -> RIO env a
pass = RIO env (a, w -> w) -> RIO env a
forall w env (m :: * -> *) a.
(HasWriteRef w env, MonadReader env m, MonadIO m) =>
m (a, w -> w) -> m a
passWriteRef

type ResourceMap = IORef ReleaseMap

withResourceMap :: MonadUnliftIO m => (ResourceMap -> m a) -> m a
withResourceMap :: (ResourceMap -> m a) -> m a
withResourceMap ResourceMap -> m a
inner =
  ((forall a. m a -> IO a) -> IO a) -> m a
forall (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. m a -> IO a) -> IO b) -> m b
withRunInIO (\forall a. m a -> IO a
run -> ResourceT IO a -> IO a
forall (m :: * -> *) a. MonadUnliftIO m => ResourceT m a -> m a
runResourceT ((ResourceMap -> IO a) -> ResourceT IO a
forall (m :: * -> *) a. (ResourceMap -> m a) -> ResourceT m a
ResourceT (m a -> IO a
forall a. m a -> IO a
run (m a -> IO a) -> (ResourceMap -> m a) -> ResourceMap -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResourceMap -> m a
inner)))

class HasResourceMap env where
  resourceMapL :: Lens' env ResourceMap

instance HasResourceMap (IORef ReleaseMap) where
  resourceMapL :: (ResourceMap -> f ResourceMap) -> ResourceMap -> f ResourceMap
resourceMapL = (ResourceMap -> f ResourceMap) -> ResourceMap -> f ResourceMap
forall a. a -> a
id

data SimpleResourceEnv env = SimpleResourceEnv
  { SimpleResourceEnv env -> ResourceMap
sreMap :: !ResourceMap
  , SimpleResourceEnv env -> env
sreEnv :: !env
  } deriving stock (a -> SimpleResourceEnv b -> SimpleResourceEnv a
(a -> b) -> SimpleResourceEnv a -> SimpleResourceEnv b
(forall a b.
 (a -> b) -> SimpleResourceEnv a -> SimpleResourceEnv b)
-> (forall a b. a -> SimpleResourceEnv b -> SimpleResourceEnv a)
-> Functor SimpleResourceEnv
forall a b. a -> SimpleResourceEnv b -> SimpleResourceEnv a
forall a b. (a -> b) -> SimpleResourceEnv a -> SimpleResourceEnv b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> SimpleResourceEnv b -> SimpleResourceEnv a
$c<$ :: forall a b. a -> SimpleResourceEnv b -> SimpleResourceEnv a
fmap :: (a -> b) -> SimpleResourceEnv a -> SimpleResourceEnv b
$cfmap :: forall a b. (a -> b) -> SimpleResourceEnv a -> SimpleResourceEnv b
Functor, SimpleResourceEnv a -> Bool
(a -> m) -> SimpleResourceEnv a -> m
(a -> b -> b) -> b -> SimpleResourceEnv a -> b
(forall m. Monoid m => SimpleResourceEnv m -> m)
-> (forall m a. Monoid m => (a -> m) -> SimpleResourceEnv a -> m)
-> (forall m a. Monoid m => (a -> m) -> SimpleResourceEnv a -> m)
-> (forall a b. (a -> b -> b) -> b -> SimpleResourceEnv a -> b)
-> (forall a b. (a -> b -> b) -> b -> SimpleResourceEnv a -> b)
-> (forall b a. (b -> a -> b) -> b -> SimpleResourceEnv a -> b)
-> (forall b a. (b -> a -> b) -> b -> SimpleResourceEnv a -> b)
-> (forall a. (a -> a -> a) -> SimpleResourceEnv a -> a)
-> (forall a. (a -> a -> a) -> SimpleResourceEnv a -> a)
-> (forall a. SimpleResourceEnv a -> [a])
-> (forall a. SimpleResourceEnv a -> Bool)
-> (forall a. SimpleResourceEnv a -> Int)
-> (forall a. Eq a => a -> SimpleResourceEnv a -> Bool)
-> (forall a. Ord a => SimpleResourceEnv a -> a)
-> (forall a. Ord a => SimpleResourceEnv a -> a)
-> (forall a. Num a => SimpleResourceEnv a -> a)
-> (forall a. Num a => SimpleResourceEnv a -> a)
-> Foldable SimpleResourceEnv
forall a. Eq a => a -> SimpleResourceEnv a -> Bool
forall a. Num a => SimpleResourceEnv a -> a
forall a. Ord a => SimpleResourceEnv a -> a
forall m. Monoid m => SimpleResourceEnv m -> m
forall a. SimpleResourceEnv a -> Bool
forall a. SimpleResourceEnv a -> Int
forall a. SimpleResourceEnv a -> [a]
forall a. (a -> a -> a) -> SimpleResourceEnv a -> a
forall m a. Monoid m => (a -> m) -> SimpleResourceEnv a -> m
forall b a. (b -> a -> b) -> b -> SimpleResourceEnv a -> b
forall a b. (a -> b -> b) -> b -> SimpleResourceEnv a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: SimpleResourceEnv a -> a
$cproduct :: forall a. Num a => SimpleResourceEnv a -> a
sum :: SimpleResourceEnv a -> a
$csum :: forall a. Num a => SimpleResourceEnv a -> a
minimum :: SimpleResourceEnv a -> a
$cminimum :: forall a. Ord a => SimpleResourceEnv a -> a
maximum :: SimpleResourceEnv a -> a
$cmaximum :: forall a. Ord a => SimpleResourceEnv a -> a
elem :: a -> SimpleResourceEnv a -> Bool
$celem :: forall a. Eq a => a -> SimpleResourceEnv a -> Bool
length :: SimpleResourceEnv a -> Int
$clength :: forall a. SimpleResourceEnv a -> Int
null :: SimpleResourceEnv a -> Bool
$cnull :: forall a. SimpleResourceEnv a -> Bool
toList :: SimpleResourceEnv a -> [a]
$ctoList :: forall a. SimpleResourceEnv a -> [a]
foldl1 :: (a -> a -> a) -> SimpleResourceEnv a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> SimpleResourceEnv a -> a
foldr1 :: (a -> a -> a) -> SimpleResourceEnv a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> SimpleResourceEnv a -> a
foldl' :: (b -> a -> b) -> b -> SimpleResourceEnv a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> SimpleResourceEnv a -> b
foldl :: (b -> a -> b) -> b -> SimpleResourceEnv a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> SimpleResourceEnv a -> b
foldr' :: (a -> b -> b) -> b -> SimpleResourceEnv a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> SimpleResourceEnv a -> b
foldr :: (a -> b -> b) -> b -> SimpleResourceEnv a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> SimpleResourceEnv a -> b
foldMap' :: (a -> m) -> SimpleResourceEnv a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> SimpleResourceEnv a -> m
foldMap :: (a -> m) -> SimpleResourceEnv a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> SimpleResourceEnv a -> m
fold :: SimpleResourceEnv m -> m
$cfold :: forall m. Monoid m => SimpleResourceEnv m -> m
Foldable, Functor SimpleResourceEnv
Foldable SimpleResourceEnv
Functor SimpleResourceEnv
-> Foldable SimpleResourceEnv
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> SimpleResourceEnv a -> f (SimpleResourceEnv b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    SimpleResourceEnv (f a) -> f (SimpleResourceEnv a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SimpleResourceEnv a -> m (SimpleResourceEnv b))
-> (forall (m :: * -> *) a.
    Monad m =>
    SimpleResourceEnv (m a) -> m (SimpleResourceEnv a))
-> Traversable SimpleResourceEnv
(a -> f b) -> SimpleResourceEnv a -> f (SimpleResourceEnv b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
SimpleResourceEnv (m a) -> m (SimpleResourceEnv a)
forall (f :: * -> *) a.
Applicative f =>
SimpleResourceEnv (f a) -> f (SimpleResourceEnv a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SimpleResourceEnv a -> m (SimpleResourceEnv b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SimpleResourceEnv a -> f (SimpleResourceEnv b)
sequence :: SimpleResourceEnv (m a) -> m (SimpleResourceEnv a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
SimpleResourceEnv (m a) -> m (SimpleResourceEnv a)
mapM :: (a -> m b) -> SimpleResourceEnv a -> m (SimpleResourceEnv b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SimpleResourceEnv a -> m (SimpleResourceEnv b)
sequenceA :: SimpleResourceEnv (f a) -> f (SimpleResourceEnv a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
SimpleResourceEnv (f a) -> f (SimpleResourceEnv a)
traverse :: (a -> f b) -> SimpleResourceEnv a -> f (SimpleResourceEnv b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SimpleResourceEnv a -> f (SimpleResourceEnv b)
$cp2Traversable :: Foldable SimpleResourceEnv
$cp1Traversable :: Functor SimpleResourceEnv
Traversable, (forall x. SimpleResourceEnv env -> Rep (SimpleResourceEnv env) x)
-> (forall x.
    Rep (SimpleResourceEnv env) x -> SimpleResourceEnv env)
-> Generic (SimpleResourceEnv env)
forall x. Rep (SimpleResourceEnv env) x -> SimpleResourceEnv env
forall x. SimpleResourceEnv env -> Rep (SimpleResourceEnv env) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall env x.
Rep (SimpleResourceEnv env) x -> SimpleResourceEnv env
forall env x.
SimpleResourceEnv env -> Rep (SimpleResourceEnv env) x
$cto :: forall env x.
Rep (SimpleResourceEnv env) x -> SimpleResourceEnv env
$cfrom :: forall env x.
SimpleResourceEnv env -> Rep (SimpleResourceEnv env) x
Generic)
    deriving anyclass (SimpleResourceEnv env -> ()
(SimpleResourceEnv env -> ()) -> NFData (SimpleResourceEnv env)
forall env. NFData env => SimpleResourceEnv env -> ()
forall a. (a -> ()) -> NFData a
rnf :: SimpleResourceEnv env -> ()
$crnf :: forall env. NFData env => SimpleResourceEnv env -> ()
NFData)

instance HasResourceMap (SimpleResourceEnv env) where
  resourceMapL :: (ResourceMap -> f ResourceMap)
-> SimpleResourceEnv env -> f (SimpleResourceEnv env)
resourceMapL = (SimpleResourceEnv env -> ResourceMap)
-> (SimpleResourceEnv env -> ResourceMap -> SimpleResourceEnv env)
-> Lens' (SimpleResourceEnv env) ResourceMap
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens SimpleResourceEnv env -> ResourceMap
forall env. SimpleResourceEnv env -> ResourceMap
sreMap (\(SimpleResourceEnv ResourceMap
_ env
env) ResourceMap
m -> ResourceMap -> env -> SimpleResourceEnv env
forall env. ResourceMap -> env -> SimpleResourceEnv env
SimpleResourceEnv ResourceMap
m env
env)

runSimpleResourceRIO :: MonadUnliftIO m => env -> RIO (SimpleResourceEnv env) a -> m a
runSimpleResourceRIO :: env -> RIO (SimpleResourceEnv env) a -> m a
runSimpleResourceRIO env
env RIO (SimpleResourceEnv env) a
m = (ResourceMap -> m a) -> m a
forall (m :: * -> *) a.
MonadUnliftIO m =>
(ResourceMap -> m a) -> m a
withResourceMap (\ResourceMap
rm -> SimpleResourceEnv env -> RIO (SimpleResourceEnv env) a -> m a
forall (m :: * -> *) env a. MonadIO m => env -> RIO env a -> m a
runRIO (ResourceMap -> env -> SimpleResourceEnv env
forall env. ResourceMap -> env -> SimpleResourceEnv env
SimpleResourceEnv ResourceMap
rm env
env) RIO (SimpleResourceEnv env) a
m)

resourceRIO :: HasResourceMap env => ResourceT IO a -> RIO env a
resourceRIO :: ResourceT IO a -> RIO env a
resourceRIO (ResourceT ResourceMap -> IO a
f) = Getting ResourceMap env ResourceMap -> RIO env ResourceMap
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting ResourceMap env ResourceMap
forall env. HasResourceMap env => Lens' env ResourceMap
resourceMapL RIO env ResourceMap -> (ResourceMap -> RIO env a) -> RIO env a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= IO a -> RIO env a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> RIO env a)
-> (ResourceMap -> IO a) -> ResourceMap -> RIO env a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResourceMap -> IO a
f

instance HasResourceMap env => MonadResource (RIO env) where
  liftResourceT :: ResourceT IO a -> RIO env a
liftResourceT = ResourceT IO a -> RIO env a
forall env a. HasResourceMap env => ResourceT IO a -> RIO env a
resourceRIO