!a{W      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None"#1234568=>?@ACHMSVXy{4logging-effectA ## handler that throws messages away.NThe documentation may appear a bit confusing, but note that the full type of  is:  ::  message m a -> m a logging-effectRun a #/ computation by throwing away all log requests.logging-effectA #g handler optimised for pure usage. Log messages are accumulated strictly, given that messasges form a .logging-effect"Options that be used to configure withBatchingHandler.logging-effect2The maximum amount of time to wait between flushes logging-effectAThe maximum amount of messages to hold in memory between flushes} logging-effectIf the   becomes full, %* will block until the queue is flushed if   is 3, otherwise it will drop that message and continue. logging-effectHandlers are mechanisms to interpret the meaning of logging as an action in the underlying monad. They are simply functions from log messages to m -actions. logging-effect # is a very general handler for the #5 effect. Whenever a log entry is emitted, the given  = is invoked, producing some side-effect (such as writing to stdout!, or appending a database table).logging-effect(Add call stack information to log lines.This functional requires that you pass around the call stack via implicit parameters. For more information, see the GHC manual (section 9.14.4.5).logging-effect Add a timestamp to log messages.tNote that while most log message transformers are designed to be used at the point of logging, this transformer is best applied within the handler. This is advised as timestamps are generally applied uniformly, so doing it in the handler is fine (no extra information or context of the program is required). The other reason is that logging with a timestamp requires 5 - while the rest of your computation is free to use d, it's best to avoid incurring this constraint as much as possible, as it is generally untestable.logging-effectView the underlying message.logging-effect'Retireve the time a message was logged.logging-effectGClasses of severity for log messages. These have been chosen to match syslog severity levelslogging-effectSystem is unusable. By syslog; convention, this level should not be used by applications.logging-effect Should be corrected immediately.logging-effectCritical conditions.logging-effectError conditions.logging-effect=May indicate that an error will occur if action is not taken.logging-effect2Events that are unusual, but not error conditions.logging-effect3Normal operational messages that require no action.logging-effect?Information useful to developers for debugging the application.logging-effectlAdd "Severity" information to a log message. This is often used to convey how significant a log message is.!logging-effect Retrieve the  a message."logging-effectView the underlying message.#logging-effect)The class of monads that support logging.Laws:Monoid homomorphism: $ a  $ b = $ (a  b) $logging-effect[Fold log messages into this computation. Looking to just log a message? You probably want %.EThe perhaps strange type here allows us to construct a monoid out of anyA type of log message. You can think of this as the simpler type: $logMessageFree :: [message] -> m () %logging-effect1Append a message to the log for this computation.&logging-effectRe-interpret the log messages in one computation. This can be useful to embed a computation with one log type in a larger general computation.'logging-effectMonadic version of &i. This can be used to annotate a message with something that can only be computed in a monad. See e.g. 2.(logging-effect-Given a way to render the underlying message a&, render a message with its severity.QrenderWithSeverity id (WithSeverity Informational "Flux capacitor is functional"),[Informational] Flux capacitor is functional)logging-effect ) = % .   *logging-effect * = % .   +logging-effect + = % .   ,logging-effect , = % .   -logging-effect - = % .   .logging-effect . = % .   /logging-effect / = % .   0logging-effect 0 = % .   1logging-effect-Given a way to render the underlying message a and a way to format &, render a message with its timestamp.]renderWithTimestamp (formatTime defaultTimeLocale rfc822DateFormat) id timestamppedLogMessage=[Tue, 19 Jan 2016 11:29:42 UTC] Setting target speed to plaid2logging-effect1Add the current time as a timestamp to a message.3logging-effect-Given a way to render the underlying message a$ render a message with a callstack.GThe callstack will be pretty-printed underneath the log message itself.4logging-effect Construct a  log message.2This should normally be preferred over just using  as it will append a new entry to the stack - pointing to this exact log line. However, if you are creating a combinator (such as a wrapper that logs and throws an exception), you may be better manually capturing the  and using .5logging-effectGiven a   for a given message, interleave this   into the underlying m computation whenever % is called.6logging-effect - unfortunately does admit an instance of the MFunctor! type class, which provides the hoiste method to change the monad underneath a monad transformer. However, it is possible to do this with  T provided that you have a way to re-interpret a log handler in the original monad.7logging-effect Defaults for  7 =  {5 = 1000000 , 1 = 100 ,  = } 8logging-effectCreate a new batched handler. Batched handlers take batches of messages to log at once, which can be more performant than logging each individual message./A batched handler flushes under three criteria: :The flush interval has elapsed and the queue is not empty.2The queue has become full and needs to be flushed. The scope of 8 is exited.DBatched handlers queue size and flush period can be configured via .9logging-effect9 creates a new  / that will append a given file descriptor (or 9, as it is known in the "base" library). Note that this  % requires log messages to be of type U. This abstractly specifies a pretty-printing for log lines. The two arguments two 9R determine how this pretty-printing should be realised when outputting log lines.These  Rs asynchronously log messages to the given file descriptor, rather than blocking.:logging-effectJRun a computation with access to logging by accumulating a log under its  instance.Plogging-effectThe main instance of #, which replaces calls to % with calls to a  .Xlogging-effectA pure handler of #< that accumulates log messages under the structure of their  instance.^logging-effectThe trivial instance of #* that simply discards all messages logged.1logging-effectHow to format the timestamp.logging-effect&How to render the rest of the message.9logging-effectThe  to write log messages to.logging-effectThe  ribbonFrac parameter to logging-effectsThe amount of characters per line. Lines longer than this will be pretty-printed across multiple lines if possible.;  !"#$%&'()*+,-./0123456789:;%&'#$)*+,-./021 !"(43 56 98 7:        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~+logging-effect-1.3.9-2lOAS7dXasp2YswX7IIZzdControl.Monad.LogPP renderPretty*prettyprinter-1.6.0-AeMxq3Zeqap5GCUNBSODpL"Data.Text.Prettyprint.Doc.Internal layoutPrettyDiscardLoggingTdiscardLogging PureLoggingTMkPureLoggingTBatchingOptions flushMaxDelayflushMaxQueueSize blockWhenFullHandlerLoggingT WithCallStack msgCallStackdiscardCallStack WithTimestampdiscardTimestamp msgTimestampSeverity EmergencyAlertCriticalErrorWarningNotice InformationalDebug WithSeverity msgSeveritydiscardSeverityMonadLoglogMessageFree logMessage mapLogMessagemapLogMessageMrenderWithSeveritylogDebuglogInfo logNotice logWarninglogError logCriticallogAlert logEmergencyrenderWithTimestamp timestamprenderWithCallStack withCallStack runLoggingT mapLoggingTdefaultBatchingOptionswithBatchedHandler withFDHandlerrunPureLoggingT$fMonadLogmessageCatchT$fMonadLogmessageFT$fMonadLogmessageFreeT$fMonadLogmessageListT$fMonadLogmessageContT$fMonadLogmessageRWST$fMonadLogmessageRWST0$fMonadLogmessageErrorT$fMonadLogmessageExceptT$fMonadLogmessageMaybeT$fMonadLogmessageWriterT$fMonadLogmessageWriterT0$fMonadLogmessageStateT$fMonadLogmessageStateT0$fMonadLogmessageReaderT$fMonadLogmessageIdentityT$fPrettySeverity $fMonoidAp $fSemigroupAp$fMonadFreefLoggingT$fMonadRWSrwsLoggingT$fMonadLogmessageLoggingT$fMonadReaderrLoggingT$fMonadTransLoggingT$fMonadUnliftIOLoggingT$fMonadBaseControlbLoggingT$fMonadBasebLoggingT$fMonadStatesPureLoggingT$fMonadRWSrwsPureLoggingT$fMonadLoglogPureLoggingT$fMonadFreefPureLoggingT$fMonadTransPureLoggingT$fMonadBaseControlbPureLoggingT$fMonadTransControlPureLoggingT$fMonadBasebPureLoggingT $fMonadLogmessageDiscardLoggingT$fMonadFreefDiscardLoggingT$fMonadTransDiscardLoggingT"$fMonadBaseControlbDiscardLoggingT $fEqSeverity$fEnumSeverity$fBoundedSeverity$fReadSeverity$fShowSeverity $fOrdSeverity$fEqWithSeverity$fOrdWithSeverity$fReadWithSeverity$fShowWithSeverity$fFunctorWithSeverity$fTraversableWithSeverity$fFoldableWithSeverity$fEqWithTimestamp$fOrdWithTimestamp$fReadWithTimestamp$fShowWithTimestamp$fFunctorWithTimestamp$fTraversableWithTimestamp$fFoldableWithTimestamp$fFunctorWithCallStack$fTraversableWithCallStack$fFoldableWithCallStack$fShowWithCallStack$fMonadLoggingT$fApplicativeLoggingT$fFunctorLoggingT$fMonadFixLoggingT$fAlternativeLoggingT$fMonadPlusLoggingT$fMonadIOLoggingT$fMonadWriterLoggingT$fMonadContLoggingT$fMonadErrorLoggingT$fMonadMaskLoggingT$fMonadCatchLoggingT$fMonadThrowLoggingT$fMonadStateLoggingT$fMonadFailLoggingT$fEqBatchingOptions$fOrdBatchingOptions$fReadBatchingOptions$fShowBatchingOptions$fFunctorPureLoggingT$fApplicativePureLoggingT$fMonadPureLoggingT$fMonadFixPureLoggingT$fMonadCatchPureLoggingT$fMonadThrowPureLoggingT$fMonadIOPureLoggingT$fMonadMaskPureLoggingT$fMonadReaderPureLoggingT$fMonadWriterPureLoggingT$fMonadContPureLoggingT$fMonadErrorPureLoggingT$fAlternativePureLoggingT$fMonadPlusPureLoggingT$fMonadFailPureLoggingT$fFunctorDiscardLoggingT$fApplicativeDiscardLoggingT$fMonadDiscardLoggingT$fMonadFixDiscardLoggingT$fMonadCatchDiscardLoggingT$fMonadThrowDiscardLoggingT$fMonadIODiscardLoggingT$fMonadMaskDiscardLoggingT$fMonadReaderDiscardLoggingT$fMonadWriterDiscardLoggingT$fMonadContDiscardLoggingT$fMonadErrorDiscardLoggingT$fAlternativeDiscardLoggingT$fMonadPlusDiscardLoggingT$fMonadStateDiscardLoggingT$fMonadRWSDiscardLoggingT$fMonadBaseDiscardLoggingT$fMonadFailDiscardLoggingTbaseGHC.BaseMonoidghc-prim GHC.TypesTrueControl.Monad.IO.ClassMonadIO*><> time-1.8.0.2 Data.Time.Clock.Internal.UTCTimeUTCTimeGHC.Stack.Types CallStackGHC.IO.Handle.TypesHandleDoc