Control.Eff.Log

Documentation

data Log l v

Simple log effect, useful in pure code

Instances

(MonadBase m m, Lifted m r, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (Log l ': r))

Defined in Control.Eff.Log

Associated Types

type StM (Eff (Log l ': r)) a :: Type

Methods

liftBaseWith :: (RunInBase (Eff (Log l ': r)) m -> m a) -> Eff (Log l ': r) a

restoreM :: StM (Eff (Log l ': r)) a -> Eff (Log l ': r) a

Monad m => Handle (Log l) r a ((l -> m c) -> m a)

Defined in Control.Eff.Log

Methods

handle :: (Eff r a -> (l -> m c) -> m a) -> Arrs r v a -> Log l v -> (l -> m c) -> m a

handle_relay :: (r ~ (Log l ': r'), Relay ((l -> m c) -> m a) r') => (a -> (l -> m c) -> m a) -> (Eff r a -> (l -> m c) -> m a) -> Eff r a -> (l -> m c) -> m a

respond_relay :: (a -> (l -> m c) -> m a) -> (Eff r a -> (l -> m c) -> m a) -> Eff r a -> (l -> m c) -> m a

Monad m => Handle (Log l) r a (b -> (l -> b -> b) -> m (a, b))

Defined in Control.Eff.Log

Methods

handle :: (Eff r a -> b -> (l -> b -> b) -> m (a, b)) -> Arrs r v a -> Log l v -> b -> (l -> b -> b) -> m (a, b)

handle_relay :: (r ~ (Log l ': r'), Relay (b -> (l -> b -> b) -> m (a, b)) r') => (a -> b -> (l -> b -> b) -> m (a, b)) -> (Eff r a -> b -> (l -> b -> b) -> m (a, b)) -> Eff r a -> b -> (l -> b -> b) -> m (a, b)

respond_relay :: (a -> b -> (l -> b -> b) -> m (a, b)) -> (Eff r a -> b -> (l -> b -> b) -> m (a, b)) -> Eff r a -> b -> (l -> b -> b) -> m (a, b)

type StM (Eff (Log l ': r)) a

Defined in Control.Eff.Log

type StM (Eff (Log l ': r)) a = StM (Eff r) (a, [l])

data LogM m l v

A more advanced version of Log. Adds an ability to log from multiple threads.

Instances

(MonadBase m m, Lifted m r, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (LogM m l ': r))

Defined in Control.Eff.Log

Associated Types

type StM (Eff (LogM m l ': r)) a :: Type

Methods

liftBaseWith :: (RunInBase (Eff (LogM m l ': r)) m -> m a) -> Eff (LogM m l ': r) a

restoreM :: StM (Eff (LogM m l ': r)) a -> Eff (LogM m l ': r) a

Monad m => Handle (LogM m' l) r a (Logger m' l -> m a)

Defined in Control.Eff.Log

Methods

handle :: (Eff r a -> Logger m' l -> m a) -> Arrs r v a -> LogM m' l v -> Logger m' l -> m a

handle_relay :: (r ~ (LogM m' l ': r'), Relay (Logger m' l -> m a) r') => (a -> Logger m' l -> m a) -> (Eff r a -> Logger m' l -> m a) -> Eff r a -> Logger m' l -> m a

respond_relay :: (a -> Logger m' l -> m a) -> (Eff r a -> Logger m' l -> m a) -> Eff r a -> Logger m' l -> m a

type StM (Eff (LogM m l ': r)) a

Defined in Control.Eff.Log

type StM (Eff (LogM m l ': r)) a = StM (Eff r) a

type Logger m l = l -> m ()

Monadic action that does the real logging

stdoutLogger :: (LogMessage l, MonadBase IO m) => Logger m l

Logger that outputs messages to stdout

stderrLogger :: (LogMessage l, MonadBase IO m) => Logger m l

Logger that outputs messages to stderr

class LogMessage l where

Handy typeclass to convert log messages for output

Methods

toMsg :: l -> ByteString

Instances

LogMessage ByteString

Defined in Control.Eff.Log

Methods

toMsg :: ByteString -> ByteString

LogMessage Text

Defined in Control.Eff.Log

Methods

toMsg :: Text -> ByteString

LogMessage [Char]

Defined in Control.Eff.Log

Methods

toMsg :: [Char] -> ByteString

logE :: Member (Log l) r => l -> Eff r ()

Log something.

logM :: (Member (LogM m l) r, Lifted m r) => l -> Eff r ()

Log something using LogM effect

filterLog :: forall l r a. Member (Log l) r => (l -> Bool) -> Eff r a -> Eff r a

Filter Log entries with a predicate.

Note that, most of the time an explicit type signature for the predicate will be required.

filterLog' :: Member (Log l) r => (l -> Bool) -> proxy l -> Eff r a -> Eff r a

Filter Log entries with a predicate and a proxy.

This is the same as filterLog but with a proxy l for type inference.

runLogPure :: Eff (Log l ': r) a -> Eff r (a, [l])

Collect log messages in a list.

runLog :: Lifted m r => Logger m l -> Eff (Log l ': r) a -> Eff r a

Run the Logger action in the base monad for every log line.

runLogM :: Lifted m r => Logger m l -> Eff (LogM m l ': r) a -> Eff r a

Run the Logger action in the base monad for every log line.