!?p      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoNone#%&',-.14567=>?@ACHMPSUVX_k$extensible-effects-concurrentCatch p thrown by an effect.extensible-effects-concurrentVery similar to q but for r s. Unlike s4 this will throw the given value (instead of using t).uvswqxyz{|}~tNone$%&',-.14567=>?@ACHMPSUVX_kqFextensible-effects-concurrentAn rfc 5424 facilityextensible-effects-concurrentAn rfc 5424 severityextensible-effects-concurrentComponent of an RFC-5424 extensible-effects-concurrentFRFC-5424 defines how structured data can be included in a log message.extensible-effects-concurrent<A message data type inspired by the RFC-5424 Syslog Protocol&extensible-effects-concurrent#Smart constructor for the RFC-5424  emergency  *. This corresponds to the severity value 0. See k.'extensible-effects-concurrent#Smart constructor for the RFC-5424 alert  *. This corresponds to the severity value 1. See k.(extensible-effects-concurrent#Smart constructor for the RFC-5424 critical  *. This corresponds to the severity value 2. See k.)extensible-effects-concurrent#Smart constructor for the RFC-5424 error  *. This corresponds to the severity value 3. See k.*extensible-effects-concurrent#Smart constructor for the RFC-5424 warning  *. This corresponds to the severity value 4. See k.+extensible-effects-concurrent#Smart constructor for the RFC-5424 notice  *. This corresponds to the severity value 5. See k.,extensible-effects-concurrent#Smart constructor for the RFC-5424  informational  *. This corresponds to the severity value 6. See k.-extensible-effects-concurrent#Smart constructor for the RFC-5424 debug  *. This corresponds to the severity value 7. See k..extensible-effects-concurrent#Smart constructor for the RFC-5424  facility kernelMessages. See f./extensible-effects-concurrent#Smart constructor for the RFC-5424  facility userLevelMessages. See f.0extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  mailSystem. See f.1extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  systemDaemons. See f.2extensible-effects-concurrent#Smart constructor for the RFC-5424  facility securityAuthorizationMessages4. See f.3extensible-effects-concurrent#Smart constructor for the RFC-5424  facility linePrinterSubsystem. See f.4extensible-effects-concurrent#Smart constructor for the RFC-5424  facility networkNewsSubsystem. See f.5extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  uucpSubsystem. See f.6extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  clockDaemon. See f.7extensible-effects-concurrent#Smart constructor for the RFC-5424  facility securityAuthorizationMessages10. See f.8extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  ftpDaemon. See f.9extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  ntpSubsystem. See f.:extensible-effects-concurrent#Smart constructor for the RFC-5424  facility logAuditFacility. See f.;extensible-effects-concurrent#Smart constructor for the RFC-5424  facility logAlertFacility. See f.<extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  clockDaemon2. See f.=extensible-effects-concurrent#Smart constructor for the RFC-5424  facility local0. See f.>extensible-effects-concurrent#Smart constructor for the RFC-5424  facility local1. See f.?extensible-effects-concurrent#Smart constructor for the RFC-5424  facility local2. See f.@extensible-effects-concurrent#Smart constructor for the RFC-5424  facility local3. See f.Aextensible-effects-concurrent#Smart constructor for the RFC-5424  facility local4. See f.Bextensible-effects-concurrent#Smart constructor for the RFC-5424  facility local5. See f.Cextensible-effects-concurrent#Smart constructor for the RFC-5424  facility local6. See f.Dextensible-effects-concurrent#Smart constructor for the RFC-5424  facility local7. See f.Kextensible-effects-concurrentThis instance is only2 supposed to be used for unit tests and debugging.`extensible-effects-concurrent@A lens for the key or ID of a group of RFC 5424 key-value pairs.aextensible-effects-concurrent A lens for sbextensible-effects-concurrent6The filter predicate for message that shall be logged.See Control.Eff.Log#LogPredicatecextensible-effects-concurrentThings that can become a dextensible-effects-concurrentConvert the value to a eextensible-effects-concurrentA lens for the RFC 5424  application name of a One useful pattern for using this field, is to implement log filters that allow info and debug message from the application itself while only allowing warning and error messages from third party libraries: rdebugLogsForAppName myAppName lm = view lmAppName lm == Just myAppName || lmSeverityIsAtLeast warningSeverity lm$This concept is also implemented in .fextensible-effects-concurrentA lens for the  of a gextensible-effects-concurrentA lens for the hostname of a  The function t can be used to set the field.hextensible-effects-concurrent1A lens for the user defined textual message of a iextensible-effects-concurrentA lens for a user defined  message id of a jextensible-effects-concurrentA lens for a user defined of process id of a kextensible-effects-concurrentA lens for the  of a lextensible-effects-concurrentA lens for the  of a mextensible-effects-concurrentA lens for the  of a nextensible-effects-concurrentA lens for the  of a  The function s can be used to set the field.oextensible-effects-concurrentA lens for the UTC time of a  The function r can be used to set the field.pextensible-effects-concurrent2Put the source location of the given callstack in lqextensible-effects-concurrent Prefix the h.rextensible-effects-concurrent/An IO action that sets the current UTC time in o.sextensible-effects-concurrentAn IO action appends the the  of the calling process (see ) to h.textensible-effects-concurrentEAn IO action that sets the current hosts fully qualified hostname in g.uextensible-effects-concurrent Construct a  with )vextensible-effects-concurrent Construct a  with ,wextensible-effects-concurrent Construct a  with -xextensible-effects-concurrent Construct a  with )yextensible-effects-concurrent Construct a  with ,zextensible-effects-concurrent Construct a  with -{extensible-effects-concurrent All messages.See ,Control.Eff.Log.Message#PredefinedPredicates for more predicates.|extensible-effects-concurrent No messages.See ,Control.Eff.Log.Message#PredefinedPredicates for more predicates.}extensible-effects-concurrentMatch -s that have exactly the given severity. See ~.See ,Control.Eff.Log.Message#PredefinedPredicates for more predicates.~extensible-effects-concurrentMatch s that have the given severity or worse. See }.See ,Control.Eff.Log.Message#PredefinedPredicates for more predicates.extensible-effects-concurrentMatch s whose h starts with the given string.See ,Control.Eff.Log.Message#PredefinedPredicates for more predicates.extensible-effects-concurrentApply a b based on the e and delegate to one of two bs.One useful application for this is to allow info and debug message from one application, e.g. the current application itself, while at the same time allowing only warning and error messages from third party libraries.See ,Control.Eff.Log.Message#PredefinedPredicates for more predicates.X !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~X !"#$%fkogejimlnhpqrstuvwcdxyzb{|}~`a&'()*+,-./0123456789:;<=>?@ABCDNone$%&',-.14567=>?@ACHMPSUVX_kqŧextensible-effects-concurrentA rendering function for the o field.extensible-effects-concurrent rendering functionextensible-effects-concurrentMake a  using  in the  defaultLocale.extensible-effects-concurrentDon't render the time stampextensible-effects-concurrentRender the time stamp using "%h %d %H:%M:%S"extensible-effects-concurrentRender the time stamp to  (Just "%H:%M:%S%6QZ")extensible-effects-concurrentRender the time stamp like  does, but omit the terminal Z character.extensible-effects-concurrent_Print the thread id, the message and the source file location, seperated by simple white space.extensible-effects-concurrent_Print the thread id, the message and the source file location, seperated by simple white space.extensible-effects-concurrent Print the body of a U with fix size fields (60) for the message itself and 30 characters for the locationextensible-effects-concurrentRender a field of a  using the corresponsing lens.extensible-effects-concurrentRender a field of a  using the corresponsing lens.extensible-effects-concurrentRender the source location as: at filepath:linenumber.extensible-effects-concurrent9Render the severity and facility as described in RFC-3164Render e.g. as <192>.2Useful as header for syslog compatible log output.extensible-effects-concurrent Render the 3 to contain the severity, message, message-id, pid.!Omit hostname, PID and timestamp.Render the header using renderSyslogSeverityUseful for logging to devlogextensible-effects-concurrent Render a $ human readable, for console loggingextensible-effects-concurrent Render a ( according to the rules in the RFC-3164.extensible-effects-concurrent Render a E according to the rules in the RFC-3164 but use RFC5424 time stamps.extensible-effects-concurrent Render a < according to the rules in the RFC-3164 but use the custom .extensible-effects-concurrent Render a ( according to the rules in the RFC-5424.Equivalent to  <> const " " <> .extensible-effects-concurrent Render a . according to the rules in the RFC-5424, like / but suppress the source location information.Equivalent to  <> const " " <> .extensible-effects-concurrent+Render the header and strucuted data of a @ according to the rules in the RFC-5424, but do not render the h.extensible-effects-concurrentExtract the name of an 3 the length is cropped to 32 according to RFC 5424.extensible-effects-concurrentExtract the value of an .extensible-effects-concurrent$The format string that is passed to None$%&',-.14567=>?@ACHMPSUVX_k3extensible-effects-concurrentA phantom type for the  class for pure sextensible-effects-concurrentZThe instances of this class are the monads that define (side-) effect(s) of writting logs.extensible-effects-concurrentvA list of effects that are required for writing the log messages. For example 'Lift IO' or '[]' for pure log writers.extensible-effects-concurrentRun the side effect of a  in a compatible .extensible-effects-concurrentWrite a message using the  found in the environment.4The semantics of this function are a combination of  and  , with the  read from a .extensible-effects-concurrentA Reader specialized for s The existing Reader couldn't be used together with ;, so this lazy reader was written, specialized to reading .extensible-effects-concurrent@A function that takes a log message and returns an effect that logs the message.extensible-effects-concurrent Provide the /Exposed for custom extensions, if in doubt use  withLogging.extensible-effects-concurrentGet the current .extensible-effects-concurrentModify the current .extensible-effects-concurrentThis  will discard all messages. NOTE: This is just an alias for extensible-effects-concurrentA ! that applies a predicate to the E and delegates to to the given writer of the predicate is satisfied.extensible-effects-concurrentA  that applies a function to the 2 and delegates the result to to the given writer.extensible-effects-concurrentLike % allow the function that changes the  to have effects.extensible-effects-concurrentA  monad for  based pure logging.None$%&',-.14567=>?@ACHMPSUVX_kN&extensible-effects-concurrent/A constraint alias for effects that requires a !, as well as that the contained  has a  instance.4The requirements of this constraint are provided by: withIoLoggingextensible-effects-concurrentThis effect sends s and is a reader for a b.Logs are sent via 2; for more information about log predicates, see Control.Eff.Log#LogPredicateThis effect is handled via .extensible-effects-concurrent Handle the  and  effects.It installs the given #, which determines the underlying  type parameter.Example: yexampleWithLogging :: IO () exampleWithLogging = runLift $ withLogging consoleLogWriter $ logDebug "Oh, hi there"extensible-effects-concurrent Handles the  and  effects.By default it uses the  , but using  the  can be replaced. This is like  applied to Example: |exampleWithSomeLogging :: () exampleWithSomeLogging = run $ withSomeLogging @PureLogWriter $ logDebug "Oh, hi there"extensible-effects-concurrentRaw handling of the 9 effect. Exposed for custom extensions, if in doubt use .extensible-effects-concurrentLog a message.'All logging goes through this function.*This function is the only place where the b is applied.Also, s are evaluated using , after they pass the b.extensible-effects-concurrentLog a  as  with a given .extensible-effects-concurrentLog a  as  with a given .extensible-effects-concurrentLog a  as &.extensible-effects-concurrentLog a message with '.extensible-effects-concurrentLog a ( message.extensible-effects-concurrentLog a ) message.extensible-effects-concurrentLog a * message.extensible-effects-concurrentLog a + message.extensible-effects-concurrentLog a , message.extensible-effects-concurrentLog a - message.extensible-effects-concurrentLog a  as &.extensible-effects-concurrentLog a message with '.extensible-effects-concurrentLog a ( message.extensible-effects-concurrentLog a ) message.extensible-effects-concurrentLog a * message.extensible-effects-concurrentLog a + message.extensible-effects-concurrentLog a , message.extensible-effects-concurrentLog a - message.extensible-effects-concurrentGet the current  filter/transformer function.See Control.Eff.Log#LogPredicateextensible-effects-concurrent6Keep only those messages, for which a predicate holds.,E.g. to keep only messages which begin with OMG: exampleLogPredicate :: IO Int exampleLogPredicate = runLift $ withLogging consoleLogWriter $ do logMsg "test" setLogPredicate (\ msg -> case view lmMessage msg of 'O':'M':'G':_ -> True _ -> False) (do logMsg "this message will not be logged" logMsg "OMG logged" return 42)9In order to also delegate to the previous predicate, use See Control.Eff.Log#LogPredicateextensible-effects-concurrent Change the b. Other than = this function allows to include the previous predicate, too.jFor to discard all messages currently no satisfying the predicate and also all messages that are to long: modifyLogPredicate (previousPredicate msg -> previousPredicate msg && length (lmMessage msg) < 29 ) (do logMsg "this message will not be logged" logMsg "this message might be logged") See Control.Eff.Log#LogPredicateextensible-effects-concurrentInclude s that match a b.excludeLogMessages p$ allows log message to be logged if p m<Although it is enough if the previous predicate holds. See  and .See Control.Eff.Log#LogPredicateextensible-effects-concurrentExclude s that match a b.excludeLogMessages p discards logs if p mMAlso the previous predicate must also hold for a message to be logged. See  and .See Control.Eff.Log#LogPredicateextensible-effects-concurrentConsume log messages./Exposed for custom extensions, if in doubt use .Respond to all +s logged from the given action, up to any  liftings.&Note that all logging is done through + and that means only messages passing the b are received.The s are consumed@ once they are passed to the given callback function, previous M invocations further up in the call stack will not get the messages anymore.Use 7 if the messages shall be passed any previous handler.'NOTE: The effects of this function are lost when using , ,  and .1In contrast the functions based on modifying the  , such as  or C, are save to use in combination with the aforementioned liftings.extensible-effects-concurrent Change the s using an effectful function./Exposed for custom extensions, if in doubt use .This differs from V in that the intercepted messages will be written either way, albeit in altered form.'NOTE: The effects of this function are lost when using , ,  and .1In contrast the functions based on modifying the  , such as  or C, are save to use in combination with the aforementioned liftings.extensible-effects-concurrentInternal function.extensible-effects-concurrentChange the current .extensible-effects-concurrentReplace the current 1. To add an additional log message consumer use extensible-effects-concurrentModify the the &s written in the given sub-expression.Note: This is equivalent to  . extensible-effects-concurrentModify the the -s written in the given sub-expression, as in  but with a effectful function.Note: This is equivalent to  . extensible-effects-concurrentCombine the effects of a given  and the existing one. import Data.Text as T import Data.Text.IO as T exampleAddLogWriter :: IO () exampleAddLogWriter = go >>= T.putStrLn where go = fmap (unlines . map renderLogMessageConsoleLog . snd) $ runLift $ runCaptureLogWriter $ withLogging captureLogWriter $ addLogWriter (mappingLogWriter (lmMessage %~ ("CAPTURED "++)) captureLogWriter) $ addLogWriter (filteringLogWriter severeMessages (mappingLogWriter (lmMessage %~ ("TRACED "++)) debugTraceLogWriter)) $ do logEmergency "test emergencySeverity 1" logCritical "test criticalSeverity 2" logAlert "test alertSeverity 3" logError "test errorSeverity 4" logWarning "test warningSeverity 5" logInfo "test informationalSeverity 6" logDebug "test debugSeverity 7" severeMessages = view (lmSeverity . to (<= errorSeverity)) extensible-effects-concurrent!This instance allows lifting the  effect into a base monad, e.g. . This instance needs a / in the base monad, that is capable to handle  invocations.$$None$%&',-.14567=>?@ACHMPSUVX_k7Mrextensible-effects-concurrentEach process is identified by a single process id, that stays constant throughout the life cycle of a process. Also, message sending relies on these values to address messages to processes. extensible-effects-concurrentyA monitored process exited. This message is sent to a process by the scheduler, when a process that was monitored died. extensible-effects-concurrentBA value that contains a unique reference of a process monitoring.extensible-effects-concurrentAn existential wrapper around extensible-effects-concurrentThis adds a layer of the  effect on top of  extensible-effects-concurrenteptions containing s. See 1, 4 or 5extensible-effects-concurrent's which are recoverable are interrupts.extensible-effects-concurrentA sum-type with reasons for why a process exists the scheduling loop, this includes errors, that can occur when scheduling messages. extensible-effects-concurrentA process has finished a unit of work and might exit or work on something else. This is primarily used for interrupting infinite server loops, allowing for additional cleanup work before exiting (e.g. with )extensible-effects-concurrent1A process that should be running was not running.extensible-effects-concurrentA  timeout has occurred.extensible-effects-concurrentA linked process is downextensible-effects-concurrent0An exit reason that has an error message and is .extensible-effects-concurrent8A process function returned or exited without any error.extensible-effects-concurrent An unhandled  allows .extensible-effects-concurrentOAn unexpected runtime exception was thrown, i.e. an exception derived from extensible-effects-concurrent)A process was cancelled (e.g. killed, in  !)extensible-effects-concurrentcThis value indicates whether a process exited in way consistent with the planned behaviour or not.extensible-effects-concurrent#This kind is used to indicate if a H can be treated like a short interrupt which can be handled or ignored.extensible-effects-concurrentThe state that a  is currently in.extensible-effects-concurrent;The process has just been started but not scheduled yet.extensible-effects-concurrent#The process yielded it's time sliceextensible-effects-concurrent%The process is busy with non-blockingextensible-effects-concurrent*The process is busy with sending a messageextensible-effects-concurrent The process is busy with killingextensible-effects-concurrent The process is busy with killingextensible-effects-concurrentThe process blocked by a Kextensible-effects-concurrentThe process blocked by a Zextensible-effects-concurrentThe process blocked by a [ extensible-effects-concurrentThe process blocked by a T extensible-effects-concurrentThe process blocked by a U extensible-effects-concurrentThe process was interrupted extensible-effects-concurrent#The process was shutdown or crashed extensible-effects-concurrentCons  onto a list of effects.extensible-effects-concurrentAA function that decided if the next message will be received by %. It conveniently is an instance of  so the message selector can be combined: > > selectInt :: MessageSelector Int > selectInt = selectMessage > > selectString :: MessageSelector String > selectString = selectMessage > > selectIntOrString :: MessageSelector (Either Int String) > selectIntOrString = > Left  $ selectTimeout | Right  $ selectStringextensible-effects-concurrentEvery  action returns it's actual result wrapped in this type. It will allow to signal errors as well as pass on normal results such as incoming messages.extensible-effects-concurrent=The current operation of the process was interrupted with a . If 9A holds for the given reason, the process may choose to continue.extensible-effects-concurrent:The process may resume to do work, using the given result.extensible-effects-concurrentData flows between es via these messages.&This is just a newtype wrapper around ~. The reason this type exists is to force construction through the code in this module, which always evaluates a message to  normal form before sending it to another process.extensible-effects-concurrentThe process effect is the basis for message passing concurrency. This effect describes an interface for concurrent, communicating isolated processes identified uniquely by a process-id.Processes can raise exceptions that can be caught, exit gracefully or with an error, or be killed by other processes, with the option of ignoring the shutdown request.vProcess Scheduling is implemented in different modules. All scheduler implementations should follow some basic rules:fair scheduling sending a message does not blockreceiving a message does block*spawning a child blocks only a very momentJa newly spawned process shall be scheduled before the parent process after the spawnRawGwhen the first process exists, all process should be killed immediatelyextensible-effects-concurrent3Remove all messages from the process' message queue extensible-effects-concurrentIn cooperative schedulers, this will give processing time to the scheduler. Every other operation implicitly serves the same purpose.extensible-effects-concurrentReturn the current extensible-effects-concurrentjStart a new process, the new process will execute an effect, the function will return immediately with a . extensible-effects-concurrentStart a new process, and # to it .extensible-effects-concurrentGet the process state (or  if the process is dead)extensible-effects-concurrentTShutdown the process; irregardless of the exit reason, this function never returns,extensible-effects-concurrent$Raise an error, that can be handled.extensible-effects-concurrent\Request that another a process interrupts. The targeted process is interrupted and gets an ], the target process may decide to ignore the interrupt and continue as if nothing happened.extensible-effects-concurrent-Send a message to a process addressed by the . Sending a message should always succeed and return  immediatelyb, even if the destination process does not exist, or does not accept messages of the given type.extensible-effects-concurrent}Receive a message that matches a criteria. This should block until an a message was received. The message is returned as a ` value. The function should also return if an exception was caught or a shutdown was requested. extensible-effects-concurrentGenerate a unique  for the current process.! extensible-effects-concurrent>Monitor another process. When the monitored process exits a  is sent to the calling process. The return value is a unique identifier for that monitor. There can be multiple monitors on the same process, and a message for each will be sent. If the process is already dead, the 7 message will be sent immediately, without exit reason" extensible-effects-concurrentRemove a monitor.# extensible-effects-concurrentaConnect the calling process to another process, such that if one of the processes crashes (i.e. 8 returns #), the other is shutdown with the  .$ extensible-effects-concurrent2Unlink the calling process from the other process.%extensible-effects-concurrent3Deeply evaluate the given value and wrap it into a .&extensible-effects-concurrent Convert a  back to a value.'extensible-effects-concurrent Convert a  back to an unwrapped .( extensible-effects-concurrent>Create a message selector for a value that can be obtained by &.) extensible-effects-concurrent+Create a message selector from a predicate.* extensible-effects-concurrentSelect a message of type a> and apply the given function to it. If the function returns  The ( function will return the result (sans Maybe).+ extensible-effects-concurrentCreate a message selector., extensible-effects-concurrentACreate a message selector that will match every message. This is lazy because the result is not ed.-extensible-effects-concurrentGet the .extensible-effects-concurrentGet the  of a ./extensible-effects-concurrentA predicate for linked process crashes.0extensible-effects-concurrent Handle all s of an  by wrapping them up in  and then do a process .1extensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a L via a call to 7.2 extensible-effects-concurrentLike 1, but instead of passing the  to a handler function,  is returned.3extensible-effects-concurrent'Handle interrupts by logging them with < and otherwise ignoring them.4extensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a L via a call to 7.5extensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a L via a call to 7.6extensible-effects-concurrentWrap all (left) s into  and return the (right)  s as is.7extensible-effects-concurrent Throw an , can be handled by 1 or 4 or 5.8extensible-effects-concurrentA predicate for crashes. A crash' happens when a process exits with an  other than 9extensible-effects-concurrentkA predicate for recoverable exit reasons. This predicate defines the exit reasons which functions such as =:extensible-effects-concurrent Partition a  back into either a  or a  ;extensible-effects-concurrentPrint a  to  a formatted  when 8 is >. This can be useful in combination with view patterns, e.g.: slogCrash :: ExitReason -> Eff e () logCrash (toCrashReason -> Just reason) = logError reason logCrash _ = return ()Though this can be improved to: -logCrash = traverse_ logError . toCrashReason<extensible-effects-concurrentLog the s=extensible-effects-concurrentExecute a and action and return the result; if the process is interrupted by an error or exception, or an explicit shutdown from another process, or through a crash of a linked process, i.e. whenever the exit reason satisfies 9, return the exit reason.>extensible-effects-concurrent Execute a : action and resume the process, exit the process when an  was raised. Use = to catch interrupts.?extensible-effects-concurrent Execute a : action and resume the process, exit the process when an  was raised. Use = to catch interrupts.@extensible-effects-concurrentUse > to execute  . Refer to  for more information.Aextensible-effects-concurrent-Send a message to a process addressed by the . See .,The message will be reduced to normal form () by/in the caller process.Bextensible-effects-concurrentSend a % value to a process addressed by the . See .Cextensible-effects-concurrent Exit a process addressed by the Z. The process will exit, it might do some cleanup, but is ultimately unrecoverable. See .Dextensible-effects-concurrent&Interrupts a process addressed by the 7. The process might exit, or it may continue. | Like D, but also return True iff the process to exit exists.Eextensible-effects-concurrentjStart a new process, the new process will execute an effect, the function will return immediately with a 7. If the new process is interrupted, the process will  with the  wrapped in 4. For specific use cases it might be better to use H.Fextensible-effects-concurrentLike E but return ().G extensible-effects-concurrent0Start a new process, and immediately link to it.Hextensible-effects-concurrentjStart a new process, the new process will execute an effect, the function will return immediately with a $. The spawned process has only the raw   effects. For non-library code E might be better suited.Iextensible-effects-concurrentLike H but return ().J extensible-effects-concurrentReturn  if the process is alive.Kextensible-effects-concurrent)Block until a message was received. See  for more documentation.Lextensible-effects-concurrent0Block until a message was received, that is not ( after applying a callback to it. See  for more documentation.Mextensible-effects-concurrent%Receive and cast the message to some  instance. See P for more documentation. This will wait for a message of the return type using LN extensible-effects-concurrentPRemove and return all messages currently enqueued in the process message queue.Oextensible-effects-concurrentZEnter a loop to receive messages and pass them to a callback, until the function returns y a result. Only the messages of the given type will be received. If the process is interrupted by an exception of by a ; from another process, with an exit reason that satisfies 9*, then the callback will be invoked with  C, otherwise the process will be exited with the same reason using \ . See also  for more documentation.Pextensible-effects-concurrentLike O but  not selective . See also ,, O.Qextensible-effects-concurrentLike O& but refined to casting to a specific  using (.Rextensible-effects-concurrent Returns the  of the current process.Sextensible-effects-concurrentGenerate a unique  for the current process.T extensible-effects-concurrent>Monitor another process. When the monitored process exits a  is sent to the calling process. The return value is a unique identifier for that monitor. There can be multiple monitors on the same process, and a message for each will be sent. If the process is already dead, the 7 message will be sent immediately, without exit reasonU extensible-effects-concurrentRemove a monitor created with T.V extensible-effects-concurrentT8 another process before while performing an action and U afterwards.W extensible-effects-concurrentA I for receiving either a monitor of the given process or another message.X extensible-effects-concurrentMake an  for a  message. For example: @doSomething >>= either (interrupt . becauseProcessIsDown) returnY extensible-effects-concurrentA  for the  message of a specific process.Z extensible-effects-concurrentaConnect the calling process to another process, such that if one of the processes crashes (i.e. 8 returns #), the other is shutdown with the  .[ extensible-effects-concurrent2Unlink the calling process from the other process.\extensible-effects-concurrentExit the process with a .]extensible-effects-concurrentExit the process.^extensible-effects-concurrentExit the process with an error.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ !"#$%&'     @ABCDSMLNKQOP()*+,RJEFGHI\]^Z[TUYXVW01243567=>?-9./8;:<None#%&',-.14567=>?@ACHMPSUVX_kQs  extensible-effects-concurrent+A value to be sent when timer started with  has elapsed. extensible-effects-concurrent$The reference to a timer started by  , required to stop a timer via . extensible-effects-concurrentA number of micro seconds. extensible-effects-concurrentbWait for a message of the given type for the given time. When no message arrives in time, return . This is based on . extensible-effects-concurrentbWait for a message of the given type for the given time. When no message arrives in time, return  . This is based on  and .extensible-effects-concurrentLike W combined with . extensible-effects-concurrentA  matching  messages created by . extensible-effects-concurrentsSend a message to a given process after waiting. The message is created by applying the function parameter to the 9, such that the message can directly refer to the timer. extensible-effects-concurrent/Start a new timer, after the time has elapsed, < is sent to calling process. The message also contains the ! returned by this function. Use  to cancel the timer. Use  to receive the message using L7. To receive messages with guarded with a timeout see . extensible-effects-concurrentCancel a timer started with .  None#%&',-.14567=>?@ACHMPSUVX_kjOextensible-effects-concurrent'This is a tag-type that wraps around a  and holds an  index type.extensible-effects-concurrentyThe (promoted) constructors of this type specify (at the type level) the reply behavior of a specific constructor of an Api instance.extensible-effects-concurrent[Specify that handling a request is a blocking operation with a specific return type, e.g. -('Synchronous (Either RentalError RentalId))extensible-effects-concurrent,Non-blocking, asynchronous, request handlingextensible-effects-concurrent}This data family defines an API, a communication interface description between at least two processes. The processes act as servers or  client(s), regarding a specific instance of this type.PThe first parameter is usually a user defined phantom type that identifies the  instance.LThe second parameter specifies if a specific constructor of an (GADT-like) Api instance is ;, i.e. returns a result and blocks the caller or if it is Example:  data BookShop deriving Typeable data instance Api BookShop r where RentBook :: BookId -> Api BookShop ('Synchronous (Either RentalError RentalId)) BringBack :: RentalId -> Api BookShop 'Asynchronous type BookId = Int type RentalId = Int type RentalError = String extensible-effects-concurrentTag a  with an  type index to mark it a  process handling that APIextensible-effects-concurrentTag a  with an  type index to mark it a  process handling that API  "None$%&',-.14567=>?@ACHMPSUVX_ku<extensible-effects-concurrentWraps the source  and a unique identifier for a .extensible-effects-concurrentGet the reply of an Api foo ('Synchronous reply).extensible-effects-concurrentGet the reply of an Api foo ('Synchronous reply).extensible-effects-concurrentThe wrapper around replies to s.extensible-effects-concurrent=A wrapper sum type for calls and casts for the methods of an  subtypeextensible-effects-concurrent TODO removeextensible-effects-concurrentSend a  to a .&The reply will be deeply evaluated to . #None#%&',-.14567=>?@ACHMPSUVX_kv !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~$ None#%&',-.14567=>?@ACHMPSUVX_k extensible-effects-concurrentJJust a wrapper around a function that will be applied to the result of a s  clause, or an ! caught during the execution of receive or a  extensible-effects-concurrent+Helper type class for the return values of  et al. extensible-effects-concurrent!An existential wrapper around a 8 and a function that handles the selected message. The api" type parameter is a phantom type..The return value of the handler function is a . extensible-effects-concurrent(A command to the server loop started by . Typically returned by a 4 to indicate if the server should continue or stop.extensible-effects-concurrent/Tell the server to keep the server loop runningextensible-effects-concurrent)Tell the server to exit, this will cause 8 to stop handling requests without exiting the process. extensible-effects-concurrentServe an  in a newly spawned process.extensible-effects-concurrentServe an * in a newly spawned -and linked - process. extensible-effects-concurrentServer an w in a newly spawned process; the callbacks have access to some state initialed by the function in the first parameter. extensible-effects-concurrentServer an w in a newly spawned process; The caller provides an effect handler for arbitrary effects used by the server callbacks.extensible-effects-concurrentServer an  in a newly spawned process; The caller provides an effect handler for arbitrary effects used by the server callbacks. Links to the calling process like Z would.extensible-effects-concurrentReceive loop for   $%s. This starts a receive loop for a ". It is used behind the scenes by  and . extensible-effects-concurrentA smart constructor for s extensible-effects-concurrentA smart constructor for s extensible-effects-concurrentA smart constructor for s extensible-effects-concurrentA smart constructor for s extensible-effects-concurrentA smart constructor for sExample ihandleCalls ( (RentBook bookId customerId) runCall -> runCall $ do rentalIdE <- rentBook bookId customerId case rentalIdE of -- on fail we just don't send a reply, let the caller run into -- timeout Left err -> return (Nothing, AwaitNext) Right rentalId -> return (Just rentalId, AwaitNext))  extensible-effects-concurrentA smart constructor for sextensible-effects-concurrentA variation of ( that allows to defer a reply to a call. extensible-effects-concurrentA smart constructor for s extensible-effects-concurrent Compose two s to a type-level pair of them. 1handleCalls api1calls ^: handleCalls api2calls ^: extensible-effects-concurrent]Make a fallback handler, i.e. a handler to which no other can be composed to from the right. extensible-effects-concurrentA # that drops the left-over messages. extensible-effects-concurrentA 1 that terminates if there are unhandled messages. extensible-effects-concurrentA # that drops the left-over messages. extensible-effects-concurrentA smart constructor for s5 None#%&',-.14567=>?@ACHMPSUVX_kextensible-effects-concurrentA type class for 7 values that have an implementation which handles the .   None#%&',-.14567=>?@ACHMPSUVX_kY extensible-effects-concurrentThe reader effect for s for s, see  extensible-effects-concurrentInstead of passing around a & value and passing to functions like  or , a  can provided by a  effect, if there is only a  single server for a given I instance. This type alias is convenience to express that an effect has  and a reader for a .extensible-effects-concurrentSend an v request that has no return value and return as fast as possible. The type signature enforces that the corresponding  clause is [. The operation never fails, if it is important to know if the message was delivered, use  instead.,The message will be reduced to normal form () in the caller process.extensible-effects-concurrentSend an : request and wait for the server to return a result value.3The type signature enforces that the corresponding  clause is .Always prefer   over  extensible-effects-concurrentSend an : request and wait for the server to return a result value.3The type signature enforces that the corresponding  clause is .OIf the server that was called dies, this function interrupts the process with j. If the server takes longer to reply than the given timeout, this function interrupts the process with .!Always prefer this function over  extensible-effects-concurrent"Run a reader effect that contains the one server handling a specific  instance. extensible-effects-concurrentGet the  registered with  . extensible-effects-concurrentLike  but take the  from the reader provided by  . extensible-effects-concurrentLike  but take the  from the reader provided by  .           None#%&',-.14567=>?@ACHMPSUVX_k؀extensible-effects-concurrent]Contains the communication channels to interact with a scheduler running in its' own thread.extensible-effects-concurrent>Fork a scheduler with a process that communicates with it via $, which is also the reason for the Lift IO constraint.extensible-effects-concurrent?Exit the scheduler immediately using an asynchronous exception.extensible-effects-concurrentSend a V effect to the main process of a scheduler, this blocks until the effect is executed.extensible-effects-concurrentCombination of  and .extensible-effects-concurrentCombination of  and .None#%&',-.14567=>?@ACHMPSUVX_kextensible-effects-concurrent<Alias for the effect that contains the observers managed by !extensible-effects-concurrentInternal state for !extensible-effects-concurrentAn  for managing 6s, encompassing registration and de-registration of s.extensible-effects-concurrent.Describes a process that observes another via   messages.An observer consists of a filter and a process id. The filter converts an observation to a message understood by the observer process, and the  is used to send the message.extensible-effects-concurrent$This message denotes that the given # should receive observations until  is received.extensible-effects-concurrent$This message denotes that the given ) should not receive observations anymore.extensible-effects-concurrent.This message denotes that the given value was ".extensible-effects-concurrentAnd an ; to the set of recipients for all observations reported by "{. Note that the observers are keyed by the observing process, i.e. a previous entry for the process contained in the m is overwritten. If you want multiple entries for a single process, just combine several filter functions.extensible-effects-concurrent Send the  messageextensible-effects-concurrent Based on the  instance for \ this simplified writing a callback handler for observations. In order to register to and  use .extensible-effects-concurrentUse a  as an  for .extensible-effects-concurrent Create an  that conditionally accepts all observations of the given type and applies the given function to them; the function takes an observation and returns an 1 cast that the observer server is compatible to. extensible-effects-concurrent#Provide the implementation for the  Api, this handled  and  messages. It also adds the  constraint to the effect list.!extensible-effects-concurrentKeep track of registered s. Handle the  introduced by  ."extensible-effects-concurrent>Report an observation to all observers. The process needs to ! and to  .extensible-effects-concurrentA minimal Api for handling observations. This is one simple way of receiving observations - of course users can use any other  ) message type for receiving observations.extensible-effects-concurrentzApi for managing observers. This can be added to any server for any number of different observation types. The functions ! and  ' are used to include observer handling; !" !"None#%&',-.14567=>?@ACHMPSUVX_k)extensible-effects-concurrentA  for an *.*extensible-effects-concurrent Contains a  capturing observations. See /, +.+extensible-effects-concurrent=Read queued observations captured and enqueued in the shared  by /v. This blocks until something was captured or an interrupt or exceptions was thrown. For a non-blocking variant use , or -.,extensible-effects-concurrent=Read queued observations captured and enqueued in the shared  by /9. Return the oldest enqueued observation immediately or  if the queue is empty. Use ++ to block until an observation is observed.-extensible-effects-concurrentTRead at once all currently queued observations captured and enqueued in the shared  by /]. This returns immediately all currently enqueued observations. For a blocking variant use +..extensible-effects-concurrent-Create a mutable queue for observations. Use /C for a simple way to get a process that enqueues all observations.Example withObservationQueue 100 $ do q <- ask @(ObservationQueueReader TestEvent) wq <- spawnLinkObservationQueueWriter q registerObserver wq testServer ... cast testServer DoSomething evt <- readObservationQueue @TestEvent ... /extensible-effects-concurrent'Spawn a process that can be used as an + that enqueues the observations into an *. See . for an example.$The observations can be obtained by +. All observations are captured up to the queue size limit, such that the first message received will be first message returned by +.)*+,-./*)+,-./None#%&',-.14567=>?@ACHMPSUVX_k$0extensible-effects-concurrentAlias for the  that contains the captured s from 1.1extensible-effects-concurrentA 7 monad that provides pure logging by capturing via the  effect.4extensible-effects-concurrentA 7 monad that provides pure logging by capturing via the  effect.See %5extensible-effects-concurrentRun a  for s.Such a  is needed to handle 06extensible-effects-concurrentA  monad for pure logging.The " instance for this type assumes a  effect.012345412305None#%&',-.14567=>?@ACHMPSUVX_kC:extensible-effects-concurrentThe concrete list of "ects for logging with an IO based , and a .;extensible-effects-concurrentA  that uses an  action to write the message.This is just an alias for  but with IOT as parameter. This reduces the need to apply something to the extra type argument @IO.,Example use cases for this function are the consoleLogWriter and the <.<extensible-effects-concurrentA  that renders s to strings via  and prints them to an  using  hPutStrLn.=extensible-effects-concurrentEnable logging to IO using the >.Example: exampleWithIoLogging :: IO () exampleWithIoLogging = runLift $ withIoLogging debugTraceLogWriter "my-app" local7 (lmSeverityIsAtLeast informationalSeverity) $ logInfo "Oh, hi there">extensible-effects-concurrentDecorate an IO based  to fill out these fields in s::The messages will carry the given application name in the e field.The o- field contains the UTC time of the log eventThe g, field contains the FQDN of the current hostThe f field contains the given It works by using .?extensible-effects-concurrent Render a , but set the timestamp and thread id fields.=extensible-effects-concurrentThe ) that will be used to write log messages.extensible-effects-concurrent-The default application name to put into the e field.extensible-effects-concurrent.The default RFC-5424 facility to put into the f field.extensible-effects-concurrentEThe inital predicate for log messages, there are some pre-defined in ,Control.Eff.Log.Message#PredefinedPredicates>extensible-effects-concurrent-The default application name to put into the e field.extensible-effects-concurrent.The default RFC-5424 facility to put into the f field.extensible-effects-concurrentThe IO based writer to decorate:;<=>?;<>=:?None#%&',-.14567=>?@ACHMPSUVX_kV8@extensible-effects-concurrent$Enable logging to a file, with some  fields preset as described in =.@If the file or its directory does not exist, it will be created.Example: exampleWithFileLogging :: IO () exampleWithFileLogging = runLift $ withFileLogging "/var/log/my-app.log" "my-app" local7 allLogMessages $ logInfo "Oh, hi there" To vary the  use =.Aextensible-effects-concurrentEnable logging to a file.JIf the file or its directory does not exist, it will be created. Example: exampleWithFileLogWriter :: IO () exampleWithFileLogWriter = runLift $ withSomeLogging @IO $ withFileLogWriter "test.log" $ logInfo "Oh, hi there"@extensible-effects-concurrentPath to the log-file.extensible-effects-concurrent-The default application name to put into the e field.extensible-effects-concurrent.The default RFC-5424 facility to put into the f field.extensible-effects-concurrentEThe inital predicate for log messages, there are some pre-defined in ,Control.Eff.Log.Message#PredefinedPredicatesAextensible-effects-concurrentPath to the log-file.@A@ANone#%&',-.14567=>?@ACHMPSUVX_kg&Bextensible-effects-concurrentEnable logging via  using the D , with some  fields preset as in =. Log messages are rendered using .Example: exampleWithTraceLogging :: IO () exampleWithTraceLogging = runLift $ withTraceLogging "my-app" local7 allLogMessages $ logInfo "Oh, hi there"Cextensible-effects-concurrentEnable logging via  using the D!. The logging monad type can be any type with a  instance. Log messages are rendered using .Example: exampleWithTraceLogWriter :: IO () exampleWithTraceLogWriter = runLift $ withSomeLogging @IO $ withTraceLogWriter $ logInfo "Oh, hi there"Dextensible-effects-concurrentWrite s via .Bextensible-effects-concurrent-The default application name to put into the e field.extensible-effects-concurrent.The default RFC-5424 facility to put into the f field.extensible-effects-concurrentEThe inital predicate for log messages, there are some pre-defined in ,Control.Eff.Log.Message#PredefinedPredicatesBCDCBDNone#%&',-.14567=>?@ACHMPSUVX_kz1Eextensible-effects-concurrentEnable logging to standard output using the G , with some  fields preset as in =. Log messages are rendered using .Example: exampleWithConsoleLogging :: IO () exampleWithConsoleLogging = runLift $ withConsoleLogging "my-app" local7 allLogMessages $ logInfo "Oh, hi there" To vary the  use =.Fextensible-effects-concurrentEnable logging to standard output using the G. Log messages are rendered using .Example: exampleWithConsoleLogWriter :: IO () exampleWithConsoleLogWriter = runLift $ withSomeLogging @IO $ withConsoleLogWriter $ logInfo "Oh, hi there"Gextensible-effects-concurrentWrite %s to standard output, formatted with ?.It uses H with .Hextensible-effects-concurrentA  that uses a  to render, and  to print it.Eextensible-effects-concurrent-The default application name to put into the e field.extensible-effects-concurrent.The default RFC-5424 facility to put into the f field.extensible-effects-concurrentEThe inital predicate for log messages, there are some pre-defined in ,Control.Eff.Log.Message#PredefinedPredicatesEFGHFEGHNone#%&',-.14567=>?@ACHMPSUVX_kIextensible-effects-concurrentThis is a wrapper around J and =.Example: exampleWithAsyncLogging :: IO () exampleWithAsyncLogging = runLift $ withAsyncLogWriter consoleLogWriter (1000::Int) "my-app" local0 allLogMessages $ do logMsg "test 1" logMsg "test 2" logMsg "test 3" Jextensible-effects-concurrentMove the current  into its own thread.7A bounded queue is used to forward logs to the process.@If an exception is received, the logging process will be killed.Log messages are deeply evaluated before being sent to the logger process, to prevent that lazy evaluation leads to heavy work being done in the logger process instead of the caller process.Example: exampleAsyncLogWriter :: IO () exampleAsyncLogWriter = runLift $ withLogging consoleLogWriter $ withAsyncLogWriter (1000::Int) $ do logMsg "test 1" logMsg "test 2" logMsg "test 3" Iextensible-effects-concurrentYSize of the log message input queue. If the queue is full, message are dropped silently.extensible-effects-concurrent-The default application name to put into the e field.extensible-effects-concurrent.The default RFC-5424 facility to put into the f field.extensible-effects-concurrentEThe inital predicate for log messages, there are some pre-defined in ,Control.Eff.Log.Message#PredefinedPredicatesJextensible-effects-concurrentYSize of the log message input queue. If the queue is full, message are dropped silently.IJJINone#%&',-.14567=>?@ACHMPSUVX_k0 extensible-effects-concurrentVInternal data structure that is part of the coroutine based scheduler implementation.extensible-effects-concurrentaAdd monitor: If the process is dead, enqueue a ProcessDown message into the owners message queueKextensible-effects-concurrentLike L but pure. The yield effect is just  return (). schedulePure == runIdentity . O (Identity . run) (return ())Lextensible-effects-concurrentInvoke O with lift  as yield effect. scheduleIO runEff == O (runLift . runEff) (liftIO )Mextensible-effects-concurrentInvoke O with lift  as yield effect. scheduleMonadIOEff == O id (liftIO )Nextensible-effects-concurrentRun processes that have the  and the 8 effects. The user must provide a log handler function."Log messages are evaluated strict. scheduleIOWithLogging == L . Oextensible-effects-concurrent Handle the G effect, as well as all lower effects using an effect handler function. Execute the main  and all the other processes E}ed by it in the current thread concurrently, using a co-routine based, round-robin scheduler. If a process exits with eg.g ] or ^" or is killed by another process Left ...: is returned. Otherwise, the result will be wrapped in a Right.UEvery time a process _yields_ the effects are evaluated down to the a value of type m (Either String a).4If the evaluator function runs the action down e.g. IOh this might improve memory consumption, for long running services, with processes that loop endlessly.extensible-effects-concurrent Internal  handler function.Pextensible-effects-concurrent Execute a  using O on top of  IO and  String effects.Oextensible-effects-concurrentAn that performs a yield w.r.t. the underlying effect r . E.g. if Lift IO$ is present, this might be: @lift .KLMNOPOKLMNPNone#%&',-.14567=>?@ACHMPSUVX_kёextensible-effects-concurrenttA message queue of a process, contains the actual queue and maybe an exit reason. The message queue is backed by a  sequence with  values.extensible-effects-concurrent2Information about a process, needed to implement , handlers. The message queue is backed by a  that contains a .extensible-effects-concurrent Return any  from a  in a  and reset the  field to  in the .extensible-effects-concurrentjContains all process info'elements, as well as the state needed to implement inter-process communication.extensible-effects-concurrent"Set of monitors and monitor ownersTextensible-effects-concurrentThe concrete list of 'ects for this scheduler implementation.Uextensible-effects-concurrentType class constraint to indicate that an effect union contains the effects required by every process and the scheduler implementation itself.Vextensible-effects-concurrent+The concrete list of the effects, that the  usesWextensible-effects-concurrentThe concrete list of Dects of processes compatible with this scheduler. This builds upon T.extensible-effects-concurrent/Add monitor: If the process is dead, enqueue a ' message into the owners message queueextensible-effects-concurrent Create a new extensible-effects-concurrent Create a new extensible-effects-concurrent Create a new k run an IO action, catching all exceptions, and when the actions returns, clean up and kill all processes.Xextensible-effects-concurrent<Start the message passing concurrency system then execute a  on top of T0 effect. All logging is sent to standard output.Yextensible-effects-concurrent<Start the message passing concurrency system then execute a  on top of T0 effect. All logging is sent to standard output.Zextensible-effects-concurrentjThis is the main entry point to running a message passing concurrency application. This function takes a  on top of the T effect for concurrent logging.TUVWXYZZXYWVTUNone#%&',-.14567=>?@ACHMPSUVX_k@\extensible-effects-concurrent$Enable logging to a remote host via UDP , with some  fields preset as in =.See &]extensible-effects-concurrent+Enable logging to a (remote-) host via UDP.See &\extensible-effects-concurrent rendering functionextensible-effects-concurrentHostname or IPextensible-effects-concurrent Port e.g. "514"extensible-effects-concurrent-The default application name to put into the e field.extensible-effects-concurrent.The default RFC-5424 facility to put into the f field.extensible-effects-concurrentEThe inital predicate for log messages, there are some pre-defined in ,Control.Eff.Log.Message#PredefinedPredicates]extensible-effects-concurrent rendering functionextensible-effects-concurrentHostname or IPextensible-effects-concurrent Port e.g. "514"extensible-effects-concurrent rendering functionextensible-effects-concurrentHostname or IPextensible-effects-concurrent Port e.g. "514"\]]\None#%&',-.14567=>?@ACHMPSUVX_k^extensible-effects-concurrentEnable logging to a unix domain socket , with some  fields preset as in =.See '_extensible-effects-concurrent2Enable logging to a (remote-) host via UnixSocket.See '^extensible-effects-concurrent rendering functionextensible-effects-concurrentPath to the socket fileextensible-effects-concurrent-The default application name to put into the e field.extensible-effects-concurrent.The default RFC-5424 facility to put into the f field.extensible-effects-concurrentEThe inital predicate for log messages, there are some pre-defined in ,Control.Eff.Log.Message#PredefinedPredicates_extensible-effects-concurrent rendering functionextensible-effects-concurrentPath to the socket fileextensible-effects-concurrent rendering functionextensible-effects-concurrentPath to the socket file^__^None#%&',-.14567=>?@ACHMPSUVX_kc`extensible-effects-concurrentExample code for:E; See laextensible-effects-concurrentExample code for:Gbextensible-effects-concurrentExample code for:cextensible-effects-concurrentExample code for:}~dextensible-effects-concurrentExample code for:54eextensible-effects-concurrentExample code for:Ifextensible-effects-concurrent(Example code for RFC5424 formatted logs.gextensible-effects-concurrent@Example code for RFC3164 with RFC5424 time stamp formatted logs.hextensible-effects-concurrent1Example code logging via a unix domain socket to devlog.iextensible-effects-concurrent1Example code logging via a unix domain socket to devlog.jextensible-effects-concurrent;Example code logging RFC5424 via UDP port 514 on localhost.kextensible-effects-concurrent;Example code logging RFC5424 via UDP port 514 on localhost.lextensible-effects-concurrentExample logging client code Dqhmextensible-effects-concurrent'Example logging client code using many bs.}~`abcdefghijklm`abcdefghijklmNone#%&',-.14567=>?@ACHMPSUVX_k wnextensible-effects-concurrent A version of ()! that hopefully tricks GHC into notP creating a space leak. The intuition is, that we want to do something that is cheap, and hence should be  recomputed instead of shared.oextensible-effects-concurrent A version of (*! that hopefully tricks GHC into notP creating a space leak. The intuition is, that we want to do something that is cheap, and hence should be  recomputed instead of shared.nono None#%&',-.14567=>?@ACHMPSUVX_k  !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^      !")*+,-./012345:;<=>?@ABCDEFGHIJKPTUVWXYZ\]^_no      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^      !")*+,-./TUVWXYZKP+None$%&',-.14567=>?@ACHMPSUVX_kk,-./0123456789::;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~./00./       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"""""""""""                                                 ! " $ # $ % & ' ( ) * + , -./00123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|%}~'&"" ++++++++;extensible-effects-concurrent-0.22.1-FKlhjcXeDP7FN41qcROTm9Control.Eff.ExceptionExtraControl.Eff.Log.MessageControl.Eff.Log.MessageRendererControl.Eff.Log.WriterControl.Eff.Log.HandlerControl.Eff.Concurrent.Process$Control.Eff.Concurrent.Process.TimerControl.Eff.Concurrent.ApiControl.Eff.Concurrent!Control.Eff.Concurrent.Api.Server$Control.Eff.Concurrent.Api.GenServer!Control.Eff.Concurrent.Api.Client*Control.Eff.Concurrent.Process.Interactive#Control.Eff.Concurrent.Api.Observer)Control.Eff.Concurrent.Api.Observer.QueueControl.Eff.LogWriter.CaptureControl.Eff.LogWriter.IOControl.Eff.LogWriter.File Control.Eff.LogWriter.DebugTraceControl.Eff.LogWriter.ConsoleControl.Eff.LogWriter.Async6Control.Eff.Concurrent.Process.SingleThreadedScheduler.Control.Eff.Concurrent.Process.ForkIOSchedulerControl.Eff.LogWriter.UDP Control.Eff.LogWriter.UnixSocketControl.Eff.Log.ExamplesControl.Eff.LoopDebugTraceControl.Exception.Safe SomeExceptionAsynccancel"Control.Eff.Concurrent.Api.RequestControl.Eff.LogcallexampleLogCaptureexampleUdpRFC3164LoggingexampleDevLogSyslogLogging Control.Monadforever replicateM_#Paths_extensible_effects_concurrentliftTry maybeThrow$fMonadMaskEff$fMonadCatchEff$fMonadThrowEff$fMonadMaskEff0$fMonadCatchEff0$fMonadThrowEff0$fMonadMaskEff1$fMonadCatchEff1$fMonadThrowEff1$fMonadMaskEff2$fMonadCatchEff2$fMonadThrowEff2Facility fromFacilitySeverity fromSeverity SdParameter MkSdParameterStructuredDataElement SdElement _sdElementId_sdElementParameters LogMessage MkLogMessage _lmFacility _lmSeverity _lmTimestamp _lmHostname _lmAppName _lmProcessId _lmMessageId_lmStructuredData _lmThreadId _lmSrcLoc _lmMessageemergencySeverity alertSeveritycriticalSeverity errorSeveritywarningSeveritynoticeSeverityinformationalSeverity debugSeveritykernelMessagesuserLevelMessages mailSystem systemDaemonssecurityAuthorizationMessages4linePrinterSubsystemnetworkNewsSubsystem uucpSubsystem clockDaemonsecurityAuthorizationMessages10 ftpDaemon ntpSubsystemlogAuditFacilitylogAlertFacility clockDaemon2local0local1local2local3local4local5local6local7$fNFDataSdParameter$fNFDataStructuredDataElement$fDefaultSeverity$fShowSeverity$fDefaultFacility$fNFDataLogMessage$fShowLogMessage$fDefaultLogMessage$fEqSdParameter$fOrdSdParameter$fGenericSdParameter$fShowSdParameter$fEqStructuredDataElement$fOrdStructuredDataElement$fGenericStructuredDataElement$fShowStructuredDataElement $fEqSeverity $fOrdSeverity$fGenericSeverity$fNFDataSeverity $fEqFacility $fOrdFacility$fShowFacility$fGenericFacility$fNFDataFacility$fEqLogMessage$fGenericLogMessage sdElementIdsdElementParameters LogPredicate ToLogMessage toLogMessage lmAppName lmFacility lmHostname lmMessage lmMessageId lmProcessId lmSeveritylmSrcLoclmStructuredData lmThreadId lmTimestamp setCallStackprefixLogMessagesWithsetLogMessageTimestampsetLogMessageThreadIdsetLogMessageHostname errorMessage infoMessage debugMessageerrorMessageIO infoMessageIOdebugMessageIOallLogMessages noLogMessages lmSeverityIslmSeverityIsAtLeastlmMessageStartsWithdiscriminateByAppName$fIsStringLogMessage$fToLogMessageText$fToLogMessageLogMessageLogMessageTimeRendererLogMessageRenderermkLogMessageTimeRenderersuppressTimestamprfc3164Timestamprfc5424Timestamprfc5424NoZTimestamprenderLogMessageBodyrenderLogMessageBodyNoLocationrenderLogMessageBodyFixWidthrenderMaybeLogMessageLensrenderLogMessageSrcLocrenderSyslogSeverityAndFacilityrenderLogMessageSyslogrenderLogMessageConsoleLog renderRFC3164"renderRFC3164WithRFC5424TimestampsrenderRFC3164WithTimestamp renderRFC5424renderRFC5424NoLocationrenderRFC5424Header PureLogWriterMkPureLogWriterrunPureLogWriterHandleLogWriterLogWriterEffectshandleLogWriterEffectliftWriteLogMessageLogWriterReader LogWriter MkLogWriter runLogWriterrunLogWriterReader askLogWriterlocalLogWriterReader noOpLogWriterfilteringLogWritermappingLogWritermappingLogWriterM$fDefaultLogWriter$fMonadBaseControlmEff$fHandleLogWriterReaderea->$fHandleLogWriterIO$fHandleLogWriterPureLogWriter$fApplicativePureLogWriter$fFunctorPureLogWriter$fMonadPureLogWriterLogsToLogs withLoggingwithSomeLoggingrunLogslogMsglogWithSeveritylogWithSeverity' logEmergencylogAlert logCriticallogError logWarning logNoticelogInfologDebug logEmergency' logAlert' logCritical' logError' logWarning' logNotice'logInfo' logDebug'askLogPredicatesetLogPredicatemodifyLogPredicateincludeLogMessagesexcludeLogMessagesrespondToLogMessageinterceptLogMessagesmodifyLogWriter setLogWriter censorLogs censorLogsM addLogWriter$fHandleLogsea-> ProcessId_fromProcessId ProcessDown downReference downReasonMonitorReference monitorIndexmonitoredProcessSomeExitReasonInterruptableProcess InterruptsInterruptReason ExitReasonProcessFinishedProcessNotRunningProcessTimeoutLinkedProcessCrashed ProcessError ExitNormally NotRecoveredUnexpectedExceptionKilled ExitSeverity NormalExitCrash ExitRecovery Recoverable NoRecovery ProcessStateProcessBooting ProcessIdle ProcessBusyProcessBusySendingProcessBusySendingShutdownProcessBusySendingInterruptProcessBusyReceivingProcessBusyLinkingProcessBusyUnlinkingProcessBusyMonitoringProcessBusyDemonitoringProcessInterruptedProcessShuttingDown ConsProcessMessageSelectorrunMessageSelector ResumeProcess Interrupted ResumeWith StrictDynamicProcess FlushMessages YieldProcessSelfPidSpawn SpawnLinkGetProcessStateShutdown SendShutdown SendInterrupt SendMessageReceiveSelectedMessage MakeReferenceMonitor DemonitorLinkUnlinktoStrictDynamicfromStrictDynamicunwrapStrictDynamic selectMessage filterMessageselectMessageWithselectDynamicMessageselectAnyMessagetoExitRecoverytoExitSeverity isBecauseDownprovideInterruptsShutdownhandleInterruptstryUninterrupted logInterruptsexitOnInterruptprovideInterrupts!mergeEitherInterruptAndExitReason interruptisCrash isRecoverablefromSomeExitReason toCrashReasonlogProcessExitexecuteAndResumeexecuteAndResumeOrExitexecuteAndResumeOrThrow yieldProcess sendMessagesendAnyMessage sendShutdown sendInterruptspawnspawn_ spawnLinkspawnRaw spawnRaw_isProcessAlivereceiveAnyMessagereceiveSelectedMessagereceiveMessage flushMessagesreceiveSelectedLoopreceiveAnyLoop receiveLoopself makeReferencemonitor demonitor withMonitorreceiveWithMonitorbecauseProcessIsDownselectProcessDown linkProcess unlinkProcess exitBecause exitNormally exitWithError$fShowStrictDynamic$fAlternativeMessageSelector$fApplicativeMessageSelector$fDefaultProcessState$fNFDataProcessState$fShowExitRecovery$fNFDataExitRecovery$fNFDataExitSeverity$fShowExitSeverity$fShowProcessId$fReadProcessId$fShowMonitorReference$fNFDataMonitorReference$fEqExitReason$fOrdExitReason$fNFDataExitReason$fExceptionExitReason$fExceptionExitReason0$fShowExitReason$fNFDataSomeExitReason$fShowSomeExitReason$fEqSomeExitReason$fOrdSomeExitReason$fShowProcessDown$fNFDataProcessDown$fNFData1ResumeProcess$fNFDataResumeProcess $fShowProcess$fSemigroupMessageSelector$fMonoidMessageSelector$fFunctorMessageSelector$fReadProcessState$fShowProcessState$fOrdProcessState$fEqProcessState$fEnumProcessState$fGenericProcessState$fOrdExitRecovery$fEqExitRecovery$fGenericExitRecovery$fOrdExitSeverity$fEqExitSeverity$fGenericExitSeverity $fEqProcessId$fOrdProcessId$fBoundedProcessId$fNumProcessId$fEnumProcessId$fIntegralProcessId$fRealProcessId$fNFDataProcessId$fReadMonitorReference$fEqMonitorReference$fOrdMonitorReference$fGenericMonitorReference$fGenericProcessDown$fEqProcessDown$fOrdProcessDown$fGenericResumeProcess$fGeneric1ResumeProcess$fShowResumeProcess fromProcessId TimerElapsedfromTimerElapsedTimerReferenceTimeoutfromTimeoutMicros receiveAfterreceiveSelectedAfterreceiveSelectedWithMonitorAfterselectTimerElapsed sendAfter startTimer cancelTimer $fShowTimeout$fShowTimerReference$fShowTimerElapsed$fNFDataTimeout $fOrdTimeout $fEqTimeout $fNumTimeout$fIntegralTimeout $fRealTimeout $fEnumTimeout$fNFDataTimerReference$fOrdTimerReference$fEqTimerReference$fNumTimerReference$fIntegralTimerReference$fRealTimerReference$fEnumTimerReference$fNFDataTimerElapsed$fOrdTimerElapsed$fEqTimerElapsedServer _fromServer Synchronicity Synchronous AsynchronousApi $fShowServer $fEqServer $fOrdServer$fNFDataServer fromServer proxyAsServerasServer RequestOrigin_requestOriginPid_requestOriginCallRefReplyRequestCallCastmkRequestOrigin sendReplyInterruptCallback ToServerPids ServerPids toServerPidsMessageCallbackCallbackResult AwaitNext StopServerspawnApiServerspawnLinkApiServerspawnApiServerStatefulspawnApiServerEffectfulspawnLinkApiServerEffectful apiServerLoophandleMessageshandleSelectedMessageshandleAnyMessages handleCasts handleCallshandleCastsAndCallshandleCallsDeferredhandleProcessDowns^:fallbackHandlerdropUnhandledMessagesexitOnUnhandledlogUnhandledMessagesstopServerOnInterrupt$fDefaultMessageCallback$fMonoidMessageCallback$fSemigroupMessageCallback$fToServerPidsTYPEapi1$fToServerPids[]:$fToServerPids[][]$fDefaultInterruptCallback SomeMessage MkSomeMessageApiReply GenServerGenServerState genServerInitgenServerHandlegenServerInterruptgenServerInfoCommand runGenServer ServerReader ServesApicastcallWithTimeoutregisterServer whereIsServercallRegisteredcastRegisteredSchedulerSessionforkInteractiveSchedulerkillInteractiveSchedulersubmit submitCast submitCall ObserverStateObserverRegistryObserverRegisterObserverForgetObserverObservedregisterObserverforgetObserverhandleObservations toObserver toObserverForhandleObserverRegistrationmanageObserversobserved $fNFDataApi $fEqObserver $fOrdObserver$fShowObserver$fNFDataObserver $fNFDataApi0ObservationQueueReaderObservationQueuereadObservationQueuetryReadObservationQueueflushObservationQueuewithObservationQueuespawnLinkObservationQueueWriterCaptureLogWriter CaptureLogs MkCaptureLogs unCaptureLogscaptureLogWriterrunCaptureLogWriter$fHandleLogWriterCaptureLogs$fFunctorCaptureLogs$fApplicativeCaptureLogs$fMonadCaptureLogs LoggingAndIo mkLogWriterIOioHandleLogWriter withIoLoggingdefaultIoLogWriterprintLogMessagewithFileLoggingwithFileLogWriterwithTraceLoggingwithTraceLogWriterdebugTraceLogWriterwithConsoleLoggingwithConsoleLogWriterconsoleLogWriterstdoutLogWriterwithAsyncLoggingwithAsyncLogWriter schedulePure scheduleIOscheduleMonadIOEffscheduleIOWithLogging scheduleMdefaultMainSingleThreaded $fShowSTS $fShowOnYield$fDefaultMessageQ SchedulerIOHasSchedulerIOInterruptableProcEffProcEff defaultMaindefaultMainWithLogWriterschedule$fShowProcessInfowithUDPLoggingwithUDPLogWriterwithUnixSocketLoggingwithUnixSocketLogWriterexampleLoggingexampleWithLoggingexampleWithSomeLoggingexampleLogPredicateexampleAsyncLoggingexampleRFC5424Logging*exampleRFC3164WithRFC5424TimestampsLoggingexampleDevLogRFC5424LoggingexampleUdpRFC5424LoggingloggingExampleClientlogPredicatesExampleClient foreverCheapreplicateCheapM_baseGHC.Exception.Type Exception1extensible-effects-5.0.0.1-KFGF1U0sTnhHZKk4SF5FANControl.Eff.Exception liftEither GHC.MaybeMaybe liftMaybeFail ignoreFail liftMaybeM liftEitherM rethrowErroronFail catchErrorrunFailrunErrordie throwError_ throwErrorexc withExceptionExcGHC.Stack.TypesSrcLoc GHC.Conc.SyncThreadId myThreadId time-1.8.0.2Data.Time.Format formatTimeData.Time.Format.Localeiso8601DateFormatrenderShowMaybeLogMessageLenssdName sdParamValueControl.Eff.InternalEffData.OpenUnion SetMember1data-default-class-0.1.2.0-FeIQ5tLoVZBHMSgrT9zptQData.Default.Classdefdeepseq-1.4.4.0Control.DeepSeqdeepseq text-1.2.3.1Data.Text.InternalTextGHC.BaseString,monad-control-1.0.2.3-K5aaLNgoHQJImsHP4Tz6gtControl.Monad.Trans.ControlMonadBaseControl(exceptions-0.10.1-DdWfqA1lutT4wybeL2xRnxControl.Monad.Catch MonadMask MonadCatch MonadThrowsendLogMessageToLogWriterghc-prim GHC.TypesIO Alternative Data.DynamicDynamicNothingIntTrueJustforce Data.EitherEitherrnfData.Typeable.InternalTypeableLeftApiType ReplyTypeControl.Eff.Reader.StrictReaderGHC.MVarMVar ObserversD:R:ApiObserverr0D:R:ApiObserverRegistryr0 stm-2.5.0.0Control.Concurrent.STM.TBQueueTBQueueControl.Eff.Writer.StrictWriterGHC.IO.Handle.TypesHandle Debug.TracetraceMMonad Data.Text.IOputStrLnOnYield addMonitoringyieldLift handleProcessMessageQcontainers-0.6.0.1Data.Sequence.InternalSeq ProcessInfoTVartryTakeNextShutdownRequestSTM_shutdownRequestsSchedulerState_processMonitorsnewProcessInfonewSchedulerStatewithNewSchedulerState withUDPSocketwithUnixSocketSocketversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName