Colog.Monad

Core of the mtl implementation.

Documentation

newtype LoggerT msg m a

newtype wrapper ReaderT that keeps LogAction in its context.

Constructors

LoggerT

Fields

• runLoggerT :: ReaderT (LogAction (LoggerT msg m) msg) m a

Instances

MonadTrans (LoggerT msg)

Defined in Colog.Monad

Methods

lift :: Monad m => m a -> LoggerT msg m a

MonadFail m => MonadFail (LoggerT msg m)

Defined in Colog.Monad

Methods

fail :: String -> LoggerT msg m a

MonadIO m => MonadIO (LoggerT msg m)

Defined in Colog.Monad

Methods

liftIO :: IO a -> LoggerT msg m a

Applicative m => Applicative (LoggerT msg m)

Defined in Colog.Monad

Methods

pure :: a -> LoggerT msg m a

(<*>) :: LoggerT msg m (a -> b) -> LoggerT msg m a -> LoggerT msg m b

liftA2 :: (a -> b -> c) -> LoggerT msg m a -> LoggerT msg m b -> LoggerT msg m c

(*>) :: LoggerT msg m a -> LoggerT msg m b -> LoggerT msg m b

(<*) :: LoggerT msg m a -> LoggerT msg m b -> LoggerT msg m a

Functor m => Functor (LoggerT msg m)

Defined in Colog.Monad

Methods

fmap :: (a -> b) -> LoggerT msg m a -> LoggerT msg m b

(<$) :: a -> LoggerT msg m b -> LoggerT msg m a

Monad m => Monad (LoggerT msg m)

Defined in Colog.Monad

Methods

(>>=) :: LoggerT msg m a -> (a -> LoggerT msg m b) -> LoggerT msg m b

(>>) :: LoggerT msg m a -> LoggerT msg m b -> LoggerT msg m b

return :: a -> LoggerT msg m a

MonadUnliftIO m => MonadUnliftIO (LoggerT msg m)

Defined in Colog.Monad

Methods

withRunInIO :: ((forall a. LoggerT msg m a -> IO a) -> IO b) -> LoggerT msg m b

Monad m => MonadReader (LogAction (LoggerT msg m) msg) (LoggerT msg m)

Defined in Colog.Monad

Methods

ask :: LoggerT msg m (LogAction (LoggerT msg m) msg)

local :: (LogAction (LoggerT msg m) msg -> LogAction (LoggerT msg m) msg) -> LoggerT msg m a -> LoggerT msg m a

reader :: (LogAction (LoggerT msg m) msg -> a) -> LoggerT msg m a

class HasLog env msg (m :: Type -> Type) where

This types class contains simple pair of getter-setter and related functions. It also provides the useful lens logActionL with the default implementation using type class methods. The default one could be easily overritten under your instances.

Every instance of the this typeclass should satisfy the following laws:

1. Set-Get: getLogAction (setLogAction l env) ≡ l
2. Get-Set: setLogAction (getLogAction env) env ≡ env
3. Set-Set: setLogAction l2 (setLogAction l1 env) ≡ setLogAction l2 env
4. Set-Over: overLogAction f env ≡ setLogAction (f $ getLogAction env) env

Minimal complete definition

logActionL | getLogAction, (setLogAction | overLogAction)

Methods

getLogAction :: env -> LogAction m msg

Extracts LogAction from the environment.

setLogAction :: LogAction m msg -> env -> env

Sets LogAction to the given one inside the environment.

overLogAction :: (LogAction m msg -> LogAction m msg) -> env -> env

Applies function to the LogAction inside the environment.

logActionL :: Lens' env (LogAction m msg)

Lens for LogAction inside the environment.

Instances

HasLog (LogAction m msg) msg m

Defined in Colog.Core.Class

Methods

getLogAction :: LogAction m msg -> LogAction m msg

setLogAction :: LogAction m msg -> LogAction m msg -> LogAction m msg

overLogAction :: (LogAction m msg -> LogAction m msg) -> LogAction m msg -> LogAction m msg

logActionL :: Lens' (LogAction m msg) (LogAction m msg)

type WithLog env msg m = (MonadReader env m, HasLog env msg m, HasCallStack)

Type alias for constraint for:

1. Monad m have access to environment env.
2. Environment env contains LogAction that can log messages of type msg.
3. Function call stack.

If you use this constraint, function call stack will be propagated and you will have access to code lines that log messages.

logMsg :: forall msg env m. WithLog env msg m => msg -> m ()

Perform logging action with given message msg. This function works for monads that have access to LogAction.

You can use this function like this:

example :: WithLog env String m => m ()
example = do
    logMsg "First message..."
    logMsg "Second message..."

logMsgs :: forall msg env f m. (Foldable f, WithLog env msg m) => f msg -> m ()

Logs multiple messages.

withLog :: WithLog env msg m => (LogAction m msg -> LogAction m msg) -> m a -> m a

Performs given monadic logging action by applying function to every logging record.

app :: WithLog env String m => m ()
app = withLog (cmap ("app:" ++)) $ do
    logMsg "First message..."
    logMsg "Second message..."

liftLogAction :: (Monad m, MonadTrans t) => LogAction m msg -> LogAction (t m) msg

Lifts LogAction by allowing to log in a transformed monad.

usingLoggerT :: Monad m => LogAction m msg -> LoggerT msg m a -> m a

Runner for LoggerT monad. Let's consider one simple example of monadic action you have:

app :: WithLog env String m => m ()
app = do
    logMsg "Starting application..."
    withLog (cmap ("app:" ++)) $ do
        logMsg "Application started."
        logMsg "Application finished."

You can use the following way of running such example:

usingLoggerT (LogAction putStrLn) app

And you will see this output:

Starting application...
app:Application started.
app:Application finished.