Copyright	(c) 2019-2020 Kowainik
License	MPL-2.0
Maintainer	Kowainik <xrom.xkov@gmail.com>
Safe Haskell	None
Language	Haskell2010

Colog.Polysemy.Effect

Contents

Effect
Actions
Direct usages
Interpretations
Interpretations for Other Effects

Description

This module contains logging effect which can be interpreted in terms of LogAction from the co-log-core package.

Synopsis

data Log (msg :: Type) (m :: Type -> Type) (a :: Type) where
- Log :: msg -> Log msg m ()
log :: forall msg r. Member (Log msg) r => msg -> Sem r ()
type LogActionSem r msg = LogAction (Sem r) msg
runLogActionSem :: forall msg r a. LogActionSem r msg -> Sem (Log msg ': r) a -> Sem r a
runLogAction :: forall m msg r a. Member (Embed m) r => LogAction m msg -> Sem (Log msg ': r) a -> Sem r a
runLogAsTrace :: forall r a. Member Trace r => Sem (Log String ': r) a -> Sem r a
runLogAsOutput :: forall msg r a. Member (Output msg) r => Sem (Log msg ': r) a -> Sem r a
runTraceAsLog :: forall r a. Member (Log String) r => Sem (Trace ': r) a -> Sem r a
runOutputAsLog :: forall msg r a. Member (Log msg) r => Sem (Output msg ': r) a -> Sem r a

Effect

data Log (msg :: Type) (m :: Type -> Type) (a :: Type) where Source #

Effect responsible for logging messages of type msg. Has similar structure to LogAction.

You can think of this effect in the following way in terms of the existing effects in polysemy:

Like Output but specialised for logging.
Like Trace but polymorphic over logged message.

Constructors

Log :: msg -> Log msg m ()

Actions

log Source #

Arguments

:: forall msg r. Member (Log msg) r
=> msg	Message to log
-> Sem r ()	Effectful computation with no result

Log a message. If you semantic monad Sem has effect Log then you can send messages of type msg to that effect. This function can be used like this:

application :: Member (Log String) r => Sem r ()
application = do
    log "Application started..."
    log "Application finished..."

Direct usages

type LogActionSem r msg = LogAction (Sem r) msg Source #

LogAction that works directly with the Sem monad.

Since: 0.0.1.0

runLogActionSem :: forall msg r a. LogActionSem r msg -> Sem (Log msg ': r) a -> Sem r a Source #

Run Sem action with the corresponding LogActionSem. If you have plain LogAction that works with some monad m, use runLogAction instead.

Since: 0.0.1.0

Interpretations

runLogAction :: forall m msg r a. Member (Embed m) r => LogAction m msg -> Sem (Log msg ': r) a -> Sem r a Source #

Run a Log effect in terms of the given LogAction. The idea behind this function is the following: if you have LogAction m msg then you can use this action to tell how to io interpret effect Log. However, this is only possible if you also have Lift m effect because running log action requires access to monad m.

This function allows to use extensible effects provided by the polysemy library with logging provided by co-log. You can construct LogAction independently and then just pass to this function to tell how to log messages.

Several examples:

runLogAction mempty: interprets the Log effect by ignoring all messages.
runLogAction logStringStdout: interprets Log effect by allowing to log String to stdout.

runLogAsTrace :: forall r a. Member Trace r => Sem (Log String ': r) a -> Sem r a Source #

Run Log as the Trace effect. This function can be useful if you have an interpreter for the Trace effect and you want to log strings using that interpreter.

runLogAsOutput :: forall msg r a. Member (Output msg) r => Sem (Log msg ': r) a -> Sem r a Source #

Run Log as the Output effect. This function can be useful if you have an interpreter for the Output effect and you want to log messages using that interpreter.

Interpretations for Other Effects

runTraceAsLog :: forall r a. Member (Log String) r => Sem (Trace ': r) a -> Sem r a Source #

Run Trace as the Log effect. This function can be useful if you have an interpreter for the Log effect and you want to log strings using that interpreter.

runOutputAsLog :: forall msg r a. Member (Log msg) r => Sem (Output msg ': r) a -> Sem r a Source #

Run Output as the Log effect. This function can be useful if you have an interpreter for the Log effect and you want to log messages using that interpreter.