{-# LANGUAGE CPP #-}
{-# LANGUAGE AutoDeriveTypeable #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE ImplicitParams #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
module Control.Monad.Log
(
logMessage, mapLogMessage, mapLogMessageM,
MonadLog(..),
logDebug, logInfo, logNotice, logWarning, logError, logCritical, logAlert, logEmergency,
PP.layoutPretty,
WithTimestamp(..), timestamp, renderWithTimestamp,
WithSeverity(..), Severity(..), renderWithSeverity,
WithCallStack(..), withCallStack, renderWithCallStack,
LoggingT(..), runLoggingT, mapLoggingT,
Handler, withFDHandler,
withBatchedHandler, BatchingOptions(..), defaultBatchingOptions,
PureLoggingT(..), runPureLoggingT,
DiscardLoggingT(DiscardLoggingT,discardLogging)
) where
import Prelude hiding (foldMap)
import Control.Applicative
import Control.Concurrent.Async (async, wait)
import Control.Concurrent.STM
import Control.Concurrent.STM.Delay
import Control.Monad (MonadPlus, guard)
import Control.Monad.Base
import Control.Monad.Catch (MonadThrow(..), MonadMask(..), MonadCatch(..), bracket)
import Control.Monad.Cont.Class (MonadCont(..))
import Control.Monad.Error.Class (MonadError(..))
import Control.Monad.Fix
import Control.Monad.Free.Class (MonadFree(..))
import Control.Monad.IO.Class (MonadIO, liftIO)
import Control.Monad.IO.Unlift (MonadUnliftIO(..), UnliftIO(..), withUnliftIO)
import Control.Monad.RWS.Class (MonadRWS)
import Control.Monad.Reader.Class (MonadReader(..))
import Control.Monad.State.Class (MonadState(..))
import Control.Monad.Trans.Class (MonadTrans(..))
import Control.Monad.Trans.Control
import Control.Monad.Trans.Reader (ReaderT(..))
import Control.Monad.Trans.State.Strict (StateT(..))
import Control.Monad.Writer.Class (MonadWriter(..))
import Data.Semigroup ((<>))
import Data.Time (UTCTime, getCurrentTime)
#if MIN_VERSION_base(4,9,0)
import qualified Control.Monad.Fail as Fail
#endif
#if !MIN_VERSION_base(4, 9, 0)
import GHC.SrcLoc (SrcLoc, showSrcLoc)
import GHC.Stack
#else
import GHC.Stack (SrcLoc, CallStack, getCallStack, prettySrcLoc)
#endif
import System.IO (Handle, hFlush)
import qualified Data.Text.Lazy as LT
import qualified Data.Text.Prettyprint.Doc as PP
import qualified Data.Text.Prettyprint.Doc.Render.Text as PP
import qualified Data.List.NonEmpty as NEL
import qualified Control.Monad.Trans.Identity as Identity
import qualified Control.Monad.Trans.Reader as Reader
import qualified Control.Monad.Trans.State.Lazy as LazyState
import qualified Control.Monad.Trans.State.Strict as StrictState
import qualified Control.Monad.Trans.Writer.Lazy as LazyWriter
import qualified Control.Monad.Trans.Writer.Strict as StrictWriter
import qualified Control.Monad.Trans.Maybe as Maybe
import qualified Control.Monad.Trans.Except as Except
import qualified Control.Monad.Trans.RWS.Lazy as LazyRWS
import qualified Control.Monad.Trans.RWS.Strict as StrictRWS
import qualified Control.Monad.Trans.Cont as Cont
import qualified Control.Monad.Trans.Free as Free
import qualified Control.Monad.Trans.Free.Church as Free
import qualified Control.Monad.Catch.Pure as Exceptions
class Monad m => MonadLog message m | m -> message where
logMessageFree :: (forall n. Monoid n => (message -> n) -> n) -> m ()
default logMessageFree :: (m ~ t n, MonadTrans t, MonadLog message n) => (forall mon. Monoid mon => (message -> mon) -> mon) -> m ()
logMessageFree forall mon. Monoid mon => (message -> mon) -> mon
inj = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall message (m :: * -> *).
MonadLog message m =>
(forall mon. Monoid mon => (message -> mon) -> mon) -> m ()
logMessageFree forall mon. Monoid mon => (message -> mon) -> mon
inj)
{-# INLINEABLE logMessageFree #-}
logMessage :: MonadLog message m => message -> m ()
logMessage :: forall message (m :: * -> *). MonadLog message m => message -> m ()
logMessage message
m = forall message (m :: * -> *).
MonadLog message m =>
(forall mon. Monoid mon => (message -> mon) -> mon) -> m ()
logMessageFree (\message -> n
inject -> message -> n
inject message
m)
{-# INLINEABLE logMessage #-}
mapLogMessage
:: MonadLog message' m
=> (message -> message') -> LoggingT message m a -> m a
mapLogMessage :: forall message' (m :: * -> *) message a.
MonadLog message' m =>
(message -> message') -> LoggingT message m a -> m a
mapLogMessage message -> message'
f LoggingT message m a
m =
forall message (m :: * -> *) a.
LoggingT message m a -> Handler m message -> m a
runLoggingT LoggingT message m a
m
(forall message (m :: * -> *). MonadLog message m => message -> m ()
logMessage forall b c a. (b -> c) -> (a -> b) -> a -> c
. message -> message'
f)
{-# INLINEABLE mapLogMessage #-}
mapLogMessageM
:: MonadLog message' m
=> (message -> m message') -> LoggingT message m a -> m a
mapLogMessageM :: forall message' (m :: * -> *) message a.
MonadLog message' m =>
(message -> m message') -> LoggingT message m a -> m a
mapLogMessageM message -> m message'
f LoggingT message m a
m =
forall message (m :: * -> *) a.
LoggingT message m a -> Handler m message -> m a
runLoggingT LoggingT message m a
m ((forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall message (m :: * -> *). MonadLog message m => message -> m ()
logMessage) forall b c a. (b -> c) -> (a -> b) -> a -> c
. message -> m message'
f)
{-# INLINEABLE mapLogMessageM #-}
instance MonadLog message m => MonadLog message (Identity.IdentityT m)
instance MonadLog message m => MonadLog message (Reader.ReaderT r m)
instance MonadLog message m => MonadLog message (StrictState.StateT s m)
instance MonadLog message m => MonadLog message (LazyState.StateT s m)
instance (Monoid w, MonadLog message m) => MonadLog message (StrictWriter.WriterT w m)
instance (Monoid w, MonadLog message m) => MonadLog message (LazyWriter.WriterT w m)
instance MonadLog message m => MonadLog message (Maybe.MaybeT m)
instance MonadLog message m => MonadLog message (Except.ExceptT e m)
instance (Monoid w, MonadLog message m) => MonadLog message (StrictRWS.RWST r w s m)
instance (Monoid w, MonadLog message m) => MonadLog message (LazyRWS.RWST r w s m)
instance MonadLog message m => MonadLog message (Cont.ContT r m)
instance (Functor f, MonadLog message m) => MonadLog message (Free.FreeT f m)
instance (Functor f, MonadLog message m) => MonadLog message (Free.FT f m)
instance MonadLog message m => MonadLog message (Exceptions.CatchT m)
data WithSeverity a =
WithSeverity {forall a. WithSeverity a -> Severity
msgSeverity :: Severity
,forall a. WithSeverity a -> a
discardSeverity :: a
}
deriving (WithSeverity a -> WithSeverity a -> Bool
forall a. Eq a => WithSeverity a -> WithSeverity a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WithSeverity a -> WithSeverity a -> Bool
$c/= :: forall a. Eq a => WithSeverity a -> WithSeverity a -> Bool
== :: WithSeverity a -> WithSeverity a -> Bool
$c== :: forall a. Eq a => WithSeverity a -> WithSeverity a -> Bool
Eq,WithSeverity a -> WithSeverity a -> Bool
WithSeverity a -> WithSeverity a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (WithSeverity a)
forall a. Ord a => WithSeverity a -> WithSeverity a -> Bool
forall a. Ord a => WithSeverity a -> WithSeverity a -> Ordering
forall a.
Ord a =>
WithSeverity a -> WithSeverity a -> WithSeverity a
min :: WithSeverity a -> WithSeverity a -> WithSeverity a
$cmin :: forall a.
Ord a =>
WithSeverity a -> WithSeverity a -> WithSeverity a
max :: WithSeverity a -> WithSeverity a -> WithSeverity a
$cmax :: forall a.
Ord a =>
WithSeverity a -> WithSeverity a -> WithSeverity a
>= :: WithSeverity a -> WithSeverity a -> Bool
$c>= :: forall a. Ord a => WithSeverity a -> WithSeverity a -> Bool
> :: WithSeverity a -> WithSeverity a -> Bool
$c> :: forall a. Ord a => WithSeverity a -> WithSeverity a -> Bool
<= :: WithSeverity a -> WithSeverity a -> Bool
$c<= :: forall a. Ord a => WithSeverity a -> WithSeverity a -> Bool
< :: WithSeverity a -> WithSeverity a -> Bool
$c< :: forall a. Ord a => WithSeverity a -> WithSeverity a -> Bool
compare :: WithSeverity a -> WithSeverity a -> Ordering
$ccompare :: forall a. Ord a => WithSeverity a -> WithSeverity a -> Ordering
Ord,ReadPrec [WithSeverity a]
ReadPrec (WithSeverity a)
ReadS [WithSeverity a]
forall a. Read a => ReadPrec [WithSeverity a]
forall a. Read a => ReadPrec (WithSeverity a)
forall a. Read a => Int -> ReadS (WithSeverity a)
forall a. Read a => ReadS [WithSeverity a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [WithSeverity a]
$creadListPrec :: forall a. Read a => ReadPrec [WithSeverity a]
readPrec :: ReadPrec (WithSeverity a)
$creadPrec :: forall a. Read a => ReadPrec (WithSeverity a)
readList :: ReadS [WithSeverity a]
$creadList :: forall a. Read a => ReadS [WithSeverity a]
readsPrec :: Int -> ReadS (WithSeverity a)
$creadsPrec :: forall a. Read a => Int -> ReadS (WithSeverity a)
Read,Int -> WithSeverity a -> ShowS
forall a. Show a => Int -> WithSeverity a -> ShowS
forall a. Show a => [WithSeverity a] -> ShowS
forall a. Show a => WithSeverity a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WithSeverity a] -> ShowS
$cshowList :: forall a. Show a => [WithSeverity a] -> ShowS
show :: WithSeverity a -> String
$cshow :: forall a. Show a => WithSeverity a -> String
showsPrec :: Int -> WithSeverity a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> WithSeverity a -> ShowS
Show,forall a b. a -> WithSeverity b -> WithSeverity a
forall a b. (a -> b) -> WithSeverity a -> WithSeverity b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> WithSeverity b -> WithSeverity a
$c<$ :: forall a b. a -> WithSeverity b -> WithSeverity a
fmap :: forall a b. (a -> b) -> WithSeverity a -> WithSeverity b
$cfmap :: forall a b. (a -> b) -> WithSeverity a -> WithSeverity b
Functor,Functor WithSeverity
Foldable WithSeverity
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
WithSeverity (m a) -> m (WithSeverity a)
forall (f :: * -> *) a.
Applicative f =>
WithSeverity (f a) -> f (WithSeverity a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithSeverity a -> m (WithSeverity b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithSeverity a -> f (WithSeverity b)
sequence :: forall (m :: * -> *) a.
Monad m =>
WithSeverity (m a) -> m (WithSeverity a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
WithSeverity (m a) -> m (WithSeverity a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithSeverity a -> m (WithSeverity b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithSeverity a -> m (WithSeverity b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
WithSeverity (f a) -> f (WithSeverity a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
WithSeverity (f a) -> f (WithSeverity a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithSeverity a -> f (WithSeverity b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithSeverity a -> f (WithSeverity b)
Traversable,forall a. Eq a => a -> WithSeverity a -> Bool
forall a. Num a => WithSeverity a -> a
forall a. Ord a => WithSeverity a -> a
forall m. Monoid m => WithSeverity m -> m
forall a. WithSeverity a -> Bool
forall a. WithSeverity a -> Int
forall a. WithSeverity a -> [a]
forall a. (a -> a -> a) -> WithSeverity a -> a
forall m a. Monoid m => (a -> m) -> WithSeverity a -> m
forall b a. (b -> a -> b) -> b -> WithSeverity a -> b
forall a b. (a -> b -> b) -> b -> WithSeverity a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => WithSeverity a -> a
$cproduct :: forall a. Num a => WithSeverity a -> a
sum :: forall a. Num a => WithSeverity a -> a
$csum :: forall a. Num a => WithSeverity a -> a
minimum :: forall a. Ord a => WithSeverity a -> a
$cminimum :: forall a. Ord a => WithSeverity a -> a
maximum :: forall a. Ord a => WithSeverity a -> a
$cmaximum :: forall a. Ord a => WithSeverity a -> a
elem :: forall a. Eq a => a -> WithSeverity a -> Bool
$celem :: forall a. Eq a => a -> WithSeverity a -> Bool
length :: forall a. WithSeverity a -> Int
$clength :: forall a. WithSeverity a -> Int
null :: forall a. WithSeverity a -> Bool
$cnull :: forall a. WithSeverity a -> Bool
toList :: forall a. WithSeverity a -> [a]
$ctoList :: forall a. WithSeverity a -> [a]
foldl1 :: forall a. (a -> a -> a) -> WithSeverity a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> WithSeverity a -> a
foldr1 :: forall a. (a -> a -> a) -> WithSeverity a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> WithSeverity a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> WithSeverity a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> WithSeverity a -> b
foldl :: forall b a. (b -> a -> b) -> b -> WithSeverity a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> WithSeverity a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> WithSeverity a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> WithSeverity a -> b
foldr :: forall a b. (a -> b -> b) -> b -> WithSeverity a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> WithSeverity a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> WithSeverity a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> WithSeverity a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> WithSeverity a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> WithSeverity a -> m
fold :: forall m. Monoid m => WithSeverity m -> m
$cfold :: forall m. Monoid m => WithSeverity m -> m
Foldable)
data Severity =
Emergency
| Alert
| Critical
| Error
| Warning
| Notice
| Informational
| Debug
deriving (Severity -> Severity -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Severity -> Severity -> Bool
$c/= :: Severity -> Severity -> Bool
== :: Severity -> Severity -> Bool
$c== :: Severity -> Severity -> Bool
Eq,Int -> Severity
Severity -> Int
Severity -> [Severity]
Severity -> Severity
Severity -> Severity -> [Severity]
Severity -> Severity -> Severity -> [Severity]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Severity -> Severity -> Severity -> [Severity]
$cenumFromThenTo :: Severity -> Severity -> Severity -> [Severity]
enumFromTo :: Severity -> Severity -> [Severity]
$cenumFromTo :: Severity -> Severity -> [Severity]
enumFromThen :: Severity -> Severity -> [Severity]
$cenumFromThen :: Severity -> Severity -> [Severity]
enumFrom :: Severity -> [Severity]
$cenumFrom :: Severity -> [Severity]
fromEnum :: Severity -> Int
$cfromEnum :: Severity -> Int
toEnum :: Int -> Severity
$ctoEnum :: Int -> Severity
pred :: Severity -> Severity
$cpred :: Severity -> Severity
succ :: Severity -> Severity
$csucc :: Severity -> Severity
Enum,Severity
forall a. a -> a -> Bounded a
maxBound :: Severity
$cmaxBound :: Severity
minBound :: Severity
$cminBound :: Severity
Bounded,ReadPrec [Severity]
ReadPrec Severity
Int -> ReadS Severity
ReadS [Severity]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Severity]
$creadListPrec :: ReadPrec [Severity]
readPrec :: ReadPrec Severity
$creadPrec :: ReadPrec Severity
readList :: ReadS [Severity]
$creadList :: ReadS [Severity]
readsPrec :: Int -> ReadS Severity
$creadsPrec :: Int -> ReadS Severity
Read,Int -> Severity -> ShowS
[Severity] -> ShowS
Severity -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Severity] -> ShowS
$cshowList :: [Severity] -> ShowS
show :: Severity -> String
$cshow :: Severity -> String
showsPrec :: Int -> Severity -> ShowS
$cshowsPrec :: Int -> Severity -> ShowS
Show,Eq Severity
Severity -> Severity -> Bool
Severity -> Severity -> Ordering
Severity -> Severity -> Severity
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Severity -> Severity -> Severity
$cmin :: Severity -> Severity -> Severity
max :: Severity -> Severity -> Severity
$cmax :: Severity -> Severity -> Severity
>= :: Severity -> Severity -> Bool
$c>= :: Severity -> Severity -> Bool
> :: Severity -> Severity -> Bool
$c> :: Severity -> Severity -> Bool
<= :: Severity -> Severity -> Bool
$c<= :: Severity -> Severity -> Bool
< :: Severity -> Severity -> Bool
$c< :: Severity -> Severity -> Bool
compare :: Severity -> Severity -> Ordering
$ccompare :: Severity -> Severity -> Ordering
Ord)
instance PP.Pretty Severity where
pretty :: forall ann. Severity -> Doc ann
pretty = forall a ann. Pretty a => a -> Doc ann
PP.pretty forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
LT.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show
renderWithSeverity
:: (a -> PP.Doc ann) -> (WithSeverity a -> PP.Doc ann)
renderWithSeverity :: forall a ann. (a -> Doc ann) -> WithSeverity a -> Doc ann
renderWithSeverity a -> Doc ann
k (WithSeverity Severity
u a
a) =
forall ann. Doc ann -> Doc ann
PP.brackets (forall a ann. Pretty a => a -> Doc ann
PP.pretty Severity
u) forall ann. Doc ann -> Doc ann -> Doc ann
PP.<+> forall ann. Doc ann -> Doc ann
PP.align (a -> Doc ann
k a
a)
logDebug :: MonadLog (WithSeverity a) m => a -> m ()
logDebug :: forall a (m :: * -> *). MonadLog (WithSeverity a) m => a -> m ()
logDebug = forall message (m :: * -> *). MonadLog message m => message -> m ()
logMessage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Severity -> a -> WithSeverity a
WithSeverity Severity
Debug
{-# INLINEABLE logDebug #-}
logInfo :: MonadLog (WithSeverity a) m => a -> m ()
logInfo :: forall a (m :: * -> *). MonadLog (WithSeverity a) m => a -> m ()
logInfo = forall message (m :: * -> *). MonadLog message m => message -> m ()
logMessage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Severity -> a -> WithSeverity a
WithSeverity Severity
Informational
{-# INLINEABLE logInfo #-}
logNotice :: MonadLog (WithSeverity a) m => a -> m ()
logNotice :: forall a (m :: * -> *). MonadLog (WithSeverity a) m => a -> m ()
logNotice = forall message (m :: * -> *). MonadLog message m => message -> m ()
logMessage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Severity -> a -> WithSeverity a
WithSeverity Severity
Notice
{-# INLINEABLE logNotice #-}
logWarning :: MonadLog (WithSeverity a) m => a -> m ()
logWarning :: forall a (m :: * -> *). MonadLog (WithSeverity a) m => a -> m ()
logWarning = forall message (m :: * -> *). MonadLog message m => message -> m ()
logMessage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Severity -> a -> WithSeverity a
WithSeverity Severity
Warning
{-# INLINEABLE logWarning #-}
logError :: MonadLog (WithSeverity a) m => a -> m ()
logError :: forall a (m :: * -> *). MonadLog (WithSeverity a) m => a -> m ()
logError = forall message (m :: * -> *). MonadLog message m => message -> m ()
logMessage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Severity -> a -> WithSeverity a
WithSeverity Severity
Error
{-# INLINEABLE logError #-}
logCritical :: MonadLog (WithSeverity a) m => a -> m ()
logCritical :: forall a (m :: * -> *). MonadLog (WithSeverity a) m => a -> m ()
logCritical = forall message (m :: * -> *). MonadLog message m => message -> m ()
logMessage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Severity -> a -> WithSeverity a
WithSeverity Severity
Critical
{-# INLINEABLE logCritical #-}
logAlert :: MonadLog (WithSeverity a) m => a -> m ()
logAlert :: forall a (m :: * -> *). MonadLog (WithSeverity a) m => a -> m ()
logAlert = forall message (m :: * -> *). MonadLog message m => message -> m ()
logMessage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Severity -> a -> WithSeverity a
WithSeverity Severity
Alert
{-# INLINEABLE logAlert #-}
logEmergency :: MonadLog (WithSeverity a) m => a -> m ()
logEmergency :: forall a (m :: * -> *). MonadLog (WithSeverity a) m => a -> m ()
logEmergency = forall message (m :: * -> *). MonadLog message m => message -> m ()
logMessage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Severity -> a -> WithSeverity a
WithSeverity Severity
Emergency
{-# INLINEABLE logEmergency #-}
data WithTimestamp a =
WithTimestamp {forall a. WithTimestamp a -> a
discardTimestamp :: a
,forall a. WithTimestamp a -> UTCTime
msgTimestamp :: UTCTime
}
deriving (WithTimestamp a -> WithTimestamp a -> Bool
forall a. Eq a => WithTimestamp a -> WithTimestamp a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WithTimestamp a -> WithTimestamp a -> Bool
$c/= :: forall a. Eq a => WithTimestamp a -> WithTimestamp a -> Bool
== :: WithTimestamp a -> WithTimestamp a -> Bool
$c== :: forall a. Eq a => WithTimestamp a -> WithTimestamp a -> Bool
Eq,WithTimestamp a -> WithTimestamp a -> Bool
WithTimestamp a -> WithTimestamp a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (WithTimestamp a)
forall a. Ord a => WithTimestamp a -> WithTimestamp a -> Bool
forall a. Ord a => WithTimestamp a -> WithTimestamp a -> Ordering
forall a.
Ord a =>
WithTimestamp a -> WithTimestamp a -> WithTimestamp a
min :: WithTimestamp a -> WithTimestamp a -> WithTimestamp a
$cmin :: forall a.
Ord a =>
WithTimestamp a -> WithTimestamp a -> WithTimestamp a
max :: WithTimestamp a -> WithTimestamp a -> WithTimestamp a
$cmax :: forall a.
Ord a =>
WithTimestamp a -> WithTimestamp a -> WithTimestamp a
>= :: WithTimestamp a -> WithTimestamp a -> Bool
$c>= :: forall a. Ord a => WithTimestamp a -> WithTimestamp a -> Bool
> :: WithTimestamp a -> WithTimestamp a -> Bool
$c> :: forall a. Ord a => WithTimestamp a -> WithTimestamp a -> Bool
<= :: WithTimestamp a -> WithTimestamp a -> Bool
$c<= :: forall a. Ord a => WithTimestamp a -> WithTimestamp a -> Bool
< :: WithTimestamp a -> WithTimestamp a -> Bool
$c< :: forall a. Ord a => WithTimestamp a -> WithTimestamp a -> Bool
compare :: WithTimestamp a -> WithTimestamp a -> Ordering
$ccompare :: forall a. Ord a => WithTimestamp a -> WithTimestamp a -> Ordering
Ord,ReadPrec [WithTimestamp a]
ReadPrec (WithTimestamp a)
ReadS [WithTimestamp a]
forall a. Read a => ReadPrec [WithTimestamp a]
forall a. Read a => ReadPrec (WithTimestamp a)
forall a. Read a => Int -> ReadS (WithTimestamp a)
forall a. Read a => ReadS [WithTimestamp a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [WithTimestamp a]
$creadListPrec :: forall a. Read a => ReadPrec [WithTimestamp a]
readPrec :: ReadPrec (WithTimestamp a)
$creadPrec :: forall a. Read a => ReadPrec (WithTimestamp a)
readList :: ReadS [WithTimestamp a]
$creadList :: forall a. Read a => ReadS [WithTimestamp a]
readsPrec :: Int -> ReadS (WithTimestamp a)
$creadsPrec :: forall a. Read a => Int -> ReadS (WithTimestamp a)
Read,Int -> WithTimestamp a -> ShowS
forall a. Show a => Int -> WithTimestamp a -> ShowS
forall a. Show a => [WithTimestamp a] -> ShowS
forall a. Show a => WithTimestamp a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WithTimestamp a] -> ShowS
$cshowList :: forall a. Show a => [WithTimestamp a] -> ShowS
show :: WithTimestamp a -> String
$cshow :: forall a. Show a => WithTimestamp a -> String
showsPrec :: Int -> WithTimestamp a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> WithTimestamp a -> ShowS
Show,forall a b. a -> WithTimestamp b -> WithTimestamp a
forall a b. (a -> b) -> WithTimestamp a -> WithTimestamp b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> WithTimestamp b -> WithTimestamp a
$c<$ :: forall a b. a -> WithTimestamp b -> WithTimestamp a
fmap :: forall a b. (a -> b) -> WithTimestamp a -> WithTimestamp b
$cfmap :: forall a b. (a -> b) -> WithTimestamp a -> WithTimestamp b
Functor,Functor WithTimestamp
Foldable WithTimestamp
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
WithTimestamp (m a) -> m (WithTimestamp a)
forall (f :: * -> *) a.
Applicative f =>
WithTimestamp (f a) -> f (WithTimestamp a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithTimestamp a -> m (WithTimestamp b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithTimestamp a -> f (WithTimestamp b)
sequence :: forall (m :: * -> *) a.
Monad m =>
WithTimestamp (m a) -> m (WithTimestamp a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
WithTimestamp (m a) -> m (WithTimestamp a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithTimestamp a -> m (WithTimestamp b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithTimestamp a -> m (WithTimestamp b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
WithTimestamp (f a) -> f (WithTimestamp a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
WithTimestamp (f a) -> f (WithTimestamp a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithTimestamp a -> f (WithTimestamp b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithTimestamp a -> f (WithTimestamp b)
Traversable,forall a. Eq a => a -> WithTimestamp a -> Bool
forall a. Num a => WithTimestamp a -> a
forall a. Ord a => WithTimestamp a -> a
forall m. Monoid m => WithTimestamp m -> m
forall a. WithTimestamp a -> Bool
forall a. WithTimestamp a -> Int
forall a. WithTimestamp a -> [a]
forall a. (a -> a -> a) -> WithTimestamp a -> a
forall m a. Monoid m => (a -> m) -> WithTimestamp a -> m
forall b a. (b -> a -> b) -> b -> WithTimestamp a -> b
forall a b. (a -> b -> b) -> b -> WithTimestamp a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => WithTimestamp a -> a
$cproduct :: forall a. Num a => WithTimestamp a -> a
sum :: forall a. Num a => WithTimestamp a -> a
$csum :: forall a. Num a => WithTimestamp a -> a
minimum :: forall a. Ord a => WithTimestamp a -> a
$cminimum :: forall a. Ord a => WithTimestamp a -> a
maximum :: forall a. Ord a => WithTimestamp a -> a
$cmaximum :: forall a. Ord a => WithTimestamp a -> a
elem :: forall a. Eq a => a -> WithTimestamp a -> Bool
$celem :: forall a. Eq a => a -> WithTimestamp a -> Bool
length :: forall a. WithTimestamp a -> Int
$clength :: forall a. WithTimestamp a -> Int
null :: forall a. WithTimestamp a -> Bool
$cnull :: forall a. WithTimestamp a -> Bool
toList :: forall a. WithTimestamp a -> [a]
$ctoList :: forall a. WithTimestamp a -> [a]
foldl1 :: forall a. (a -> a -> a) -> WithTimestamp a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> WithTimestamp a -> a
foldr1 :: forall a. (a -> a -> a) -> WithTimestamp a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> WithTimestamp a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> WithTimestamp a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> WithTimestamp a -> b
foldl :: forall b a. (b -> a -> b) -> b -> WithTimestamp a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> WithTimestamp a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> WithTimestamp a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> WithTimestamp a -> b
foldr :: forall a b. (a -> b -> b) -> b -> WithTimestamp a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> WithTimestamp a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> WithTimestamp a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> WithTimestamp a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> WithTimestamp a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> WithTimestamp a -> m
fold :: forall m. Monoid m => WithTimestamp m -> m
$cfold :: forall m. Monoid m => WithTimestamp m -> m
Foldable)
renderWithTimestamp :: (UTCTime -> String)
-> (a -> PP.Doc ann)
-> (WithTimestamp a -> PP.Doc ann)
renderWithTimestamp :: forall a ann.
(UTCTime -> String) -> (a -> Doc ann) -> WithTimestamp a -> Doc ann
renderWithTimestamp UTCTime -> String
formatter a -> Doc ann
k (WithTimestamp a
a UTCTime
t) =
forall ann. Doc ann -> Doc ann
PP.brackets (forall a ann. Pretty a => a -> Doc ann
PP.pretty (String -> Text
LT.pack (UTCTime -> String
formatter UTCTime
t))) forall ann. Doc ann -> Doc ann -> Doc ann
PP.<+> forall ann. Doc ann -> Doc ann
PP.align (a -> Doc ann
k a
a)
timestamp :: (MonadIO m) => a -> m (WithTimestamp a)
timestamp :: forall (m :: * -> *) a. MonadIO m => a -> m (WithTimestamp a)
timestamp a
msg = do
UTCTime
now <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO UTCTime
getCurrentTime
forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a. a -> UTCTime -> WithTimestamp a
WithTimestamp a
msg UTCTime
now)
{-# INLINEABLE timestamp #-}
data WithCallStack a = WithCallStack { forall a. WithCallStack a -> CallStack
msgCallStack :: CallStack
, forall a. WithCallStack a -> a
discardCallStack :: a }
deriving (forall a b. a -> WithCallStack b -> WithCallStack a
forall a b. (a -> b) -> WithCallStack a -> WithCallStack b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> WithCallStack b -> WithCallStack a
$c<$ :: forall a b. a -> WithCallStack b -> WithCallStack a
fmap :: forall a b. (a -> b) -> WithCallStack a -> WithCallStack b
$cfmap :: forall a b. (a -> b) -> WithCallStack a -> WithCallStack b
Functor,Functor WithCallStack
Foldable WithCallStack
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
WithCallStack (m a) -> m (WithCallStack a)
forall (f :: * -> *) a.
Applicative f =>
WithCallStack (f a) -> f (WithCallStack a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithCallStack a -> m (WithCallStack b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithCallStack a -> f (WithCallStack b)
sequence :: forall (m :: * -> *) a.
Monad m =>
WithCallStack (m a) -> m (WithCallStack a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
WithCallStack (m a) -> m (WithCallStack a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithCallStack a -> m (WithCallStack b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithCallStack a -> m (WithCallStack b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
WithCallStack (f a) -> f (WithCallStack a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
WithCallStack (f a) -> f (WithCallStack a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithCallStack a -> f (WithCallStack b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithCallStack a -> f (WithCallStack b)
Traversable,forall a. Eq a => a -> WithCallStack a -> Bool
forall a. Num a => WithCallStack a -> a
forall a. Ord a => WithCallStack a -> a
forall m. Monoid m => WithCallStack m -> m
forall a. WithCallStack a -> Bool
forall a. WithCallStack a -> Int
forall a. WithCallStack a -> [a]
forall a. (a -> a -> a) -> WithCallStack a -> a
forall m a. Monoid m => (a -> m) -> WithCallStack a -> m
forall b a. (b -> a -> b) -> b -> WithCallStack a -> b
forall a b. (a -> b -> b) -> b -> WithCallStack a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => WithCallStack a -> a
$cproduct :: forall a. Num a => WithCallStack a -> a
sum :: forall a. Num a => WithCallStack a -> a
$csum :: forall a. Num a => WithCallStack a -> a
minimum :: forall a. Ord a => WithCallStack a -> a
$cminimum :: forall a. Ord a => WithCallStack a -> a
maximum :: forall a. Ord a => WithCallStack a -> a
$cmaximum :: forall a. Ord a => WithCallStack a -> a
elem :: forall a. Eq a => a -> WithCallStack a -> Bool
$celem :: forall a. Eq a => a -> WithCallStack a -> Bool
length :: forall a. WithCallStack a -> Int
$clength :: forall a. WithCallStack a -> Int
null :: forall a. WithCallStack a -> Bool
$cnull :: forall a. WithCallStack a -> Bool
toList :: forall a. WithCallStack a -> [a]
$ctoList :: forall a. WithCallStack a -> [a]
foldl1 :: forall a. (a -> a -> a) -> WithCallStack a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> WithCallStack a -> a
foldr1 :: forall a. (a -> a -> a) -> WithCallStack a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> WithCallStack a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> WithCallStack a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> WithCallStack a -> b
foldl :: forall b a. (b -> a -> b) -> b -> WithCallStack a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> WithCallStack a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> WithCallStack a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> WithCallStack a -> b
foldr :: forall a b. (a -> b -> b) -> b -> WithCallStack a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> WithCallStack a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> WithCallStack a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> WithCallStack a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> WithCallStack a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> WithCallStack a -> m
fold :: forall m. Monoid m => WithCallStack m -> m
$cfold :: forall m. Monoid m => WithCallStack m -> m
Foldable,Int -> WithCallStack a -> ShowS
forall a. Show a => Int -> WithCallStack a -> ShowS
forall a. Show a => [WithCallStack a] -> ShowS
forall a. Show a => WithCallStack a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WithCallStack a] -> ShowS
$cshowList :: forall a. Show a => [WithCallStack a] -> ShowS
show :: WithCallStack a -> String
$cshow :: forall a. Show a => WithCallStack a -> String
showsPrec :: Int -> WithCallStack a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> WithCallStack a -> ShowS
Show)
renderWithCallStack :: (a -> PP.Doc ann) -> WithCallStack a -> PP.Doc ann
renderWithCallStack :: forall a ann. (a -> Doc ann) -> WithCallStack a -> Doc ann
renderWithCallStack a -> Doc ann
k (WithCallStack CallStack
stack a
msg) =
a -> Doc ann
k a
msg forall a. Semigroup a => a -> a -> a
<> forall ann. Doc ann
PP.line forall a. Semigroup a => a -> a -> a
<> forall ann. Int -> Doc ann -> Doc ann
PP.indent Int
2 (forall ann. [(String, SrcLoc)] -> Doc ann
prettyCallStack (CallStack -> [(String, SrcLoc)]
getCallStack CallStack
stack))
#if MIN_VERSION_base(4, 9, 0)
showSrcLoc :: SrcLoc -> String
showSrcLoc :: SrcLoc -> String
showSrcLoc = SrcLoc -> String
prettySrcLoc
#endif
prettyCallStack :: [(String,SrcLoc)] -> PP.Doc ann
prettyCallStack :: forall ann. [(String, SrcLoc)] -> Doc ann
prettyCallStack [] = Doc ann
"empty callstack"
prettyCallStack ((String, SrcLoc)
root:[(String, SrcLoc)]
rest) =
forall {ann}. (String, SrcLoc) -> Doc ann
prettyCallSite (String, SrcLoc)
root forall a. Semigroup a => a -> a -> a
<> forall ann. Doc ann
PP.line forall a. Semigroup a => a -> a -> a
<> forall ann. Int -> Doc ann -> Doc ann
PP.indent Int
2 (forall ann. [Doc ann] -> Doc ann
PP.vsep (forall a b. (a -> b) -> [a] -> [b]
map forall {ann}. (String, SrcLoc) -> Doc ann
prettyCallSite [(String, SrcLoc)]
rest))
where prettyCallSite :: (String, SrcLoc) -> Doc ann
prettyCallSite (String
f,SrcLoc
loc) =
forall a ann. Pretty a => a -> Doc ann
PP.pretty (String -> Text
LT.pack String
f) forall a. Semigroup a => a -> a -> a
<> Doc ann
", called at " forall a. Semigroup a => a -> a -> a
<>
forall a ann. Pretty a => a -> Doc ann
PP.pretty (String -> Text
LT.pack (SrcLoc -> String
showSrcLoc SrcLoc
loc))
withCallStack :: (?stack :: CallStack) => a -> WithCallStack a
withCallStack :: forall a. (?stack::CallStack) => a -> WithCallStack a
withCallStack = forall a. CallStack -> a -> WithCallStack a
WithCallStack ?stack::CallStack
?stack
newtype LoggingT message m a =
LoggingT (ReaderT (Handler m message) m a)
deriving (forall a. a -> LoggingT message m a
forall a b.
LoggingT message m a
-> LoggingT message m b -> LoggingT message m b
forall a b.
LoggingT message m a
-> (a -> LoggingT message m b) -> LoggingT message m b
forall {message} {m :: * -> *}.
Monad m =>
Applicative (LoggingT message m)
forall message (m :: * -> *) a.
Monad m =>
a -> LoggingT message m a
forall message (m :: * -> *) a b.
Monad m =>
LoggingT message m a
-> LoggingT message m b -> LoggingT message m b
forall message (m :: * -> *) a b.
Monad m =>
LoggingT message m a
-> (a -> LoggingT message m b) -> LoggingT message m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: forall a. a -> LoggingT message m a
$creturn :: forall message (m :: * -> *) a.
Monad m =>
a -> LoggingT message m a
>> :: forall a b.
LoggingT message m a
-> LoggingT message m b -> LoggingT message m b
$c>> :: forall message (m :: * -> *) a b.
Monad m =>
LoggingT message m a
-> LoggingT message m b -> LoggingT message m b
>>= :: forall a b.
LoggingT message m a
-> (a -> LoggingT message m b) -> LoggingT message m b
$c>>= :: forall message (m :: * -> *) a b.
Monad m =>
LoggingT message m a
-> (a -> LoggingT message m b) -> LoggingT message m b
Monad,forall a. a -> LoggingT message m a
forall a b.
LoggingT message m a
-> LoggingT message m b -> LoggingT message m a
forall a b.
LoggingT message m a
-> LoggingT message m b -> LoggingT message m b
forall a b.
LoggingT message m (a -> b)
-> LoggingT message m a -> LoggingT message m b
forall a b c.
(a -> b -> c)
-> LoggingT message m a
-> LoggingT message m b
-> LoggingT message m c
forall {message} {m :: * -> *}.
Applicative m =>
Functor (LoggingT message m)
forall message (m :: * -> *) a.
Applicative m =>
a -> LoggingT message m a
forall message (m :: * -> *) a b.
Applicative m =>
LoggingT message m a
-> LoggingT message m b -> LoggingT message m a
forall message (m :: * -> *) a b.
Applicative m =>
LoggingT message m a
-> LoggingT message m b -> LoggingT message m b
forall message (m :: * -> *) a b.
Applicative m =>
LoggingT message m (a -> b)
-> LoggingT message m a -> LoggingT message m b
forall message (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> LoggingT message m a
-> LoggingT message m b
-> LoggingT message m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: forall a b.
LoggingT message m a
-> LoggingT message m b -> LoggingT message m a
$c<* :: forall message (m :: * -> *) a b.
Applicative m =>
LoggingT message m a
-> LoggingT message m b -> LoggingT message m a
*> :: forall a b.
LoggingT message m a
-> LoggingT message m b -> LoggingT message m b
$c*> :: forall message (m :: * -> *) a b.
Applicative m =>
LoggingT message m a
-> LoggingT message m b -> LoggingT message m b
liftA2 :: forall a b c.
(a -> b -> c)
-> LoggingT message m a
-> LoggingT message m b
-> LoggingT message m c
$cliftA2 :: forall message (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> LoggingT message m a
-> LoggingT message m b
-> LoggingT message m c
<*> :: forall a b.
LoggingT message m (a -> b)
-> LoggingT message m a -> LoggingT message m b
$c<*> :: forall message (m :: * -> *) a b.
Applicative m =>
LoggingT message m (a -> b)
-> LoggingT message m a -> LoggingT message m b
pure :: forall a. a -> LoggingT message m a
$cpure :: forall message (m :: * -> *) a.
Applicative m =>
a -> LoggingT message m a
Applicative,forall a b. a -> LoggingT message m b -> LoggingT message m a
forall a b.
(a -> b) -> LoggingT message m a -> LoggingT message m b
forall message (m :: * -> *) a b.
Functor m =>
a -> LoggingT message m b -> LoggingT message m a
forall message (m :: * -> *) a b.
Functor m =>
(a -> b) -> LoggingT message m a -> LoggingT message m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> LoggingT message m b -> LoggingT message m a
$c<$ :: forall message (m :: * -> *) a b.
Functor m =>
a -> LoggingT message m b -> LoggingT message m a
fmap :: forall a b.
(a -> b) -> LoggingT message m a -> LoggingT message m b
$cfmap :: forall message (m :: * -> *) a b.
Functor m =>
(a -> b) -> LoggingT message m a -> LoggingT message m b
Functor,forall a. (a -> LoggingT message m a) -> LoggingT message m a
forall {message} {m :: * -> *}.
MonadFix m =>
Monad (LoggingT message m)
forall message (m :: * -> *) a.
MonadFix m =>
(a -> LoggingT message m a) -> LoggingT message m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: forall a. (a -> LoggingT message m a) -> LoggingT message m a
$cmfix :: forall message (m :: * -> *) a.
MonadFix m =>
(a -> LoggingT message m a) -> LoggingT message m a
MonadFix,forall a. LoggingT message m a
forall a. LoggingT message m a -> LoggingT message m [a]
forall a.
LoggingT message m a
-> LoggingT message m a -> LoggingT message m a
forall {message} {m :: * -> *}.
Alternative m =>
Applicative (LoggingT message m)
forall message (m :: * -> *) a.
Alternative m =>
LoggingT message m a
forall message (m :: * -> *) a.
Alternative m =>
LoggingT message m a -> LoggingT message m [a]
forall message (m :: * -> *) a.
Alternative m =>
LoggingT message m a
-> LoggingT message m a -> LoggingT message m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
many :: forall a. LoggingT message m a -> LoggingT message m [a]
$cmany :: forall message (m :: * -> *) a.
Alternative m =>
LoggingT message m a -> LoggingT message m [a]
some :: forall a. LoggingT message m a -> LoggingT message m [a]
$csome :: forall message (m :: * -> *) a.
Alternative m =>
LoggingT message m a -> LoggingT message m [a]
<|> :: forall a.
LoggingT message m a
-> LoggingT message m a -> LoggingT message m a
$c<|> :: forall message (m :: * -> *) a.
Alternative m =>
LoggingT message m a
-> LoggingT message m a -> LoggingT message m a
empty :: forall a. LoggingT message m a
$cempty :: forall message (m :: * -> *) a.
Alternative m =>
LoggingT message m a
Alternative,forall a. LoggingT message m a
forall a.
LoggingT message m a
-> LoggingT message m a -> LoggingT message m a
forall {message} {m :: * -> *}.
MonadPlus m =>
Monad (LoggingT message m)
forall {message} {m :: * -> *}.
MonadPlus m =>
Alternative (LoggingT message m)
forall message (m :: * -> *) a. MonadPlus m => LoggingT message m a
forall message (m :: * -> *) a.
MonadPlus m =>
LoggingT message m a
-> LoggingT message m a -> LoggingT message m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
mplus :: forall a.
LoggingT message m a
-> LoggingT message m a -> LoggingT message m a
$cmplus :: forall message (m :: * -> *) a.
MonadPlus m =>
LoggingT message m a
-> LoggingT message m a -> LoggingT message m a
mzero :: forall a. LoggingT message m a
$cmzero :: forall message (m :: * -> *) a. MonadPlus m => LoggingT message m a
MonadPlus,forall a. IO a -> LoggingT message m a
forall {message} {m :: * -> *}.
MonadIO m =>
Monad (LoggingT message m)
forall message (m :: * -> *) a.
MonadIO m =>
IO a -> LoggingT message m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: forall a. IO a -> LoggingT message m a
$cliftIO :: forall message (m :: * -> *) a.
MonadIO m =>
IO a -> LoggingT message m a
MonadIO,forall b.
((forall a. LoggingT message m a -> IO a) -> IO b)
-> LoggingT message m b
forall {message} {m :: * -> *}.
MonadUnliftIO m =>
MonadIO (LoggingT message m)
forall message (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. LoggingT message m a -> IO a) -> IO b)
-> LoggingT message m b
forall (m :: * -> *).
MonadIO m
-> (forall b. ((forall a. m a -> IO a) -> IO b) -> m b)
-> MonadUnliftIO m
withRunInIO :: forall b.
((forall a. LoggingT message m a -> IO a) -> IO b)
-> LoggingT message m b
$cwithRunInIO :: forall message (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. LoggingT message m a -> IO a) -> IO b)
-> LoggingT message m b
MonadUnliftIO,MonadWriter w,forall a b.
((a -> LoggingT message m b) -> LoggingT message m a)
-> LoggingT message m a
forall {message} {m :: * -> *}.
MonadCont m =>
Monad (LoggingT message m)
forall message (m :: * -> *) a b.
MonadCont m =>
((a -> LoggingT message m b) -> LoggingT message m a)
-> LoggingT message m a
forall (m :: * -> *).
Monad m -> (forall a b. ((a -> m b) -> m a) -> m a) -> MonadCont m
callCC :: forall a b.
((a -> LoggingT message m b) -> LoggingT message m a)
-> LoggingT message m a
$ccallCC :: forall message (m :: * -> *) a b.
MonadCont m =>
((a -> LoggingT message m b) -> LoggingT message m a)
-> LoggingT message m a
MonadCont,MonadError e,forall b.
((forall a. LoggingT message m a -> LoggingT message m a)
-> LoggingT message m b)
-> LoggingT message m b
forall a b c.
LoggingT message m a
-> (a -> ExitCase b -> LoggingT message m c)
-> (a -> LoggingT message m b)
-> LoggingT message m (b, c)
forall {message} {m :: * -> *}.
MonadMask m =>
MonadCatch (LoggingT message m)
forall message (m :: * -> *) b.
MonadMask m =>
((forall a. LoggingT message m a -> LoggingT message m a)
-> LoggingT message m b)
-> LoggingT message m b
forall message (m :: * -> *) a b c.
MonadMask m =>
LoggingT message m a
-> (a -> ExitCase b -> LoggingT message m c)
-> (a -> LoggingT message m b)
-> LoggingT message m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: forall a b c.
LoggingT message m a
-> (a -> ExitCase b -> LoggingT message m c)
-> (a -> LoggingT message m b)
-> LoggingT message m (b, c)
$cgeneralBracket :: forall message (m :: * -> *) a b c.
MonadMask m =>
LoggingT message m a
-> (a -> ExitCase b -> LoggingT message m c)
-> (a -> LoggingT message m b)
-> LoggingT message m (b, c)
uninterruptibleMask :: forall b.
((forall a. LoggingT message m a -> LoggingT message m a)
-> LoggingT message m b)
-> LoggingT message m b
$cuninterruptibleMask :: forall message (m :: * -> *) b.
MonadMask m =>
((forall a. LoggingT message m a -> LoggingT message m a)
-> LoggingT message m b)
-> LoggingT message m b
mask :: forall b.
((forall a. LoggingT message m a -> LoggingT message m a)
-> LoggingT message m b)
-> LoggingT message m b
$cmask :: forall message (m :: * -> *) b.
MonadMask m =>
((forall a. LoggingT message m a -> LoggingT message m a)
-> LoggingT message m b)
-> LoggingT message m b
MonadMask,forall e a.
Exception e =>
LoggingT message m a
-> (e -> LoggingT message m a) -> LoggingT message m a
forall {message} {m :: * -> *}.
MonadCatch m =>
MonadThrow (LoggingT message m)
forall message (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
LoggingT message m a
-> (e -> LoggingT message m a) -> LoggingT message m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: forall e a.
Exception e =>
LoggingT message m a
-> (e -> LoggingT message m a) -> LoggingT message m a
$ccatch :: forall message (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
LoggingT message m a
-> (e -> LoggingT message m a) -> LoggingT message m a
MonadCatch,forall e a. Exception e => e -> LoggingT message m a
forall {message} {m :: * -> *}.
MonadThrow m =>
Monad (LoggingT message m)
forall message (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> LoggingT message m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: forall e a. Exception e => e -> LoggingT message m a
$cthrowM :: forall message (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> LoggingT message m a
MonadThrow,MonadState s, forall a. String -> LoggingT message m a
forall {message} {m :: * -> *}.
MonadFail m =>
Monad (LoggingT message m)
forall message (m :: * -> *) a.
MonadFail m =>
String -> LoggingT message m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
fail :: forall a. String -> LoggingT message m a
$cfail :: forall message (m :: * -> *) a.
MonadFail m =>
String -> LoggingT message m a
Fail.MonadFail)
instance MonadBase b m => MonadBase b (LoggingT message m) where
liftBase :: forall α. b α -> LoggingT message m α
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase
instance MonadBaseControl b m => MonadBaseControl b (LoggingT message m) where
type StM (LoggingT message m) a = StM m a
liftBaseWith :: forall a.
(RunInBase (LoggingT message m) b -> b a) -> LoggingT message m a
liftBaseWith RunInBase (LoggingT message m) b -> b a
runInBase =
forall message (m :: * -> *) a.
ReaderT (Handler m message) m a -> LoggingT message m a
LoggingT (forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT (\Handler m message
handler ->
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
(RunInBase m b -> b a) -> m a
liftBaseWith
(\RunInBase m b
runInReader ->
RunInBase (LoggingT message m) b -> b a
runInBase (\(LoggingT (ReaderT Handler m message -> m a
m)) ->
RunInBase m b
runInReader (Handler m message -> m a
m Handler m message
handler)))))
restoreM :: forall a. StM (LoggingT message m) a -> LoggingT message m a
restoreM StM (LoggingT message m) a
st = forall message (m :: * -> *) a.
ReaderT (Handler m message) m a -> LoggingT message m a
LoggingT (forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT (\Handler m message
_ -> forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
StM m a -> m a
restoreM StM (LoggingT message m) a
st))
runLoggingT
:: LoggingT message m a -> Handler m message -> m a
runLoggingT :: forall message (m :: * -> *) a.
LoggingT message m a -> Handler m message -> m a
runLoggingT (LoggingT (ReaderT Handler m message -> m a
m)) Handler m message
handler = Handler m message -> m a
m Handler m message
handler
{-# INLINEABLE runLoggingT #-}
instance MonadTrans (LoggingT message) where
lift :: forall (m :: * -> *) a. Monad m => m a -> LoggingT message m a
lift = forall message (m :: * -> *) a.
ReaderT (Handler m message) m a -> LoggingT message m a
LoggingT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const
{-# INLINEABLE lift #-}
instance MonadReader r m => MonadReader r (LoggingT message m) where
ask :: LoggingT message m r
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall r (m :: * -> *). MonadReader r m => m r
ask
{-# INLINEABLE ask #-}
local :: forall a. (r -> r) -> LoggingT message m a -> LoggingT message m a
local r -> r
f (LoggingT (ReaderT Handler m message -> m a
m)) = forall message (m :: * -> *) a.
ReaderT (Handler m message) m a -> LoggingT message m a
LoggingT (forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT (forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r -> r
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handler m message -> m a
m))
{-# INLINEABLE local #-}
reader :: forall a. (r -> a) -> LoggingT message m a
reader r -> a
f = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader r -> a
f)
{-# INLINEABLE reader #-}
newtype Ap m = Ap { forall (m :: * -> *). Ap m -> m ()
runAp :: m () }
instance Applicative m => Semigroup (Ap m) where
Ap m ()
l <> :: Ap m -> Ap m -> Ap m
<> Ap m ()
r = forall (m :: * -> *). m () -> Ap m
Ap (m ()
l forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m ()
r)
{-# INLINEABLE (<>) #-}
instance Applicative m => Monoid (Ap m) where
mempty :: Ap m
mempty = forall (m :: * -> *). m () -> Ap m
Ap (forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
{-# INLINEABLE mempty #-}
#if !(MIN_VERSION_base(4,11,0))
Ap l `mappend` Ap r = Ap (l *> r)
{-# INLINEABLE mappend #-}
#endif
instance Monad m => MonadLog message (LoggingT message m) where
logMessageFree :: (forall n. Monoid n => (message -> n) -> n)
-> LoggingT message m ()
logMessageFree forall n. Monoid n => (message -> n) -> n
foldMap = forall message (m :: * -> *) a.
ReaderT (Handler m message) m a -> LoggingT message m a
LoggingT (forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT (\Handler m message
handler -> forall (m :: * -> *). Ap m -> m ()
runAp (forall n. Monoid n => (message -> n) -> n
foldMap (forall (m :: * -> *). m () -> Ap m
Ap forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handler m message
handler))))
{-# INLINEABLE logMessageFree #-}
instance MonadRWS r w s m => MonadRWS r w s (LoggingT message m)
instance (Functor f,MonadFree f m) => MonadFree f (LoggingT message m)
mapLoggingT :: (forall x. (Handler m message -> m x) -> (Handler n message' -> n x))
-> LoggingT message m a
-> LoggingT message' n a
mapLoggingT :: forall (m :: * -> *) message (n :: * -> *) message' a.
(forall x. (Handler m message -> m x) -> Handler n message' -> n x)
-> LoggingT message m a -> LoggingT message' n a
mapLoggingT forall x. (Handler m message -> m x) -> Handler n message' -> n x
eta (LoggingT (ReaderT Handler m message -> m a
f)) = forall message (m :: * -> *) a.
ReaderT (Handler m message) m a -> LoggingT message m a
LoggingT (forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT (forall x. (Handler m message -> m x) -> Handler n message' -> n x
eta Handler m message -> m a
f))
{-# INLINEABLE mapLoggingT #-}
type Handler m message = message -> m ()
data BatchingOptions =
BatchingOptions {BatchingOptions -> Int
flushMaxDelay :: Int
,BatchingOptions -> Int
flushMaxQueueSize :: Int
,BatchingOptions -> Bool
blockWhenFull :: Bool
}
deriving (BatchingOptions -> BatchingOptions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BatchingOptions -> BatchingOptions -> Bool
$c/= :: BatchingOptions -> BatchingOptions -> Bool
== :: BatchingOptions -> BatchingOptions -> Bool
$c== :: BatchingOptions -> BatchingOptions -> Bool
Eq,Eq BatchingOptions
BatchingOptions -> BatchingOptions -> Bool
BatchingOptions -> BatchingOptions -> Ordering
BatchingOptions -> BatchingOptions -> BatchingOptions
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BatchingOptions -> BatchingOptions -> BatchingOptions
$cmin :: BatchingOptions -> BatchingOptions -> BatchingOptions
max :: BatchingOptions -> BatchingOptions -> BatchingOptions
$cmax :: BatchingOptions -> BatchingOptions -> BatchingOptions
>= :: BatchingOptions -> BatchingOptions -> Bool
$c>= :: BatchingOptions -> BatchingOptions -> Bool
> :: BatchingOptions -> BatchingOptions -> Bool
$c> :: BatchingOptions -> BatchingOptions -> Bool
<= :: BatchingOptions -> BatchingOptions -> Bool
$c<= :: BatchingOptions -> BatchingOptions -> Bool
< :: BatchingOptions -> BatchingOptions -> Bool
$c< :: BatchingOptions -> BatchingOptions -> Bool
compare :: BatchingOptions -> BatchingOptions -> Ordering
$ccompare :: BatchingOptions -> BatchingOptions -> Ordering
Ord,ReadPrec [BatchingOptions]
ReadPrec BatchingOptions
Int -> ReadS BatchingOptions
ReadS [BatchingOptions]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BatchingOptions]
$creadListPrec :: ReadPrec [BatchingOptions]
readPrec :: ReadPrec BatchingOptions
$creadPrec :: ReadPrec BatchingOptions
readList :: ReadS [BatchingOptions]
$creadList :: ReadS [BatchingOptions]
readsPrec :: Int -> ReadS BatchingOptions
$creadsPrec :: Int -> ReadS BatchingOptions
Read,Int -> BatchingOptions -> ShowS
[BatchingOptions] -> ShowS
BatchingOptions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BatchingOptions] -> ShowS
$cshowList :: [BatchingOptions] -> ShowS
show :: BatchingOptions -> String
$cshow :: BatchingOptions -> String
showsPrec :: Int -> BatchingOptions -> ShowS
$cshowsPrec :: Int -> BatchingOptions -> ShowS
Show)
defaultBatchingOptions :: BatchingOptions
defaultBatchingOptions :: BatchingOptions
defaultBatchingOptions = Int -> Int -> Bool -> BatchingOptions
BatchingOptions Int
1000000 Int
100 Bool
True
withBatchedHandler :: (MonadIO io,MonadMask io)
=> BatchingOptions
-> (NEL.NonEmpty message -> IO ())
-> (Handler io message -> io a)
-> io a
withBatchedHandler :: forall (io :: * -> *) message a.
(MonadIO io, MonadMask io) =>
BatchingOptions
-> (NonEmpty message -> IO ())
-> (Handler io message -> io a)
-> io a
withBatchedHandler BatchingOptions{Bool
Int
blockWhenFull :: Bool
flushMaxQueueSize :: Int
flushMaxDelay :: Int
blockWhenFull :: BatchingOptions -> Bool
flushMaxQueueSize :: BatchingOptions -> Int
flushMaxDelay :: BatchingOptions -> Int
..} NonEmpty message -> IO ()
flush Handler io message -> io a
k =
do TVar Bool
closed <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (forall a. a -> IO (TVar a)
newTVarIO Bool
False)
TBQueue message
channel <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (forall a. Natural -> IO (TBQueue a)
newTBQueueIO (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
flushMaxQueueSize))
forall (m :: * -> *) a c b.
MonadMask m =>
m a -> (a -> m c) -> (a -> m b) -> m b
bracket (forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (forall a. IO a -> IO (Async a)
async (forall {m :: * -> *}. Monad m => m Bool -> m ()
repeatWhileTrue (TVar Bool -> TBQueue message -> IO Bool
publish TVar Bool
closed TBQueue message
channel))))
(\Async ()
publisher ->
do forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (do forall a. STM a -> IO a
atomically (forall a. TVar a -> a -> STM ()
writeTVar TVar Bool
closed Bool
True)
forall a. Async a -> IO a
wait Async ()
publisher))
(\Async ()
_ ->
Handler io message -> io a
k (\message
msg ->
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (forall a. STM a -> IO a
atomically
(forall a. TBQueue a -> a -> STM ()
writeTBQueue TBQueue message
channel message
msg forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
Bool -> STM ()
check (Bool -> Bool
not Bool
blockWhenFull)))))
where repeatWhileTrue :: m Bool -> m ()
repeatWhileTrue m Bool
m =
do Bool
again <- m Bool
m
if Bool
again
then m Bool -> m ()
repeatWhileTrue m Bool
m
else forall (m :: * -> *) a. Monad m => a -> m a
return ()
publish :: TVar Bool -> TBQueue message -> IO Bool
publish TVar Bool
closed TBQueue message
channel =
do Delay
flushAlarm <- Int -> IO Delay
newDelay Int
flushMaxDelay
([message]
messages,Bool
stillOpen) <-
forall a. STM a -> IO a
atomically
(do [message]
messages <-
Delay -> STM [message]
flushAfter Delay
flushAlarm forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> STM [message]
flushFull forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> STM [message]
flushOnClose
Bool
stillOpen <- forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> Bool
not (forall a. TVar a -> STM a
readTVar TVar Bool
closed)
forall (m :: * -> *) a. Monad m => a -> m a
return ([message]
messages,Bool
stillOpen))
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ NonEmpty message -> IO ()
flush (forall a. [a] -> Maybe (NonEmpty a)
NEL.nonEmpty [message]
messages)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
stillOpen
where flushAfter :: Delay -> STM [message]
flushAfter Delay
flushAlarm =
do Delay -> STM ()
waitDelay Delay
flushAlarm
forall a. TBQueue a -> STM Bool
isEmptyTBQueue TBQueue message
channel forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (f :: * -> *). Alternative f => Bool -> f ()
guard forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Bool
not
forall {a}. TBQueue a -> STM [a]
emptyTBQueue TBQueue message
channel
flushFull :: STM [message]
flushFull =
do forall a. TBQueue a -> STM Bool
isFullTBQueue TBQueue message
channel forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (f :: * -> *). Alternative f => Bool -> f ()
guard
forall {a}. TBQueue a -> STM [a]
emptyTBQueue TBQueue message
channel
flushOnClose :: STM [message]
flushOnClose =
do forall a. TVar a -> STM a
readTVar TVar Bool
closed forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (f :: * -> *). Alternative f => Bool -> f ()
guard
forall {a}. TBQueue a -> STM [a]
emptyTBQueue TBQueue message
channel
emptyTBQueue :: TBQueue a -> STM [a]
emptyTBQueue TBQueue a
q =
do Maybe a
mx <- forall a. TBQueue a -> STM (Maybe a)
tryReadTBQueue TBQueue a
q
case Maybe a
mx of
Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return []
Just a
x -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a
x forall a. a -> [a] -> [a]
:) (TBQueue a -> STM [a]
emptyTBQueue TBQueue a
q)
withFDHandler
:: (MonadIO io,MonadMask io)
=> BatchingOptions
-> Handle
-> Double
-> Int
-> (Handler io (PP.Doc ann) -> io a)
-> io a
withFDHandler :: forall (io :: * -> *) ann a.
(MonadIO io, MonadMask io) =>
BatchingOptions
-> Handle
-> Double
-> Int
-> (Handler io (Doc ann) -> io a)
-> io a
withFDHandler BatchingOptions
options Handle
fd Double
ribbonFrac Int
width = forall (io :: * -> *) message a.
(MonadIO io, MonadMask io) =>
BatchingOptions
-> (NonEmpty message -> IO ())
-> (Handler io message -> io a)
-> io a
withBatchedHandler BatchingOptions
options NonEmpty (Doc ann) -> IO ()
flush
where
flush :: NonEmpty (Doc ann) -> IO ()
flush NonEmpty (Doc ann)
messages = do
forall ann. Handle -> SimpleDocStream ann -> IO ()
PP.renderIO
Handle
fd
(forall ann. LayoutOptions -> Doc ann -> SimpleDocStream ann
PP.layoutPretty
(PageWidth -> LayoutOptions
PP.LayoutOptions (Int -> Double -> PageWidth
PP.AvailablePerLine Int
width Double
ribbonFrac))
(forall ann. [Doc ann] -> Doc ann
PP.vsep (forall a. NonEmpty a -> [a]
NEL.toList NonEmpty (Doc ann)
messages) forall a. Semigroup a => a -> a -> a
<> forall ann. Doc ann
PP.line'))
Handle -> IO ()
hFlush Handle
fd
newtype PureLoggingT log m a = MkPureLoggingT (StateT log m a)
deriving (forall a b. a -> PureLoggingT log m b -> PureLoggingT log m a
forall a b.
(a -> b) -> PureLoggingT log m a -> PureLoggingT log m b
forall log (m :: * -> *) a b.
Functor m =>
a -> PureLoggingT log m b -> PureLoggingT log m a
forall log (m :: * -> *) a b.
Functor m =>
(a -> b) -> PureLoggingT log m a -> PureLoggingT log m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> PureLoggingT log m b -> PureLoggingT log m a
$c<$ :: forall log (m :: * -> *) a b.
Functor m =>
a -> PureLoggingT log m b -> PureLoggingT log m a
fmap :: forall a b.
(a -> b) -> PureLoggingT log m a -> PureLoggingT log m b
$cfmap :: forall log (m :: * -> *) a b.
Functor m =>
(a -> b) -> PureLoggingT log m a -> PureLoggingT log m b
Functor,forall a. a -> PureLoggingT log m a
forall a b.
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m a
forall a b.
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m b
forall a b.
PureLoggingT log m (a -> b)
-> PureLoggingT log m a -> PureLoggingT log m b
forall a b c.
(a -> b -> c)
-> PureLoggingT log m a
-> PureLoggingT log m b
-> PureLoggingT log m c
forall {log} {m :: * -> *}. Monad m => Functor (PureLoggingT log m)
forall log (m :: * -> *) a. Monad m => a -> PureLoggingT log m a
forall log (m :: * -> *) a b.
Monad m =>
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m a
forall log (m :: * -> *) a b.
Monad m =>
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m b
forall log (m :: * -> *) a b.
Monad m =>
PureLoggingT log m (a -> b)
-> PureLoggingT log m a -> PureLoggingT log m b
forall log (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> PureLoggingT log m a
-> PureLoggingT log m b
-> PureLoggingT log m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: forall a b.
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m a
$c<* :: forall log (m :: * -> *) a b.
Monad m =>
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m a
*> :: forall a b.
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m b
$c*> :: forall log (m :: * -> *) a b.
Monad m =>
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m b
liftA2 :: forall a b c.
(a -> b -> c)
-> PureLoggingT log m a
-> PureLoggingT log m b
-> PureLoggingT log m c
$cliftA2 :: forall log (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> PureLoggingT log m a
-> PureLoggingT log m b
-> PureLoggingT log m c
<*> :: forall a b.
PureLoggingT log m (a -> b)
-> PureLoggingT log m a -> PureLoggingT log m b
$c<*> :: forall log (m :: * -> *) a b.
Monad m =>
PureLoggingT log m (a -> b)
-> PureLoggingT log m a -> PureLoggingT log m b
pure :: forall a. a -> PureLoggingT log m a
$cpure :: forall log (m :: * -> *) a. Monad m => a -> PureLoggingT log m a
Applicative,forall a. a -> PureLoggingT log m a
forall a b.
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m b
forall a b.
PureLoggingT log m a
-> (a -> PureLoggingT log m b) -> PureLoggingT log m b
forall log (m :: * -> *).
Monad m =>
Applicative (PureLoggingT log m)
forall log (m :: * -> *) a. Monad m => a -> PureLoggingT log m a
forall log (m :: * -> *) a b.
Monad m =>
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m b
forall log (m :: * -> *) a b.
Monad m =>
PureLoggingT log m a
-> (a -> PureLoggingT log m b) -> PureLoggingT log m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: forall a. a -> PureLoggingT log m a
$creturn :: forall log (m :: * -> *) a. Monad m => a -> PureLoggingT log m a
>> :: forall a b.
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m b
$c>> :: forall log (m :: * -> *) a b.
Monad m =>
PureLoggingT log m a
-> PureLoggingT log m b -> PureLoggingT log m b
>>= :: forall a b.
PureLoggingT log m a
-> (a -> PureLoggingT log m b) -> PureLoggingT log m b
$c>>= :: forall log (m :: * -> *) a b.
Monad m =>
PureLoggingT log m a
-> (a -> PureLoggingT log m b) -> PureLoggingT log m b
Monad,forall a. (a -> PureLoggingT log m a) -> PureLoggingT log m a
forall {log} {m :: * -> *}.
MonadFix m =>
Monad (PureLoggingT log m)
forall log (m :: * -> *) a.
MonadFix m =>
(a -> PureLoggingT log m a) -> PureLoggingT log m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: forall a. (a -> PureLoggingT log m a) -> PureLoggingT log m a
$cmfix :: forall log (m :: * -> *) a.
MonadFix m =>
(a -> PureLoggingT log m a) -> PureLoggingT log m a
MonadFix,forall e a.
Exception e =>
PureLoggingT log m a
-> (e -> PureLoggingT log m a) -> PureLoggingT log m a
forall {log} {m :: * -> *}.
MonadCatch m =>
MonadThrow (PureLoggingT log m)
forall log (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
PureLoggingT log m a
-> (e -> PureLoggingT log m a) -> PureLoggingT log m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: forall e a.
Exception e =>
PureLoggingT log m a
-> (e -> PureLoggingT log m a) -> PureLoggingT log m a
$ccatch :: forall log (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
PureLoggingT log m a
-> (e -> PureLoggingT log m a) -> PureLoggingT log m a
MonadCatch,forall e a. Exception e => e -> PureLoggingT log m a
forall {log} {m :: * -> *}.
MonadThrow m =>
Monad (PureLoggingT log m)
forall log (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> PureLoggingT log m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: forall e a. Exception e => e -> PureLoggingT log m a
$cthrowM :: forall log (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> PureLoggingT log m a
MonadThrow,forall a. IO a -> PureLoggingT log m a
forall {log} {m :: * -> *}. MonadIO m => Monad (PureLoggingT log m)
forall log (m :: * -> *) a.
MonadIO m =>
IO a -> PureLoggingT log m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: forall a. IO a -> PureLoggingT log m a
$cliftIO :: forall log (m :: * -> *) a.
MonadIO m =>
IO a -> PureLoggingT log m a
MonadIO,forall b.
((forall a. PureLoggingT log m a -> PureLoggingT log m a)
-> PureLoggingT log m b)
-> PureLoggingT log m b
forall a b c.
PureLoggingT log m a
-> (a -> ExitCase b -> PureLoggingT log m c)
-> (a -> PureLoggingT log m b)
-> PureLoggingT log m (b, c)
forall {log} {m :: * -> *}.
MonadMask m =>
MonadCatch (PureLoggingT log m)
forall log (m :: * -> *) b.
MonadMask m =>
((forall a. PureLoggingT log m a -> PureLoggingT log m a)
-> PureLoggingT log m b)
-> PureLoggingT log m b
forall log (m :: * -> *) a b c.
MonadMask m =>
PureLoggingT log m a
-> (a -> ExitCase b -> PureLoggingT log m c)
-> (a -> PureLoggingT log m b)
-> PureLoggingT log m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: forall a b c.
PureLoggingT log m a
-> (a -> ExitCase b -> PureLoggingT log m c)
-> (a -> PureLoggingT log m b)
-> PureLoggingT log m (b, c)
$cgeneralBracket :: forall log (m :: * -> *) a b c.
MonadMask m =>
PureLoggingT log m a
-> (a -> ExitCase b -> PureLoggingT log m c)
-> (a -> PureLoggingT log m b)
-> PureLoggingT log m (b, c)
uninterruptibleMask :: forall b.
((forall a. PureLoggingT log m a -> PureLoggingT log m a)
-> PureLoggingT log m b)
-> PureLoggingT log m b
$cuninterruptibleMask :: forall log (m :: * -> *) b.
MonadMask m =>
((forall a. PureLoggingT log m a -> PureLoggingT log m a)
-> PureLoggingT log m b)
-> PureLoggingT log m b
mask :: forall b.
((forall a. PureLoggingT log m a -> PureLoggingT log m a)
-> PureLoggingT log m b)
-> PureLoggingT log m b
$cmask :: forall log (m :: * -> *) b.
MonadMask m =>
((forall a. PureLoggingT log m a -> PureLoggingT log m a)
-> PureLoggingT log m b)
-> PureLoggingT log m b
MonadMask,MonadReader r,MonadWriter w,forall a b.
((a -> PureLoggingT log m b) -> PureLoggingT log m a)
-> PureLoggingT log m a
forall {log} {m :: * -> *}.
MonadCont m =>
Monad (PureLoggingT log m)
forall log (m :: * -> *) a b.
MonadCont m =>
((a -> PureLoggingT log m b) -> PureLoggingT log m a)
-> PureLoggingT log m a
forall (m :: * -> *).
Monad m -> (forall a b. ((a -> m b) -> m a) -> m a) -> MonadCont m
callCC :: forall a b.
((a -> PureLoggingT log m b) -> PureLoggingT log m a)
-> PureLoggingT log m a
$ccallCC :: forall log (m :: * -> *) a b.
MonadCont m =>
((a -> PureLoggingT log m b) -> PureLoggingT log m a)
-> PureLoggingT log m a
MonadCont,MonadError e,forall a. PureLoggingT log m a
forall a. PureLoggingT log m a -> PureLoggingT log m [a]
forall a.
PureLoggingT log m a
-> PureLoggingT log m a -> PureLoggingT log m a
forall {log} {m :: * -> *}.
MonadPlus m =>
Applicative (PureLoggingT log m)
forall log (m :: * -> *) a. MonadPlus m => PureLoggingT log m a
forall log (m :: * -> *) a.
MonadPlus m =>
PureLoggingT log m a -> PureLoggingT log m [a]
forall log (m :: * -> *) a.
MonadPlus m =>
PureLoggingT log m a
-> PureLoggingT log m a -> PureLoggingT log m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
many :: forall a. PureLoggingT log m a -> PureLoggingT log m [a]
$cmany :: forall log (m :: * -> *) a.
MonadPlus m =>
PureLoggingT log m a -> PureLoggingT log m [a]
some :: forall a. PureLoggingT log m a -> PureLoggingT log m [a]
$csome :: forall log (m :: * -> *) a.
MonadPlus m =>
PureLoggingT log m a -> PureLoggingT log m [a]
<|> :: forall a.
PureLoggingT log m a
-> PureLoggingT log m a -> PureLoggingT log m a
$c<|> :: forall log (m :: * -> *) a.
MonadPlus m =>
PureLoggingT log m a
-> PureLoggingT log m a -> PureLoggingT log m a
empty :: forall a. PureLoggingT log m a
$cempty :: forall log (m :: * -> *) a. MonadPlus m => PureLoggingT log m a
Alternative,forall a. PureLoggingT log m a
forall a.
PureLoggingT log m a
-> PureLoggingT log m a -> PureLoggingT log m a
forall {log} {m :: * -> *}.
MonadPlus m =>
Monad (PureLoggingT log m)
forall log (m :: * -> *).
MonadPlus m =>
Alternative (PureLoggingT log m)
forall log (m :: * -> *) a. MonadPlus m => PureLoggingT log m a
forall log (m :: * -> *) a.
MonadPlus m =>
PureLoggingT log m a
-> PureLoggingT log m a -> PureLoggingT log m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
mplus :: forall a.
PureLoggingT log m a
-> PureLoggingT log m a -> PureLoggingT log m a
$cmplus :: forall log (m :: * -> *) a.
MonadPlus m =>
PureLoggingT log m a
-> PureLoggingT log m a -> PureLoggingT log m a
mzero :: forall a. PureLoggingT log m a
$cmzero :: forall log (m :: * -> *) a. MonadPlus m => PureLoggingT log m a
MonadPlus,forall a. String -> PureLoggingT log m a
forall {log} {m :: * -> *}.
MonadFail m =>
Monad (PureLoggingT log m)
forall log (m :: * -> *) a.
MonadFail m =>
String -> PureLoggingT log m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
fail :: forall a. String -> PureLoggingT log m a
$cfail :: forall log (m :: * -> *) a.
MonadFail m =>
String -> PureLoggingT log m a
Fail.MonadFail)
instance MonadBase b m => MonadBase b (PureLoggingT message m) where
liftBase :: forall α. b α -> PureLoggingT message m α
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase
instance MonadTransControl (PureLoggingT message) where
type StT (PureLoggingT message) a = StT (StateT message) a
liftWith :: forall (m :: * -> *) a.
Monad m =>
(Run (PureLoggingT message) -> m a) -> PureLoggingT message m a
liftWith = forall (m :: * -> *) (n :: (* -> *) -> * -> *)
(t :: (* -> *) -> * -> *) a.
(Monad m, MonadTransControl n) =>
(forall b. n m b -> t m b)
-> (forall (o :: * -> *) b. t o b -> n o b)
-> (RunDefault t n -> m a)
-> t m a
defaultLiftWith forall log (m :: * -> *) a. StateT log m a -> PureLoggingT log m a
MkPureLoggingT (\(MkPureLoggingT StateT message o b
m) -> StateT message o b
m)
restoreT :: forall (m :: * -> *) a.
Monad m =>
m (StT (PureLoggingT message) a) -> PureLoggingT message m a
restoreT = forall (m :: * -> *) (n :: (* -> *) -> * -> *) a
(t :: (* -> *) -> * -> *).
(Monad m, MonadTransControl n) =>
(n m a -> t m a) -> m (StT n a) -> t m a
defaultRestoreT forall log (m :: * -> *) a. StateT log m a -> PureLoggingT log m a
MkPureLoggingT
instance MonadBaseControl b m => MonadBaseControl b (PureLoggingT message m) where
type StM (PureLoggingT message m) a = ComposeSt (PureLoggingT message) m a
liftBaseWith :: forall a.
(RunInBase (PureLoggingT message m) b -> b a)
-> PureLoggingT message m a
liftBaseWith = forall (t :: (* -> *) -> * -> *) (b :: * -> *) (m :: * -> *) a.
(MonadTransControl t, MonadBaseControl b m) =>
(RunInBaseDefault t m b -> b a) -> t m a
defaultLiftBaseWith
restoreM :: forall a.
StM (PureLoggingT message m) a -> PureLoggingT message m a
restoreM = forall (t :: (* -> *) -> * -> *) (b :: * -> *) (m :: * -> *) a.
(MonadTransControl t, MonadBaseControl b m) =>
ComposeSt t m a -> t m a
defaultRestoreM
runPureLoggingT
:: Monoid log
=> PureLoggingT log m a -> m (a,log)
runPureLoggingT :: forall log (m :: * -> *) a.
Monoid log =>
PureLoggingT log m a -> m (a, log)
runPureLoggingT (MkPureLoggingT (StateT log -> m (a, log)
m)) = log -> m (a, log)
m forall a. Monoid a => a
mempty
{-# INLINEABLE runPureLoggingT #-}
mkPureLoggingT
:: (Monad m,Monoid log)
=> m (a,log) -> PureLoggingT log m a
mkPureLoggingT :: forall (m :: * -> *) log a.
(Monad m, Monoid log) =>
m (a, log) -> PureLoggingT log m a
mkPureLoggingT m (a, log)
m =
forall log (m :: * -> *) a. StateT log m a -> PureLoggingT log m a
MkPureLoggingT
(forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT (\log
s ->
do (a
a,log
l) <- m (a, log)
m
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a,forall a. Monoid a => a -> a -> a
mappend log
s log
l)))
{-# INLINEABLE mkPureLoggingT #-}
instance MonadTrans (PureLoggingT log) where
lift :: forall (m :: * -> *) a. Monad m => m a -> PureLoggingT log m a
lift = forall log (m :: * -> *) a. StateT log m a -> PureLoggingT log m a
MkPureLoggingT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
{-# INLINEABLE lift #-}
instance (Functor f, MonadFree f m) => MonadFree f (PureLoggingT log m)
instance (Monad m, Monoid log) => MonadLog log (PureLoggingT log m) where
logMessageFree :: (forall n. Monoid n => (log -> n) -> n) -> PureLoggingT log m ()
logMessageFree forall n. Monoid n => (log -> n) -> n
foldMap = forall (m :: * -> *) log a.
(Monad m, Monoid log) =>
m (a, log) -> PureLoggingT log m a
mkPureLoggingT (forall (m :: * -> *) a. Monad m => a -> m a
return ((), forall n. Monoid n => (log -> n) -> n
foldMap forall a. a -> a
id))
{-# INLINEABLE logMessageFree #-}
instance MonadRWS r w s m => MonadRWS r w s (PureLoggingT message m)
instance MonadState s m => MonadState s (PureLoggingT log m) where
state :: forall a. (s -> (a, s)) -> PureLoggingT log m a
state s -> (a, s)
f = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state s -> (a, s)
f)
{-# INLINEABLE state #-}
get :: PureLoggingT log m s
get = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall s (m :: * -> *). MonadState s m => m s
get
{-# INLINEABLE get #-}
put :: s -> PureLoggingT log m ()
put = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *). MonadState s m => s -> m ()
put
{-# INLINEABLE put #-}
newtype DiscardLoggingT message m a =
DiscardLoggingT {forall message (m :: * -> *) a. DiscardLoggingT message m a -> m a
discardLogging :: m a
}
deriving (forall a b.
a -> DiscardLoggingT message m b -> DiscardLoggingT message m a
forall a b.
(a -> b)
-> DiscardLoggingT message m a -> DiscardLoggingT message m b
forall message (m :: * -> *) a b.
Functor m =>
a -> DiscardLoggingT message m b -> DiscardLoggingT message m a
forall message (m :: * -> *) a b.
Functor m =>
(a -> b)
-> DiscardLoggingT message m a -> DiscardLoggingT message m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b.
a -> DiscardLoggingT message m b -> DiscardLoggingT message m a
$c<$ :: forall message (m :: * -> *) a b.
Functor m =>
a -> DiscardLoggingT message m b -> DiscardLoggingT message m a
fmap :: forall a b.
(a -> b)
-> DiscardLoggingT message m a -> DiscardLoggingT message m b
$cfmap :: forall message (m :: * -> *) a b.
Functor m =>
(a -> b)
-> DiscardLoggingT message m a -> DiscardLoggingT message m b
Functor,forall a. a -> DiscardLoggingT message m a
forall a b.
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m a
forall a b.
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m b
forall a b.
DiscardLoggingT message m (a -> b)
-> DiscardLoggingT message m a -> DiscardLoggingT message m b
forall a b c.
(a -> b -> c)
-> DiscardLoggingT message m a
-> DiscardLoggingT message m b
-> DiscardLoggingT message m c
forall {message} {m :: * -> *}.
Applicative m =>
Functor (DiscardLoggingT message m)
forall message (m :: * -> *) a.
Applicative m =>
a -> DiscardLoggingT message m a
forall message (m :: * -> *) a b.
Applicative m =>
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m a
forall message (m :: * -> *) a b.
Applicative m =>
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m b
forall message (m :: * -> *) a b.
Applicative m =>
DiscardLoggingT message m (a -> b)
-> DiscardLoggingT message m a -> DiscardLoggingT message m b
forall message (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> DiscardLoggingT message m a
-> DiscardLoggingT message m b
-> DiscardLoggingT message m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: forall a b.
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m a
$c<* :: forall message (m :: * -> *) a b.
Applicative m =>
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m a
*> :: forall a b.
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m b
$c*> :: forall message (m :: * -> *) a b.
Applicative m =>
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m b
liftA2 :: forall a b c.
(a -> b -> c)
-> DiscardLoggingT message m a
-> DiscardLoggingT message m b
-> DiscardLoggingT message m c
$cliftA2 :: forall message (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> DiscardLoggingT message m a
-> DiscardLoggingT message m b
-> DiscardLoggingT message m c
<*> :: forall a b.
DiscardLoggingT message m (a -> b)
-> DiscardLoggingT message m a -> DiscardLoggingT message m b
$c<*> :: forall message (m :: * -> *) a b.
Applicative m =>
DiscardLoggingT message m (a -> b)
-> DiscardLoggingT message m a -> DiscardLoggingT message m b
pure :: forall a. a -> DiscardLoggingT message m a
$cpure :: forall message (m :: * -> *) a.
Applicative m =>
a -> DiscardLoggingT message m a
Applicative,forall a. a -> DiscardLoggingT message m a
forall a b.
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m b
forall a b.
DiscardLoggingT message m a
-> (a -> DiscardLoggingT message m b)
-> DiscardLoggingT message m b
forall {message} {m :: * -> *}.
Monad m =>
Applicative (DiscardLoggingT message m)
forall message (m :: * -> *) a.
Monad m =>
a -> DiscardLoggingT message m a
forall message (m :: * -> *) a b.
Monad m =>
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m b
forall message (m :: * -> *) a b.
Monad m =>
DiscardLoggingT message m a
-> (a -> DiscardLoggingT message m b)
-> DiscardLoggingT message m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: forall a. a -> DiscardLoggingT message m a
$creturn :: forall message (m :: * -> *) a.
Monad m =>
a -> DiscardLoggingT message m a
>> :: forall a b.
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m b
$c>> :: forall message (m :: * -> *) a b.
Monad m =>
DiscardLoggingT message m a
-> DiscardLoggingT message m b -> DiscardLoggingT message m b
>>= :: forall a b.
DiscardLoggingT message m a
-> (a -> DiscardLoggingT message m b)
-> DiscardLoggingT message m b
$c>>= :: forall message (m :: * -> *) a b.
Monad m =>
DiscardLoggingT message m a
-> (a -> DiscardLoggingT message m b)
-> DiscardLoggingT message m b
Monad,forall a.
(a -> DiscardLoggingT message m a) -> DiscardLoggingT message m a
forall {message} {m :: * -> *}.
MonadFix m =>
Monad (DiscardLoggingT message m)
forall message (m :: * -> *) a.
MonadFix m =>
(a -> DiscardLoggingT message m a) -> DiscardLoggingT message m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: forall a.
(a -> DiscardLoggingT message m a) -> DiscardLoggingT message m a
$cmfix :: forall message (m :: * -> *) a.
MonadFix m =>
(a -> DiscardLoggingT message m a) -> DiscardLoggingT message m a
MonadFix,forall e a.
Exception e =>
DiscardLoggingT message m a
-> (e -> DiscardLoggingT message m a)
-> DiscardLoggingT message m a
forall {message} {m :: * -> *}.
MonadCatch m =>
MonadThrow (DiscardLoggingT message m)
forall message (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
DiscardLoggingT message m a
-> (e -> DiscardLoggingT message m a)
-> DiscardLoggingT message m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: forall e a.
Exception e =>
DiscardLoggingT message m a
-> (e -> DiscardLoggingT message m a)
-> DiscardLoggingT message m a
$ccatch :: forall message (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
DiscardLoggingT message m a
-> (e -> DiscardLoggingT message m a)
-> DiscardLoggingT message m a
MonadCatch,forall e a. Exception e => e -> DiscardLoggingT message m a
forall {message} {m :: * -> *}.
MonadThrow m =>
Monad (DiscardLoggingT message m)
forall message (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> DiscardLoggingT message m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: forall e a. Exception e => e -> DiscardLoggingT message m a
$cthrowM :: forall message (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> DiscardLoggingT message m a
MonadThrow,forall a. IO a -> DiscardLoggingT message m a
forall {message} {m :: * -> *}.
MonadIO m =>
Monad (DiscardLoggingT message m)
forall message (m :: * -> *) a.
MonadIO m =>
IO a -> DiscardLoggingT message m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: forall a. IO a -> DiscardLoggingT message m a
$cliftIO :: forall message (m :: * -> *) a.
MonadIO m =>
IO a -> DiscardLoggingT message m a
MonadIO,forall b.
((forall a. DiscardLoggingT message m a -> IO a) -> IO b)
-> DiscardLoggingT message m b
forall {message} {m :: * -> *}.
MonadUnliftIO m =>
MonadIO (DiscardLoggingT message m)
forall message (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. DiscardLoggingT message m a -> IO a) -> IO b)
-> DiscardLoggingT message m b
forall (m :: * -> *).
MonadIO m
-> (forall b. ((forall a. m a -> IO a) -> IO b) -> m b)
-> MonadUnliftIO m
withRunInIO :: forall b.
((forall a. DiscardLoggingT message m a -> IO a) -> IO b)
-> DiscardLoggingT message m b
$cwithRunInIO :: forall message (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. DiscardLoggingT message m a -> IO a) -> IO b)
-> DiscardLoggingT message m b
MonadUnliftIO,forall b.
((forall a.
DiscardLoggingT message m a -> DiscardLoggingT message m a)
-> DiscardLoggingT message m b)
-> DiscardLoggingT message m b
forall a b c.
DiscardLoggingT message m a
-> (a -> ExitCase b -> DiscardLoggingT message m c)
-> (a -> DiscardLoggingT message m b)
-> DiscardLoggingT message m (b, c)
forall {message} {m :: * -> *}.
MonadMask m =>
MonadCatch (DiscardLoggingT message m)
forall message (m :: * -> *) b.
MonadMask m =>
((forall a.
DiscardLoggingT message m a -> DiscardLoggingT message m a)
-> DiscardLoggingT message m b)
-> DiscardLoggingT message m b
forall message (m :: * -> *) a b c.
MonadMask m =>
DiscardLoggingT message m a
-> (a -> ExitCase b -> DiscardLoggingT message m c)
-> (a -> DiscardLoggingT message m b)
-> DiscardLoggingT message m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: forall a b c.
DiscardLoggingT message m a
-> (a -> ExitCase b -> DiscardLoggingT message m c)
-> (a -> DiscardLoggingT message m b)
-> DiscardLoggingT message m (b, c)
$cgeneralBracket :: forall message (m :: * -> *) a b c.
MonadMask m =>
DiscardLoggingT message m a
-> (a -> ExitCase b -> DiscardLoggingT message m c)
-> (a -> DiscardLoggingT message m b)
-> DiscardLoggingT message m (b, c)
uninterruptibleMask :: forall b.
((forall a.
DiscardLoggingT message m a -> DiscardLoggingT message m a)
-> DiscardLoggingT message m b)
-> DiscardLoggingT message m b
$cuninterruptibleMask :: forall message (m :: * -> *) b.
MonadMask m =>
((forall a.
DiscardLoggingT message m a -> DiscardLoggingT message m a)
-> DiscardLoggingT message m b)
-> DiscardLoggingT message m b
mask :: forall b.
((forall a.
DiscardLoggingT message m a -> DiscardLoggingT message m a)
-> DiscardLoggingT message m b)
-> DiscardLoggingT message m b
$cmask :: forall message (m :: * -> *) b.
MonadMask m =>
((forall a.
DiscardLoggingT message m a -> DiscardLoggingT message m a)
-> DiscardLoggingT message m b)
-> DiscardLoggingT message m b
MonadMask,MonadReader r,MonadWriter w,forall a b.
((a -> DiscardLoggingT message m b) -> DiscardLoggingT message m a)
-> DiscardLoggingT message m a
forall {message} {m :: * -> *}.
MonadCont m =>
Monad (DiscardLoggingT message m)
forall message (m :: * -> *) a b.
MonadCont m =>
((a -> DiscardLoggingT message m b) -> DiscardLoggingT message m a)
-> DiscardLoggingT message m a
forall (m :: * -> *).
Monad m -> (forall a b. ((a -> m b) -> m a) -> m a) -> MonadCont m
callCC :: forall a b.
((a -> DiscardLoggingT message m b) -> DiscardLoggingT message m a)
-> DiscardLoggingT message m a
$ccallCC :: forall message (m :: * -> *) a b.
MonadCont m =>
((a -> DiscardLoggingT message m b) -> DiscardLoggingT message m a)
-> DiscardLoggingT message m a
MonadCont,MonadError e,forall a. DiscardLoggingT message m a
forall a.
DiscardLoggingT message m a -> DiscardLoggingT message m [a]
forall a.
DiscardLoggingT message m a
-> DiscardLoggingT message m a -> DiscardLoggingT message m a
forall {message} {m :: * -> *}.
Alternative m =>
Applicative (DiscardLoggingT message m)
forall message (m :: * -> *) a.
Alternative m =>
DiscardLoggingT message m a
forall message (m :: * -> *) a.
Alternative m =>
DiscardLoggingT message m a -> DiscardLoggingT message m [a]
forall message (m :: * -> *) a.
Alternative m =>
DiscardLoggingT message m a
-> DiscardLoggingT message m a -> DiscardLoggingT message m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
many :: forall a.
DiscardLoggingT message m a -> DiscardLoggingT message m [a]
$cmany :: forall message (m :: * -> *) a.
Alternative m =>
DiscardLoggingT message m a -> DiscardLoggingT message m [a]
some :: forall a.
DiscardLoggingT message m a -> DiscardLoggingT message m [a]
$csome :: forall message (m :: * -> *) a.
Alternative m =>
DiscardLoggingT message m a -> DiscardLoggingT message m [a]
<|> :: forall a.
DiscardLoggingT message m a
-> DiscardLoggingT message m a -> DiscardLoggingT message m a
$c<|> :: forall message (m :: * -> *) a.
Alternative m =>
DiscardLoggingT message m a
-> DiscardLoggingT message m a -> DiscardLoggingT message m a
empty :: forall a. DiscardLoggingT message m a
$cempty :: forall message (m :: * -> *) a.
Alternative m =>
DiscardLoggingT message m a
Alternative,forall a. DiscardLoggingT message m a
forall a.
DiscardLoggingT message m a
-> DiscardLoggingT message m a -> DiscardLoggingT message m a
forall {message} {m :: * -> *}.
MonadPlus m =>
Monad (DiscardLoggingT message m)
forall {message} {m :: * -> *}.
MonadPlus m =>
Alternative (DiscardLoggingT message m)
forall message (m :: * -> *) a.
MonadPlus m =>
DiscardLoggingT message m a
forall message (m :: * -> *) a.
MonadPlus m =>
DiscardLoggingT message m a
-> DiscardLoggingT message m a -> DiscardLoggingT message m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
mplus :: forall a.
DiscardLoggingT message m a
-> DiscardLoggingT message m a -> DiscardLoggingT message m a
$cmplus :: forall message (m :: * -> *) a.
MonadPlus m =>
DiscardLoggingT message m a
-> DiscardLoggingT message m a -> DiscardLoggingT message m a
mzero :: forall a. DiscardLoggingT message m a
$cmzero :: forall message (m :: * -> *) a.
MonadPlus m =>
DiscardLoggingT message m a
MonadPlus,MonadState s,MonadRWS r w s,MonadBase b,forall a. String -> DiscardLoggingT message m a
forall {message} {m :: * -> *}.
MonadFail m =>
Monad (DiscardLoggingT message m)
forall message (m :: * -> *) a.
MonadFail m =>
String -> DiscardLoggingT message m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
fail :: forall a. String -> DiscardLoggingT message m a
$cfail :: forall message (m :: * -> *) a.
MonadFail m =>
String -> DiscardLoggingT message m a
Fail.MonadFail)
instance MonadBaseControl b m => MonadBaseControl b (DiscardLoggingT message m) where
type StM (DiscardLoggingT message m) a = StM m a
liftBaseWith :: forall a.
(RunInBase (DiscardLoggingT message m) b -> b a)
-> DiscardLoggingT message m a
liftBaseWith RunInBase (DiscardLoggingT message m) b -> b a
runInBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
(RunInBase m b -> b a) -> m a
liftBaseWith (\RunInBase m b
runInOrig -> RunInBase (DiscardLoggingT message m) b -> b a
runInBase (RunInBase m b
runInOrig forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall message (m :: * -> *) a. DiscardLoggingT message m a -> m a
discardLogging)))
restoreM :: forall a.
StM (DiscardLoggingT message m) a -> DiscardLoggingT message m a
restoreM = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
StM m a -> m a
restoreM
instance MonadTrans (DiscardLoggingT message) where
lift :: forall (m :: * -> *) a.
Monad m =>
m a -> DiscardLoggingT message m a
lift = forall message (m :: * -> *) a. m a -> DiscardLoggingT message m a
DiscardLoggingT
{-# INLINEABLE lift #-}
instance (Functor f,MonadFree f m) => MonadFree f (DiscardLoggingT message m)
instance Monad m => MonadLog message (DiscardLoggingT message m) where
logMessageFree :: (forall n. Monoid n => (message -> n) -> n)
-> DiscardLoggingT message m ()
logMessageFree forall n. Monoid n => (message -> n) -> n
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ()
{-# INLINEABLE logMessageFree #-}