úÎxànäª      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©None"#0123457;<=>?AFKQTVl\4A ## handler that throws messages away.NThe documentation may appear a bit confusing, but note that the full type of  is:  ::  messsage m a -> m a Run a #/ computation by throwing away all log requests.A #g handler optimised for pure usage. Log messages are accumulated strictly, given that messasges form a ª."Options that be used to configure withBatchingHandler.2The maximum amount of time to wait between flushes AThe maximum amount of messages to hold in memory between flushes} If the   becomes full, %* will block until the queue is flushed if   is «3, otherwise it will drop that message and continue. “Handlers 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.  # 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).(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). 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.View the underlying message.'Retireve the time a message was logged.GClasses of severity for log messages. These have been chosen to match syslog severity levelsSystem is unusable. By syslog; convention, this level should not be used by applications. Should be corrected immediately.Critical conditions.Error conditions.=May indicate that an error will occur if action is not taken.2Events that are unusual, but not error conditions.3Normal operational messages that require no action.?Information useful to developers for debugging the application.lAdd "Severity" information to a log message. This is often used to convey how significant a log message is.! Retrieve the  a message."View the underlying message.#)The class of monads that support logging.Laws:Monoid homomorphism: $ a ­ $ b = $ (a ® b) $[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 () %1Append a message to the log for this computation.&Re-interpret the log messages in one computation. This can be useful to embed a computation with one log type in a larger general computation.'Monadic 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.(-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) ) = % .   * * = % .   + + = % .   , , = % .   - - = % .   . . = % .   / / = % .   0 0 = % .   1-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 plaid21Add the current time as a timestamp to a message.3-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.4 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 .5Given a   for a given message, interleave this   into the underlying m computation whenever % is called.6 - 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.7 Defaults for  7 =  {5 = 1000000 , 1 = 100 ,  = «} 8œCreate 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 .99 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.:JRun a computation with access to logging by accumulating a log under its ª instance.PThe main instance of #, which replaces calls to % with calls to a  .WA pure handler of #< that accumulates log messages under the structure of their ª instance.]The trivial instance of #* that simply discards all messages logged.1How to format the timestamp.&How to render the rest of the message.9The ± to write log messages to.The  ribbonFrac parameter to sThe 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.2.6-9zg91LRVhe11GS85BTVYh5Control.Monad.Log-wl-pprint-text-1.1.1.1-99DR6HvbZf120TaZlmhFqcText.PrettyPrint.Leijen.Text renderPrettyDiscardLoggingTdiscardLogging 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$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$fEqBatchingOptions$fOrdBatchingOptions$fReadBatchingOptions$fShowBatchingOptions$fFunctorPureLoggingT$fApplicativePureLoggingT$fMonadPureLoggingT$fMonadFixPureLoggingT$fMonadCatchPureLoggingT$fMonadThrowPureLoggingT$fMonadIOPureLoggingT$fMonadMaskPureLoggingT$fMonadReaderPureLoggingT$fMonadWriterPureLoggingT$fMonadContPureLoggingT$fMonadErrorPureLoggingT$fAlternativePureLoggingT$fMonadPlusPureLoggingT$fFunctorDiscardLoggingT$fApplicativeDiscardLoggingT$fMonadDiscardLoggingT$fMonadFixDiscardLoggingT$fMonadCatchDiscardLoggingT$fMonadThrowDiscardLoggingT$fMonadIODiscardLoggingT$fMonadMaskDiscardLoggingT$fMonadReaderDiscardLoggingT$fMonadWriterDiscardLoggingT$fMonadContDiscardLoggingT$fMonadErrorDiscardLoggingT$fAlternativeDiscardLoggingT$fMonadPlusDiscardLoggingT$fMonadStateDiscardLoggingT$fMonadRWSDiscardLoggingT$fMonadBaseDiscardLoggingTbaseGHC.BaseMonoidghc-prim GHC.TypesTrueControl.Monad.IO.ClassMonadIO*>Data.Semigroup<> time-1.8.0.2 Data.Time.Clock.Internal.UTCTimeUTCTimeGHC.Stack.Types CallStackGHC.IO.Handle.TypesHandleDocAprunAp