-- |Description: Interpreters
module Polysemy.Log.Colog.Colog where

import qualified Colog (Message, Msg(Msg), Severity(..), logTextStdout, richMessageAction)
import qualified Colog.Polysemy as Colog
import Colog.Polysemy (runLogAction)
import Polysemy (interpretH, runT)
import Polysemy.Async (Async)
import Polysemy.Conc (Race)
import Polysemy.Internal (InterpretersFor)
import Polysemy.Internal.Tactics (liftT)
import Polysemy.Resource (Resource)
import Polysemy.Time (GhcTime, interpretTimeGhc)

import Polysemy.Log.Conc (interceptDataLogConc)
import Polysemy.Log.Data.DataLog (DataLog(DataLog, Local))
import Polysemy.Log.Data.Log (Log)
import Polysemy.Log.Data.LogEntry (LogEntry (LogEntry))
import Polysemy.Log.Data.LogMessage (LogMessage(..))
import qualified Polysemy.Log.Data.Severity as Severity
import Polysemy.Log.Data.Severity (Severity)
import Polysemy.Log.Format (formatLogEntry)
import Polysemy.Log.Log (interpretLogDataLog)

-- |Convert 'Severity' into the /co-log/ variant, 'Colog.Severity'.
-- 'Severity.Trace' is conflated with 'Colog.Debug', and 'Severity.Crit' into 'Colog.Error'.
severityToColog ::
  Severity ->
  Colog.Severity
severityToColog :: Severity -> Severity
severityToColog = \case
  Severity
Severity.Trace -> Severity
Colog.Debug
  Severity
Severity.Debug -> Severity
Colog.Debug
  Severity
Severity.Info -> Severity
Colog.Info
  Severity
Severity.Warn -> Severity
Colog.Warning
  Severity
Severity.Error -> Severity
Colog.Error
  Severity
Severity.Crit -> Severity
Colog.Error
{-# INLINE severityToColog #-}

-- |Convert a default log message into the /co-log/-native 'Colog.Message'.
toColog :: LogEntry LogMessage -> Colog.Message
toColog :: LogEntry LogMessage -> Message
toColog (LogEntry LogMessage {Text
Severity
$sel:severity:LogMessage :: LogMessage -> Severity
$sel:message:LogMessage :: LogMessage -> Text
message :: Text
severity :: Severity
..} UTCTime
_ CallStack
source) =
  Severity -> CallStack -> Text -> Message
forall sev. sev -> CallStack -> Text -> Msg sev
Colog.Msg (Severity -> Severity
severityToColog Severity
severity) CallStack
source Text
message
{-# INLINE toColog #-}

-- |Reinterpret 'DataLog' as 'Colog.Log'.
-- Maintains a context function as state that is applied to each logged message, allowing the context of a block to be
-- modified.
interpretDataLogCologLocal ::
  ∀ a b r .
  Member (Colog.Log b) r =>
  (a -> b) ->
  (a -> a) ->
  InterpreterFor (DataLog a) r
interpretDataLogCologLocal :: (a -> b) -> (a -> a) -> InterpreterFor (DataLog a) r
interpretDataLogCologLocal a -> b
convert a -> a
context =
  (forall x (rInitial :: EffectRow).
 DataLog a (Sem rInitial) x
 -> Tactical (DataLog a) (Sem rInitial) r x)
-> Sem (DataLog a : r) a -> Sem r a
forall (e :: Effect) (r :: EffectRow) a.
(forall x (rInitial :: EffectRow).
 e (Sem rInitial) x -> Tactical e (Sem rInitial) r x)
-> Sem (e : r) a -> Sem r a
interpretH \case
    DataLog msg ->
      Sem r () -> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f ())
forall (m :: * -> *) (f :: * -> *) (r :: EffectRow) (e :: Effect)
       a.
Functor f =>
Sem r a -> Sem (WithTactics e f m r) (f a)
liftT (b -> Sem r ()
forall msg (r :: EffectRow). Member (Log msg) r => msg -> Sem r ()
Colog.log (a -> b
convert (a -> a
context a
msg)))
    Local f ma ->
      Sem r (f x)
-> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f x)
forall (e :: Effect) (r :: EffectRow) a. Sem r a -> Sem (e : r) a
raise (Sem r (f x)
 -> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f x))
-> (Sem (DataLog a : r) (f x) -> Sem r (f x))
-> Sem (DataLog a : r) (f x)
-> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> (a -> a) -> InterpreterFor (DataLog a) r
forall a b (r :: EffectRow).
Member (Log b) r =>
(a -> b) -> (a -> a) -> InterpreterFor (DataLog a) r
interpretDataLogCologLocal a -> b
convert (a -> a
f (a -> a) -> (a -> a) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
context) (Sem (DataLog a : r) (f x)
 -> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f x))
-> Sem
     (WithTactics (DataLog a) f (Sem rInitial) r)
     (Sem (DataLog a : r) (f x))
-> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f x)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Sem rInitial x
-> Sem
     (WithTactics (DataLog a) f (Sem rInitial) r)
     (Sem (DataLog a : r) (f x))
forall (m :: * -> *) a (e :: Effect) (f :: * -> *)
       (r :: EffectRow).
m a -> Sem (WithTactics e f m r) (Sem (e : r) (f a))
runT Sem rInitial x
ma
{-# INLINE interpretDataLogCologLocal #-}

-- |Reinterpret 'DataLog' as 'Colog.Log'.
interpretDataLogColog ::
  ∀ a r .
  Member (Colog.Log a) r =>
  InterpreterFor (DataLog a) r
interpretDataLogColog :: InterpreterFor (DataLog a) r
interpretDataLogColog =
  (a -> a) -> (a -> a) -> InterpreterFor (DataLog a) r
forall a b (r :: EffectRow).
Member (Log b) r =>
(a -> b) -> (a -> a) -> InterpreterFor (DataLog a) r
interpretDataLogCologLocal a -> a
forall a. a -> a
id a -> a
forall a. a -> a
id
{-# INLINE interpretDataLogColog #-}

-- |Reinterpret 'DataLog', specialized to the default message, as 'Colog.Log'.
interpretDataLogNative ::
  Member (Colog.Log Colog.Message) r =>
  InterpreterFor (DataLog (LogEntry LogMessage)) r
interpretDataLogNative :: InterpreterFor (DataLog (LogEntry LogMessage)) r
interpretDataLogNative =
  (LogEntry LogMessage -> Message)
-> (LogEntry LogMessage -> LogEntry LogMessage)
-> InterpreterFor (DataLog (LogEntry LogMessage)) r
forall a b (r :: EffectRow).
Member (Log b) r =>
(a -> b) -> (a -> a) -> InterpreterFor (DataLog a) r
interpretDataLogCologLocal LogEntry LogMessage -> Message
toColog LogEntry LogMessage -> LogEntry LogMessage
forall a. a -> a
id
{-# INLINE interpretDataLogNative #-}

-- |Reinterpret 'Log' as 'Colog.Log', using the /polysemy-log/ default message.
--
-- Since this adds a timestamp, it has a dependency on 'GhcTime'.
-- Use 'interpretLogColog'' for a variant that interprets 'GhcTime' in-place.
interpretLogColog ::
  Members [Colog.Log (LogEntry LogMessage), GhcTime] r =>
  InterpreterFor Log r
interpretLogColog :: InterpreterFor Log r
interpretLogColog =
  forall (r :: EffectRow).
Member (Log (LogEntry LogMessage)) r =>
InterpreterFor (DataLog (LogEntry LogMessage)) r
forall a (r :: EffectRow).
Member (Log a) r =>
InterpreterFor (DataLog a) r
interpretDataLogColog @(LogEntry LogMessage) (Sem (DataLog (LogEntry LogMessage) : r) a -> Sem r a)
-> (Sem (Log : r) a -> Sem (DataLog (LogEntry LogMessage) : r) a)
-> Sem (Log : r) a
-> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (Log : DataLog (LogEntry LogMessage) : r) a
-> Sem (DataLog (LogEntry LogMessage) : r) a
forall (r :: EffectRow).
Members '[DataLog (LogEntry LogMessage), GhcTime] r =>
InterpreterFor Log r
interpretLogDataLog (Sem (Log : DataLog (LogEntry LogMessage) : r) a
 -> Sem (DataLog (LogEntry LogMessage) : r) a)
-> (Sem (Log : r) a
    -> Sem (Log : DataLog (LogEntry LogMessage) : r) a)
-> Sem (Log : r) a
-> Sem (DataLog (LogEntry LogMessage) : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (Log : r) a -> Sem (Log : DataLog (LogEntry LogMessage) : r) a
forall (e2 :: Effect) (e1 :: Effect) (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : r) a
raiseUnder
{-# INLINE interpretLogColog #-}

-- |Reinterpret 'Log' as 'Colog.Log', also interpreting 'GhcTime'.
interpretLogColog' ::
  Members [Colog.Log (LogEntry LogMessage), Embed IO] r =>
  InterpretersFor [Log, GhcTime] r
interpretLogColog' :: InterpretersFor '[Log, GhcTime] r
interpretLogColog' =
  Sem (GhcTime : r) a -> Sem r a
forall (r :: EffectRow).
Member (Embed IO) r =>
InterpreterFor GhcTime r
interpretTimeGhc (Sem (GhcTime : r) a -> Sem r a)
-> (Sem (Log : GhcTime : r) a -> Sem (GhcTime : r) a)
-> Sem (Log : GhcTime : r) a
-> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem (Log : GhcTime : r) a -> Sem (GhcTime : r) a
forall (r :: EffectRow).
Members '[Log (LogEntry LogMessage), GhcTime] r =>
InterpreterFor Log r
interpretLogColog
{-# INLINE interpretLogColog' #-}

-- |Interpret 'Colog.Log' by printing to stdout, using the provided message formatter.
interpretCologStdoutFormat ::
  ∀ msg m r .
  MonadIO m =>
  Member (Embed m) r =>
  (msg -> Text) ->
  InterpreterFor (Colog.Log msg) r
interpretCologStdoutFormat :: (msg -> Text) -> InterpreterFor (Log msg) r
interpretCologStdoutFormat msg -> Text
format =
  LogAction m msg -> Sem (Log msg : r) a -> Sem r a
forall (m :: * -> *) msg (r :: EffectRow) a.
Member (Embed m) r =>
LogAction m msg -> Sem (Log msg : r) a -> Sem r a
runLogAction @m ((msg -> Text) -> LogAction m Text -> LogAction m msg
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap msg -> Text
format LogAction m Text
forall (m :: * -> *). MonadIO m => LogAction m Text
Colog.logTextStdout)
{-# INLINE interpretCologStdoutFormat #-}

-- |Interpret 'Colog.Log' with the default message by printing to stdout, using the default message formatter.
interpretCologStdout ::
  ∀ m r .
  MonadIO m =>
  Member (Embed m) r =>
  InterpreterFor (Colog.Log (LogEntry LogMessage)) r
interpretCologStdout :: InterpreterFor (Log (LogEntry LogMessage)) r
interpretCologStdout =
  (LogEntry LogMessage -> Text)
-> InterpreterFor (Log (LogEntry LogMessage)) r
forall msg (m :: * -> *) (r :: EffectRow).
(MonadIO m, Member (Embed m) r) =>
(msg -> Text) -> InterpreterFor (Log msg) r
interpretCologStdoutFormat @_ @m LogEntry LogMessage -> Text
formatLogEntry
{-# INLINE interpretCologStdout #-}

-- |Interpret 'Log' fully in terms of 'Colog.Log', using the default message and stdout.
interpretLogStdout ::
  Member (Embed IO) r =>
  InterpreterFor Log r
interpretLogStdout :: InterpreterFor Log r
interpretLogStdout =
  forall (r :: EffectRow).
(MonadIO IO, Member (Embed IO) r) =>
InterpreterFor (Log (LogEntry LogMessage)) r
forall (m :: * -> *) (r :: EffectRow).
(MonadIO m, Member (Embed m) r) =>
InterpreterFor (Log (LogEntry LogMessage)) r
interpretCologStdout @IO (Sem (Log (LogEntry LogMessage) : r) a -> Sem r a)
-> (Sem (Log : r) a -> Sem (Log (LogEntry LogMessage) : r) a)
-> Sem (Log : r) a
-> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (GhcTime : Log (LogEntry LogMessage) : r) a
-> Sem (Log (LogEntry LogMessage) : r) a
forall (r :: EffectRow).
Member (Embed IO) r =>
InterpreterFor GhcTime r
interpretTimeGhc (Sem (GhcTime : Log (LogEntry LogMessage) : r) a
 -> Sem (Log (LogEntry LogMessage) : r) a)
-> (Sem (Log : r) a
    -> Sem (GhcTime : Log (LogEntry LogMessage) : r) a)
-> Sem (Log : r) a
-> Sem (Log (LogEntry LogMessage) : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  forall (r :: EffectRow).
Member (Log (LogEntry LogMessage)) r =>
InterpreterFor (DataLog (LogEntry LogMessage)) r
forall a (r :: EffectRow).
Member (Log a) r =>
InterpreterFor (DataLog a) r
interpretDataLogColog @(LogEntry LogMessage) (Sem
   (DataLog (LogEntry LogMessage)
      : GhcTime : Log (LogEntry LogMessage) : r)
   a
 -> Sem (GhcTime : Log (LogEntry LogMessage) : r) a)
-> (Sem (Log : r) a
    -> Sem
         (DataLog (LogEntry LogMessage)
            : GhcTime : Log (LogEntry LogMessage) : r)
         a)
-> Sem (Log : r) a
-> Sem (GhcTime : Log (LogEntry LogMessage) : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem
  (Log
     : DataLog (LogEntry LogMessage) : GhcTime
     : Log (LogEntry LogMessage) : r)
  a
-> Sem
     (DataLog (LogEntry LogMessage)
        : GhcTime : Log (LogEntry LogMessage) : r)
     a
forall (r :: EffectRow).
Members '[DataLog (LogEntry LogMessage), GhcTime] r =>
InterpreterFor Log r
interpretLogDataLog (Sem
   (Log
      : DataLog (LogEntry LogMessage) : GhcTime
      : Log (LogEntry LogMessage) : r)
   a
 -> Sem
      (DataLog (LogEntry LogMessage)
         : GhcTime : Log (LogEntry LogMessage) : r)
      a)
-> (Sem (Log : r) a
    -> Sem
         (Log
            : DataLog (LogEntry LogMessage) : GhcTime
            : Log (LogEntry LogMessage) : r)
         a)
-> Sem (Log : r) a
-> Sem
     (DataLog (LogEntry LogMessage)
        : GhcTime : Log (LogEntry LogMessage) : r)
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (Log : r) a
-> Sem
     (Log
        : DataLog (LogEntry LogMessage) : GhcTime
        : Log (LogEntry LogMessage) : r)
     a
forall (e2 :: Effect) (e3 :: Effect) (e4 :: Effect) (e1 :: Effect)
       (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : e3 : e4 : r) a
raiseUnder3
{-# INLINE interpretLogStdout #-}

-- |Like 'interpretLogStdout', but process messages concurrently.
interpretLogStdoutConc ::
  Members [Resource, Async, Race, Embed IO] r =>
  InterpreterFor Log r
interpretLogStdoutConc :: InterpreterFor Log r
interpretLogStdoutConc =
  forall (r :: EffectRow).
(MonadIO IO, Member (Embed IO) r) =>
InterpreterFor (Log (LogEntry LogMessage)) r
forall (m :: * -> *) (r :: EffectRow).
(MonadIO m, Member (Embed m) r) =>
InterpreterFor (Log (LogEntry LogMessage)) r
interpretCologStdout @IO (Sem (Log (LogEntry LogMessage) : r) a -> Sem r a)
-> (Sem (Log : r) a -> Sem (Log (LogEntry LogMessage) : r) a)
-> Sem (Log : r) a
-> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (GhcTime : Log (LogEntry LogMessage) : r) a
-> Sem (Log (LogEntry LogMessage) : r) a
forall (r :: EffectRow).
Member (Embed IO) r =>
InterpreterFor GhcTime r
interpretTimeGhc (Sem (GhcTime : Log (LogEntry LogMessage) : r) a
 -> Sem (Log (LogEntry LogMessage) : r) a)
-> (Sem (Log : r) a
    -> Sem (GhcTime : Log (LogEntry LogMessage) : r) a)
-> Sem (Log : r) a
-> Sem (Log (LogEntry LogMessage) : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  forall (r :: EffectRow).
Member (Log (LogEntry LogMessage)) r =>
InterpreterFor (DataLog (LogEntry LogMessage)) r
forall a (r :: EffectRow).
Member (Log a) r =>
InterpreterFor (DataLog a) r
interpretDataLogColog @(LogEntry LogMessage) (Sem
   (DataLog (LogEntry LogMessage)
      : GhcTime : Log (LogEntry LogMessage) : r)
   a
 -> Sem (GhcTime : Log (LogEntry LogMessage) : r) a)
-> (Sem (Log : r) a
    -> Sem
         (DataLog (LogEntry LogMessage)
            : GhcTime : Log (LogEntry LogMessage) : r)
         a)
-> Sem (Log : r) a
-> Sem (GhcTime : Log (LogEntry LogMessage) : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Int
-> Sem
     (DataLog (LogEntry LogMessage)
        : GhcTime : Log (LogEntry LogMessage) : r)
     a
-> Sem
     (DataLog (LogEntry LogMessage)
        : GhcTime : Log (LogEntry LogMessage) : r)
     a
forall msg (r :: EffectRow) a.
Members '[DataLog msg, Resource, Async, Race, Embed IO] r =>
Int -> Sem r a -> Sem r a
interceptDataLogConc @(LogEntry LogMessage) Int
64 (Sem
   (DataLog (LogEntry LogMessage)
      : GhcTime : Log (LogEntry LogMessage) : r)
   a
 -> Sem
      (DataLog (LogEntry LogMessage)
         : GhcTime : Log (LogEntry LogMessage) : r)
      a)
-> (Sem (Log : r) a
    -> Sem
         (DataLog (LogEntry LogMessage)
            : GhcTime : Log (LogEntry LogMessage) : r)
         a)
-> Sem (Log : r) a
-> Sem
     (DataLog (LogEntry LogMessage)
        : GhcTime : Log (LogEntry LogMessage) : r)
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem
  (Log
     : DataLog (LogEntry LogMessage) : GhcTime
     : Log (LogEntry LogMessage) : r)
  a
-> Sem
     (DataLog (LogEntry LogMessage)
        : GhcTime : Log (LogEntry LogMessage) : r)
     a
forall (r :: EffectRow).
Members '[DataLog (LogEntry LogMessage), GhcTime] r =>
InterpreterFor Log r
interpretLogDataLog (Sem
   (Log
      : DataLog (LogEntry LogMessage) : GhcTime
      : Log (LogEntry LogMessage) : r)
   a
 -> Sem
      (DataLog (LogEntry LogMessage)
         : GhcTime : Log (LogEntry LogMessage) : r)
      a)
-> (Sem (Log : r) a
    -> Sem
         (Log
            : DataLog (LogEntry LogMessage) : GhcTime
            : Log (LogEntry LogMessage) : r)
         a)
-> Sem (Log : r) a
-> Sem
     (DataLog (LogEntry LogMessage)
        : GhcTime : Log (LogEntry LogMessage) : r)
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (Log : r) a
-> Sem
     (Log
        : DataLog (LogEntry LogMessage) : GhcTime
        : Log (LogEntry LogMessage) : r)
     a
forall (e2 :: Effect) (e3 :: Effect) (e4 :: Effect) (e1 :: Effect)
       (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : e3 : e4 : r) a
raiseUnder3
{-# INLINE interpretLogStdoutConc #-}

-- |Interpret 'Colog.Log' with the /co-log/ message protocol by printing to stdout, using /co-log/'s rich message
-- formatter.
interpretCologStdoutNative ::
  ∀ m r .
  MonadIO m =>
  Member (Embed m) r =>
  InterpreterFor (Colog.Log Colog.Message) r
interpretCologStdoutNative :: InterpreterFor (Log Message) r
interpretCologStdoutNative =
  LogAction m Message -> Sem (Log Message : r) a -> Sem r a
forall (m :: * -> *) msg (r :: EffectRow) a.
Member (Embed m) r =>
LogAction m msg -> Sem (Log msg : r) a -> Sem r a
runLogAction @m LogAction m Message
forall (m :: * -> *). MonadIO m => LogAction m Message
Colog.richMessageAction
{-# INLINE interpretCologStdoutNative #-}

-- |Reinterpret 'Log' as 'Colog.Log', using the /co-log/ message protocol.
interpretLogCologAsNative ::
  Members [Colog.Log Colog.Message, GhcTime] r =>
  InterpreterFor Log r
interpretLogCologAsNative :: InterpreterFor Log r
interpretLogCologAsNative =
  Sem (DataLog (LogEntry LogMessage) : r) a -> Sem r a
forall (r :: EffectRow).
Member (Log Message) r =>
InterpreterFor (DataLog (LogEntry LogMessage)) r
interpretDataLogNative (Sem (DataLog (LogEntry LogMessage) : r) a -> Sem r a)
-> (Sem (Log : r) a -> Sem (DataLog (LogEntry LogMessage) : r) a)
-> Sem (Log : r) a
-> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (Log : DataLog (LogEntry LogMessage) : r) a
-> Sem (DataLog (LogEntry LogMessage) : r) a
forall (r :: EffectRow).
Members '[DataLog (LogEntry LogMessage), GhcTime] r =>
InterpreterFor Log r
interpretLogDataLog (Sem (Log : DataLog (LogEntry LogMessage) : r) a
 -> Sem (DataLog (LogEntry LogMessage) : r) a)
-> (Sem (Log : r) a
    -> Sem (Log : DataLog (LogEntry LogMessage) : r) a)
-> Sem (Log : r) a
-> Sem (DataLog (LogEntry LogMessage) : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (Log : r) a -> Sem (Log : DataLog (LogEntry LogMessage) : r) a
forall (e2 :: Effect) (e1 :: Effect) (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : r) a
raiseUnder
{-# INLINE interpretLogCologAsNative #-}

-- |Interpret 'Log' fully in terms of 'Colog.Log', using /co-log/'s message protocol and stdout.
interpretLogStdoutAsNative ::
  Member (Embed IO) r =>
  InterpretersFor [Log, Colog.Log Colog.Message] r
interpretLogStdoutAsNative :: InterpretersFor '[Log, Log Message] r
interpretLogStdoutAsNative =
  forall (r :: EffectRow).
(MonadIO IO, Member (Embed IO) r) =>
InterpreterFor (Log Message) r
forall (m :: * -> *) (r :: EffectRow).
(MonadIO m, Member (Embed m) r) =>
InterpreterFor (Log Message) r
interpretCologStdoutNative @IO (Sem (Log Message : r) a -> Sem r a)
-> (Sem (Log : Log Message : r) a -> Sem (Log Message : r) a)
-> Sem (Log : Log Message : r) a
-> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (GhcTime : Log Message : r) a -> Sem (Log Message : r) a
forall (r :: EffectRow).
Member (Embed IO) r =>
InterpreterFor GhcTime r
interpretTimeGhc (Sem (GhcTime : Log Message : r) a -> Sem (Log Message : r) a)
-> (Sem (Log : Log Message : r) a
    -> Sem (GhcTime : Log Message : r) a)
-> Sem (Log : Log Message : r) a
-> Sem (Log Message : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (Log : GhcTime : Log Message : r) a
-> Sem (GhcTime : Log Message : r) a
forall (r :: EffectRow).
Members '[Log Message, GhcTime] r =>
InterpreterFor Log r
interpretLogCologAsNative (Sem (Log : GhcTime : Log Message : r) a
 -> Sem (GhcTime : Log Message : r) a)
-> (Sem (Log : Log Message : r) a
    -> Sem (Log : GhcTime : Log Message : r) a)
-> Sem (Log : Log Message : r) a
-> Sem (GhcTime : Log Message : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (Log : Log Message : r) a
-> Sem (Log : GhcTime : Log Message : r) a
forall (e2 :: Effect) (e1 :: Effect) (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : r) a
raiseUnder
{-# INLINE interpretLogStdoutAsNative #-}

-- |Interpret 'Log' fully in terms of 'Colog.Log', using /co-log/'s message protocol and stdout.
interpretLogStdoutAsNativeConc ::
  Members [Resource, Async, Race, Embed IO] r =>
  InterpretersFor [Log, Colog.Log Colog.Message] r
interpretLogStdoutAsNativeConc :: InterpretersFor '[Log, Log Message] r
interpretLogStdoutAsNativeConc =
  forall (r :: EffectRow).
(MonadIO IO, Member (Embed IO) r) =>
InterpreterFor (Log Message) r
forall (m :: * -> *) (r :: EffectRow).
(MonadIO m, Member (Embed m) r) =>
InterpreterFor (Log Message) r
interpretCologStdoutNative @IO (Sem (Log Message : r) a -> Sem r a)
-> (Sem (Log : Log Message : r) a -> Sem (Log Message : r) a)
-> Sem (Log : Log Message : r) a
-> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (GhcTime : Log Message : r) a -> Sem (Log Message : r) a
forall (r :: EffectRow).
Member (Embed IO) r =>
InterpreterFor GhcTime r
interpretTimeGhc (Sem (GhcTime : Log Message : r) a -> Sem (Log Message : r) a)
-> (Sem (Log : Log Message : r) a
    -> Sem (GhcTime : Log Message : r) a)
-> Sem (Log : Log Message : r) a
-> Sem (Log Message : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a
-> Sem (GhcTime : Log Message : r) a
forall (r :: EffectRow).
Member (Log Message) r =>
InterpreterFor (DataLog (LogEntry LogMessage)) r
interpretDataLogNative (Sem (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a
 -> Sem (GhcTime : Log Message : r) a)
-> (Sem (Log : Log Message : r) a
    -> Sem
         (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a)
-> Sem (Log : Log Message : r) a
-> Sem (GhcTime : Log Message : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Int
-> Sem
     (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a
-> Sem
     (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a
forall msg (r :: EffectRow) a.
Members '[DataLog msg, Resource, Async, Race, Embed IO] r =>
Int -> Sem r a -> Sem r a
interceptDataLogConc @(LogEntry LogMessage) Int
64 (Sem (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a
 -> Sem
      (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a)
-> (Sem (Log : Log Message : r) a
    -> Sem
         (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a)
-> Sem (Log : Log Message : r) a
-> Sem
     (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem
  (Log : DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a
-> Sem
     (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a
forall (r :: EffectRow).
Members '[DataLog (LogEntry LogMessage), GhcTime] r =>
InterpreterFor Log r
interpretLogDataLog (Sem
   (Log : DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a
 -> Sem
      (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a)
-> (Sem (Log : Log Message : r) a
    -> Sem
         (Log : DataLog (LogEntry LogMessage) : GhcTime : Log Message : r)
         a)
-> Sem (Log : Log Message : r) a
-> Sem
     (DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem (Log : Log Message : r) a
-> Sem
     (Log : DataLog (LogEntry LogMessage) : GhcTime : Log Message : r) a
forall (e2 :: Effect) (e3 :: Effect) (e1 :: Effect)
       (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : e3 : r) a
raiseUnder2
{-# INLINE interpretLogStdoutAsNativeConc #-}