extensible-effects-concurrent-0.1.2.2: Message passing concurrency as extensible-effect

Safe HaskellNone
LanguageHaskell2010

Control.Eff.Log

Description

An extensible effect that wraps MonadLog into an extensible effect.

Synopsis

Documentation

handleLogsWith :: forall m r message a. (Monad m, SetMember Lift (Lift m) r) => Eff (Logs message ': r) a -> (forall b. (Handler m message -> m b) -> m b) -> Eff r a Source #

Handle Logs effects using LoggingT Handlers.

data Logs message a where Source #

The Effect type to wrap MonadLog. This is a

Constructors

LogMessageFree :: (forall n. Monoid n => (message -> n) -> n) -> Logs message () 

Instances

MonadLog String (Eff ProcIO) # 

Methods

logMessageFree :: (forall n. Monoid n => (String -> n) -> n) -> Eff ProcIO () #

logMessageFreeEff :: Member (Logs message) r => (forall n. Monoid n => (message -> n) -> n) -> Eff r () Source #

Effectful version of the strange logMessageFree function.

logMsg :: Member (Logs m) r => m -> Eff r () Source #

Effectful version of the logMessage function.

data LogChannel message Source #

Input queue for a concurrent logger.

logChannelPutIO :: LogChannel message -> message -> IO () Source #

Enqueue a log message into a log channel

forwardLogsToChannel :: forall r message a. SetMember Lift (Lift IO) r => LogChannel message -> Eff (Logs message ': r) a -> Eff r a Source #

Send the log messages to a LogChannel.

forkLogChannel :: forall message. (message -> IO ()) -> Maybe message -> IO (LogChannel message) Source #

Fork LogChannel backed by a process that repeatedly receives log messages sent by forwardLogstochannel or logChannelPutIO. The process logs by invoken the given IO action. To stop and terminate a LogChannel invoke joinLogChannel.

joinLogChannel :: Maybe message -> LogChannel message -> IO () Source #

Close a log channel. Subsequent loggin requests will no be handled any more.

logChannelBracket :: Maybe message -> Maybe message -> (LogChannel message -> IO a) -> LoggingT message IO a Source #

Wrap LogChannel creation and destruction around a monad action in brackety manner.