{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE UndecidableInstances #-}
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