boots-0.0.3: Boot application by plugins

Copyright2019 Daniel YU
LicenseBSD3
Maintainerleptonyu@gmail.com
Stabilityexperimental
Portabilityportable
Safe HaskellNone
LanguageHaskell2010

Boots

Contents

Description

Boot application by using plugins.

  • Motivation

Simplify to create an application in Haskell.

When we decide to create an application using Haskell. We may need using configurations, loggers as basic functions. If this application needs storages, caches, etc., then we have to weaving the management of connection of these facilities into the application. Connections need to be created before and be destroyed after using them. There is a common strategy to manage connections, that is using Cont. Then we can encapsulate the management of connections separately. For example, we can write a database plugin Plugin cxt m DBConnection, which can manage the database connections in monad m with context cxt. Context cxt may be requested for getting configurations or logging functions. When all the components of application are encapsulated by plugins, then building an application will be simplified.

  • Have a Try
>>> booting (pluginSimple "application") (logInfo "hello")
2019-07-27 19:35:30  INFO [application] Ghci1 - hello
>>> booting (pluginSimple "application") (require "user" >>= logInfo)
2019-07-27 19:37:45  INFO [application] Ghci2 - daniel

Main

main :: IO ()
main = bootApp (pluginSimple "application") go
  where
    go = forever $ do
      user <- require "user"              -- Request for configuration.
      logInfo $ "Hello, " <> user <> "!"  -- Request for logging.
      liftIO $ threadDelay 1000000
Synopsis

Plugin

boot :: Monad m => Plugin () m (m ()) -> m () Source #

Run application only in plugin.

data Plugin i m u Source #

Plugin generates component u with the context of component i running in monad m.

Instances
MonadReader i (Plugin i m) Source # 
Instance details

Defined in Boots.Internal.Plugin

Methods

ask :: Plugin i m i #

local :: (i -> i) -> Plugin i m a -> Plugin i m a #

reader :: (i -> a) -> Plugin i m a #

MonadTrans (Plugin i) Source # 
Instance details

Defined in Boots.Internal.Plugin

Methods

lift :: Monad m => m a -> Plugin i m a #

Monad (Plugin i m) Source # 
Instance details

Defined in Boots.Internal.Plugin

Methods

(>>=) :: Plugin i m a -> (a -> Plugin i m b) -> Plugin i m b #

(>>) :: Plugin i m a -> Plugin i m b -> Plugin i m b #

return :: a -> Plugin i m a #

fail :: String -> Plugin i m a #

Functor (Plugin i m) Source # 
Instance details

Defined in Boots.Internal.Plugin

Methods

fmap :: (a -> b) -> Plugin i m a -> Plugin i m b #

(<$) :: a -> Plugin i m b -> Plugin i m a #

Applicative (Plugin i m) Source # 
Instance details

Defined in Boots.Internal.Plugin

Methods

pure :: a -> Plugin i m a #

(<*>) :: Plugin i m (a -> b) -> Plugin i m a -> Plugin i m b #

liftA2 :: (a -> b -> c) -> Plugin i m a -> Plugin i m b -> Plugin i m c #

(*>) :: Plugin i m a -> Plugin i m b -> Plugin i m b #

(<*) :: Plugin i m a -> Plugin i m b -> Plugin i m a #

MonadIO m => MonadIO (Plugin i m) Source # 
Instance details

Defined in Boots.Internal.Plugin

Methods

liftIO :: IO a -> Plugin i m a #

MonadThrow m => MonadThrow (Plugin i m) Source # 
Instance details

Defined in Boots.Internal.Plugin

Methods

throwM :: Exception e => e -> Plugin i m a #

(MonadIO m, HasLogger cxt) => MonadLogger (Plugin cxt m) Source # 
Instance details

Defined in Boots.Plugin.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> Plugin cxt m () #

(MonadIO m, HasLogger cxt) => MonadLoggerIO (Plugin cxt m) Source # 
Instance details

Defined in Boots.Plugin.Logger

Methods

askLoggerIO :: Plugin cxt m (Loc -> LogSource -> LogLevel -> LogStr -> IO ()) #

Monad m => MonadCont (Plugin i m) Source # 
Instance details

Defined in Boots.Internal.Plugin

Methods

callCC :: ((a -> Plugin i m b) -> Plugin i m a) -> Plugin i m a #

HasSalak cxt => MonadSalak (Plugin cxt m) Source # 
Instance details

Defined in Boots.Plugin.Salak

Methods

askSalak :: Plugin cxt m SourcePack #

askReload :: Plugin cxt m (IO ReloadResult) #

require :: (MonadThrow (Plugin cxt m), FromProp (Plugin cxt m) a) => Text -> Plugin cxt m a #

runPlugin :: i -> Plugin i m u -> (u -> m ()) -> m () Source #

Run plugin in given context i.

promote :: i -> Plugin i m u -> Plugin x m u Source #

Promote a plugin into another.

combine :: [Plugin i m i] -> Plugin i m i Source #

Combines plugins into one.

withPlugin :: (i -> j) -> Plugin j m u -> Plugin i m u Source #

Convert a plugin into another.

mapPlugin :: (m () -> m ()) -> Plugin i m u -> Plugin i m u Source #

Apply a function to transform the result of a continuation-passing computation.

isoPlugin :: (m () -> n ()) -> (n () -> m ()) -> Plugin i n u -> Plugin i m u Source #

Transform a plugin with monad n to a plugin with monad m.

bracketP Source #

Arguments

:: MonadCatch m 
=> m u

Open resource.

-> (u -> m ())

Close resource.

-> Plugin i m u

Resource plugin.

Create bracket style plugin, used for manage resources, which need to open and close.

A simple example:

>>> res = bracketP (putStrLn "open") (const $ putStrLn "close")
>>> runPlugin () res (const $ putStrLn "using")
open
using
close

wrapP :: ((u -> m ()) -> m ()) -> Plugin i m u Source #

Warp plugin.

Application

bootApp :: Plugin () m cxt -> AppT cxt m () -> m () Source #

Run application in context with the help of plugin. Context cxt can't escape from m. If you want to define your own AppT then please use boot or runPlugin.

data AppT cxt m a Source #

Application monad transformation.

Instances
Monad m => MonadReader cxt (AppT cxt m) Source # 
Instance details

Defined in Boots.Internal.App

Methods

ask :: AppT cxt m cxt #

local :: (cxt -> cxt) -> AppT cxt m a -> AppT cxt m a #

reader :: (cxt -> a) -> AppT cxt m a #

MonadTrans (AppT cxt) Source # 
Instance details

Defined in Boots.Internal.App

Methods

lift :: Monad m => m a -> AppT cxt m a #

Monad m => Monad (AppT cxt m) Source # 
Instance details

Defined in Boots.Internal.App

Methods

(>>=) :: AppT cxt m a -> (a -> AppT cxt m b) -> AppT cxt m b #

(>>) :: AppT cxt m a -> AppT cxt m b -> AppT cxt m b #

return :: a -> AppT cxt m a #

fail :: String -> AppT cxt m a #

Functor m => Functor (AppT cxt m) Source # 
Instance details

Defined in Boots.Internal.App

Methods

fmap :: (a -> b) -> AppT cxt m a -> AppT cxt m b #

(<$) :: a -> AppT cxt m b -> AppT cxt m a #

Applicative m => Applicative (AppT cxt m) Source # 
Instance details

Defined in Boots.Internal.App

Methods

pure :: a -> AppT cxt m a #

(<*>) :: AppT cxt m (a -> b) -> AppT cxt m a -> AppT cxt m b #

liftA2 :: (a -> b -> c) -> AppT cxt m a -> AppT cxt m b -> AppT cxt m c #

(*>) :: AppT cxt m a -> AppT cxt m b -> AppT cxt m b #

(<*) :: AppT cxt m a -> AppT cxt m b -> AppT cxt m a #

MonadIO m => MonadIO (AppT cxt m) Source # 
Instance details

Defined in Boots.Internal.App

Methods

liftIO :: IO a -> AppT cxt m a #

MonadUnliftIO m => MonadUnliftIO (AppT cxt m) Source # 
Instance details

Defined in Boots.Internal.App

Methods

askUnliftIO :: AppT cxt m (UnliftIO (AppT cxt m)) #

withRunInIO :: ((forall a. AppT cxt m a -> IO a) -> IO b) -> AppT cxt m b #

MonadThrow m => MonadThrow (AppT cxt m) Source # 
Instance details

Defined in Boots.Internal.App

Methods

throwM :: Exception e => e -> AppT cxt m a #

MonadCatch m => MonadCatch (AppT cxt m) Source # 
Instance details

Defined in Boots.Internal.App

Methods

catch :: Exception e => AppT cxt m a -> (e -> AppT cxt m a) -> AppT cxt m a #

MonadMask m => MonadMask (AppT cxt m) Source # 
Instance details

Defined in Boots.Internal.App

Methods

mask :: ((forall a. AppT cxt m a -> AppT cxt m a) -> AppT cxt m b) -> AppT cxt m b #

uninterruptibleMask :: ((forall a. AppT cxt m a -> AppT cxt m a) -> AppT cxt m b) -> AppT cxt m b #

generalBracket :: AppT cxt m a -> (a -> ExitCase b -> AppT cxt m c) -> (a -> AppT cxt m b) -> AppT cxt m (b, c) #

(MonadIO m, HasLogger cxt) => MonadLogger (AppT cxt m) Source # 
Instance details

Defined in Boots.Plugin.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> AppT cxt m () #

(MonadIO m, HasLogger cxt) => MonadLoggerIO (AppT cxt m) Source # 
Instance details

Defined in Boots.Plugin.Logger

Methods

askLoggerIO :: AppT cxt m (Loc -> LogSource -> LogLevel -> LogStr -> IO ()) #

(Monad m, HasSalak cxt) => MonadSalak (AppT cxt m) Source # 
Instance details

Defined in Boots.Plugin.Salak

Methods

askSalak :: AppT cxt m SourcePack #

askReload :: AppT cxt m (IO ReloadResult) #

require :: (MonadThrow (AppT cxt m), FromProp (AppT cxt m) a) => Text -> AppT cxt m a #

type App cxt = AppT cxt IO Source #

Simple IO monad.

runAppT :: cxt -> AppT cxt m a -> m a Source #

Run application monad transformation.

liftIO :: MonadIO m => IO a -> m a #

Lift a computation from the IO monad.

ask :: MonadReader r m => m r #

Retrieves the monad environment.

lift :: (MonadTrans t, Monad m) => m a -> t m a #

Lift a computation from the argument monad to the constructed monad.

throwM :: (MonadThrow m, Exception e) => e -> m a #

Throw an exception. Note that this throws when this action is run in the monad m, not when it is applied. It is a generalization of Control.Exception's throwIO.

Should satisfy the law:

throwM e >> f = throwM e