Data.Registry.RIO

RIO is equivalent to ResourceT (WriterT Warmup IO) It can be used to instantiate "components as records of functions" where each component can allocate resources and have a "warmup phase" to preload data or assess if it is working properly.

Documentation

newtype Stop

Data type encapsulating resource finalizers

Constructors

Stop InternalState

runStop :: Stop -> IO ()

Run all finalizers

newtype RIO a

This newtype creates a monad to sequence component creation actions, cumulating start/stop tasks found along the way

Constructors

RIO

Fields

• runRIO :: Stop -> IO (a, Warmup)

Instances

Monad RIO

Defined in Data.Registry.RIO

Methods

(>>=) :: RIO a -> (a -> RIO b) -> RIO b

(>>) :: RIO a -> RIO b -> RIO b

return :: a -> RIO a

fail :: String -> RIO a

Functor RIO

Defined in Data.Registry.RIO

Methods

fmap :: (a -> b) -> RIO a -> RIO b

(<$) :: a -> RIO b -> RIO a

Applicative RIO

Defined in Data.Registry.RIO

Methods

pure :: a -> RIO a

(<*>) :: RIO (a -> b) -> RIO a -> RIO b

liftA2 :: (a -> b -> c) -> RIO a -> RIO b -> RIO c

(*>) :: RIO a -> RIO b -> RIO b

(<*) :: RIO a -> RIO b -> RIO a

MonadIO RIO

Defined in Data.Registry.RIO

Methods

liftIO :: IO a -> RIO a

Alternative RIO

Defined in Data.Registry.RIO

Methods

empty :: RIO a

(<|>) :: RIO a -> RIO a -> RIO a

some :: RIO a -> RIO [a]

many :: RIO a -> RIO [a]

MonadThrow RIO

Defined in Data.Registry.RIO

Methods

throwM :: Exception e => e -> RIO a

MonadResource RIO

Defined in Data.Registry.RIO

Methods

liftResourceT :: ResourceT IO a -> RIO a

Alt RIO

Defined in Data.Registry.RIO

Methods

(<!>) :: RIO a -> RIO a -> RIO a

some :: Applicative RIO => RIO a -> RIO [a]

many :: Applicative RIO => RIO a -> RIO [a]

MonadBase IO RIO

Defined in Data.Registry.RIO

Methods

liftBase :: IO α -> RIO α

For production

withRIO :: MonadIO m => RIO a -> (a -> IO ()) -> m Result

Use a RIO value and make sure that resources are closed Only run the action if the warmup is successful

withRegistry :: forall a b ins out m. (Typeable a, Contains (RIO a) out, Solvable ins out, MonadIO m, MemoizedActions out) => Registry ins out -> (Result -> a -> IO b) -> m b

This function must be used to run services involving a top component It creates the top component and invokes all warmup functions

The passed function f is used to decide whether to continue or not depending on the Result

We also make sure that all effects are memoized by calling memoizeAll on the Registry here!

runRegistryT :: forall a ins out m. (Typeable a, Contains (RIO a) out, Solvable ins out, MonadIO m, MemoizedActions out) => Registry ins out -> ResourceT m (a, Warmup)

This can be used if you want to insert the component creation inside another action managed with ResourceT. Or if you want to call runResourceT yourself later

For testing

unsafeRunRIO :: (Typeable a, MonadIO m) => RIO a -> m a

This runs a RIO value without closing down resources or executing startup actions

withNoWarmupRIO :: MonadIO m => RIO a -> (a -> IO b) -> m b

Use a RIO value and make sure that resources are closed Don't run the warmup

withRIOIgnoreWarmupResult :: MonadIO m => RIO a -> (a -> IO b) -> m b

Use a RIO value and make sure that resources are closed Run the warmup but ignore the result

withRIOAndWarmupResult :: MonadIO m => (Result -> IO ()) -> RIO a -> (a -> IO b) -> m b

Use a RIO value and make sure that resources are closed Run a unit function with the warmup result (print or throw exception)

executeRegistry :: forall a ins out m. (Typeable a, Contains (RIO a) out, Solvable ins out, MonadIO m) => Registry ins out -> m (a, Warmup, Stop)

Instantiate the component but don't execute the warmup (it may take time) and keep the Stop value to clean resources later This function statically checks that the component can be instantiated

unsafeRun :: forall a ins out m. (Typeable a, Contains (RIO a) out, MonadIO m) => Registry ins out -> m a

Instantiate the component but don't execute the warmup (it may take time) and lose a way to cleanu up resources | Almost no compilation time is spent on checking that component resolution is possible

unsafeRunDynamic :: forall a ins out m. (Typeable a, MonadIO m) => Registry ins out -> m a

Instantiate the component but don't execute the warmup (it may take time) and lose a way to cleanu up resources Don't even check that a component can be built out of the registry

unsafeRunWithStop :: forall a ins out m. (Typeable a, Contains (RIO a) out, MonadIO m) => Registry ins out -> m (a, Stop)

Same as unsafeRun but keep the Stop value to be able to clean resources later

unsafeRunDynamicWithStop :: forall a ins out m. (Typeable a, MonadIO m) => Registry ins out -> m (a, Stop)

warmupWith :: Warmup -> RIO ()

Lift a Warmup action into the RIO monad

allocate :: IO a -> (a -> IO ()) -> RIO a

Allocate some resource