!_8      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                   !"#$%&'()*+,-./01234567None"%&',-.14567=>?@ACHMPSUVX_k!'extensible-effects-concurrentCatch 8 thrown by an effect.extensible-effects-concurrentVery similar to 9 but for : s. Unlike ;4 this will throw the given value (instead of using <).=>;?9@ABCDEFGHIJK<None"%&',-.14567=>?@ACHMPSUVX_kKextensible-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-concurrentExtract the name of an 3 the length is cropped to 32 according to RFC 5424.&extensible-effects-concurrentExtract the value of an .'extensible-effects-concurrent#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.0extensible-effects-concurrent#Smart constructor for the RFC-5424  facility userLevelMessages. See f.1extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  mailSystem. See f.2extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  systemDaemons. See f.3extensible-effects-concurrent#Smart constructor for the RFC-5424  facility securityAuthorizationMessages4. See f.4extensible-effects-concurrent#Smart constructor for the RFC-5424  facility linePrinterSubsystem. See f.5extensible-effects-concurrent#Smart constructor for the RFC-5424  facility networkNewsSubsystem. See f.6extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  uucpSubsystem. See f.7extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  clockDaemon. See f.8extensible-effects-concurrent#Smart constructor for the RFC-5424  facility securityAuthorizationMessages10. See f.9extensible-effects-concurrent#Smart constructor for the RFC-5424  facility  ftpDaemon. See f.:extensible-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.Aextensible-effects-concurrent#Smart constructor for the RFC-5424  facility local3. See f.Bextensible-effects-concurrent#Smart constructor for the RFC-5424  facility local4. See f.Cextensible-effects-concurrent#Smart constructor for the RFC-5424  facility local5. See f.Dextensible-effects-concurrent#Smart constructor for the RFC-5424  facility local6. See f.Eextensible-effects-concurrent#Smart constructor for the RFC-5424  facility local7. See f.`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.Handler#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 w 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 L of a mextensible-effects-concurrentA lens for the  of a nextensible-effects-concurrentA lens for the M of a  The function v can be used to set the field.oextensible-effects-concurrentA lens for the UTC time of a  The function u can be used to set the field.Nextensible-effects-concurrentPrint a ; in a very incomplete way, use only for tests and debuggingpextensible-effects-concurrent Render a  human readable.qextensible-effects-concurrent Render a \ according to the rules in the given RFC, except for the rules concerning unicode and asciirextensible-effects-concurrent Render a , but set the timestamp and thread id fields.sextensible-effects-concurrent2Put the source location of the given callstack in ltextensible-effects-concurrent Prefix the h.uextensible-effects-concurrent/An IO action that sets the current UTC time in o.vextensible-effects-concurrentAn IO action appends the the M of the calling process (see O) to h.wextensible-effects-concurrentEAn IO action that sets the current hosts fully qualified hostname in g.xextensible-effects-concurrent Construct a  with *yextensible-effects-concurrent Construct a  with -zextensible-effects-concurrent Construct a  with .{extensible-effects-concurrent Construct a  with *|extensible-effects-concurrent Construct a  with -}extensible-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.\ !"#$%&'()*+,-./0123456789:;<=>?@ABCDE`abcdefghijklmnopqrstuvwxyz{|}~\ !"#$fkogejimlnhstuvwqrpxyzcd{|}b~%&`a'()*+,-./0123456789:;<=>?@ABCDENone#%&',-.14567=>?@ACHMPSUVX_kextensible-effects-concurrentAlias for the P that contains the captured s from .extensible-effects-concurrentA 7 monad that provides pure logging by capturing via the P effect.extensible-effects-concurrentA phantom type for the  class for pure sextensible-effects-concurrentZThe instances of this class are the monads that define (side-) effect(s) of writting logs.extensible-effects-concurrentvA list of effects that are required for writing the log messages. For example 'Lift IO' or '[]' for pure log writers.extensible-effects-concurrentRun the side effect of a  in a compatible 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 p. to the log message and then traces it using T. This  work with any base monad.extensible-effects-concurrentA 7 monad that provides pure logging by capturing via the P effect.extensible-effects-concurrentRun a P for s.Such a P is needed for extensible-effects-concurrentA  that uses an U action to write the message.,Example use cases for this function are the  and the .extensible-effects-concurrentA  that renders s to strings via p and prints them to an V using  hPutStrLn.extensible-effects-concurrentWrite %s to standard output, formatted with r.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 n field contains the thread-IdThe g, field contains the FQDN of the current hostThe f field contains the given It works by using .extensible-effects-concurrentA ! that applies a predicate to the E and delegates to to the given writer of the predicate is satisfied.extensible-effects-concurrentA  that applies a function to the 2 and delegates the result to to the given writer.extensible-effects-concurrentLike % allow the function that changes the  to have effects.extensible-effects-concurrentA  monad for  based pure logging.extensible-effects-concurrentA  monad for pure logging.The " instance for this type assumes a P effect.extensible-effects-concurrent-The default application name to put into the e field.extensible-effects-concurrent.The default RFC-5424 facility to put into the f field.extensible-effects-concurrentThe IO based writer to decorateNone#%&',-.14567=>?@ACHMPSUVX_kR !extensible-effects-concurrentThe concrete list of Q"ects for logging with an IO based , and a .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:extensible-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.Handler#LogPredicateThis effect is handled via .extensible-effects-concurrentEnable logging to standard output using the  in combination with the .Example: exampleWithConsoleLogging :: IO () exampleWithConsoleLogging = runLift $ withConsoleLogging "my-app" local7 allLogMessages $ logInfo "Oh, hi there" To vary the  use .extensible-effects-concurrentEnable logging to IO using the .5To log to the console (standard output), one can use .Example: exampleWithIoLogging :: IO () exampleWithIoLogging = runLift $ withIoLogging consoleLogWriter "my-app" local7 (lmSeverityIsAtLeast informationalSeverity) $ logInfo "Oh, hi there"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 W, after they pass the b.extensible-effects-concurrentLog a X as  with a given .extensible-effects-concurrentLog a X 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.Handler#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.Handler#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.Handler#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.Handler#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.Handler#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 Y 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 Y, Z, [ 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 Y, Z, [ 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.  exampleAddLogWriter :: IO () exampleAddLogWriter = go >>= putStrLn where go = fmap (unlines . map renderLogMessage . snd) $ runLift $ runCapturedLogsWriter $ withLogging listLogWriter $ addLogWriter (mappingLogWriter (lmMessage %~ ("CAPTURED "++)) listLogWriter) $ 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-concurrentOpen a file and add the  in the $ tha appends the log messages to it.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.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-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#PredefinedPredicatesNone#%&',-.14567=>?@ACHMPSUVX_kExextensible-effects-concurrentEach process is identified by a single process id, that stays constant throughout the life cycle of a process. Also, message sending relies on these values to address messages to processes. extensible-effects-concurrentyA monitored process exited. This message is sent to a process by the scheduler, when a process that was monitored died. extensible-effects-concurrentBA value that contains a unique reference of a process monitoring.extensible-effects-concurrentAn existential wrapper around extensible-effects-concurrentThis adds a layer of the  effect on top of extensible-effects-concurrentJeptions containing s. See 0, 3 or 4extensible-effects-concurrent's which are recoverable are interrupts.extensible-effects-concurrentA sum-type with reasons for why a process exists the scheduling loop, this includes errors, that can occur when scheduling messages. extensible-effects-concurrentA process has finished a unit of work and might exit or work on something else. This is primarily used for interrupting infinite server loops, allowing for additional cleanup work before exiting (e.g. with )extensible-effects-concurrent1A process that should be running was not running.extensible-effects-concurrentA linked process is downextensible-effects-concurrent3An exit reason that has an error message but isn't .extensible-effects-concurrent8A process function returned or exited without any error.extensible-effects-concurrent An unhandled  allows .extensible-effects-concurrentOAn unexpected runtime exception was thrown, i.e. an exception derived from extensible-effects-concurrent)A process was cancelled (e.g. killed, in )extensible-effects-concurrentcThis value indicates whether a process exited in way consistent with the planned behaviour or not.extensible-effects-concurrent#This kind is used to indicate if a H can be treated like a short interrupt which can be handled or ignored.extensible-effects-concurrentThe state that a  is currently in.extensible-effects-concurrent;The process has just been started but not scheduled yet.extensible-effects-concurrent#The process yielded it's time sliceextensible-effects-concurrent%The process is busy with non-blockingextensible-effects-concurrent*The process is busy with sending a messageextensible-effects-concurrent The process is busy with killingextensible-effects-concurrent The process is busy with killingextensible-effects-concurrentThe process blocked by a Jextensible-effects-concurrentThe process blocked by a Yextensible-effects-concurrentThe process blocked by a Zextensible-effects-concurrentThe process blocked by a Sextensible-effects-concurrentThe process blocked by a Textensible-effects-concurrentThe process was interruptedextensible-effects-concurrent#The process was shutdown or crashedextensible-effects-concurrentCons  onto a list of effects.extensible-effects-concurrentEvery function for a things needs such a proxy value for the low-level effect list, i.e. the effects identified by r in  r : r;, this might be dependent on the scheduler implementation.extensible-effects-concurrent1Tell the type checker what effects we have below extensible-effects-concurrentLike  but shorter extensible-effects-concurrentLike  but different extensible-effects-concurrentAA function that decided if the next message will be received by %. It conveniently is an instance of ^ so the message selector can be combined: > > selectInt :: MessageSelector Int > selectInt = selectMessage > > selectString :: MessageSelector String > selectString = selectMessage > > selectIntOrString :: MessageSelector (Either Int String) > selectIntOrString = > Left  $ selectTimeout | Right  $ selectString extensible-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 8A 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-concurrentThe process effect is the basis for message passing concurrency. This effect describes an interface for concurrent, communicating isolated processes identified uniquely by a process-id.Processes can raise exceptions that can be caught, exit gracefully or with an error, or be killed by other processes, with the option of ignoring the shutdown request.vProcess Scheduling is implemented in different modules. All scheduler implementations should follow some basic rules:fair scheduling sending a message does not blockreceiving a message does block*spawning a child blocks only a very momentJa newly spawned process shall be scheduled before the parent process after the spawnRawGwhen the first process exists, all process should be killed immediatelyextensible-effects-concurrent3Remove all messages from the process' message queue extensible-effects-concurrentIn cooperative schedulers, this will give processing time to the scheduler. Every other operation implicitly serves the same purpose.extensible-effects-concurrentReturn the current extensible-effects-concurrentjStart a new process, the new process will execute an effect, the function will return immediately with a . extensible-effects-concurrentStart a new process, and  to it .extensible-effects-concurrentGet the process state (or _ if the process is dead)extensible-effects-concurrentTShutdown the process; irregardless of the exit reason, this function never returns,extensible-effects-concurrent$Raise an error, that can be handled.extensible-effects-concurrent\Request that another a process interrupts. The targeted process is interrupted and gets an  ], the target process may decide to ignore the interrupt and continue as if nothing happened.extensible-effects-concurrent-Send a message to a process addressed by the . Sending a message should always succeed and return  immediatelyb, even if the destination process does not exist, or does not accept messages of the given type.extensible-effects-concurrent}Receive a message that matches a criteria. This should block until an a message was received. The message is returned as a  ` value. The function should also return if an exception was caught or a shutdown was requested.extensible-effects-concurrentGenerate a unique ` for the current process. extensible-effects-concurrent>Monitor another process. When the monitored process exits a  is sent to the calling process. The return value is a unique identifier for that monitor. There can be multiple monitors on the same process, and a message for each will be sent. If the process is already dead, the 7 message will be sent immediately, without exit reason extensible-effects-concurrentRemove a monitor. extensible-effects-concurrentaConnect the calling process to another process, such that if one of the processes crashes (i.e. 7 returns a#), the other is shutdown with the  . extensible-effects-concurrent2Unlink the calling process from the other process.  extensible-effects-concurrent>Create a message selector for a value that can be obtained by b. It will also c the result.! extensible-effects-concurrent>Create a message selector for a value that can be obtained by b. It will also c the result." extensible-effects-concurrent4Create a message selector from a predicate. It will c the result.# extensible-effects-concurrent4Create a message selector from a predicate. It will c the result.$ 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 ). It will c the result.% 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 ). It will c the result.& extensible-effects-concurrent#Create a message selector. It will c the result.' 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 ced.) extensible-effects-concurrent>Create a message selector for a value that can be obtained by b& with a proxy argument. It will also c the result.* extensible-effects-concurrent>Create a message selector for a value that can be obtained by b& with a proxy argument. It will also c the result.+extensible-effects-concurrent Return a  for a  effect.,extensible-effects-concurrentGet the -extensible-effects-concurrentGet the  of a ..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 .0extensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a K via a call to 6.1 extensible-effects-concurrentLike 0, but instead of passing the  to a handler function, e is returned.2extensible-effects-concurrent'Handle interrupts by logging them with ; and otherwise ignoring them.3extensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a K via a call to 6.4extensible-effects-concurrentHandle \s arising during process operations, e.g. when a linked process crashes while we wait in a K via a call to 6.5extensible-effects-concurrentWrap all (left) s into  and return the (right)  s as is.6extensible-effects-concurrent Throw an , can be handled by 0 or 3 or 4.7extensible-effects-concurrentA predicate for crashes. A crash' happens when a process exits with an  other than 8extensible-effects-concurrentkA predicate for recoverable exit reasons. This predicate defines the exit reasons which functions such as <9extensible-effects-concurrent Partition a  back into either a  or a  :extensible-effects-concurrentPrint a  to d a formatted X when 7 is a>. This can be useful in combination with view patterns, e.g.: slogCrash :: ExitReason -> Eff e () logCrash (toCrashReason -> Just reason) = logError reason logCrash _ = return ()Though this can be improved to: -logCrash = traverse_ logError . toCrashReason;extensible-effects-concurrentLog the s<extensible-effects-concurrentExecute a and action and return the result; if the process is interrupted by an error or exception, or an explicit shutdown from another process, or through a crash of a linked process, i.e. whenever the exit reason satisfies 8, return the exit reason.=extensible-effects-concurrent Execute a : action and resume the process, exit the process when an  was raised. Use < to catch interrupts.>extensible-effects-concurrent Execute a : action and resume the process, exit the process when an  was raised. Use < to catch interrupts.?extensible-effects-concurrentUse = to execute  . Refer to  for more information.@extensible-effects-concurrent-Send a message to a process addressed by the . See .Aextensible-effects-concurrentSend a f% value to a process addressed by the . See .Bextensible-effects-concurrent Exit a process addressed by the Z. The process will exit, it might do some cleanup, but is ultimately unrecoverable. See .Cextensible-effects-concurrent&Interrupts a process addressed by the 7. The process might exit, or it may continue. | Like C, but also return True iff the process to exit exists.Dextensible-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 G.Eextensible-effects-concurrentLike D but return ().F extensible-effects-concurrent0Start a new process, and immediately link to it.Gextensible-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 D might be better suited.Hextensible-effects-concurrentLike G but return ().I extensible-effects-concurrentReturn a if the process is alive.Jextensible-effects-concurrent)Block until a message was received. See  for more documentation.Kextensible-effects-concurrent0Block until a message was received, that is not _( after applying a callback to it. See  for more documentation.Lextensible-effects-concurrent%Receive and cast the message to some g instance. See P for more documentation. This will wait for a message of the return type using KM extensible-effects-concurrentPRemove and return all messages currently enqueued in the process message queue.Nextensible-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 8*, then the callback will be invoked with h C, otherwise the process will be exited with the same reason using [ . See also  for more documentation.Oextensible-effects-concurrentLike N but  not selective . See also (, N.Pextensible-effects-concurrentLike N& but refined to casting to a specific g using !.Qextensible-effects-concurrent Returns the  of the current process.Rextensible-effects-concurrentGenerate a unique ` for the current process.S 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 reasonT extensible-effects-concurrentRemove a monitor created with S.U extensible-effects-concurrentS8 another process before while performing an action and T afterwards.V extensible-effects-concurrentA  I for receiving either a monitor of the given process or another message.W extensible-effects-concurrentMake an  for a  message. For example: @doSomething >>= either (interrupt . becauseProcessIsDown) returnX extensible-effects-concurrentA   for the  message of a specific process.Y extensible-effects-concurrentaConnect the calling process to another process, such that if one of the processes crashes (i.e. 7 returns a#), the other is shutdown with the  .Z extensible-effects-concurrent2Unlink the calling process from the other process.[extensible-effects-concurrentExit the process with a .\extensible-effects-concurrentExit the process.]extensible-effects-concurrentExit the process with an error.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]   +?@ABCRLKMJPNO   !)*"#$%&'(QIDEFGH[\]YZSTXWUV/0132456<=>,8-.7:9;None"%&',-.14567=>?@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 _. 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 h . This is based on  and . 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 K7. To receive messages with guarded with a timeout see . extensible-effects-concurrentCancel a timer started with .  None"%&',-.14567=>?@ACHMPSUVX_kwextensible-effects-concurrent'This is a tag-type that wraps around a  and holds an  index type.extensible-effects-concurrentyThe (promoted) constructors of this type specify (at the type level) the reply behavior of a specific constructor of an Api instance.extensible-effects-concurrent[Specify that handling a request is a blocking operation with a specific return type, e.g. -('Synchronous (Either RentalError RentalId))extensible-effects-concurrent,Non-blocking, asynchronous, request handlingextensible-effects-concurrent}This data family defines an API, a communication interface description between at least two processes. The processes act as servers or  client(s), regarding a specific instance of this type.PThe first parameter is usually a user defined phantom type that identifies the  instance.LThe second parameter specifies if a specific constructor of an (GADT-like) Api instance is ;, i.e. returns a result and blocks the caller or if it is Example:  data BookShop deriving Typeable data instance Api BookShop r where RentBook :: BookId -> Api BookShop ('Synchronous (Either RentalError RentalId)) BringBack :: RentalId -> Api BookShop 'Asynchronous type BookId = Int type RentalId = Int type RentalError = String extensible-effects-concurrentTag a  with an  type index to mark it a  process handling that APIextensible-effects-concurrentTag a  with an  type index to mark it a  process handling that API  None#%&',-.14567=>?@ACHMPSUVX_kextensible-effects-concurrentWraps the source  and a unique identifier for a .iextensible-effects-concurrentGet the reply of an Api foo ('Synchronous reply).jextensible-effects-concurrentGet the reply of an Api foo ('Synchronous reply).extensible-effects-concurrentThe wrapper around replies to s.extensible-effects-concurrent=A wrapper sum type for calls and casts for the methods of an  subtypeextensible-effects-concurrent TODO removeextensible-effects-concurrentSend a  to a .  None"%&',-.14567=>?@ACHMPSUVX_kextensible-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 k effect, if there is only a  single server for a given I instance. This type alias is convenience to express that an effect has  and a reader for a .extensible-effects-concurrentSend an v request that has no return value and return as fast as possible. The type signature enforces that the corresponding  clause is [. The operation never fails, if it is important to know if the message was delivered, use  instead.extensible-effects-concurrentSend an : request and wait for the server to return a result value.3The type signature enforces that the corresponding  clause is .extensible-effects-concurrent"Run a reader effect that contains the one server handling a specific  instance.extensible-effects-concurrentGet the  registered with .extensible-effects-concurrentLike  but take the  from the reader provided by .extensible-effects-concurrentLike  but take the  from the reader provided by . None"%&',-.14567=>?@ACHMPSUVX_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 l$, which is also the reason for the Lift IO constraint.extensible-effects-concurrent?Exit the scheduler immediately using an asynchronous exception.extensible-effects-concurrentSend a V effect to the main process of a scheduler, this blocks until the effect is executed.extensible-effects-concurrentCombination of  and .extensible-effects-concurrentCombination of  and . None"%&',-.14567=>?@ACHMPSUVX_k*extensible-effects-concurrentFork a new process in which the given log message writer, will listen on a message queue, to which all log message will be relayed.@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: exampleAsyncLogging :: IO () exampleAsyncLogging = runLift $ withSomeLogging @IO $ withAsyncLogging (1000::Int) consoleLogWriter $ 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. None"%&',-.14567=>?@ACHMPSUVX_kextensible-effects-concurrentExample code for:rthextensible-effects-concurrentExample code for:extensible-effects-concurrentExample code for:extensible-effects-concurrentExample code for:extensible-effects-concurrentExample code for:extensible-effects-concurrentExample code for: !"#$%&'()*+,-./0123456789:;<=>?@ABCDE`abcdefghijklmnopqrstuvwxyz{|}~ None"%&',-.14567=>?@ACHMPSUVX_k mextensible-effects-concurrentVInternal data structure that is part of the coroutine based scheduler implementation.nextensible-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 o as yield effect. scheduleIO runEff ==  (runLift . runEff) (liftIO o)extensible-effects-concurrentInvoke  with lift o as yield effect. scheduleMonadIOEff ==  id (liftIO o)extensible-effects-concurrentRun processes that have the  and the p8 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 D}ed by it in the current thread concurrently, using a co-routine based, round-robin scheduler. If a process exits with eg.g \ or ]" or is killed by another process Left ...: is returned. Otherwise, the result will be wrapped in a Right.UEvery time a process _yields_ the effects are evaluated down to the a value of type m (Either String a).4If the evaluator function runs the action down e.g. IOh this might improve memory consumption, for long running services, with processes that loop endlessly.qextensible-effects-concurrent Internal  handler function.extensible-effects-concurrent Execute a  using  on top of p IO and  String effects.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 o.None"%&',-.14567=>?@ACHMPSUVX_kJrextensible-effects-concurrenttA message queue of a process, contains the actual queue and maybe an exit reason. The message queue is backed by a s sequence with f values.textensible-effects-concurrent2Information about a process, needed to implement , handlers. The message queue is backed by a u that contains a r.vextensible-effects-concurrent Return any w from a r in a u and reset the w field to _ in the u.xextensible-effects-concurrentjContains all process info'elements, as well as the state needed to implement inter process communication.yextensible-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-concurrent+The concrete list of the effects, that the  usesextensible-effects-concurrentThe concrete list of QDects of processes compatible with this scheduler. This builds upon .zextensible-effects-concurrent/Add monitor: If the process is dead, enqueue a ' message into the owners message queue{extensible-effects-concurrent Create a new t|extensible-effects-concurrent Create a new x}extensible-effects-concurrent Create a new xk 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"%&',-.14567=>?@ACHMPSUVX_k*G extensible-effects-concurrentJJust a wrapper around a function that will be applied to the result of a s  clause, or an ! caught during the execution of receive or a  extensible-effects-concurrent+Helper type class for the return values of  et al. extensible-effects-concurrent!An existential wrapper around a  8 and a function that handles the selected message. The api" type parameter is a phantom type..The return value if the handler function is a . extensible-effects-concurrent(A command to the server loop started by . Typically returned by a 4 to indicate if the server should continue or stop.extensible-effects-concurrent/Tell the server to keep the server loop runningextensible-effects-concurrent)Tell the server to exit, this will cause 8 to stop handling requests without exiting the process. extensible-effects-concurrentServe an  in a newly spawned process.extensible-effects-concurrentServe an * in a newly spawned -and linked - process. extensible-effects-concurrentServer an w in a newly spawned process; the callbacks have access to some state initialed by the function in the first parameter. extensible-effects-concurrentServer an w in a newly spawned process; The caller provides an effect handler for arbitrary effects used by the server callbacks.extensible-effects-concurrentServer an  in a newly spawned process; The caller provides an effect handler for arbitrary effects used by the server callbacks. Links to the calling process like Y would.extensible-effects-concurrentReceive loop for   %s. This starts a receive loop for a ". It is used behind the scenes by  and . extensible-effects-concurrentA smart constructor for s  extensible-effects-concurrentA smart constructor for s  extensible-effects-concurrentA smart constructor for s  extensible-effects-concurrentA smart constructor for s  extensible-effects-concurrentA smart constructor for sExample ihandleCalls ( (RentBook bookId customerId) runCall -> runCall $ do rentalIdE <- rentBook bookId customerId case rentalIdE of -- on fail we just don't send a reply, let the caller run into -- timeout Left err -> return (Nothing, AwaitNext) Right rentalId -> return (Just rentalId, AwaitNext))   extensible-effects-concurrentA smart constructor for sextensible-effects-concurrentA variation of  ( that allows to defer a reply to a call. extensible-effects-concurrentA smart constructor for s extensible-effects-concurrent Compose two s to a type-level pair of them. 1handleCalls api1calls ^: handleCalls api2calls ^: extensible-effects-concurrent]Make a fallback handler, i.e. a handler to which no other can be composed to from the right. extensible-effects-concurrentA # that drops the left-over messages. extensible-effects-concurrentA 1 that terminates if there are unhandled messages. extensible-effects-concurrentA # that drops the left-over messages. extensible-effects-concurrentA smart constructor for s          5None"%&',-.14567=>?@ACHMPSUVX_kTextensible-effects-concurrent<Alias for the effect that contains the observers managed by *~extensible-effects-concurrentInternal state for *extensible-effects-concurrentAn  for managing 6s, encompassing registration and de-registration of s.extensible-effects-concurrent.Describes a process that observes another via   messages.An observer consists of a filter and a process id. The filter converts an observation to a message understood by the observer process, and the  is used to send the message.!extensible-effects-concurrent$This message denotes that the given # should receive observations until " is received."extensible-effects-concurrent$This message denotes that the given ) should not receive observations anymore.#extensible-effects-concurrent.This message denotes that the given value was +.$extensible-effects-concurrentAnd an ; to the set of recipients for all observations reported by +{. Note that the observers are keyed by the observing process, i.e. a previous entry for the process contained in the m is overwritten. If you want multiple entries for a single process, just combine several filter functions.%extensible-effects-concurrent Send the " message&extensible-effects-concurrent Based on the  instance for \ this simplified writing a callback handler for observations. In order to register to and  use '.'extensible-effects-concurrentUse a  as an  for &.(extensible-effects-concurrent Create an  that conditionally accepts all observations of the given type and applies the given function to them; the function takes an observation and returns an 1 cast that the observer server is compatible to.)extensible-effects-concurrent#Provide the implementation for the  Api, this handled ! and " messages. It also adds the  constraint to the effect list.*extensible-effects-concurrentKeep track of registered s. Handle the  introduced by ).+extensible-effects-concurrent>Report an observation to all observers. The process needs to * and to ).extensible-effects-concurrentA minimal Api for handling observations. This is one simple way of receiving observations - of course users can use any other  ) message type for receiving observations.extensible-effects-concurrentzApi for managing observers. This can be added to any server for any number of different observation types. The functions * and )' are used to include observer handling;!"# $%&'()*+ !"#$%&'()*+None"%&',-.14567=>?@ACHMPSUVX_knR/extensible-effects-concurrentA k for an 0.0extensible-effects-concurrent Contains a  capturing observations. See 5, 1.1extensible-effects-concurrent=Read queued observations captured and enqueued in the shared  by 5v. This blocks until something was captured or an interrupt or exceptions was thrown. For a non-blocking variant use 2 or 3.2extensible-effects-concurrent=Read queued observations captured and enqueued in the shared  by 59. Return the oldest enqueued observation immediately or _ if the queue is empty. Use 1+ to block until an observation is observed.3extensible-effects-concurrentTRead at once all currently queued observations captured and enqueued in the shared  by 5]. This returns immediately all currently enqueued observations. For a blocking variant use 1.4extensible-effects-concurrent-Create a mutable queue for observations. Use 5C for a simple way to get a process that enqueues all observations.Example withObservationQueue 100 $ do q <- ask @(ObservationQueueReader TestEvent) wq <- spawnLinkObservationQueueWriter q registerObserver wq testServer ... cast testServer DoSomething evt <- readObservationQueue @TestEvent ... 5extensible-effects-concurrent'Spawn a process that can be used as an + that enqueues the observations into an 0. See 4 for an example.$The observations can be obtained by 1. All observations are captured up to the queue size limit, such that the first message received will be first message returned by 1./0123450/12345None"%&',-.14567=>?@ACHMPSUVX_kw&6extensible-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.7extensible-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.6767None"%&',-.14567=>?@ACHMPSUVX_kx| !"#$%&'()*+,-./0123456789:;<=>?@ABCDE`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]!"#      $%&'()*+/01234567      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]     !"# $%&'()*+/012345None#%&',-.14567=>?@ACHMPSUVX_k !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"##!"      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                    !"#$%&'()*+,,-./0123456789:;<=>?@ABCDEFGHIDJKGHLGHMGHNGHOGHPGHQGHRGHSGHTGHUGHVGHWGHXGHYGHZGH[GH[D\]D^_`D^aGbcGdeGfghijDklmnoDpqrstDuvwxyz{|z{}z{~DuDJmnmnDrsDJDDDDGD  D^Gd D^;extensible-effects-concurrent-0.20.0-LexraGXxQGALMFlu1ocCWoControl.Eff.ExceptionExtraControl.Eff.Log.MessageControl.Eff.Log.WriterControl.Eff.Log.HandlerControl.Eff.Concurrent.Process$Control.Eff.Concurrent.Process.TimerControl.Eff.Concurrent.ApiControl.Eff.Concurrent!Control.Eff.Concurrent.Api.Client*Control.Eff.Concurrent.Process.InteractiveControl.Eff.Log.ChannelControl.Eff.Log6Control.Eff.Concurrent.Process.SingleThreadedScheduler.Control.Eff.Concurrent.Process.ForkIOScheduler!Control.Eff.Concurrent.Api.Server#Control.Eff.Concurrent.Api.Observer)Control.Eff.Concurrent.Api.Observer.QueueControl.Eff.LoopDebugTraceControl.Exception.Safe SomeExceptionAsynccancel"Control.Eff.Concurrent.Api.Requestcall Control.Monadforever replicateM_#Paths_extensible_effects_concurrentliftTry maybeThrow$fMonadMaskEff$fMonadCatchEff$fMonadThrowEff$fMonadMaskEff0$fMonadCatchEff0$fMonadThrowEff0$fMonadMaskEff1$fMonadCatchEff1$fMonadThrowEff1$fMonadMaskEff2$fMonadCatchEff2$fMonadThrowEff2Facility fromFacilitySeverity fromSeverity SdParameter MkSdParameterStructuredDataElement SdElement _sdElementId_sdElementParameters LogMessage MkLogMessage _lmFacility _lmSeverity _lmTimestamp _lmHostname _lmAppName _lmProcessId _lmMessageId_lmStructuredData _lmThreadId _lmSrcLoc _lmMessagesdName sdParamValueemergencySeverity alertSeveritycriticalSeverity errorSeveritywarningSeveritynoticeSeverityinformationalSeverity debugSeveritykernelMessagesuserLevelMessages mailSystem systemDaemonssecurityAuthorizationMessages4linePrinterSubsystemnetworkNewsSubsystem uucpSubsystem clockDaemonsecurityAuthorizationMessages10 ftpDaemon ntpSubsystemlogAuditFacilitylogAlertFacility clockDaemon2local0local1local2local3local4local5local6local7$fNFDataSdParameter$fShowSdParameter$fNFDataStructuredDataElement$fShowStructuredDataElement$fDefaultSeverity$fShowSeverity$fDefaultFacility$fNFDataLogMessage$fDefaultLogMessage$fEqSdParameter$fOrdSdParameter$fGenericSdParameter$fEqStructuredDataElement$fOrdStructuredDataElement$fGenericStructuredDataElement $fEqSeverity $fOrdSeverity$fGenericSeverity$fNFDataSeverity $fEqFacility $fOrdFacility$fShowFacility$fGenericFacility$fNFDataFacility$fEqLogMessage$fGenericLogMessage sdElementIdsdElementParameters LogPredicate ToLogMessage toLogMessage lmAppName lmFacility lmHostname lmMessage lmMessageId lmProcessId lmSeveritylmSrcLoclmStructuredData lmThreadId lmTimestamprenderLogMessage renderRFC5424printLogMessage setCallStackprefixLogMessagesWithsetLogMessageTimestampsetLogMessageThreadIdsetLogMessageHostname errorMessage infoMessage debugMessageerrorMessageIO infoMessageIOdebugMessageIOallLogMessages noLogMessages lmSeverityIslmSeverityIsAtLeastlmMessageStartsWithdiscriminateByAppName$fIsStringLogMessage$fShowLogMessage$fToLogMessage[]$fToLogMessageLogMessageCapturedLogsWriter CaptureLogs MkCaptureLogs unCaptureLogs PureLogWriterMkPureLogWriterrunPureLogWriterHandleLogWriterLogWriterEffectshandleLogWriterEffectliftWriteLogMessageLogWriterReader LogWriter MkLogWriter runLogWriterrunLogWriterReader askLogWriterlocalLogWriterReader noOpLogWriterdebugTraceLogWriter listLogWriterrunCapturedLogsWriter ioLogWriterioHandleLogWriterconsoleLogWriterdefaultIoLogWriterfilteringLogWritermappingLogWritermappingLogWriterM$fDefaultLogWriter$fMonadBaseControlmEff$fHandleLogWriterReaderea->$fHandleLogWriterIO$fHandleLogWriterPureLogWriter$fHandleLogWriterCaptureLogs$fApplicativePureLogWriter$fFunctorPureLogWriter$fMonadPureLogWriter$fFunctorCaptureLogs$fApplicativeCaptureLogs$fMonadCaptureLogs LoggingAndIoLogsToLogswithConsoleLogging withIoLogging withLoggingwithSomeLoggingrunLogslogMsglogWithSeverity logEmergencylogAlert logCriticallogError logWarning logNoticelogInfologDebugaskLogPredicatesetLogPredicatemodifyLogPredicateincludeLogMessagesexcludeLogMessagesrespondToLogMessageinterceptLogMessagesmodifyLogWriter setLogWriter censorLogs censorLogsM addLogWriterwithLogFileAppender$fHandleLogsea-> ProcessId_fromProcessId ProcessDown downReference downReasonMonitorReference monitorIndexmonitoredProcessSomeExitReasonInterruptableProcess InterruptsInterruptReason ExitReasonProcessFinishedProcessNotRunningLinkedProcessCrashed ProcessError ExitNormally NotRecoveredUnexpectedExceptionKilled ExitSeverity NormalExitCrash ExitRecovery Recoverable NoRecovery ProcessStateProcessBooting ProcessIdle ProcessBusyProcessBusySendingProcessBusySendingShutdownProcessBusySendingInterruptProcessBusyReceivingProcessBusyLinkingProcessBusyUnlinkingProcessBusyMonitoringProcessBusyDemonitoringProcessInterruptedProcessShuttingDown ConsProcessSchedulerProxySP SchedulerMessageSelectorrunMessageSelector ResumeProcess Interrupted ResumeWithProcess FlushMessages YieldProcessSelfPidSpawn SpawnLinkGetProcessStateShutdown SendShutdown SendInterrupt SendMessageReceiveSelectedMessage MakeReferenceMonitor DemonitorLinkUnlink selectMessageselectMessageLazy filterMessagefilterMessageLazyselectMessageWithselectMessageWithLazyselectDynamicMessageselectDynamicMessageLazyselectAnyMessageLazyselectMessageProxyselectMessageProxyLazythisSchedulerProxytoExitRecoverytoExitSeverity isBecauseDownprovideInterruptsShutdownhandleInterruptstryUninterrupted logInterruptsexitOnInterruptprovideInterrupts!mergeEitherInterruptAndExitReason interruptisCrash isRecoverablefromSomeExitReason toCrashReasonlogProcessExitexecuteAndResumeexecuteAndResumeOrExitexecuteAndResumeOrThrow yieldProcess sendMessagesendAnyMessage sendShutdown sendInterruptspawnspawn_ spawnLinkspawnRaw spawnRaw_isProcessAlivereceiveAnyMessagereceiveSelectedMessagereceiveMessage flushMessagesreceiveSelectedLoopreceiveAnyLoop receiveLoopself makeReferencemonitor demonitor withMonitorreceiveWithMonitorbecauseProcessIsDownselectProcessDown linkProcess unlinkProcess exitBecause exitNormally exitWithError$fAlternativeMessageSelector$fApplicativeMessageSelector$fDefaultProcessState$fNFDataProcessState$fShowExitRecovery$fNFDataExitRecovery$fNFDataExitSeverity$fShowExitSeverity$fShowProcessId$fReadProcessId$fShowMonitorReference$fNFDataMonitorReference$fEqExitReason$fOrdExitReason$fNFDataExitReason$fExceptionExitReason$fExceptionExitReason0$fShowExitReason$fNFDataSomeExitReason$fShowSomeExitReason$fEqSomeExitReason$fOrdSomeExitReason$fShowProcessDown$fNFDataProcessDown$fNFData1ResumeProcess$fNFDataResumeProcess $fShowProcess$fSemigroupMessageSelector$fMonoidMessageSelector$fFunctorMessageSelector$fReadProcessState$fShowProcessState$fOrdProcessState$fEqProcessState$fEnumProcessState$fGenericProcessState$fOrdExitRecovery$fEqExitRecovery$fGenericExitRecovery$fOrdExitSeverity$fEqExitSeverity$fGenericExitSeverity $fEqProcessId$fOrdProcessId$fBoundedProcessId$fNumProcessId$fEnumProcessId$fIntegralProcessId$fRealProcessId$fNFDataProcessId$fReadMonitorReference$fEqMonitorReference$fOrdMonitorReference$fGenericMonitorReference$fGenericProcessDown$fEqProcessDown$fOrdProcessDown$fGenericResumeProcess$fGeneric1ResumeProcess$fShowResumeProcess fromProcessId TimerElapsedfromTimerElapsedTimerReferenceTimeoutfromTimeoutMicros receiveAfterreceiveSelectedAfterselectTimerElapsed sendAfter startTimer cancelTimer $fShowTimeout$fShowTimerReference$fShowTimerElapsed$fNFDataTimeout $fOrdTimeout $fEqTimeout $fNumTimeout$fIntegralTimeout $fRealTimeout $fEnumTimeout$fNFDataTimerReference$fOrdTimerReference$fEqTimerReference$fNumTimerReference$fIntegralTimerReference$fRealTimerReference$fEnumTimerReference$fNFDataTimerElapsed$fOrdTimerElapsed$fEqTimerElapsedServer _fromServer Synchronicity Synchronous AsynchronousApi $fShowServer $fEqServer $fOrdServer fromServer proxyAsServerasServer RequestOrigin_requestOriginPid_requestOriginCallRefReplyRequestCallCastmkRequestOrigin sendReply ServerReader ServesApicastregisterServer whereIsServercallRegisteredcastRegisteredSchedulerSessionforkInteractiveSchedulerkillInteractiveSchedulersubmit submitCast submitCallwithAsyncLoggingexampleLoggingexampleWithLoggingexampleWithSomeLoggingexampleLogPredicateexampleLogCaptureexampleAsyncLogging schedulePure scheduleIOscheduleMonadIOEffscheduleIOWithLogging scheduleMdefaultMainSingleThreaded $fShowSTS $fShowOnYield$fDefaultMessageQ SchedulerIOHasSchedulerIOInterruptableProcEffProcEff defaultMaindefaultMainWithLogWriterschedule$fShowProcessInfoInterruptCallback ToServerPids ServerPids toServerPidsMessageCallbackCallbackResult AwaitNext StopServerspawnApiServerspawnLinkApiServerspawnApiServerStatefulspawnApiServerEffectfulspawnLinkApiServerEffectful apiServerLoophandleMessageshandleSelectedMessageshandleAnyMessages handleCasts handleCallshandleCastsAndCallshandleCallsDeferredhandleProcessDowns^:fallbackHandlerdropUnhandledMessagesexitOnUnhandledlogUnhandledMessagesstopServerOnInterrupt$fDefaultMessageCallback$fMonoidMessageCallback$fSemigroupMessageCallback$fToServerPidsTYPEapi1$fToServerPids[]:$fToServerPids[][]$fDefaultInterruptCallback ObserverStateObserverRegistryObserverRegisterObserverForgetObserverObservedregisterObserverforgetObserverhandleObservations toObserver toObserverForhandleObserverRegistrationmanageObserversobserved $fEqObserver $fOrdObserver$fShowObserverObservationQueueReaderObservationQueuereadObservationQueuetryReadObservationQueueflushObservationQueuewithObservationQueuespawnLinkObservationQueueWriter foreverCheapreplicateCheapM_baseGHC.Exception.Type Exception1extensible-effects-5.0.0.1-KFGF1U0sTnhHZKk4SF5FANControl.Eff.Exception liftEither GHC.MaybeMaybe liftMaybeFail ignoreFail liftMaybeM liftEitherM rethrowErroronFail catchErrorrunFailrunErrordie throwError_ throwErrorexc withExceptionExcGHC.Stack.TypesSrcLoc GHC.Conc.SyncThreadId showLmMessage myThreadIdControl.Eff.Writer.StrictWriterControl.Eff.InternalEffData.OpenUnion SetMember1data-default-class-0.1.2.0-FeIQ5tLoVZBHMSgrT9zptQData.Default.Classdef Debug.TracetraceMghc-prim GHC.TypesIOGHC.IO.Handle.TypesHandledeepseq-1.4.4.0Control.DeepSeqdeepseqGHC.BaseString,monad-control-1.0.2.3-K5aaLNgoHQJImsHP4Tz6gtControl.Monad.Trans.ControlMonadBaseControl(exceptions-0.10.1-DdWfqA1lutT4wybeL2xRnxControl.Monad.Catch MonadMask MonadCatch MonadThrowsendLogMessageToLogWriter AlternativeNothingIntTrue Data.Dynamic fromDynamicforceJust Data.EitherEitherDynamicData.Typeable.InternalTypeableLeftApiType ReplyTypeControl.Eff.Reader.StrictReaderGHC.MVarMVarOnYield addMonitoringyieldLift handleProcessMessageQcontainers-0.6.0.1Data.Sequence.InternalSeq ProcessInfoTVartryTakeNextShutdownRequestSTM_shutdownRequestsSchedulerState_processMonitorsnewProcessInfonewSchedulerStatewithNewSchedulerState ObserversD:R:ApiObserverr0D:R:ApiObserverRegistryr0 stm-2.5.0.0Control.Concurrent.STM.TBQueueTBQueueversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName