!W".      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-. / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                     !"#$%&'()*+,-$ None$%&',-.145678=>?@ACHMPSUVX_k1w.extensible-effects-concurrent Render a / to a 0.1extensible-effects-concurrent Render a / to a 0 with a precedence parameter.2extensible-effects-concurrentThis is equivalent to 3 03extensible-effects-concurrentAn internal utility to print /" without the kinds. This is like 4 in that it accepts a  precedenceS parameter, and the result is in parentheses when the precedence is higher than 9..123None$%&',-.145678=>?@ACHMPSUVX_k5extensible-effects-concurrentCatch 5 thrown by an effect.extensible-effects-concurrentVery similar to 6 but for 7 s. Unlike 84 this will throw the given value (instead of using 9).:;8<6=>?@ABCDEFGH9None%%&',-.145678=>?@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 I of a mextensible-effects-concurrentA lens for the  of a nextensible-effects-concurrentA lens for the J 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 J of the calling process (see K) 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%%&',-.145678=>?@ACHMPSUVX_kqׇextensible-effects-concurrentA rendering function for the o field.extensible-effects-concurrent rendering functionextensible-effects-concurrentMake a  using L 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 M (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.Nextensible-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.Oextensible-effects-concurrentExtract the name of an 3 the length is cropped to 32 according to RFC 5424.Pextensible-effects-concurrentExtract the value of an .extensible-effects-concurrent$The format string that is passed to LNone%%&',-.145678=>?@ACHMPSUVX_kextensible-effects-concurrentZThe instances of this class are the monads that define (side-) effect(s) of writting logs.extensible-effects-concurrentThe Qects required by the  method.extensible-effects-concurrentRun the side effect of a  in a compatible Q.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 R;, 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 Sextensible-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 capturing messages using a T.The " instance for this type assumes a T effect.extensible-effects-concurrentEmbed U actions consuming all sVWXYNone%%&',-.145678=>?@ACHMPSUVX_kcT(extensible-effects-concurrentA constraint that required  U e and Z U e.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 a.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 a.1In contrast the functions based on modifying the  , such as  or C, are save to use in combination with the aforementioned liftings.bextensible-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-concurrentAThis instance is for pure logging - i.e. discarding all messages.extensible-effects-concurrent!This instance allows lifting the  effect into a base monad, e.g. U. This instance needs a / in the base monad, that is capable to handle  invocations.%%None%%&',-.145678=>?@ACHMPSUVX_kl4extensible-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-concurrentGeptions containing s. See F, I or Jextensible-effects-concurrent=A constraint for an effect set that requires the presence of .4This constrains the effect list to look like this:  [e1 ... eN, %& [e(N+1) .. e(N+k)], e(N+1) .. e(N+k)] It contrains e to support the (only) % effect.This is more relaxed that  since it does not require .extensible-effects-concurrentCons %( onto a list of effects. This is called  SafeProcesses3 because the the actions cannot be interrupted in.extensible-effects-concurrent=A constraint for an effect set that requires the presence of .4This constrains the effect list to look like this:  [e1 ... eN, , %& [e(N+1) .. e(N+k)], e(N+1) .. e(N+k)] It contrains e beyond  to encompass .extensible-effects-concurrentThis adds a layer of the  effect on top of extensible-effects-concurrent s which are .extensible-effects-concurrentxA sum-type with reasons for why a process operation, such as receiving messages, is interrupted in 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-concurrentAn error causes the process to exit immediately. For example an unexpected runtime exception was thrown, i.e. an exception derived from !" Or a  Interrupt was not recovered.extensible-effects-concurrentUA process shall exit immediately, without any cleanup 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 slice extensible-effects-concurrent%The process is busy with non-blocking extensible-effects-concurrentThe process is busy with 5 extensible-effects-concurrent*The process is busy with sending a message extensible-effects-concurrent The process is busy with killingextensible-effects-concurrent The process is busy with killingextensible-effects-concurrentThe process blocked by a bextensible-effects-concurrentThe process blocked by a rextensible-effects-concurrentThe process blocked by a sextensible-effects-concurrentThe process blocked by a kextensible-effects-concurrentThe process blocked by a lextensible-effects-concurrentThe process was interruptedextensible-effects-concurrent#The process was shutdown or crashedextensible-effects-concurrentAA function that decided if the next message will be received by /%. It conveniently is an instance of c 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 NA 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-concurrent Serialize a message into a  value to be sent via W.AThis indirection allows, among other things, the composition of %&s.extensible-effects-concurrentData flows between %es via these messages.&This is just a newtype wrapper around d~. 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-concurrent!A multi-line text describing the current, state of a process for debugging purposes."extensible-effects-concurrentA short title for a % for logging purposes.%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 immediately&extensible-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 3 to it .+extensible-effects-concurrentTShutdown the process; irregardless of the exit reason, this function never returns,,extensible-effects-concurrentTShutdown another process immediately, the other process has no way of handling this!-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.0extensible-effects-concurrentGenerate a unique e for the current process.1 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 reason2 extensible-effects-concurrentRemove a monitor.3 extensible-effects-concurrentaConnect the calling process to another process, such that if one of the processes crashes (i.e. M returns f#), the other is shutdown with the  .4 extensible-effects-concurrent2Unlink the calling process from the other process.5extensible-effects-concurrent Update the  of a process6extensible-effects-concurrentGet the  (or g if the process is dead)7extensible-effects-concurrentAn isomorphism lens for the "8extensible-effects-concurrentAn isomorphism lens for the 9extensible-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 d.< 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 h 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 ied.Aextensible-effects-concurrentGet the Bextensible-effects-concurrentGet the  of a .Cextensible-effects-concurrentReturn either  or C from a  ;If the  is  then return Dextensible-effects-concurrentA predicate for linked process crashes.Eextensible-effects-concurrent Handle all s of an  by wrapping them up in C and then do a process +.Fextensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a c via a call to L.G extensible-effects-concurrentLike F, but instead of passing the  to a handler function, j is returned.Hextensible-effects-concurrent'Handle interrupts by logging them with Q and otherwise ignoring them.Iextensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a c via a call to L.Jextensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a c via a call to L.Kextensible-effects-concurrentWrap all (left) s into C and return the (right)  s as is.Lextensible-effects-concurrent Throw an , can be handled by F or I or J.Mextensible-effects-concurrentA predicate for crashes. A crash' happens when a process exits with an  other than Nextensible-effects-concurrentkA predicate for recoverable exit reasons. This predicate defines the exit reasons which functions such as ROextensible-effects-concurrent Partition a  back into either a  or a  Pextensible-effects-concurrentPrint a  to h a formatted ] when M is f>. This can be useful in combination with view patterns, e.g.: rlogCrash :: Interrupt -> Eff e () logCrash (toCrashReason -> Just reason) = logError reason logCrash _ = return ()Though this can be improved to: -logCrash = traverse_ logError . toCrashReasonQextensible-effects-concurrentLog the sRextensible-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 N, return the exit reason.Sextensible-effects-concurrent Execute a %: action and resume the process, exit the process when an  was raised. Use R to catch interrupts.Textensible-effects-concurrent Execute a %: action and resume the process, exit the process when an  was raised. Use R to catch interrupts.Uextensible-effects-concurrentUse S to execute ' . Refer to ' for more information.Vextensible-effects-concurrent-Send a message to a process addressed by the . See ..,The message will be reduced to normal form (k) by/in the caller process.Wextensible-effects-concurrentSend a d% value to a process addressed by the . See ..Xextensible-effects-concurrent Exit a process addressed by the Z. The process will exit, it might do some cleanup, but is ultimately unrecoverable. See ,.Yextensible-effects-concurrent&Interrupts a process addressed by the 7. The process might exit, or it may continue. | Like Y, but also return True iff the process to exit exists.Zextensible-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 C4. For specific use cases it might be better to use ].[extensible-effects-concurrentLike Z but return ().\ extensible-effects-concurrent0Start a new process, and immediately link to it.]extensible-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 Z might be better suited.^extensible-effects-concurrentLike ] but return ()._ extensible-effects-concurrentReturn f if the process is alive.`extensible-effects-concurrent Return the ",  and 2, for the given process, if the process is alive.aextensible-effects-concurrent Replace the  of the process.bextensible-effects-concurrent)Block until a message was received. See / for more documentation.cextensible-effects-concurrent0Block until a message was received, that is not g( after applying a callback to it. See / for more documentation.dextensible-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 ce extensible-effects-concurrentPRemove and return all messages currently enqueued in the process message queue.fextensible-effects-concurrentZEnter a loop to receive messages and pass them to a callback, until the function returns hy 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 N*, then the callback will be invoked with l C, otherwise the process will be exited with the same reason using t . See also / for more documentation.gextensible-effects-concurrentLike f but  not selective . See also @, f.hextensible-effects-concurrentLike f& but refined to casting to a specific / using <.iextensible-effects-concurrent Returns the  of the current process.jextensible-effects-concurrentGenerate a unique e for the current process.k 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 reasonl extensible-effects-concurrentRemove a monitor created with k.m extensible-effects-concurrentk8 another process before while performing an action and l afterwards.n extensible-effects-concurrentA I for receiving either a monitor of the given process or another message.o extensible-effects-concurrentMake an  for a  message. For example: @doSomething >>= either (interrupt . becauseProcessIsDown) returnp extensible-effects-concurrentA  for the  message of a specific process.'The parameter is the value obtained by k.qextensible-effects-concurrentA  for the ! message. of a specific process.In contrast to p this function matches the .r extensible-effects-concurrentaConnect the calling process to another process, such that if one of the processes crashes (i.e. M returns f#), the other is shutdown with the  .s extensible-effects-concurrent2Unlink the calling process from the other process.textensible-effects-concurrentExit the process with a .uextensible-effects-concurrentExit the process.vextensible-effects-concurrentExit the process with an error.extensible-effects-concurrentA  and a . EXPERIMENTALSee .extensible-effects-concurrent1Serialize and send a message to the process in a . EXPERIMENTAL      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvӚ%&'()*+,-./0123456"#$7 !89:;     UVWjdcebhfg<=>?@i_`aZ[\]^RSTLYtuvXrsklpqomnCANBDMPOQEFGIHJKNone&%&',-.145678=>?@ACHMPSUVX_kqextensible-effects-concurrent A class for  instances that embed other .This is a part of  provide instances for your s but in client code use the  constraint.*Instances of this class serve as proof to ! that a conversion into another  actually exists.A m for the embedded  is the center of this classLaws: %embeddedPdu = prism' embedPdu fromPduextensible-effects-concurrentA m for the embedded s.extensible-effects-concurrent Embed the 8 value of an embedded protocol into the corresponding  value.extensible-effects-concurrent Examine a > value from the outer protocol, and return it, if it embeds a ) of embedded protocol, otherwise return g/extensible-effects-concurrentThis type function takes an ' and analysis the reply type, i.e. the  and evaluates to either t for an Pdu x ( t) or to '()' for an Pdu x .extensible-effects-concurrentyThe (promoted) constructors of this type specify (at the type level) the reply behavior of a specific constructor of an Pdu 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-concurrentA n( that bundles the requirements for the  values of a protocol.This ensures that \s can be strictly and deeply evaluated and shown such that for example logging is possible.extensible-effects-concurrent6A set of constraints for types that can evaluated via o, compared via p and presented dynamically via /&, and represented both as values via q.extensible-effects-concurrent$A constraint that requires that the outer ( has a clause to embed values from the inner .!Also, this constraint requires a A instance, as a proof for a possible conversion of an embedded  value into to the enclosing .FThis generates better compiler error messages, when an embedding of a  into another.This is provided by F instances. The instances are required to provide a list of embedded  values in .'Note that every type embeds itself, so  Embeds x x always holds.extensible-effects-concurrent<This type class and the associated data family defines the protocol data units (PDU) of a protocol.TA Protocol in the sense of a communication interface description between processes._The first parameter is usually a user defined type that identifies the protocol that uses the s are. It maybe a phantom type.LThe second parameter specifies if a specific constructor of an (GADT-like) Pdu instance is ;, i.e. returns a result and blocks the caller or if it is Example: \ data BookShop deriving Typeable instance Typeable r => HasPdu BookShop r where data instance Pdu BookShop r where RentBook :: BookId -> Pdu BookShop ('Synchronous (Either RentalError RentalId)) BringBack :: RentalId -> Pdu BookShop 'Asynchronous deriving Typeable type BookId = Int type RentalId = Int type RentalError = String extensible-effects-concurrentDA type level list Protocol phantom types included in the associated  instance.HThis is just a helper for better compiler error messages. It relies on  to add the constraint .extensible-effects-concurrentThe protocol data unit type for the given protocol.extensible-effects-concurrentA server process for protocol.Protocols are represented by phantom types, which are used in different places to index type families and type class instances.A %' can send and receive any messages. An  wraps around a W and carries a phantom type to indicate the kinds of messages accepted by the process.ZAs a metaphor, communication between processes can be thought of waiting for and sending protocol data units belonging to some protocol.extensible-effects-concurrentDeserialize a  from a d+ i.e. from a message received by a process.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 APIextensible-effects-concurrent Convert an ) to an endpoint for an embedded protocol.See , .extensible-effects-concurrent Convert an 7 to an endpoint for a server, that embeds the protocol.See , .&rstuvwxyz{|}~  None$%&',-.145678=>?@ACHMPSUVX_k  extensible-effects-concurrent Target of a  reply.This combines a   with a  for a  using 2. There are to smart constructors for this type:  and . Because of  the  and p$ instances are implemented via the   instances. extensible-effects-concurrentWraps the source  and a unique identifier for a .extensible-effects-concurrentThe wrapper around replies to s.extensible-effects-concurrent/A wrapper sum type for calls and casts for the s of a protocolextensible-effects-concurrentCreate a new, unique   value for the current process.extensible-effects-concurrentTurn an  + to an origin for an embedded request (See ).)This is useful of a server delegates the calls and casts: for an embedded protocol to functions, that require the  and   in order to call . See also .extensible-effects-concurrentTurn an embedded   to a   for the bigger request.This is the inverse of .*This function is strict in all parameters.extensible-effects-concurrentTurn a  for a ! instance that contains embedded  values into a   for the embedded .)This is useful of a server delegates the calls and casts: for an embedded protocol to functions, that require the  and   in order to call . See also .extensible-effects-concurrentTurn an embedded  to a  for the bigger request.*This function is strict in all parameters.extensible-effects-concurrent Answer a 2 by sending the reply value to the client process.The , the   and the   are stored in the  .extensible-effects-concurrentSmart constructor for a  . To build a  ReplyTarget for an  instance use .extensible-effects-concurrent A simple  for the   of a  .extensible-effects-concurrent A simple  for the   of a  .extensible-effects-concurrentSmart constructor for an embedded  .This combines  and  . extensible-effects-concurrent Convert a   to be usable for embedded replies.This combines a  with  to produce a  G that can be passed to functions defined soley on an embedded protocol.           None$%&',-.145678=>?@ACHMPSUVX_k . extensible-effects-concurrent+A value to be sent when timer started with 9 has elapsed.0 extensible-effects-concurrent$The reference to a timer started by 9 , required to stop a timer via :.1 extensible-effects-concurrentA number of micro seconds.4 extensible-effects-concurrentbWait for a message of the given type for the given time. When no message arrives in time, return g. This is based on 5.5 extensible-effects-concurrentbWait for a message of the given type for the given time. When no message arrives in time, return l .. This is based on 7 and 9.6extensible-effects-concurrentLike n combined with 5.7 extensible-effects-concurrentA  matching . messages created by 9.8 extensible-effects-concurrentsSend a message to a given process after waiting. The message is created by applying the function parameter to the 09, such that the message can directly refer to the timer.9 extensible-effects-concurrent/Start a new timer, after the time has elapsed, .< is sent to calling process. The message also contains the 0! returned by this function. Use : to cancel the timer. Use 7 to receive the message using c7. To receive messages with guarded with a timeout see 4.: extensible-effects-concurrentCancel a timer started with 9. ./0123456789: 1230./89:7456'None$%&',-.145678=>?@ACHMPSUVX_k !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~VWXY% None$%&',-.145678=>?@ACHMPSUVX_k Oextensible-effects-concurrentcThis event sum-type is used to communicate incoming messages and other events to the instances of V.Pextensible-effects-concurrentA E message was received. If an implementation wants to delegate nested s, it can use   to convert a  ! safely to the embedded protocol.Vextensible-effects-concurrent(A type class for effectful server loops.HThis type class serves as interface for other abstractions, for example process supervision!The methods of this class handle Os s for  instance.Instances can by  index types for ( family directly, or indirectly via the X type family.?To builder servers serving multiple protocols, use the generic  instances, for which - instances exist, like 2-,3-,4-, or 5-tuple.Wextensible-effects-concurrent6The value that defines what is required to initiate a V loop.Xextensible-effects-concurrentThe index type of the OBs that this server processes. This is the first parameter to the  and therefore of the  family.Yextensible-effects-concurrentEffects of the implementationZextensible-effects-concurrent Return the ".5Usually you should rely on the default implementation[extensible-effects-concurrent)Process the effects of the implementation\extensible-effects-concurrent Update the Model based on the O.]extensible-effects-concurrentExecute the server loop.^extensible-effects-concurrentExecute the server loop._extensible-effects-concurrentExecute the server loop.OSTUPQRVWXY\Z[]^_VWXY\Z[OSTUPQR]^_(None$%&',-.145678=>?@ACHMPSUVX_k6extensible-effects-concurrentInternal state.extensible-effects-concurrentState accessor None$%&',-.145678=>?@ACHMPSUVX_k>zbextensible-effects-concurrentThe Qect type of readonly i in a e instance.cextensible-effects-concurrentThe Qect type of mutable h in a e instance.dextensible-effects-concurrent$This type is used to build stateful EffectfulServer instances.It is a variant of EffectfulServer!, that comes pre-installed with  and  effects.eextensible-effects-concurrentA type class for server loops.AThis class serves as interface for other mechanisms, for example process supervision!The methods of this class handle Events and Requests for  instances.Instances can by  index types for ( family directly, or indirectly via the  ServerPdu type family.?To builder servers serving multiple protocols, use the generic  instances, for which - instances exist, like 2-,3-,4-, or 5-tuple.<The naming is inspired by The Elm Architecture, without the view callback.This class is based on /Control.Eff.Concurrent.Protocol.EffectfulServer and adds a default  and  effect.fextensible-effects-concurrent6The value that defines what is required to initiate a e loop.gextensible-effects-concurrentThe index type of the EventBs that this server processes. This is the first parameter to the Request and therefore of the  family.hextensible-effects-concurrent Type of the model$ data, given to every invocation of k via the c effect. The model. of a server loop is changed through incoming Event"s. It is initially calculated by j.iextensible-effects-concurrentType of read-only state.jextensible-effects-concurrentReturn an initial h and ikextensible-effects-concurrent Update the h based on the Event.mextensible-effects-concurrentExecute the server loop.nextensible-effects-concurrentExecute the server loop.oextensible-effects-concurrent Modify the h of a e.pextensible-effects-concurrent Modify the h of a e and return the old value.qextensible-effects-concurrent Modify the h of a e and return the new value.rextensible-effects-concurrent Return the h of a e.sextensible-effects-concurrentReturn a element selected by a  of the h of a e.textensible-effects-concurrentOverwrite the h of a e.uextensible-effects-concurrentOverwrite the h of a e, return the old value.vextensible-effects-concurrent,Run an action that modifies portions of the h of a e defined by the given .wextensible-effects-concurrentReturn the read-only i of a exextensible-effects-concurrentReturn the read-only i of a e as viewed through a OSTUPQRWlbcdegfhikjmnopqrstuvwxegfhikjdWlmncopqrtusvbwxOSTUPQR None$%&',-.145678=>?@ACHMPSUVX_ka zextensible-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 a request * that has no reply and return immediately.3The 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 (rnf) in the caller process.}extensible-effects-concurrentSend a request 2 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 2 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 .When working with an embedded  use .extensible-effects-concurrentLike | but take the  from the reader provided by .When working with an embedded  use .extensible-effects-concurrentLike , uses  to embed the value.>This function makes use of AmbigousTypes and TypeApplications."When not working with an embedded  use .extensible-effects-concurrentLike  , but uses  to embed the value.>This function makes use of AmbigousTypes and TypeApplications."When not working with an embedded  use . z{|}~ |}~{z None%%&',-.145678=>?@ACHMPSUVX_k~ extensible-effects-concurrent7Runtime-Errors occurring when spawning child-processes.extensible-effects-concurrent!Constraints on the parameters to .extensible-effects-concurrent(The type of value used to index running Server processes managed by a .(Note, that the type you provide must be .extensible-effects-concurrentThe index type of Server supervisors.A  p6 manages the life cycle of the processes, running the Server p methods of that specific type.0The supervisor maps an identifier value of type  p to an  p.extensible-effects-concurrent7Start and link a new supervisor process with the given SpawnFununction.!To spawn new child processes use .extensible-effects-concurrent/Stop the supervisor and shutdown all processes.(Block until the supervisor has finished.extensible-effects-concurrent-Check if a supervisor process is still alive.extensible-effects-concurrentMonitor a supervisor process.extensible-effects-concurrent0Start and monitor a new child process using the SpawnFun passed to .extensible-effects-concurrent0Start and monitor a new child process using the SpawnFun passed to .Call  and unpack the j result, ignoring the  error.extensible-effects-concurrent=Lookup the given child-id and return the output value of the SpawnFun! if the client process exists.extensible-effects-concurrent;Stop a child process, and block until the child has exited.Return f& if a process with that ID was found, . if no process with the given ID was running.extensible-effects-concurrent Return a \0 describing the current state of the supervisor.ffNone$%&',-.145678=>?@ACHMPSUVX_kextensible-effects-concurrent<Alias for the effect that contains the observers managed by extensible-effects-concurrentA protocol for managing 6s, encompassing registration and de-registration of s.extensible-effects-concurrentConvenience type alias.extensible-effects-concurrentConvenience type alias.extensible-effects-concurrent%The Information necessary to wrap an 9 event to a process specific message, e.g. the embedded   instance, and the  of the destination process.extensible-effects-concurrentA protocol to communicate % events from a sources to many sinks.4A sink is any process that serves a protocol with a  instance that embeds the  Pdu via an  instance.This type has dual use&, for one it serves as type-index for , i.e. + respectively, and secondly it contains an  and a .The # is used to serialize and send the  events, while the ! serves as key for internal maps.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-concurrentAnd an ; to the set of recipients for all observations reported by . Note that the observerRegistry 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 Send the  message, use a raw  as parameter.extensible-effects-concurrent#Provide the implementation for the  Protocol, this handled  and  messages. It also adds the  constraint to the effect list.extensible-effects-concurrentRemove the entry in the  for the  and return f if there was an entry,  otherwise.extensible-effects-concurrentKeep track of registered s. Handle the  effect, i.e. run  on an .extensible-effects-concurrent The empty extensible-effects-concurrentAn  for the  used internally.extensible-effects-concurrent>Report an observation to all observers. The process needs to  and to .None%%&',-.145678=>?@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 .sThis 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 .6Return the oldest enqueued observation immediately or g if the queue is empty. Use 9 to block until an observation is observerRegistryNotify.extensible-effects-concurrentTRead at once all currently queued observations captured and enqueued in the shared  by .ZThis returns immediately all currently enqueued observations. For a blocking variant use .extensible-effects-concurrent*Listen to, and capture observations in an .Fork an  process that runs only while the body expression is executed. Register the observer to the observable process passed to this function.-The captured observations can be obtained by ,  and ..The queue size is limited to the given number.Example  import qualified Control.Eff.Concurrent.Observer.Queue as OQ foo = do observed <- start SomeObservable OQ.observe 100 observed $ do ... cast observed DoSomething evt <- OQ.await @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 .extensible-effects-concurrent'Spawn a process that can be used as an + that enqueues the observations into an . See .$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$%&',-.145678=>?@ACHMPSUVX_kextensible-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%%&',-.145678=>?@ACHMPSUVX_k extensible-effects-concurrentA convenience type alias for  effectful callback based V instances.See .extensible-effects-concurrentIA convenience type alias for callbacks that do not need a custom effect.extensible-effects-concurrentThe name/id of a  for logging purposes.extensible-effects-concurrentThe constraints for a tangible  instance.extensible-effects-concurrent*Phantom type to indicate a callback based V instance.extensible-effects-concurrentMExecute the server loop, that dispatches incoming events to either a set of  or .extensible-effects-concurrentMExecute the server loop, that dispatches incoming events to either a set of  or .extensible-effects-concurrentA smart constructor for .extensible-effects-concurrentA simple smart constructor for .extensible-effects-concurrentA smart constructor for .extensible-effects-concurrentA simple smart constructor for .OSTUPQROSTUPQRNone%%&',-.145678=>?@ACHMPSUVX_kextensible-effects-concurrentAlias for the T that contains the captured s from .extensible-effects-concurrentA 7 monad that provides pure logging by capturing via the T effect.extensible-effects-concurrentA 7 monad that provides pure logging by capturing via the T effect.See )extensible-effects-concurrentRun a T for s.Such a T is needed to handle None$%&',-.145678=>?@ACHMPSUVX_k extensible-effects-concurrentThe concrete list of Q"ects for logging with an IO based , and a .extensible-effects-concurrentA  that uses an U 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#PredefinedPredicatesextensible-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 decorateNone$%&',-.145678=>?@ACHMPSUVX_k!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 .extensible-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#PredefinedPredicatesextensible-effects-concurrentPath to the log-file.None$%&',-.145678=>?@ACHMPSUVX_k-extensible-effects-concurrentEnable logging via  using the  , 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"extensible-effects-concurrentEnable logging via  using the !. 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"extensible-effects-concurrentWrite s via .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#PredefinedPredicatesNone$%&',-.145678=>?@ACHMPSUVX_k@*extensible-effects-concurrentEnable logging to standard output using the  , 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 .extensible-effects-concurrentEnable logging to standard output using the . Log messages are rendered using .Example: exampleWithConsoleLogWriter :: IO () exampleWithConsoleLogWriter = runLift $ withSomeLogging @IO $ withConsoleLogWriter $ logInfo "Oh, hi there"extensible-effects-concurrentWrite %s to standard output, formatted with .It uses  with .extensible-effects-concurrentA  that uses a  to render, and  to print it.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#PredefinedPredicatesNone$%&',-.145678=>?@ACHMPSUVX_kXextensible-effects-concurrentThis is a wrapper around  and .Example: exampleWithAsyncLogging :: IO () exampleWithAsyncLogging = runLift $ withAsyncLogWriter consoleLogWriter (1000::Int) "my-app" local0 allLogMessages $ do logMsg "test 1" logMsg "test 2" logMsg "test 3" extensible-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" extensible-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#PredefinedPredicatesextensible-effects-concurrentYSize of the log message input queue. If the queue is full, message are dropped silently.None$%&',-.145678=>?@ACHMPSUVX_k9extensible-effects-concurrentAConstraint for the existence of the underlying scheduler effects.extensible-effects-concurrent-The effect list for the underlying scheduler.See extensible-effects-concurrentThe effect list for %: effects in the single threaded scheduler. This is like , no  are present.See .extensible-effects-concurrentThe effect list for %* effects in the single threaded scheduler.See extensible-effects-concurrentAConstraint for the existence of the underlying scheduler effects.See extensible-effects-concurrentEThe effect list for a pure, single threaded scheduler contains only  and the  for  PureLogWriter.extensible-effects-concurrentThe effect list for %? effects in the single threaded pure scheduler. This is like , no  are present.See  and extensible-effects-concurrentThe effect list for %/ effects in the single threaded pure scheduler.See  and extensible-effects-concurrentVInternal data structure that is part of the coroutine based scheduler implementation.extensible-effects-concurrent/Add monitor: If the process is dead, enqueue a ' message into the owners message queueextensible-effects-concurrentLike  but pure. The yield effect is just  return (). schedulePure == runIdentity .  (Identity . run) (return ())extensible-effects-concurrentInvoke  with lift  as yield effect. scheduleIO runEff ==  (runLift . runEff) (liftIO )extensible-effects-concurrentInvoke  with lift  as yield effect. scheduleMonadIOEff ==  id (liftIO )extensible-effects-concurrentRun processes that have the  and the 8 effects. The user must provide a log handler function."Log messages are evaluated strict. scheduleIOWithLogging ==  . extensible-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 Z}ed by it in the current thread concurrently, using a co-routine based, round-robin scheduler. If a process exits with eg.g u or v" 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.extensible-effects-concurrent Execute a % using  on top of  IO/. All logging is written to the console using .To use another  use  instead.extensible-effects-concurrent Execute a % using  on top of  IO*. All logging is written using the given .extensible-effects-concurrentAn that performs a yield w.r.t. the underlying effect r . E.g. if Lift IO$ is present, this might be: @lift .None$%&',-.145678=>?@ACHMPSUVX_kextensible-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 g 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 ownersextensible-effects-concurrentThe concrete list of Q'ects for this scheduler implementation. extensible-effects-concurrentType class constraint to indicate that an effect union contains the effects required by every process and the scheduler implementation itself. extensible-effects-concurrentThe Q<ects for interruptable, concurrent processes, scheduled via forkIO. extensible-effects-concurrentThe concrete list of QDects of processes compatible with this scheduler. This builds upon .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. extensible-effects-concurrent<Start the message passing concurrency system then execute a % on top of 0 effect. All logging is sent to standard output. extensible-effects-concurrent<Start the message passing concurrency system then execute a % on top of 0 effect. All logging is sent to standard output.extensible-effects-concurrentjThis is the main entry point to running a message passing concurrency application. This function takes a % on top of the  effect for concurrent logging.          None$%&',-.145678=>?@ACHMPSUVX_khextensible-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#PredefinedPredicatesextensible-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$%&',-.145678=>?@ACHMPSUVX_k5extensible-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#PredefinedPredicatesextensible-effects-concurrent rendering functionextensible-effects-concurrentPath to the socket fileextensible-effects-concurrent rendering functionextensible-effects-concurrentPath to the socket fileNone$%&',-.145678=>?@ACHMPSUVX_kەextensible-effects-concurrentExample code for: See  extensible-effects-concurrentExample code for:extensible-effects-concurrentExample code for:extensible-effects-concurrentExample code for:}~extensible-effects-concurrentExample code for:extensible-effects-concurrentExample code for:extensible-effects-concurrent(Example code for RFC5424 formatted logs.extensible-effects-concurrent@Example code for RFC3164 with RFC5424 time stamp formatted logs.extensible-effects-concurrent1Example code logging via a unix domain socket to devlog.extensible-effects-concurrent1Example code logging via a unix domain socket to devlog.extensible-effects-concurrent;Example code logging RFC5424 via UDP port 514 on localhost.extensible-effects-concurrent;Example code logging RFC5424 via UDP port 514 on localhost. extensible-effects-concurrentExample logging client code qh!extensible-effects-concurrent'Example logging client code using many bs.}~ ! !None$%&',-.145678=>?@ACHMPSUVX_k"extensible-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.#extensible-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."#"#/None$%&',-.145678=>?@ACHMPSUVX_k !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~VWXY !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvrstuvwxyz{|}~      ./013456789:z{|}~     "# !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv     ./013456789: z{|}~     None$%&',-.145678=>?@ACHMPSUVX_k$extensible-effects-concurrentAConstraint for the existence of the underlying scheduler effects.See %extensible-effects-concurrent-The effect list for the underlying scheduler.See &extensible-effects-concurrentThe effect list for %: effects in the single threaded scheduler. This is like , no  are present.See 'extensible-effects-concurrentThe effect list for %* effects in the single threaded scheduler.See (extensible-effects-concurrentRun the '; using a single threaded, coroutine based, scheduler from 6Control.Eff.Concurrent.Process.SingleThreadedScheduler. !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~VWXY !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvrstuvwxyz{|}~      ./013456789:z{|}~"#$%&'( !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv      ./013456789:z{|}~"#('&%$None$%&',-.145678=>?@ACHMPSUVX_k)extensible-effects-concurrentAConstraint for the existence of the underlying scheduler effects.*extensible-effects-concurrent-The effect list for the underlying scheduler.+extensible-effects-concurrentThe effect list for %? effects in the single threaded pure scheduler. This is like , no  are present.See ,extensible-effects-concurrentThe effect list for %/ effects in the single threaded pure scheduler.See -extensible-effects-concurrentRun the ,@ using a single threaded, coroutine based, pure scheduler from 6Control.Eff.Concurrent.Process.SingleThreadedScheduler. !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~VWXY !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvrstuvwxyz{|}~      ./013456789:z{|}~"#)*+,- !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv      ./013456789:z{|}~"#-,+*)0None%%&',-.145678=>?@ACHMPSUVX_k"123456789:;<=>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~3455 34       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,,-.//0123456789:;<=>?@ABCDEFGHIJK L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s & t u v w x y z { | } ~    &       t z {                                                 &z{y      !")#$%+&'*()*+ ,-./-01 2 3 4-05-6789:-;<89=89>89?89@89A89B89C89D89E89F89G89H89I89J89K89L89L-MN-OP-OQRSTRUVWXY8Z[8\]^_`8abcdefghi8Zjklmnop-qrstuvwxvwyvwz{-q|-}~cdcd-;-;kl-kl-cdklc-0-c((((((((((((((((((((88 cd8----qn-O8Z-O00000000:extensible-effects-concurrent-0.29.2-LYViqZFOIQHPuntx6ss9SControl.Eff.ExceptionExtraControl.Eff.Log.MessageControl.Eff.Log.MessageRendererControl.Eff.Log.WriterControl.Eff.Log.HandlerControl.Eff.Concurrent.ProcessControl.Eff.Concurrent.Protocol'Control.Eff.Concurrent.Protocol.Wrapper$Control.Eff.Concurrent.Process.Timer/Control.Eff.Concurrent.Protocol.EffectfulServer.Control.Eff.Concurrent.Protocol.StatefulServer&Control.Eff.Concurrent.Protocol.Client*Control.Eff.Concurrent.Protocol.Supervisor(Control.Eff.Concurrent.Protocol.Observer.Control.Eff.Concurrent.Protocol.Observer.Queue*Control.Eff.Concurrent.Process.Interactive.Control.Eff.Concurrent.Protocol.CallbackServerControl.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.Loop%Control.Eff.Concurrent.SingleThreadedControl.Eff.Concurrent.PureControl.Eff.Concurrent.MiscControl.Exception.Safe SomeExceptionAsynccancel)Control.Eff.Concurrent.Protocol.EffectfulServerControl.Eff.Log8Control.Eff.Concurrent.Protocol.Supervisor.InternalStateexampleLogCaptureexampleUdpRFC3164LoggingexampleDevLogSyslogLogging Control.Monadforever replicateM_Control.Eff.Concurrent#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 renderRFC5424renderRFC5424NoLocationrenderRFC5424HeaderHandleLogWriter LogWriterMhandleLogWriterEffectliftWriteLogMessageLogWriterReader LogWriter MkLogWriter runLogWriterrunLogWriterReader askLogWriterlocalLogWriterReader noOpLogWriterfilteringLogWritermappingLogWritermappingLogWriterM$fHandleLogWriterWriter$fHandleLogWriterLift$fMonadBaseControlmEff$fHandleLogWriterReaderea->$fDefaultLogWriter$fFunctorLogWriterM$fApplicativeLogWriterM$fMonadLogWriterM$fApplicativeLogWriterM0$fFunctorLogWriterM0$fMonadLogWriterM0LogIoLogsToLogs withLoggingwithSomeLoggingrunLogslogMsglogWithSeveritylogWithSeverity' logEmergencylogAlert logCriticallogError logWarning logNoticelogInfologDebug logEmergency' logAlert' logCritical' logError' logWarning' logNotice'logInfo' logDebug'askLogPredicatesetLogPredicatemodifyLogPredicateincludeLogMessagesexcludeLogMessagesrespondToLogMessageinterceptLogMessagesmodifyLogWriter setLogWriter censorLogs censorLogsM addLogWriter$fHandleLogWriterLogs$fHandleLogsea-> ProcessId_fromProcessId ProcessDown downReference downReason downProcessMonitorReference monitorIndexmonitoredProcessSomeExitReason InterruptsHasSafeProcesses SafeProcesses HasProcesses ProcessesRecoverableInterrupt InterruptNormalExitRequestedOtherProcessNotRunningTimeoutInterruptLinkedProcessCrashedErrorInterrupt ExitNormallyExitUnhandledErrorExitProcessCancelled ExitSeverity NormalExitCrash ExitRecovery Recoverable NoRecovery ProcessStateProcessBooting ProcessIdle ProcessBusyProcessBusyUpdatingDetailsProcessBusySendingProcessBusySendingShutdownProcessBusySendingInterruptProcessBusyReceivingProcessBusyLinkingProcessBusyUnlinkingProcessBusyMonitoringProcessBusyDemonitoringProcessInterruptedProcessShuttingDownMessageSelectorrunMessageSelector ResumeProcess Interrupted ResumeWith Serializer MkSerializer runSerializer StrictDynamicProcessDetailsMkProcessDetails_fromProcessDetails ProcessTitleMkProcessTitle_fromProcessTitleProcess FlushMessages YieldProcessSelfPidSpawn SpawnLinkShutdown SendShutdown SendInterrupt SendMessageReceiveSelectedMessage MakeReferenceMonitor DemonitorLinkUnlinkUpdateProcessDetailsGetProcessStatefromProcessTitlefromProcessDetailstoStrictDynamicfromStrictDynamicunwrapStrictDynamic selectMessage filterMessageselectMessageWithselectDynamicMessageselectAnyMessagetoExitRecoverytoExitSeverityinterruptToExitisProcessDownInterruptprovideInterruptsShutdownhandleInterruptstryUninterrupted logInterruptsexitOnInterruptprovideInterrupts!mergeEitherInterruptAndExitReason interruptisCrash isRecoverablefromSomeExitReason toCrashReasonlogProcessExitexecuteAndResumeexecuteAndResumeOrExitexecuteAndResumeOrThrow yieldProcess sendMessagesendAnyMessage sendShutdown sendInterruptspawnspawn_ spawnLinkspawnRaw spawnRaw_isProcessAlivegetProcessStateupdateProcessDetailsreceiveAnyMessagereceiveSelectedMessagereceiveMessage flushMessagesreceiveSelectedLoopreceiveAnyLoop receiveLoopself makeReferencemonitor demonitor withMonitorreceiveWithMonitorbecauseProcessIsDownselectProcessDownselectProcessDownByProcessId linkProcess unlinkProcess exitBecause exitNormally exitWithError$fShowProcessTitle$fShowProcessDetails$fShowStrictDynamic$fNFDataStrictDynamic$fContravariantSerializer$fShowSerializer$fNFDataSerializer$fAlternativeMessageSelector$fApplicativeMessageSelector$fDefaultProcessState$fNFDataProcessState$fShowExitRecovery$fNFDataExitRecovery$fNFDataExitSeverity$fShowExitSeverity$fShowProcessId$fReadProcessId$fShowMonitorReference$fNFDataMonitorReference $fEqInterrupt$fOrdInterrupt$fNFDataInterrupt$fExceptionInterrupt$fExceptionInterrupt0$fShowInterrupt$fNFDataSomeExitReason$fShowSomeExitReason$fEqSomeExitReason$fOrdSomeExitReason$fShowProcessDown$fNFDataProcessDown$fNFData1ResumeProcess$fNFDataResumeProcess $fShowProcess$fEqProcessTitle$fOrdProcessTitle$fNFDataProcessTitle$fGenericProcessTitle$fIsStringProcessTitle$fSemigroupProcessTitle$fMonoidProcessTitle$fEqProcessDetails$fOrdProcessDetails$fNFDataProcessDetails$fGenericProcessDetails$fIsStringProcessDetails$fSemigroupProcessDetails$fMonoidProcessDetails$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$fShowResumeProcessReceiver _receiverPid_receiverSerializer fromProcessIdsendToReceiver$fShowReceiver$fContravariantReceiver $fOrdReceiver $fEqReceiver$fNFDataReceiver receiverPid HasPduPrism embeddedPduembedPdufromPdu ProtocolReply Synchronicity Synchronous Asynchronous TangiblePduTangibleEmbedsHasPduEmbeddedPduListPduEndpoint _fromEndpointdeserializePduproxyAsEndpoint asEndpointtoEmbeddedEndpointfromEmbeddedEndpoint$fShowEndpoint $fShowPdu $fNFDataPdu $fShowPdu0 $fNFDataPdu0 $fShowPdu1 $fNFDataPdu1 $fShowPdu2 $fNFDataPdu2$fHasPdu(,,,,) $fHasPdu(,,,) $fHasPdu(,,) $fHasPdu(,)$fHasPduPrism(,,,,)a5$fHasPduPrism(,,,,)a4$fHasPduPrism(,,,,)a3$fHasPduPrism(,,,,)a2$fHasPduPrism(,,,,)a1$fHasPduPrism(,,,)a4$fHasPduPrism(,,,)a3$fHasPduPrism(,,,)a2$fHasPduPrism(,,,)a1$fHasPduPrism(,,)a3$fHasPduPrism(,,)a2$fHasPduPrism(,,)a1$fHasPduPrism(,)a2$fHasPduPrism(,)a1$fHasPduPrismaa $fEqEndpoint $fOrdEndpoint$fNFDataEndpoint fromEndpoint ReplyTarget MkReplyTarget RequestOrigin_requestOriginPid_requestOriginCallRefReply_replyTo _replyValueRequestCallCastmakeRequestOrigintoEmbeddedOriginembedRequestOriginembedReplySerializer sendReply replyTargetreplyTargetOriginreplyTargetSerializerembeddedReplyTargettoEmbeddedReplyTarget$fNFDataRequestOrigin$fShowRequestOrigin $fShowReply $fNFDataReply$fNFDataRequest $fShowRequest$fNFDataReplyTarget$fShowReplyTarget$fGenericRequestOrigin$fEqRequestOrigin$fOrdRequestOrigin$fEqReplyTarget$fOrdReplyTarget TimerElapsedfromTimerElapsedTimerReferenceTimeout TimeoutMicrosfromTimeoutMicros receiveAfterreceiveSelectedAfterreceiveSelectedWithMonitorAfterselectTimerElapsed sendAfter startTimer cancelTimer $fShowTimeout$fShowTimerReference$fShowTimerElapsed$fNFDataTimeout $fOrdTimeout $fEqTimeout $fNumTimeout$fIntegralTimeout $fRealTimeout $fEnumTimeout$fNFDataTimerReference$fOrdTimerReference$fEqTimerReference$fNumTimerReference$fIntegralTimerReference$fRealTimerReference$fEnumTimerReference$fNFDataTimerElapsed$fOrdTimerElapsed$fEqTimerElapsedEventOnCallOnCast OnInterruptOnDown OnTimeOut OnMessageInit ServerPdu ServerEffects serverTitle runEffectsonEventstart startLinkprotocolServerLoop $fNFDataEvent $fShowEventSettingsReader ModelStateStateful StartArgumentProtocolModelSettingssetupupdate modifyModelgetAndModifyModelmodifyAndGetModelgetModeluseModelputModelgetAndPutModel zoomModel askSettings viewSettings$fServerStatefulqEndpointReaderHasEndpointReadercastcallcallWithTimeoutrunEndpointReader askEndpointcallEndpointReadercastEndpointReader callSingleton castSingletonSpawnErrAlreadyStartedChildIdSup MkSupConfigsupConfigChildStopTimeoutstartSupervisorstopSupervisorisSupervisorAlivemonitorSupervisor spawnChild spawnOrLookup lookupChild stopChildgetDiagnosticInfo$fNFDataSpawnErr $fServerSup: $fHasPduSup$fGenericSpawnErr$fShowSpawnErr $fOrdSpawnErr $fEqSpawnErrObserverRegistryStateObserverRegistryMkObserverRegistry_observerRegistry CanObserve IsObservableObservationSinkObserver MkObserverRegisterObserverForgetObserverObservedregisterObserverforgetObserverforgetObserverUnsafeobserverRegistryHandlePduobserverRegistryRemoveProcessevalObserverRegistryStateemptyObserverRegistryobserverRegistryNotify$fNFDataObservationSink$fHasPduObserver$fShowObserver$fNFDataObserver$fHasPduObserverRegistry$fGenericObservationSink $fEqObserver $fOrdObserverObservationQueueReaderObservationQueueawaittryReadflushobserve$fServerObservationQueue:SchedulerSessionforkInteractiveSchedulerkillInteractiveSchedulersubmit submitCast submitCall CallbacksEff CallbacksServerId MkServerId _fromServerIdTangibleCallbacks callbacks callbacksEff onEventEff $fShowInit $fNFDataInit$fServerServer:$fShowServerId$fNFDataServerId $fOrdServerId $fEqServerId$fIsStringServerIdCaptureLogWriter CaptureLogscaptureLogWriterrunCaptureLogWriter LoggingAndIo mkLogWriterIOioHandleLogWriter withIoLoggingdefaultIoLogWriterprintLogMessagewithFileLoggingwithFileLogWriterwithTraceLoggingwithTraceLogWriterdebugTraceLogWriterwithConsoleLoggingwithConsoleLogWriterconsoleLogWriterstdoutLogWriterwithAsyncLoggingwithAsyncLogWriter$fShowProcessInfoHasBaseEffectsIo BaseEffectsIo SafeEffectsIo EffectsIoHasPureBaseEffectsPureBaseEffectsPureSafeEffects PureEffects schedulePure scheduleIOscheduleMonadIOEffscheduleIOWithLogging scheduleM defaultMaindefaultMainWithLogWriter $fShowSTS $fShowOnYield$fDefaultMessageQ BaseEffectsHasBaseEffectsEffects SafeEffectsschedulewithUDPLoggingwithUDPLogWriterwithUnixSocketLoggingwithUnixSocketLogWriterexampleLoggingexampleWithLoggingexampleWithSomeLoggingexampleLogPredicateexampleAsyncLoggingexampleRFC5424Logging*exampleRFC3164WithRFC5424TimestampsLoggingexampleDevLogRFC5424LoggingexampleUdpRFC5424LoggingloggingExampleClientlogPredicatesExampleClient foreverCheapreplicateCheapM_ showSTypeablebaseData.Typeable.InternalTypeableGHC.ShowShowSshowSPrecTypeable showSTypeRepshowSTypeRepPrec showsPrecGHC.Exception.Type Exception1extensible-effects-5.0.0.1-B31EaEwr0KjDx8Jjjl5V9qControl.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.ClassdefControl.Eff.Writer.StrictWriterghc-prim GHC.TypesIO IOLogWriter MkCaptureLogsrunIOLogWriter unCaptureLogsLifteddeepseq-1.4.4.0Control.DeepSeqdeepseq text-1.2.3.1Data.Text.InternalTextGHC.BaseString,monad-control-1.0.2.3-72Lqn5gml7WCRCL7FrqymTControl.Monad.Trans.ControlMonadBaseControl(exceptions-0.10.2-BCw4sZZBgaL5zRGtRt3vrKControl.Monad.Catch MonadMask MonadCatch MonadThrowsendLogMessageToLogWriter Alternative Data.DynamicDynamicIntTrueNothingJustforce Data.EitherEitherrnfLeft"lens-4.17.1-GjSMQ2I3MoU63aIbR3DWuiControl.Lens.TypePrism ConstraintNFData GHC.ClassesOrdShow ToPduLeft ToPduRightToPdu1ToPdu2ToPdu3 ToPdu1Of4 ToPdu2Of4 ToPdu3Of4 ToPdu4Of4 ToPdu1Of5 ToPdu2Of5 ToPdu3Of5 ToPdu4Of5 ToPdu5Of5Data.SemigroupArgEq embedReplyLensChildren getChildrenChildMkChild_childMonitoring_childEndpoint MkChildren_childrenByMonitor _childrenById childEndpointchildMonitoring childrenByIdchildrenByMonitorputChildlookupChildByIdlookupChildByMonitorlookupAndRemoveChildById removeChildlookupAndRemoveChildByMonitorremoveAllChildrenControl.Eff.State.StrictStateControl.Eff.Reader.StrictReader TangibleSupFalse evalStateobserverRegistryIsocontainers-0.6.0.1Data.Map.InternalMap stm-2.5.0.0Control.Concurrent.STM.TBQueueTBQueue spawnWriterwithObservationQueue withWriterGHC.MVarMVarGHC.IO.Handle.TypesHandle Debug.TracetraceMMonad Data.Text.IOputStrLnOnYield addMonitoringyieldLift handleProcessMessageQData.Sequence.InternalSeq ProcessInfoTVartryTakeNextShutdownRequestSTM_shutdownRequestsSchedulerState_processMonitorsnewProcessInfonewSchedulerStatewithNewSchedulerState withUDPSocketwithUnixSocketSocketversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName