h,Ո      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ 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 { | } ~                                                                                                                                                                                                                                                                                                                                                                           0.7.5 Safe-Inferredcdistributed-processA bidirectional multimaps BiMultiMap a b v is a set of triplets of type  (a, b, v).0It is possible to lookup values by using either a or b as keys.distributed-process!The empty bidirectional multimap.distributed-process5A bidirectional multimap containing a single triplet. distributed-process.Yields the amount of triplets in the multimap. distributed-process"Inserts a triplet in the multimap. distributed-processLooks up all the triplets whose first component is the given value. distributed-processLooks up all the triplets whose second component is the given value. distributed-processDeletes a triplet. It yields the original multimap if the triplet is not present.distributed-process>Deletes all triplets whose first component is the given value.distributed-processLike 5 but deletes by the second component of the triplets.distributed-processYields the triplets satisfying the given predicate, and a multimap with all this triplets removed.distributed-processLike  but the predicates takes the second component of the triplets as first argument.distributed-process=Exchange the first and the second components of all triplets.distributed-processreverseDelete a bs m removes from m all the triplets wich have a8 as first component and second and third components in bs.The m map is in reversed form, meaning that the second component of the triplets is used as key.distributed-processnothingWhen p a is Just a when a satisfies predicate p . Yields Nothing otherwise.      Safe-Inferred Safe-Inferreddistributed-process Strict listNone% '%&$!" #  !"#$%&'None 9-1distributed-processEnqueue an elementEnqueue is strict.2distributed-process,Variant of enqueue for use in the STM monad.distributed-process spanMatchMsg = first (map ((MatchMsg x) -> x)) . span isMatchMsgdistributed-process spanMatchMsg = first (map ((MatchChan x) -> x)) . span isMatchChan3distributed-processDequeue an elementThe timeout (if any) is applied only to waiting for incoming messages, not to checking messages that have already arrived4distributed-processWeak reference to a CQueue3distributed-processQueuedistributed-processBlocking behaviourdistributed-processList of matchesdistributed-process only on timeout312405+-,./(*)/+.,-()*012345None77distributed-process7< is an abstract type representing an unbounded FIFO channel.8distributed-process$Build and returns a new instance of 79distributed-processIO version of 8*. This is useful for creating top-level 7s using , because using  inside  isn't possible.:distributed-processWrite a value to a 7.;distributed-processRead the next value from the 7.<distributed-process A version of ;+ which does not retry. Instead it returns Nothing if no value is available.=distributed-processReturns  if the supplied 7 is empty.=>89;<:7789;<:=>None )*/7o@distributed-process+Objects that can be sent across the networkAdistributed-processReification of .Cdistributed-processReification of @ (see #Control.Distributed.Process.Closure)Edistributed-process*Encode type representation as a bytestringFdistributed-processDecode a bytestring into a fingerprint. Throws an IO exception on failureGdistributed-processSize of a fingerprintHdistributed-process.The fingerprint of the typeRep of the argumentIdistributed-process)Show fingerprint (for debugging purposes) FEHIG@CDAB @EFHGICDAB None)*7<4QJdistributed-process$Signals to the node controller (see \)\distributed-processMessages to the node controllerbdistributed-process+Provide information about a running processpdistributed-process(Asynchronous) reply from register and  unregisterrdistributed-process(Asynchronous) reply from whereistdistributed-process(Asynchronius) reply from spawnvdistributed-processv- are used to return pids of spawned processesxdistributed-process$(Asynchronous) reply from unlinkPortzdistributed-process$(Asynchronous) reply from unlinkNode|distributed-process (Asynchronous) reply from unlink~distributed-process#(Asynchronous) reply from unmonitordistributed-processWhy did a process die?distributed-processNormal terminationdistributed-process3The process exited with an exception (provided as  because  does not implement )distributed-process)We got disconnected from the process nodedistributed-processThe process node dieddistributed-processInvalid (processnodechannel) identifierdistributed-process(Internal exception thrown indirectly by exitdistributed-processException thrown when a process attempts to register a process under an already-registered name or to unregister a name that hasn't been registered. Returns the name and the identifier of the process that owns it, if any.distributed-process2Exception thrown when a linked channel (port) diesdistributed-process(Exception thrown when a linked node diesdistributed-process,Exceptions thrown when a linked process diesdistributed-process'Message sent by channel (port) monitorsdistributed-processMessage sent by node monitorsdistributed-process Message sent by process monitorsdistributed-process8MonitorRef is opaque for regular Cloud Haskell processesdistributed-processUnique to distinguish multiple monitor requests by the same processdistributed-process ID of the entity to be monitoreddistributed-processMessages consist of their typeRep fingerprint and their encodingdistributed-process5The receive end of a typed channel (not serializable) Note that  implements , ,  and 7. This is especially useful when merging receive ports.distributed-process/The send send of a typed channel (serializable)distributed-process!The (unique) ID of this send portdistributed-process*A send port is identified by a SendPortId.7You cannot send directly to a SendPortId; instead, use newChan to create a SendPort.distributed-processProcess-local ID of the channeldistributed-processThe ID of the process that will receive messages sent on this portdistributed-processThe Cloud Haskell  typedistributed-processLocal process statedistributed-process#Processes running on our local nodedistributed-processThrown by some primitives when they notice the node has been closed.distributed-processOutgoing connectionsdistributed-processThe unique value used to create PIDs (so that processes on restarted nodes have new PIDs)distributed-processCounter to assign PIDsdistributed-processProcesses running on this nodedistributed-processLocal node statedistributed-process Local nodesdistributed-processRuntime lookup table for supporting closures TODO: this should be part of the CH state, not the local endpoint statedistributed-processInternal management event busdistributed-processChannel for the node controllerdistributed-processLocal node statedistributed-process.The network endpoint associated with this nodedistributed-process of the nodedistributed-process'Local system management event bus statedistributed-process2API for adding management agents to a running nodedistributed-process;Weak reference to the management agent controller's mailboxdistributed-process,Configuration for the local trace controllerdistributed-process5Process id of the management agent controller processdistributed-process'Provides access to the trace controllerdistributed-process1Weak reference to the tracer controller's mailboxdistributed-process1Process id for the currently active trace handlerdistributed-process!Union of all kinds of identifiersdistributed-processProcess identifierdistributed-process%Node-local identifier for the processdistributed-process,The ID of the node the process is running ondistributed-processA local process ID consists of a seed which distinguishes processes from different instances of the same local node and a counterdistributed-processNode identifierdistributed-processWrapper around #< that checks that the local node is still in a valid state.distributed-processWrapper around %< that checks that the local node is still in a valid state.distributed-processWrapper around $< that checks that the local node is still in a valid state.distributed-processDeconstructor for ! (not exported to the public API)distributed-processinternal use only.distributed-process(Turn any serialiable term into a messagedistributed-process:Turn any serializable term into an unencoded/local messagedistributed-processTurn any serializable term into an unencodede/local message, without evalutaing it! This is a dangerous business.distributed-processSerialize a messagedistributed-processDeserialize a messagetuz{xy|}~\]_^ijlmoknbcdfehg`aJOXY[WKVUMSRZPLNTQpqvwrs~|}z{xyvwturspqbchgfed`aijonmlk\]_^JPOSKLMNQRTUVWXYZ[ None7<?distributed-process(Type of a management agent's event sink.distributed-processRepresents the actions a management agent can take when evaluating an  event sink.distributed-processMonad for management agents.distributed-process6A newtype wrapper for an agent id (which is a string).distributed-processGross though it is, this synonym represents a function used to forking new processes, which has to be passed as a HOF when calling mxAgentController, since there's no other way to avoid a circular dependency with Node.hsdistributed-process;The class of things that we might be able to resolve to a  ProcessId (or not).distributed-process This is the default management event, fired for various internal events around the NT connection and Process lifecycle. All published events that conform to this type, are eligible for tracing - i.e., they will be delivered to the trace controller.distributed-process)fired whenever a local process is spawneddistributed-process5fired whenever a process/name is registered (locally)distributed-process7fired whenever a process/name is unregistered (locally)distributed-processfired whenever a process diesdistributed-processfired whenever a node dies. (i.e., the connection is broken/disconnected)distributed-process5fired whenever a message is sent from a local processdistributed-process"fired whenever a named send occursdistributed-process fired whenever a sendChan occursdistributed-process7fired whenever a message is received by a local processdistributed-process8fired whenever a message is received via a typed channeldistributed-process>fired when a network-transport connection is first establisheddistributed-processfired when a network-transport connection is broken/disconnecteddistributed-processa user defined trace eventdistributed-processa logging) event - used for debugging purposes onlydistributed-processnotifies a trace listener that all subsequent traces will be sent to piddistributed-process;notifies a trace listener that it has been disabled/removed(( None@y None )*7<Bdistributed-process A generic ok% response from the trace coordinator.distributed-processDefines what0 will be traced. Flags that control tracing of Process events, take a  controlling which processes should generate trace events in the target process.distributed-process2Defines which processes will be traced by a given  TraceFlag, either by name, or  ProcessId . Choosing TraceAll is by far the most efficient approach, as the tracer process therefore avoids deciding whether or not a trace event is viable.## NoneDdistributed-processa  b is true if the death of a. (for instance, a node) implies the death of b' (for instance, a process on that node)distributed-processNothing for the local nodedistributed-processMessage to send(c) Well-Typed / Tim WatsonBSD3 (see the file LICENSE)%Tim Watson  experimental#non-portable (requires concurrency)NoneH3distributed-process an arbitrary set of typed channels in one atomic transaction.Note there are no ordering guarnatees with respect to these disparate input sources.distributed-process+Match against any message of the right typedistributed-processMatch against any message of the right type that satisfies a predicatedistributed-processMatch against any message, regardless of the underlying (contained) typedistributed-processMatch against any message (regardless of underlying type) that satisfies a predicatedistributed-processForward a raw  to the given .distributed-processForward a raw  to the given .Unlike ", this function is insensitive to . It will try to send the message regardless of the history of connection failures between the nodes.distributed-processWrap a @ value in a  . Note that s are @ - like the datum they contain - but also note, deserialising such a  will yield a <, not the type within it! To obtain the wrapped datum, use  or  with a specific type. do self <- getSelfPid send self (wrapMessage "blah") Nothing <- expectTimeout 1000000 :: Process (Maybe String) (Just m) <- expectTimeout 1000000 :: Process (Maybe Message) (Just "blah") <- unwrapMessage m :: Process (Maybe String) distributed-process This is the unsafe variant of . See ,Control.Distributed.Process.UnsafePrimitives for details.distributed-processAttempt to unwrap a raw . If the type of the decoded message payload matches the expected type, the value will be returned with Just , otherwise Nothing# indicates the types do not match./This expression, for example, will evaluate to Nothing? > unwrapMessage (wrapMessage "foobar") :: Process (Maybe Int)$Whereas this expression, will yield  Just "foo"? > unwrapMessage (wrapMessage "foo") :: Process (Maybe String)distributed-processAttempt to handle a raw . If the type of the message matches the type of the first argument to the supplied expression, then the message will be decoded and the expression evaluated against its value. If this runtime type checking fails however, Nothing will be returned to indicate the fact. If the check succeeds and evaluation proceeds, the resulting value with be wrapped with Just.Intended for use in  and  primitives.distributed-processConditionally handle a raw . If the predicate  (a -> Bool) evaluates to True/, invokes the supplied handler, other returns Nothing to indicate failure. See 6 for further information about runtime type checking.distributed-processAs  but ignores result, which is useful if you don't care whether or not the handler succeeded.distributed-processConditional version of .distributed-process$Match against an arbitrary message.  removes the first available message from the process mailbox. To handle arbitrary raw. messages once removed from the mailbox, see  and .distributed-process:Match against an arbitrary message. Intended for use with  and , this function only. removes a message from the process mailbox, if the supplied condition matches. The success (or failure) of runtime type checks deferred to  handleMessage and friends is irrelevant here, i.e., if the condition evaluates to True then the message will be removed from the process mailbox and decoded, but that does not) guarantee that an expression passed to  handleMessage? will pass the runtime type checks and therefore be evaluated.distributed-process!Remove any message from the queuedistributed-process'Receives messages and forwards them to pid if  p msg == True.distributed-processA straight relay that forwards all messages to the supplied pid.distributed-processProxies pid and forwards messages whenever proc evaluates to True . Unlike  the predicate proc runs in the 1 monad, allowing for richer proxy behaviour. If proc returns False or the runtime type check fails, no action is taken and the proxy process will continue running.distributed-processThe process to be registered does not have to be local itself.distributed-processLike , but will replace an existing registration. The name must already be registered.distributed-process9Register a process with a remote registry (asynchronous).The process to be registered does not have to live on the same remote node. Reply wil come in the form of a p messageSee comments in distributed-processRemove a process from the local registry (asynchronous). This version will wait until a response is gotten from the management process. The name must already be registered.distributed-processDeal with the result from an attempted registration or unregistration by throwing an exception if necessarydistributed-process7Remove a process from a remote registry (asynchronous). Reply wil come in the form of a p messageSee comments in distributed-process Query the local process registrydistributed-process.Query a remote process registry (asynchronous)!Reply will come in the form of a r message.-There is currently no synchronous version of : if you implement one yourself, be sure to take into account that the remote node might die or get disconnect before it can respond (i.e. you should use 1 and take appropriate action when you receive a ).distributed-process experimental#non-portable (requires concurrency)None %&67<5distributed-processPublishes an arbitrary  Serializable1 message to the management event bus. Note that (no attempt is made to force the argument, therefore it is very important that you do not pass unevaluated thunks that might crash the receiving process via this API, since all registered agents will gain access to the data structure once it is broadcast by the agent controller.distributed-process Return the # for the currently executing agent.distributed-processThe  version of .distributed-processGracefully terminate an agent.distributed-process=Continue executing (i.e., receiving and processing messages).distributed-processCauses the currently executing  event sink to be skipped. The remaining declared event sinks will be evaluated to find a matching handler. Can be used to allow multiple event sinks to process data of the same type.distributed-process?Continue exeucting, prioritising inputs from the process' own mailbox- ahead of data from the management event bus.distributed-processContinue exeucting, prioritising inputs from the management event bus over the process' own mailbox.distributed-processLift a Process action.distributed-processSet the agent's local state.distributed-processUpdate the agent's local state.distributed-processFetch the agent's local state.distributed-process Create an  from an expression taking a  Serializable type m, that yields an  in the  monad.distributed-processActivates a new agent.distributed-process,Activates a new agent. This variant takes a  finalizer expression, that is run once the agent shuts down (even in case of failure/exceptions). The  finalizer$ expression runs in the mx monad -  MxAgent s () - such that the agent's internal state remains accessible to the shutdown/cleanup code.&&Nonedistributed-processCP a b! is a process with input of type a and output of type bdistributed-process8Static decoder, given a static serialization dictionary.See module documentation of #Control.Distributed.Process.Closure for an example.distributed-processSerialization dictionary for ()distributed-processSerialization dictionary for distributed-processSerialization dictionary for distributed-processSerialization dictionary for .distributed-processSerialization dictionary for .distributed-process version of ()distributed-process version of (*+)distributed-process version of ,-distributed-process version of (,.)distributed-process(Not quite the)  version of (,/)distributed-process version of distributed-process version of distributed-process version of distributed-process version of distributed-process version of distributed-process version of distributed-process delay them p9 is a process that waits for a signal (a message of type ()) from them/ (origin is not verified) before proceeding as p&. In order to avoid waiting forever,  delay them p monitors them<. If it receives a monitor message instead, it proceeds as p too.distributed-process version of Nonejdistributed-processSpawn a processFor more information about , see #Control.Distributed.Process.Closure. See also .distributed-processSpawn a process and link to it5Note that this is just the sequential composition of  and . (The Unified semantics that underlies Cloud Haskell does not even support a synchronous link operation)distributed-processLike !, but monitor the spawned processdistributed-process/Run a process remotely and wait for it to replyWe monitor the remote process: if it dies before it can send a reply, we die too.For more information about , C, and , see #Control.Distributed.Process.Closure. See also .distributed-processSpawn a child process, have the child link to the parent and the parent monitor the childdistributed-process-Spawn a new process, supplying it with a new  and return the corresponding .Nonedistributed-process Remote Table.distributed-process Starts a  trace relay process on the remote node, which forwards all trace events to the registered tracer on this (the calling process') node.distributed-process5Set the given flags for a remote node (asynchronous).None %&7o distributed-process(Thrown in response to the user invoking kill (see Primitives.hs). This type is deliberately not exported so it cannot be caught explicitly.distributed-processInitialize a new local node.distributed-process?Create a new local node (without any service processes running)distributed-process2Start and register the service processes on a nodedistributed-process=Force-close a local node, killing all processes on that node.distributed-process7Run a process on a local node and wait for it to finishdistributed-process#Spawn a new process on a local nodedistributed-process Unified: Table 8distributed-process+Check if a process is local to our own nodedistributed-processLookup a local closuredistributed-process5Check if an identifier refers to a valid local objectdistributed-processsplitNotif ident splits a notifications map into those notifications that should trigger when ident( fails and those links that should not.There is a hierarchy between identifiers: failure of a node implies failure of all processes on that node, and failure of a process implies failure of all typed channels to that process. In other words, if ident refers to a node, then the should trigger set will include+the notifications for the node specifically1the notifications for processes on that node, and?the notifications for typed channels to processes on that node.Similarly, if ident refers to a process, the should trigger set will include3the notifications for that process specifically and5the notifications for typed channels to that process.See  /https://github.com/haskell/containers/issues/14 for the bang on _v.distributed-processModify and evaluate the statedistributed-processWho's watching?distributed-processWho's being watched?distributed-process to linkdistributed-processWho to notify?distributed-process Who died?distributed-processHow did they die?distributed-process for linkingNoneŷdistributed-processCreate the closure, decoder, and metadata definitions for the given list of functionsdistributed-processLike , but parameterized by the declaration of a function instead of the function name. So where for  you'd do %f :: T1 -> T2 f = ... remotable ['f]with  you would instead do remotableDecl [ [d| f :: T1 -> T2 ; f = ... |] ] creates the function specified as well as the various dictionaries and static versions that  also creates. 9 is sometimes necessary when you want to refer to, say, $(mkClosure 'f) within the definition of f itself.NOTE:  creates __remoteTableDecl instead of  __remoteTable so that you can use both  and  within the same module.distributed-processConstruct a static value.If f : forall a1 .. an. T then +$(mkStatic 'f) :: forall a1 .. an. Static T. Be sure to pass f to .distributed-processIf  f : T1 -> T2! is a monomorphic function then 3$(functionSDict 'f) :: Static (SerializableDict T1).Be sure to pass f to .distributed-processIf f : T1 -> Process T2! is a monomorphic function then 3$(functionTDict 'f) :: Static (SerializableDict T2).Be sure to pass f to .distributed-processIf  f : T1 -> T2 then #$(mkClosure 'f) :: T1 -> Closure T2.TODO: The current version of mkClosure is too polymorphic (@forall a. Binary a => a -> Closure T2).distributed-processMake a Closure from a static function. This is useful for making a closure for a top-level  Process () function, because using  would require adding a dummy () argument.distributed-process7Generate the code to add the metadata to the CH runtimedistributed-processTurn a polymorphic type into a monomorphic type using ANY and codistributed-processGenerate a static valuedistributed-process.Generate a serialization dictionary with name n for type typdistributed-processCompose a set of expressionsdistributed-processLiteral string as an expressiondistributed-processLook up the "original name" (module:name) and type of a top-level functiondistributed-process Variation on 7 which takes a single expression to define the functiondistributed-process.The name of a type variable binding occurrencedistributed-processFully qualified name; that is, the name and the _current_ moduleWe ignore the module part of the Name argument (which may or may not exist) because we construct various names (, , :) and those names certainly won't have Module components.(c) Well-Typed / Tim WatsonBSD3 (see the file LICENSE)%Tim Watson  experimental#non-portable (requires concurrency)Nonedistributed-processStarts a new tracer, using the supplied trace function. Only one tracer can be registered at a time, however this function overlays the registered tracer with the supplied handler, allowing the user to layer multiple tracers on top of one another, with trace events forwarded down through all the layers in turn. Once the top layer is stopped, the user is responsible for re-registering the original (prior) tracer pid before terminating. See # for a mechanism that handles that.distributed-process Evaluate proc with tracing enabled via handler, and immediately disable tracing thereafter, before giving the result (or exception in case of failure).distributed-process Evaluate proc with the supplied flags enabled. Any previously set trace flags are restored immediately afterwards.distributed-process*Stops a user supplied tracer started with . Note that only one tracer process can be active at any given time. This process will stop the last process started with . If  is called multiple times, successive calls to this function will stop the tracers in the reverse order which they were started.This function will never stop the system tracer (i.e., the tracer initially started when the node is created), therefore once all user supplied tracers (i.e., processes started via ) have exited, subsequent calls to this function will have no effect.If the last tracer to have been registered was not started with ( then the behaviour of this function is  undefined.((Noneϧdistributed-process!Spawn a process on the local nodedistributed-processCreate a new typed channel, spawn a process on the local node, passing it the receive port, and return the send portdistributed-processLocal version of . Running a process in this way isolates it from messages sent to the caller process, and also allows silently dropping late or duplicate messages sent to the isolated process after it exits. Silently dropping messages may not always be the best approach.tuijlmoknbcdfehgpqvrsvbchgfedijonmlkrspqtuNone)*7distributed-processA RemoteRegister is a trasformer on a RemoteTable to register additional static values.distributed-processThis takes an explicit name and a value, and produces both a static reference to the name and a RemoteRegister for it.distributed-processThis takes an explicit name, a function of arity one, and creates a creates a function yielding a closure and a remote register for it.distributed-processThis takes an explict name, a function of any arity, and creates a function yielding a closure and a remote register for it.distributed-process?@ABCDEFGHIJKLMNOPQRRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvvwwxyz{| } ~                                                                                                                                                                                                                                                                                                                                                                                                                              !"#$%&'1111111110distributed-process-0.7.5-14hdXLMmdeU5goWgtdXS4F(Control.Distributed.Process.SerializableControl.Distributed.Process/Control.Distributed.Process.Internal.BiMultiMap=Control.Distributed.Process.Internal.StrictContainerAccessors/Control.Distributed.Process.Internal.StrictList/Control.Distributed.Process.Internal.StrictMVar+Control.Distributed.Process.Internal.CQueue/Control.Distributed.Process.Internal.WeakTQueue*Control.Distributed.Process.Internal.Types5Control.Distributed.Process.Management.Internal.Types3Control.Distributed.Process.Management.Internal.Bus;Control.Distributed.Process.Management.Internal.Trace.Types.Control.Distributed.Process.Internal.Messaging,Control.Distributed.Process.UnsafePrimitives/Control.Distributed.Process.Internal.PrimitivesControl.Distributed.Process.Management.Internal.Trace.Primitives>>>=#Control.Distributed.Process.ClosurebaseGHC.Fingerprint.Type FingerprintControl.Monad.IO.ClassliftIO0distributed-static-0.3.10-9WiFCCQeWGu1o48Yw3nckjControl.Distributed.StaticClosure RemoteTableStaticclosure BiMultiMapempty singletonsizeinsert lookupBy1st lookupBy2nddeletedeleteAllBy1stdeleteAllBy2ndpartitionWithKeyBy1stpartitionWithKeyBy2ndflipmapMaybe mapDefault StrictListConsNilSnocAppendappendfoldr StrictMVar newEmptyMVarnewMVartakeMVarputMVarreadMVarwithMVar modifyMVar_ modifyMVarmodifyMVarMasked mkWeakMVarMatchOnMatchMsg MatchChan BlockSpec NonBlockingBlockingTimeoutCQueue newCQueueenqueue enqueueSTMdequeue mkWeakCQueue queueSize$fFunctorMatchOnTQueue newTQueue newTQueueIO writeTQueue readTQueue tryReadTQueue isEmptyTQueue mkWeakTQueue $fEqTQueue Serializable TypeableDictSerializableDictencodeFingerprintdecodeFingerprintsizeOfFingerprint fingerprintshowFingerprint ProcessSignalLinkUnlinkMonitor UnmonitorDiedSpawnWhereIsRegister NamedSendUnreliableSend LocalSend LocalPortSendKillExitGetInfo SigShutdown GetNodeStatsNCMsg ctrlMsgSignal ctrlMsgSenderProcessInfoNone ProcessInfo infoLinks infoMonitorsinfoMessageQueueLengthinfoRegisteredNamesinfoNode NodeStatsnodeStatsProcessesnodeStatsLinksnodeStatsMonitorsnodeStatsRegisteredNames nodeStatsNode RegisterReply WhereIsReplyDidSpawnSpawnRef DidUnlinkPort DidUnlinkNodeDidUnlinkProcess DidUnmonitor DiedReason DiedNormal DiedExceptionDiedDisconnect DiedNodeDown DiedUnknownIdProcessExitExceptionProcessRegistrationExceptionPortLinkExceptionNodeLinkExceptionProcessLinkExceptionPortMonitorNotificationNodeMonitorNotificationProcessMonitorNotification MonitorRefmonitorRefCountermonitorRefIdentMessageEncodedMessageUnencodedMessagemessageEncodingmessageFingerprintmessagePayload ReceivePort receiveSTMSendPort sendPortId TypedChannel SendPortIdsendPortLocalIdsendPortProcessIdLocalSendPortIdProcess unProcessLocalProcessState_typedChannels_channelCounter _spawnCounter_monitorCounter LocalProcess processNode processThread processState processId processWeakQ processQueueNodeClosedExceptionValidLocalNodeState_localConnections_localPidUnique_localPidCounter_localProcessesLocalNodeStateLocalNodeValidLocalNodeClosedImplicitReconnectWithImplicitReconnectNoImplicitReconnect LocalNode remoteTable localEventBus localCtrlChan localState localEndPoint localNodeId MxEventBusMxEventBusInitialisingmxNewevbusstraceragentTracerweakQ tracerPid IdentifierNodeIdentifierProcessIdentifierSendPortIdentifier ProcessIdprocessLocalId processNodeIdLocalProcessId lpidCounter lpidUniqueNodeId nodeAddressnodeOffirstNonReservedProcessId nullProcessIdwithValidLocalStatemodifyValidLocalStatemodifyValidLocalState_runLocalProcess isEncoded createMessagecreateUnencodedMessageunsafeCreateUnencodedMessagemessageToPayloadpayloadToMessagelocalProcesseslocalPidCounterlocalPidUniquelocalConnectionslocalProcessWithIdlocalConnectionBetweenmonitorCounter spawnCounterchannelCounter typedChannelstypedChannelWithIdforever' $fShowNodeId$fHashableNodeId$fNFDataNodeId$fBinaryNodeId$fBinaryLocalProcessId$fHashableLocalProcessId$fShowProcessId$fHashableProcessId$fNFDataProcessId$fBinaryProcessId$fExceptionNodeClosedException$fBinarySendPortId$fNFDataSendPortId$fShowSendPortId$fHashableSendPortId$fBinaryIdentifier$fShowIdentifier$fNFDataIdentifier$fHashableIdentifier$fNFDataSendPort$fHashableSendPort$fBinarySendPort$fBinaryMessage $fShowMessage$fNFDataMessage$fBinaryMonitorRef$fNFDataMonitorRef$fHashableMonitorRef'$fExceptionProcessRegistrationException$fShowProcessExitException$fExceptionProcessExitException$fBinaryDiedReason$fNFDataDiedReason$fExceptionPortLinkException$fExceptionNodeLinkException$fExceptionProcessLinkException$fBinaryPortMonitorNotification$fBinaryNodeMonitorNotification"$fBinaryProcessMonitorNotification$fBinaryDidSpawn$fBinaryWhereIsReply$fBinaryRegisterReply$fBinaryNodeStats$fBinaryProcessInfo$fBinaryProcessInfoNone$fBinaryProcessSignal $fBinaryNCMsg$fMonadMaskProcess$fMonadCatchProcess$fMonadThrowProcess$fShowProcessSignal$fApplicativeProcess$fFunctorProcess$fMonadProcess$fMonadFailProcess$fMonadFixProcess$fMonadIOProcess $fMonadReaderLocalProcessProcess $fShowNCMsg$fShowProcessInfoNone$fShowProcessInfo$fEqProcessInfo$fShowNodeStats $fEqNodeStats$fShowRegisterReply$fShowWhereIsReply$fShowDidSpawn$fShowSpawnRef$fBinarySpawnRef $fEqSpawnRef $fOrdSpawnRef$fBinaryDidUnlinkPort$fBinaryDidUnlinkNode$fBinaryDidUnlinkProcess$fBinaryDidUnmonitor $fShowProcessMonitorNotification$fShowNodeMonitorNotification$fShowPortMonitorNotification$fShowProcessLinkException$fShowNodeLinkException$fShowPortLinkException$fShowDiedReason$fEqDiedReason"$fShowProcessRegistrationException$fEqMonitorRef$fOrdMonitorRef$fShowMonitorRef$fGenericMonitorRef$fFunctorReceivePort$fApplicativeReceivePort$fAlternativeReceivePort$fMonadReceivePort$fGenericSendPort$fShowSendPort $fEqSendPort $fOrdSendPort$fEqIdentifier$fOrdIdentifier$fGenericIdentifier$fEqSendPortId$fOrdSendPortId$fGenericSendPortId$fShowNodeClosedException$fEqImplicitReconnect$fShowImplicitReconnect $fEqProcessId$fOrdProcessId$fDataProcessId$fGenericProcessId$fEqLocalProcessId$fOrdLocalProcessId$fDataLocalProcessId$fGenericLocalProcessId$fShowLocalProcessId $fEqNodeId $fOrdNodeId $fDataNodeId$fGenericNodeIdMxSinkMxActionMxAgentDeactivateMxAgentPrioritise MxAgentReady MxAgentSkipChannelSelector InputChanMailboxMxAgentunAgent MxAgentState mxLocalStatemxBus mxAgentId MxAgentIdagentIdFork Addressable resolveToPidMxEvent MxSpawned MxRegisteredMxUnRegistered MxProcessDied MxNodeDiedMxSent MxSentToName MxSentToPort MxReceivedMxReceivedPort MxConnectedMxDisconnectedMxUserMxLogMxTraceTakeoverMxTraceDisable$fBinaryMxEvent$fAddressableMxEvent$fFunctorMxAgent$fMonadMxAgent$fMonadIOMxAgent$fMonadFixMxAgent$fMonadStateMxAgentStateMxAgent$fApplicativeMxAgent$fBinaryMxAgentId $fEqMxAgentId$fOrdMxAgentId$fGenericMxEvent $fShowMxEvent publishEventTraceOkTraceArgTraceStrTrace TraceFlagstraceConnections traceNodes traceRecv traceSendtraceUnregisteredtraceRegistered traceDied traceSpawned TraceSubjectTraceAll TraceProcs TraceNamesSetTrace TraceEnable TraceDisabledefaultTraceFlagstraceLog traceLogFmt traceEvent traceMessage enableTraceenableTraceSync disableTracedisableTraceSync setTraceFlagssetTraceFlagsSync getTraceFlagsgetCurrentTraceClient$fBinarySetTrace$fBinaryTraceSubject$fBinaryTraceFlags$fBinaryTraceOk$fGenericTraceOk$fGenericTraceFlags$fShowTraceFlags$fGenericTraceSubject$fShowTraceSubject$fGenericSetTrace $fEqSetTrace$fShowSetTrace sendPayload sendBinary sendMessage disconnectcloseImplicitReconnectionsimpliesDeathOf sendCtrlMsgnsend nsendRemotesendusendsendChan wrapMessage SayMessage sayMessage sayProcesssayTimeHandlerProcessTerminationExceptionMatch unsafeSend unsafeUSendexpectnewChanunsafeSendChan receiveChanreceiveChanTimeoutmergePortsBiased mergePortsRR receiveWaitreceiveTimeout matchChanmatchSTMmatchmatchIf matchMessagematchMessageIfforwarduforwardunsafeWrapMessage unwrapMessage handleMessagehandleMessageIfhandleMessage_handleMessageIf_matchAny matchAnyIf matchUnknowndelegaterelayproxy terminatediekillexit catchExit catchesExit getSelfPid getSelfNode getNodeStatsgetLocalNodeStatsgetProcessInfolinkmonitor withMonitor withMonitor_unlink unlinkNode unlinkPort unmonitor expectTimeout spawnAsync monitorNode monitorPortunmonitorAsynclinkNodelinkPortsayregister reregisterregisterRemoteAsyncreregisterRemoteAsync unregisterunregisterRemoteAsyncwhereiswhereisRemoteAsync unsafeNSendunsafeNSendRemoteunStatic unClosure reconnect reconnectPort&$fExceptionProcessTerminationException$fFunctorHandler$fBinarySayMessage$fShowSayMessage!$fShowProcessTerminationException$fFunctorMatch traceOnlytraceOntraceOffenableTraceAsyncdisableTraceAsyncsetTraceFlagsAsyncwithLocalTracerwithRegisteredTracer$fTraceableList$fTraceableProcessId defaultTracersystemLoggerTracereventLogTracer logfileTracertraceController AgentConfigmxAgentController mxStartAgent startTracingstartDeadLetterQueuemxNotifymxGetId mxBroadcast mxDeactivatemxReadymxSkip mxReceive mxReceiveChanliftMX mxSetLocal mxUpdateLocal mxGetLocalmxSinkmxAgentmxAgentWithFinalizeCP staticDecode sdictUnitsdictProcessId sdictSendPort sdictStatic sdictClosure sndStaticidCPsplitCPreturnCPseqCPbindCPdecodeProcessIdStaticcpLinkcpUnlinkcpSendcpExpect cpNewChancpRelaycpEnableTraceRemote cpDelayedspawn spawnLink spawnMonitorcallspawnSupervised spawnChannelstartTraceRelaysetTraceFlagsRemoteinitRemoteTable newLocalNodecloseLocalNode runProcess forkProcess$fShowProcessKillException$fExceptionProcessKillException$fApplicativeNC $fFunctorNC $fMonadNC $fMonadIONC$fMonadStateNCStateNC$fMonadReaderLocalNodeNC remotable remotableDeclmkStatic functionSDict functionTDict mkClosuremkStaticClosure startTracer withTracer withFlags stopTracer spawnLocalspawnChannelLocal callLocalMkTDictmkTDictRemoteRegister mkStaticValmkClosureValSingle mkClosureValcall' $fMkTDicta$fMkTDictProcess$fBinaryEndOfTuple $fCurryFUNFUN$fCurryFUNFUN0$fUncurryHFalseEndOfTupleaa$fUncurryHTrueTuple2FUNr$fIsFunctionab$fIsFunctionFUNb$fUncurry''argsfuncresult reverseDelete nothingWhen spanMatchMsg spanMatchChan GHC.MaybeNothing GHC.Conc.Sync atomicallyghc-prim GHC.TypesTrueData.Typeable.InternalTypeableGHC.BaseStringGHC.Exception.Type Exceptionbinary-0.8.9.1-957dData.Binary.ClassBinaryFunctor Applicative AlternativeMonad unlinkAsyncunlinkNodeAsyncunlinkPortAsynchandleRegistrationReplymonitor'link' TraceabledelayProcessKillExceptioncreateBareLocalNodestartServiceProcessesdestNidisLocalisValidLocalIdentifier splitNotifmodify'ncEffectMonitor notifyDiedcreateMetaData monomorphizegenerateStatic generateDictcomposestringEgetTypesfnDtemplate-haskell Language.Haskell.TH.Lib.InternalfunD tyVarBndrNameshowFQN staticName sdictName tdictName