!      !"#$%&'()*+,-./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_k,}extensible-effects-concurrentCatch  thrown by an effect.extensible-effects-concurrentVery similar to  but for  s. Unlike 4 this will throw the given value (instead of using ). !"#$%&'()None%%&',-.145678=>?@ACHMPSUVX_kqFFextensible-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%%&',-.145678=>?@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.0extensible-effects-concurrentExtract the name of an 3 the length is cropped to 32 according to RFC 5424.1extensible-effects-concurrentExtract the value of an .extensible-effects-concurrent$The format string that is passed to -None%%&',-.145678=>?@ACHMPSUVX_kkextensible-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-concurrentRun the side effect of a  in a compatible 2.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 3;, 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 4extensible-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%%&',-.145678=>?@ACHMPSUVX_kV['extensible-effects-concurrentA constraint that required  5 e and 6 5 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 7, after they pass the b.extensible-effects-concurrentLog a 8 as  with a given .extensible-effects-concurrentLog a 8 as  with a given .extensible-effects-concurrentLog a 9 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 9 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. 5. This instance needs a / in the base monad, that is capable to handle  invocations.%%None%%&',-.145678=>?@ACHMPSUVX_kP{extensible-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-concurrent(eptions containing s. See >, A or Bextensible-effects-concurrentCons ( onto a list of effects. This is called  SafeProcesses3 because the the actions cannot be interrupted in.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 sliceextensible-effects-concurrent%The process is busy with non-blockingextensible-effects-concurrentThe process is busy with -extensible-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 Zextensible-effects-concurrentThe process blocked by a i extensible-effects-concurrentThe process blocked by a j extensible-effects-concurrentThe process blocked by a c extensible-effects-concurrentThe process blocked by a d extensible-effects-concurrentThe process was interrupted extensible-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 ? 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 FA 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 O.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 @~. 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 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-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.(extensible-effects-concurrentGenerate a unique A 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. E returns B#), the other is shutdown with the  ., extensible-effects-concurrent2Unlink the calling process from the other process.-extensible-effects-concurrent Update the  of a process.extensible-effects-concurrentGet the  (or C if the process is dead)/extensible-effects-concurrentAn isomorphism lens for the 0extensible-effects-concurrentAn isomorphism lens for the 1extensible-effects-concurrent3Deeply evaluate the given value and wrap it into a .2extensible-effects-concurrent Convert a  back to a value.3extensible-effects-concurrent Convert a  back to an unwrapped @.4 extensible-effects-concurrent>Create a message selector for a value that can be obtained by 2.5 extensible-effects-concurrent+Create a message selector from a predicate.6 extensible-effects-concurrentSelect a message of type a> and apply the given function to it. If the function returns D The '( function will return the result (sans Maybe).7 extensible-effects-concurrentCreate a message selector.8 extensible-effects-concurrentACreate a message selector that will match every message. This is lazy because the result is not Eed.9extensible-effects-concurrentGet the :extensible-effects-concurrentGet the  of a .;extensible-effects-concurrentReturn either  or ; from a  ;If the  is  then return <extensible-effects-concurrentA predicate for linked process crashes.=extensible-effects-concurrent Handle all s of an  by wrapping them up in ; and then do a process #.>extensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a [ via a call to D.? extensible-effects-concurrentLike >, but instead of passing the  to a handler function, F is returned.@extensible-effects-concurrent'Handle interrupts by logging them with I and otherwise ignoring them.Aextensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a [ via a call to D.Bextensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a [ via a call to D.Cextensible-effects-concurrentWrap all (left) s into ; and return the (right)  s as is.Dextensible-effects-concurrent Throw an , can be handled by > or A or B.Eextensible-effects-concurrentA predicate for crashes. A crash' happens when a process exits with an  other than Fextensible-effects-concurrentkA predicate for recoverable exit reasons. This predicate defines the exit reasons which functions such as JGextensible-effects-concurrent Partition a  back into either a  or a  Hextensible-effects-concurrentPrint a  to D a formatted 9 when E is B>. 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 . toCrashReasonIextensible-effects-concurrentLog the sJextensible-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 F, return the exit reason.Kextensible-effects-concurrent Execute a : action and resume the process, exit the process when an  was raised. Use J to catch interrupts.Lextensible-effects-concurrent Execute a : action and resume the process, exit the process when an  was raised. Use J to catch interrupts.Mextensible-effects-concurrentUse K to execute  . Refer to  for more information.Nextensible-effects-concurrent-Send a message to a process addressed by the . See &.,The message will be reduced to normal form (G) by/in the caller process.Oextensible-effects-concurrentSend a @% value to a process addressed by the . See &.Pextensible-effects-concurrent Exit a process addressed by the Z. The process will exit, it might do some cleanup, but is ultimately unrecoverable. See $.Qextensible-effects-concurrent&Interrupts a process addressed by the 7. The process might exit, or it may continue. | Like Q, but also return True iff the process to exit exists.Rextensible-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 U.Sextensible-effects-concurrentLike R but return ().T extensible-effects-concurrent0Start a new process, and immediately link to it.Uextensible-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 R might be better suited.Vextensible-effects-concurrentLike U but return ().W extensible-effects-concurrentReturn B if the process is alive.Xextensible-effects-concurrent Return the ,  and 2, for the given process, if the process is alive.Yextensible-effects-concurrent Replace the  of the process.Zextensible-effects-concurrent)Block until a message was received. See ' for more documentation.[extensible-effects-concurrent0Block until a message was received, that is not C( after applying a callback to it. See ' for more documentation.\extensible-effects-concurrent%Receive and cast the message to some H instance. See 'P for more documentation. This will wait for a message of the return type using [] extensible-effects-concurrentPRemove and return all messages currently enqueued in the process message queue.^extensible-effects-concurrentZEnter a loop to receive messages and pass them to a callback, until the function returns Dy 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 F*, then the callback will be invoked with I C, otherwise the process will be exited with the same reason using k . See also ' for more documentation._extensible-effects-concurrentLike ^ but  not selective . See also 8, ^.`extensible-effects-concurrentLike ^& but refined to casting to a specific H using 4.aextensible-effects-concurrent Returns the  of the current process.bextensible-effects-concurrentGenerate a unique A for the current process.c 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 reasond extensible-effects-concurrentRemove a monitor created with c.e extensible-effects-concurrentc8 another process before while performing an action and d afterwards.f extensible-effects-concurrentA I for receiving either a monitor of the given process or another message.g extensible-effects-concurrentMake an  for a  message. For example: @doSomething >>= either (interrupt . becauseProcessIsDown) returnh extensible-effects-concurrentA  for the  message of a specific process.i extensible-effects-concurrentaConnect the calling process to another process, such that if one of the processes crashes (i.e. E returns B#), the other is shutdown with the  .j extensible-effects-concurrent2Unlink the calling process from the other process.kextensible-effects-concurrentExit the process with a .lextensible-effects-concurrentExit the process.mextensible-effects-concurrentExit the process with an error.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm !"#$%&'()*+,-./0123     MNOPQb\[]Z`^_45678aWXYRSTUVklmijcdhgef=>?A@BCDJKL;9F:<EHGINone$%&',-.145678=>?@ACHMPSUVX_kextensible-effects-concurrent'This is a tag-type that wraps around a  and holds an  index type.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 J( 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 K, compared via L and presented dynamically via H&, and represented both as values via M.extensible-effects-concurrentThis 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: N data BookShop deriving Typeable instance 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-concurrentThe protocol data unit type for the given protocol.extensible-effects-concurrentDeserialize a  from a @+ i.e. from a message received by a process.extensible-effects-concurrentThis is equivalent to  0extensible-effects-concurrentAn internal utility to print H" without the kinds. This is like N in that it accepts a  precedenceS parameter, and the result is in parentheses when the precedence is higher than 9.extensible-effects-concurrent A class for  instances that embed other . A O for the embedded  is the center of this classLaws: %embeddedPdu = prism' embedPdu fromPduextensible-effects-concurrentA O 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 C/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 , .&PQRSTUVWXYZ[\]None$%&',-.145678=>?@ACHMPSUVX_k0extensible-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 L$ 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 a for the  of a .extensible-effects-concurrent A simple a 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 # 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 C. 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 I . This is based on ! and #. extensible-effects-concurrentLike f 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 [7. To receive messages with guarded with a timeout see .$ extensible-effects-concurrentCancel a timer started with #.  !"#$ "#$! (None$%&',-.145678=>?@ACHMPSUVX_k !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~% None$%&',-.145678=>?@ACHMPSUVX_k 9extensible-effects-concurrentcThis event sum-type is used to communicate incoming messages and other events to the instances of @.:extensible-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.@extensible-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 9s s for  instance.Instances can by  index types for ( family directly, or indirectly via the B type family.?To builder servers serving multiple protocols, use the generic  instances, for which - instances exist, like 2-,3-,4-, or 5-tuple.Aextensible-effects-concurrent6The value that defines what is required to initiate a @ loop.Bextensible-effects-concurrentThe index type of the 9Bs that this server processes. This is the first parameter to the  and therefore of the  family.Cextensible-effects-concurrentEffects of the implementationDextensible-effects-concurrent Return the .5Usually you should rely on the default implementationEextensible-effects-concurrent)Process the effects of the implementationFextensible-effects-concurrent Update the Model based on the 9.Gextensible-effects-concurrentExecute the server loop.Hextensible-effects-concurrentExecute the server loop.Iextensible-effects-concurrentExecute the server loop.9=>?:;<@ABCDEFGHI@ABCDEF9=>?:;<GHI None$%&',-.145678=>?@ACHMPSUVX_kLextensible-effects-concurrentThe 2ect type of readonly R in a N instance.Mextensible-effects-concurrentThe 2ect type of mutable Q in a N instance.bextensible-effects-concurrent$This type is used to build stateful EffectfulServer instances.It is a variant of EffectfulServer!, that comes pre-installed with c and d effects.Nextensible-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 c and d effect.Oextensible-effects-concurrent6The value that defines what is required to initiate a N loop.Pextensible-effects-concurrentThe index type of the EventBs that this server processes. This is the first parameter to the Request and therefore of the  family.Qextensible-effects-concurrent Type of the model$ data, given to every invocation of T via the M effect. The model. of a server loop is changed through incoming Event"s. It is initially calculated by S.Rextensible-effects-concurrentType of read-only state.Sextensible-effects-concurrentReturn an initial Q and RTextensible-effects-concurrent Update the Q based on the Event.Uextensible-effects-concurrentExecute the server loop.Vextensible-effects-concurrentExecute the server loop.Wextensible-effects-concurrent Modify the Q of a N.Xextensible-effects-concurrent Modify the Q of a N and return the old value.Yextensible-effects-concurrent Modify the Q of a N and return the new value.Zextensible-effects-concurrent Return the Q of a N.[extensible-effects-concurrentReturn a element selected by a a of the Q of a N.\extensible-effects-concurrentOverwrite the Q of a N.]extensible-effects-concurrentOverwrite the Q of a N, return the old value.^extensible-effects-concurrent,Run an action that modifies portions of the Q of a N defined by the given a._extensible-effects-concurrentReturn the read-only R of a N`extensible-effects-concurrentReturn the read-only R of a N as viewed through a a9=>?:;<LMNPOQRTSUVWXYZ[\]^_`NPOQRTSUVMWXYZ\][^L_`9=>?:;<)None$%&',-.145678=>?@ACHMPSUVX_k&eextensible-effects-concurrentInternal state.fextensible-effects-concurrentState accessorghijeklmnopqfrstuvwx None$%&',-.145678=>?@ACHMPSUVX_k4 bextensible-effects-concurrentThe reader effect for s for s, see gcextensible-effects-concurrentInstead of passing around a & value and passing to functions like d or e, a  can provided by a d 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 .dextensible-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 e instead.,The message will be reduced to normal form (rnf) in the caller process.eextensible-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 f over efextensible-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 egextensible-effects-concurrent"Run a reader effect that contains the one server handling a specific  instance.hextensible-effects-concurrentGet the  registered with g.iextensible-effects-concurrentLike e but take the  from the reader provided by g.When working with an embedded  use k.jextensible-effects-concurrentLike d but take the  from the reader provided by g.When working with an embedded  use l.kextensible-effects-concurrentLike i, uses  to embed the value.>This function makes use of AmbigousTypes and TypeApplications."When not working with an embedded  use i.lextensible-effects-concurrentLike j , but uses  to embed the value.>This function makes use of AmbigousTypes and TypeApplications."When not working with an embedded  use j. bcdefghijkl defljkicbhg None%%&',-.145678=>?@ACHMPSUVX_kND mextensible-effects-concurrent7Runtime-Errors occurring when spawning child-processes.yextensible-effects-concurrent!Constraints on the parameters to p.oextensible-effects-concurrent(The type of value used to index running N processes managed by a p.(Note, that the type you provide must be .pextensible-effects-concurrentThe index type of N supervisors.A p p6 manages the life cycle of the processes, running the N p methods of that specific type.0The supervisor maps an identifier value of type o p to an  p.sextensible-effects-concurrent7Start and link a new supervisor process with the given SpawnFununction.!To spawn new child processes use w.textensible-effects-concurrent/Stop the supervisor and shutdown all processes.(Block until the supervisor has finished.uextensible-effects-concurrent-Check if a supervisor process is still alive.vextensible-effects-concurrentMonitor a supervisor process.wextensible-effects-concurrent6Start, link and monitor a new child process using the SpawnFun passed to s.xextensible-effects-concurrent=Lookup the given child-id and return the output value of the SpawnFun! if the client process exists.yextensible-effects-concurrent;Stop a child process, and block until the child has exited.Return B& if a process with that ID was found, z. if no process with the given ID was running.zextensible-effects-concurrent Return a 80 describing the current state of the supervisor.OqrmnopstuvwxyzpoOqrmnstuvzwxyNone$%&',-.145678=>?@ACHMPSUVX_kwextensible-effects-concurrent<Alias for the effect that contains the observers managed by extensible-effects-concurrentInternal state for extensible-effects-concurrentA protocol for managing 6s, encompassing registration and de-registration of s.extensible-effects-concurrent-The constraints on the type parameters to an 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  Protocol, 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 The empty extensible-effects-concurrent>Report an observation to all observers. The process needs to  and to .extensible-effects-concurrentA minimal Protocol for handling observations. This is one simple way of receiving observations - of course users can use any other  ) message type for receiving observations.None%%&',-.145678=>?@ACHMPSUVX_kextensible-effects-concurrentA d 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 C 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 @(ObservationQueue 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$%&',-.145678=>?@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 d.extensible-effects-concurrentCombination of  and d.None$%&',-.145678=>?@ACHMPSUVX_kextensible-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 @ instance.extensible-effects-concurrentExecute the server loop.extensible-effects-concurrentExecute the server loop.9=>?:;<9=>?:;<None%%&',-.145678=>?@ACHMPSUVX_kextensible-effects-concurrentAlias for the } that contains the captured s from .extensible-effects-concurrentA 7 monad that provides pure logging by capturing via the } effect.extensible-effects-concurrentA 7 monad that provides pure logging by capturing via the } effect.See *extensible-effects-concurrentRun a } for s.Such a } is needed to handle extensible-effects-concurrentA  monad for pure logging.The " instance for this type assumes a } effect.None$%&',-.145678=>?@ACHMPSUVX_kextensible-effects-concurrentThe concrete list of 2"ects for logging with an IO based , and a .extensible-effects-concurrentA  that uses an 5 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_kVextensible-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_kLextensible-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_kextensible-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_kK_extensible-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 .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-concurrentaAdd monitor: If the process is dead, enqueue a ProcessDown 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 R}ed by it in the current thread concurrently, using a co-routine based, round-robin scheduler. If a process exits with eg.g l or m" 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_klextensible-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 C 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 2'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 2<ects for interruptable, concurrent processes, scheduled via forkIO.extensible-effects-concurrentThe concrete list of 2Dects 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_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#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_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#PredefinedPredicatesextensible-effects-concurrent rendering functionextensible-effects-concurrentPath to the socket fileextensible-effects-concurrent rendering functionextensible-effects-concurrentPath to the socket fileNone$%&',-.145678=>?@ACHMPSUVX_kextensible-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.    0None$%&',-.145678=>?@ACHMPSUVX_kC !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmPQRSTUVWXYZ[\]   !"#$bcdefghijkl        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm !"#$bcdefghijkl  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{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmPQRSTUVWXYZ[\]   !"#$bcdefghijkl     !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm   !"#$bcdefghijkl    None$%&',-.145678=>?@ACHMPSUVX_kextensible-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{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmPQRSTUVWXYZ[\]   !"#$bcdefghijkl   !"#$%&'()*+,-./0123456789:;<=>?@ABCD`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm   !"#$bcdefghijkl  1None%%&',-.145678=>?@ACHMPSUVX_k23456789:;<=>?@@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~456645        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789: ; < = > ? @ 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 i j v w x y z { | } ~                                    'ij     *,+ !"#$%&'()*+,-./0112345467897:;<=>?@ABCDEFGH?IJKLMNOPQRSTUVWUVXUVYZP[\]FG^FG_ ` aJKbcdJKefgchFGiJKjFklmnmopqrstuvwxyz{|}~Fkpq )))))))))))))))))))) FGPM4?411111111;extensible-effects-concurrent-0.27.0-FYVu0ncBuKWBPMSvDs0PwDControl.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.PureDebugTraceControl.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 renderRFC5424renderRFC5424NoLocationrenderRFC5424Header PureLogWriterMkPureLogWriterrunPureLogWriterHandleLogWriterhandleLogWriterEffectliftWriteLogMessageLogWriterReader LogWriter MkLogWriter runLogWriterrunLogWriterReader askLogWriterlocalLogWriterReader noOpLogWriterfilteringLogWritermappingLogWritermappingLogWriterM$fDefaultLogWriter$fMonadBaseControlmEff$fHandleLogWriterReaderea->$fHandleLogWriterIOe$fHandleLogWriterPureLogWritere$fApplicativePureLogWriter$fFunctorPureLogWriter$fMonadPureLogWriterLogIoLogsToLogs withLoggingwithSomeLoggingrunLogslogMsglogWithSeveritylogWithSeverity' logEmergencylogAlert logCriticallogError logWarning logNoticelogInfologDebug logEmergency' logAlert' logCritical' logError' logWarning' logNotice'logInfo' logDebug'askLogPredicatesetLogPredicatemodifyLogPredicateincludeLogMessagesexcludeLogMessagesrespondToLogMessageinterceptLogMessagesmodifyLogWriter setLogWriter censorLogs censorLogsM addLogWriter$fHandleLogsea-> ProcessId_fromProcessId ProcessDown downReference downReasonMonitorReference monitorIndexmonitoredProcessSomeExitReason Interrupts SafeProcesses 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 withMonitorreceiveWithMonitorbecauseProcessIsDownselectProcessDown linkProcess unlinkProcess exitBecause exitNormally exitWithError$fShowProcessTitle$fShowProcessDetails$fShowStrictDynamic$fNFDataStrictDynamic$fContravariantSerializer$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$fShowResumeProcess fromProcessIdEndpoint _fromEndpoint ProtocolReply Synchronicity Synchronous Asynchronous TangiblePduTangibleHasPduPdudeserializePduprettyTypeableShowsprettyTypeableShowsPrec$fShowEndpoint $fEqEndpoint $fOrdEndpoint$fNFDataEndpoint EmbedProtocol embeddedPduembedPdufromPdu fromEndpointproxyAsEndpoint asEndpointtoEmbeddedEndpointfromEmbeddedEndpoint $fShowPdu $fNFDataPdu $fShowPdu0 $fNFDataPdu0 $fShowPdu1 $fNFDataPdu1 $fShowPdu2 $fNFDataPdu2$fEmbedProtocol(,,,,)a5r$fEmbedProtocol(,,,,)a4r$fEmbedProtocol(,,,,)a3r$fEmbedProtocol(,,,,)a2r$fEmbedProtocol(,,,,)a1r$fEmbedProtocol(,,,)a4r$fEmbedProtocol(,,,)a3r$fEmbedProtocol(,,,)a2r$fEmbedProtocol(,,,)a1r$fEmbedProtocol(,,)a3r$fEmbedProtocol(,,)a2r$fEmbedProtocol(,,)a1r$fEmbedProtocol(,)a2r$fEmbedProtocol(,)a1r$fEmbedProtocolaar$fHasPdu(,,,,)r$fHasPdu(,,,)r $fHasPdu(,,)r $fHasPdu(,)r 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 ModelState StartArgumentProtocolModelSettingssetupupdate modifyModelgetAndModifyModelmodifyAndGetModelgetModeluseModelputModelgetAndPutModel zoomModel askSettings viewSettings$fServerStatefulqEndpointReaderServesProtocolcastcallcallWithTimeoutrunEndpointReader askEndpointcallEndpointReadercastEndpointReader callSingleton castSingletonSpawnErrAlreadyStartedChildIdSup MkSupConfigsupConfigChildStopTimeoutstartSupervisorstopSupervisorisSupervisorAlivemonitorSupervisor spawnChild lookupChild stopChildgetDiagnosticInfo$fNFDataSpawnErr $fServerSup: $fHasPduSupr$fGenericSpawnErr$fShowSpawnErr $fOrdSpawnErr $fEqSpawnErr ObserverState ObserversObserverRegistryTangibleObserverObserverRegisterObserverForgetObserverObservedregisterObserverforgetObserverhandleObservations toObserver toObserverForhandleObserverRegistrationmanageObserversemptyObserversobserved$fHasPduObserverr $fEqObserver $fOrdObserver$fShowObserver$fNFDataObserver$fHasPduObserverRegistryr $fEqObservers$fOrdObservers$fShowObservers$fNFDataObserversObservationQueueReaderObservationQueuereadObservationQueuetryReadObservationQueueflushObservationQueuewithObservationQueuespawnLinkObservationQueueWriter$fServerObservationQueue:SchedulerSessionforkInteractiveSchedulerkillInteractiveSchedulersubmit submitCast submitCallServerId MkServerId _fromServerIdTangibleCallbacks $fShowInit $fNFDataInit$fServerServer:$fShowServerId$fNFDataServerId $fOrdServerId $fEqServerId$fIsStringServerIdCaptureLogWriter CaptureLogs MkCaptureLogs unCaptureLogscaptureLogWriterrunCaptureLogWriter$fHandleLogWriterCaptureLogse$fFunctorCaptureLogs$fApplicativeCaptureLogs$fMonadCaptureLogs LoggingAndIo mkLogWriterIOioHandleLogWriter withIoLoggingdefaultIoLogWriterprintLogMessagewithFileLoggingwithFileLogWriterwithTraceLoggingwithTraceLogWriterdebugTraceLogWriterwithConsoleLoggingwithConsoleLogWriterconsoleLogWriterstdoutLogWriterwithAsyncLoggingwithAsyncLogWriter$fShowProcessInfoHasBaseEffectsIo BaseEffectsIo SafeEffectsIo EffectsIoHasPureBaseEffectsPureBaseEffectsPureSafeEffects PureEffects schedulePure scheduleIOscheduleMonadIOEffscheduleIOWithLogging scheduleM defaultMaindefaultMainWithLogWriter $fShowSTS $fShowOnYield$fDefaultMessageQ BaseEffectsHasBaseEffectsEffects SafeEffectsschedulewithUDPLoggingwithUDPLogWriterwithUnixSocketLoggingwithUnixSocketLogWriterexampleLoggingexampleWithLoggingexampleWithSomeLoggingexampleLogPredicateexampleAsyncLoggingexampleRFC5424Logging*exampleRFC3164WithRFC5424TimestampsLoggingexampleDevLogRFC5424LoggingexampleUdpRFC5424LoggingloggingExampleClientlogPredicatesExampleClient foreverCheapreplicateCheapM_baseGHC.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.Classdefghc-prim GHC.TypesIOLifteddeepseq-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.EitherEitherrnfData.Typeable.InternalTypeableLeft ConstraintNFData GHC.ClassesOrdGHC.ShowShow showsPrec"lens-4.17.1-GjSMQ2I3MoU63aIbR3DWuiControl.Lens.TypePrism ToPduLeft ToPduRightToPdu1ToPdu2ToPdu3 ToPdu1Of4 ToPdu2Of4 ToPdu3Of4 ToPdu4Of4 ToPdu1Of5 ToPdu2Of5 ToPdu3Of5 ToPdu4Of5 ToPdu5Of5Data.SemigroupArgEq embedReplyLensStatefulControl.Eff.State.StrictStateControl.Eff.Reader.StrictReaderChildren getChildrenChildMkChild_childMonitoring_childEndpoint MkChildren_childrenByMonitor _childrenById childEndpointchildMonitoring childrenByIdchildrenByMonitorputChildlookupChildByIdlookupChildByMonitorlookupAndRemoveChildById removeChildlookupAndRemoveChildByMonitorremoveAllChildren TangibleSupFalse stm-2.5.0.0Control.Concurrent.STM.TBQueueTBQueueGHC.MVarMVarControl.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