EM      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = >?@ABCDEFGHIJKLNone Strict list       None    None= is an abstract type representing an unbounded FIFO channel. $Build and returns a new instance of  IO version of ). This is useful for creating top-level  s using , because using  M inside  isn't  possible. Write a value to a . Read the next value from the .  A version of " which does not retry. Instead it  returns Nothing if no value is available. Returns N if the supplied  is empty. OP OPNone     None*Enqueue an element Enqueue is strict. +Dequeue an element KThe timeout (if any) is applied only to waiting for incoming messages, not 0 to checking messages that have already arrived ,Weak reference to a CQueue Q!"#$%&'(R)*STU+Queue Blocking behaviour List of matches V only on timeout , !"#$%&'()*+, ($'&%!#")*+, Q!#"$'&%(R)*STU+,None-,Objects that can be sent across the network .Reification of - (see #Control.Distributed.Process.Closure) 0+Encode type representation as a bytestring 1JDecode a bytestring into a fingerprint. Throws an IO exception on failure 2Size of a fingerprint 3/The fingerprint of the typeRep of the argument 4*Show fingerprint (for debugging purposes) -./01234W -./01234 -01324./-./01234WNone=5$Signals to the node controller (see B) B Messages to the node controller H,Provide information about a running process O(Asynchronous) reply from register and  unregister Q(Asynchronous) reply from whereis S(Asynchronius) reply from spawn UU. are used to return pids of spawned processes W%(Asynchronous) reply from unlinkPort Y%(Asynchronous) reply from unlinkNode [!(Asynchronous) reply from unlink ]$(Asynchronous) reply from unmonitor _Why did a process die? `Invalid (processnodechannel) identifier aThe process node died b*We got disconnected from the process node c%The process exited with an exception  (provided as X because Y does not implement Z) dNormal termination e(Internal exception thrown indirectly by exit g5Exception thrown when a process attempts to register 2 a process under an already-registered name or to  unregister a name that hasn't been registered i3Exception thrown when a linked channel (port) dies k)Exception thrown when a linked node dies m-Exceptions thrown when a linked process dies o(Message sent by channel (port) monitors qMessage sent by node monitors s!Message sent by process monitors u9MonitorRef is opaque for regular Cloud Haskell processes w!ID of the entity to be monitored xDUnique to distinguish multiple monitor requests by the same process yAMessages consist of their typeRep fingerprint and their encoding }6The receive end of a typed channel (not serializable)  Note that } implements [, \, ]  and ^8. This is especially useful when merging receive ports. 0The send send of a typed channel (serializable) "The (unique) ID of this send port +A send port is identified by a SendPortId. 7You cannot send directly to a SendPortId; instead, use newChan  to create a SendPort. CThe ID of the process that will receive messages sent on this port  Process-local ID of the channel The Cloud Haskell  type Local process state $Processes running on our local node Local node state Processes running on this node Counter to assign PIDs The unique1 value used to create PIDs (so that processes on  restarted nodes have new PIDs) Outgoing connections  Local nodes  of the node /The network endpoint associated with this node Local node state  Channel for the node controller Current active system debug/ trace log -Runtime lookup table for supporting closures I TODO: this should be part of the CH state, not the local endpoint state 3Required for system tracing in the node controller "Union of all kinds of identifiers Process identifier -The ID of the node the process is running on &Node-local identifier for the process IA local process ID consists of a seed which distinguishes processes from : different instances of the same local node and a counter Node identifier Deconstructor for " (not exported to the public API) )Turn any serialiable term into a message Serialize a message Deserialize a message 56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~_`abcdefghijklmnopqrstuvwxy56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Ҟ}~yz{|uvwxstqropefmnklijgh_dcba`]^[\YZWXUVSTQROPHIJKLMNFGBCDE5A@?>=<;:9876U5 A@?>=<;:9876BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_dcba`efghijklmnopqrstuvwxyz{|}~_`abcdefghijklmnopqrstuvwxy None z{|} z{|} Nonea  b is true if the death of a (for instance, a node)  implies the death of b( (for instance, a process on that node) ~~ NoneIYou need this when using   Thrown by  GRepresents a received message and provides two basic operations on it. forward the message to  ProcessId Handle the message. M If the type of the message matches the type of the first argument to O the supplied expression, then the expression will be evaluated against 6 it. If this runtime type checking fails, then Nothing will be returned L to indicate the fact. If the check succeeds and evaluation proceeds : however, the resulting value with be wrapped with Just. Opaque type used in  and  Send a message &Wait for a message of a specific type Create a new typed channel "Send a message on a typed channel &Wait for a message on a typed channel Like / but with a timeout. If the timeout is 0, do a # non-blocking check for a message.  Merge a list of typed channels. HThe result port is left-biased: if there are messages available on more 9 than one port, the first available message is returned. Like 0, but with a round-robin scheduler (rather than  left-biased) <Test the matches in order against each message in the queue Like  but with a timeout. HIf the timeout is zero do a non-blocking check for matching messages. A O non-zero timeout is applied only when waiting for incoming messages (that is,  after@ we have checked the messages that are already in the mailbox). ,Match against any message of the right type GMatch against any message of the right type that satisfies a predicate $Match against an arbitrary message.  removes the first available / message from the process mailbox, and via the  type,  supports forwarding or handling the message if it is of the correct  type. If not of the right type, then the   maybeHandleMessage5 function will not evaluate the supplied expression,  butD the message will still have been removed from the process mailbox! $Match against an arbitrary message.  will only remove the # message from the process mailbox, if% the supplied condition matches. The 0 success (or failure) of runtime type checks in maybeHandleMessage does not 1 count 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 maybeHandleMessage will pass the K runtime type checks and therefore be evaluated. If the types do not match  up, then maybeHandleMessage returns V. "Remove any message from the queue =Terminate immediately (throws a ProcessTerminationException) Die immediately - throws a e with the given reason. *Forceful request to kill a process. Where  provides an exception ! that can be caught and handled, $ throws an unexposed exception type / which cannot be handled explicitly (by type). +Graceful request to exit a process. Throws e with the  supplied reason encoded as a message. Any  exit signal raised in this ! manner can be handled using the  family of functions. Catches e-. The handler will not be applied unless its @ type matches the encoded data stored in the exception (see the reason  argument given to the / primitive). If the handler cannot be applied, " the exception will be re-thrown.  To handle e without regard for reason, see  .  To handle multiple reasons of differing types, see . Lift  (almost). As e stores the exit reason as a typed, encoded K message, a handler must accept an input of the expected type. In order to N handle a list of potentially different handlers (and therefore input types),  a handler passed to  must accept  and return  Maybe (i.e., Just p* if it handled the exit reason, otherwise Nothing). See  and AsbtractMessage for more details. Our own process ID "Get the node ID of our local node ,Get information about the specified process (Link to a remote process (asynchronous) <When process A links to process B (that is, process A calls   link pidB=) then an asynchronous exception will be thrown to process A L when process B terminates (normally or abnormally), or when process A gets - disconnected from process B. Although it is  technically possible to catch O these exceptions, chances are if you find yourself trying to do so you should  probably be using  rather than . In particular, code such as  " link pidB -- Link to process B 2 expect -- Wait for a message from process B  unlink pidB -- Unlink again doesn'Bt quite do what one might expect: if process B sends a message to  process A, and subsequently terminates$, then process A might or might not K be terminated too, depending on whether the exception is thrown before or  after the ) (i.e., this code has a race condition). 9Linking is all-or-nothing: A is either linked to B, or it's not. A second  call to  has no effect.  Note that & provides unidirectional linking (see spawnSupervised). I Linking makes no distinction between normal and abnormal termination of  the remote process. 'Monitor another process (asynchronous) <When process A monitors process B (that is, process A calls   monitor pidB ) then process A will receive a ProcessMonitorNotification L when process B terminates (normally or abnormally), or when process A gets M disconnected from process B. You receive this message like any other (using  '); the notification includes a reason ( DiedNormal,  DiedException,  DiedDisconnect , etc.). Every call to ! returns a new monitor reference u; if H multiple monitors are set up, multiple notifications will be delivered 1 and monitors can be disabled individually using . 5Establishes temporary monitoring of another process. withMonitor pid code sets up monitoring of pid for the duration  of code6. Note: although monitoring is no longer active when   withMonitor2 returns, there might still be unreceived monitor  messages in the queue. Remove a link IThis is synchronous in the sense that once it returns you are guaranteed M that no exception will be raised if the remote process dies. However, it is N asynchronous in the sense that we do not wait for a response from the remote  node. Remove a node link This has the same synchronous/asynchronous nature as . "Remove a channel (send port) link This has the same synchronous/asynchronous nature as . Remove a monitor This has the same synchronous/asynchronous nature as .  Lift   Lift   Lift   Lift   Lift  Lift  Lift  Lift  Like  but with a timeout Asynchronous version of spawn (spawn is defined in terms of  and ) Monitor a node (asynchronous) 'Monitor a typed channel (asynchronous)  Remove a monitor (asynchronous) Link to a node (asynchronous) !Link to a channel (asynchronous) %Remove a process link (asynchronous) "Remove a node link (asynchronous) 1Remove a channel (send port) link (asynchronous)  Log a string  say message= sends a message (time, pid of the current process, message)  to the process registered as logger#. By default, this process simply  sends the string to stderr*. Individual Cloud Haskell backends might 8 replace this with a different logger process, however. ;Register a process with the local registry (asynchronous). < This version will wait until a response is gotten from the > management process. The name must not already be registered. ' The process need not be on this node. % A bad registration will result in a g ?The process to be registered does not have to be local itself. Like -, but will replace an existing registration. & The name must already be registered. :Register a process with a remote registry (asynchronous). LThe process to be registered does not have to live on the same remote node. ! Reply wil come in the form of a O message See comments in  9Remove 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. FDeal with the result from an attempted registration or unregistration ' by throwing an exception if necessary 8Remove a process from a remote registry (asynchronous).  Reply wil come in the form of a O message See comments in  !Query the local process registry /Query a remote process registry (asynchronous) !Reply will come in the form of a Q message. -There is currently no synchronous version of : if J you implement one yourself, be sure to take into account that the remote I node might die or get disconnect before it can respond (i.e. you should  use 0 and take appropriate action when you receive a  NodeMonitorNotification).  =Named send to a process in the local registry (asynchronous) !<Named send to a process in a remote registry (asynchronous) "Resolve a static value #Resolve a closure $JCloud Haskell provides the illusion of connection-less, reliable, ordered G message passing. However, when network connections get disrupted this N illusion cannot always be maintained. Once a network connection breaks (even L temporarily) no further communication on that connection will be possible. G For example, if process A sends a message to process B, and A is then L notified (by monitor notification) that it got disconnected from B, A will 0 not be able to send any further messages to B, unless A explicitly H indicates that it is acceptable to attempt to reconnect to B using the  Cloud Haskell $ primitive. Importantly, when A calls $' it acknowledges that some messages to K B might have been lost. For instance, if A sends messages m1 and m2 to B, N then receives a monitor notification that its connection to B has been lost,  calls $: and then sends m3, it is possible that B will receive m1  and m3 but not m2.  Note that $ does not mean  reconnect now but rather / it is okay ) to attempt to reconnect on the next send/. In particular, if no further K communication attempts are made to B then A can use reconnect to clean up  its connection to B. %Reconnect to a sendport. See $ for more information. &FSend a message to the internal (system) trace facility. If tracing is Q enabled, this will create a custom trace event. Note that several Cloud Haskell 9 sub-systems also generate trace events for informational/debugging purposes, B thus traces generated this way will not be the only output seen. Just as with the  Debug.Trace module, this is a debugging/tracing facility J for use in development, and should not be used in a production setting - K which is why the default behaviour is to trace to the GHC eventlog. For a 7 general purpose logging facility, you should consider . ITrace events can be written to the GHC event log, a text file, or to the % standard system logger process (see %). The default behaviour for writing N to the eventlog requires specific intervention to work, without which traces  are silently dropped/)ignored and no output will be generated. M The GHC eventlog documentation provides information about enabling, viewing  and working with event traces:  1http://hackage.haskell.org/trac/ghc/wiki/EventLog. KWhen a new local node is started, the contents of the environment variable  DISTRIBUTED_PROCESS_TRACE_FILE, are checked for a valid file path. If this R exists and the file can be opened for writing, all trace output will be directed M thence. If the environment variable is empty, the path invalid, or the file J unavailable for writing - e.g., because another node has already started  tracing to it - then the !DISTRIBUTED_PROCESS_TRACE_CONSOLE environment  variable is checked for any1 non-empty value. If this is set, then all trace M output will be directed to the system logger process. If neither evironment P variable provides a valid trace configuration, all internal traces are written  to Debug.Trace.traceEventIO$, which writes to the GHC eventlog.  Users of the simplelocalnet- Cloud Haskell backend should also note that M because the trace file option only supports trace output from a single node Q (so as to avoid interleaving), a file trace configured for the master node will N prevent slaves from tracing to the file and they will fall back to using the  console/ or eventlog instead. Monitor a processnodechannel Link to a processnodechannel X      !"#$%&Nothing for the local node Message to send OHIJKLMNe      !"#$%&OeHIJKLMN !#"     $%&Q      !"#$%& None'CP a b! is a process with input of type a and output of type b )9Static decoder, given a static serialization dictionary. See module documentation of #Control.Distributed.Process.Closure for an  example. *Serialization dictionary for '()' +Serialization dictionary for  ,Serialization dictionary for  .' version of  /' version of () 0' version of  1' version of ( ) 2(Not quite the) ' version of (!) 3' version of  4' version of  5' version of  6' version of  7' version of   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 simply terminates. 8' version of  '()*+,-./012345678'()*+,-./012345678()*+,-'./021345678'()*+,-./012345678 None (Thrown in response to the user invoking kill (see Primitives.hs). This F type is deliberately not exported so it cannot be caught explicitly. :Initialize a new local node. @Create a new local node (without any service processes running) 3Start and register the service processes on a node $ (for now, this is only the logger) ;Force-close a local node 4TODO: for now we just close the associated endpoint <8Run a process on a local node and wait for it to finish =$Spawn a new process on a local node  Unified: Table 8 ,Check if a process is local to our own node Lookup a local closure 6Check if an identifier refers to a valid local object splitNotif ident' splits a notifications map into those ( notifications that should trigger when ident fails and those links that  should not. LThere is a hierarchy between identifiers: failure of a node implies failure L of all processes on that node, and failure of a process implies failure of 8 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 specifically 5 * the notifications for processes on that node, and C * the notifications for typed channels to processes on that node. Similarly, if ident refers to a process, the should trigger set will  include 5 the notifications for that process specifically and 9 * the notifications for typed channels to that process.  See https: github.comhaskell containersissues14 for the bang on _v. Modify and evaluate the state H9:;<=Who' s watching? Who's being watched? V to link Who to notify?  Who died? How did they die? V for linking 9:;<=:;=<999:;<=None>Spawn a process For more information about , see  #Control.Distributed.Process.Closure.  See also A. ?Spawn a process and link to it 5Note that this is just the sequential composition of > and .  (The Unified> semantics that underlies Cloud Haskell does not even support  a synchronous link operation) @Like ?", but monitor the spawned process A0Run a process remotely and wait for it to reply MWe monitor the remote process: if it dies before it can send a reply, we die  too. For more information about , ., and , see  #Control.Distributed.Process.Closure.  See also >. BHSpawn a child process, have the child link to the parent and the parent  monitor the child C-Spawn a new process, supplying it with a new } and return  the corresponding . D"Spawn a process on the local node EJCreate a new typed channel, spawn a process on the local node, passing it , the receive port, and return the send port >?@ABCDEHIJKLMNOPQRSTU_`abcdghijklmnopqrstu}      !"#$%>?@ABCDE}>AghUHIJKLMNumnklijstqrop_dcba`"# !QROP     B?@CSTDE$%>?@ABCDENoneFICreate the closure, decoder, and metadata definitions for the given list  of functions GLike F5, but parameterized by the declaration of a function , instead of the function name. So where for F you'd do   f :: T1 -> T2  f = ...   remotable ['f] with G you would instead do   remotableDecl [  [d| f :: T1 -> T2 ;  f = ...  |]  ] G7 creates the function specified as well as the various ' dictionaries and static versions that F also creates.  G8 is sometimes necessary when you want to refer to, say,   $(mkClosure 'f) within the definition of f itself. NOTE: G creates __remoteTableDecl instead of  __remoteTable  so that you can use both F and G within the same  module. HConstruct a static value. If f : forall a1 .. an. T  then  $(mkStatic 'f) :: forall a1 .. an. Static T.  Be sure to pass f to F. IIf  f : T1 -> T2 is a monomorphic function  then $(functionSDict '"f) :: Static (SerializableDict T1). Be sure to pass f to F. JIf f : T1 -> Process T2 is a monomorphic function  then $(functionTDict '"f) :: Static (SerializableDict T2). Be sure to pass f to F. LMake a Closure- from a static function. This is useful for " making a closure for a top-level  Process () function, because  using K would require adding a dummy () argument. 8Generate the code to add the metadata to the CH runtime ATurn a polymorphic type into a monomorphic type using ANY and co Generate a static value .Generate a serialization dictionary with name n for type typ Compose a set of expressions  Literal string as an expression  Look up the  original name0 (module:name) and type of a top-level function  Variation on 8 which takes a single expression to define the function /The name of a type variable binding occurrence AFully qualified name; that is, the name and the _current_ module LWe 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. FGHIJKLFGHIJKLFGHIJKLFGHIJKL"None./')*+,./01234567FGHIJKL./)*+,'./02134567FGHKLIJ#$%&'(&')&'*&'+,-./0123456789:;<=>?@@ABCDEFGHIJKLMNOPQRSTUVVWXYZ[\]^_`abcdefghiijkllmmnopqrssttuuvvwwxxyyzz{|}~                                                    ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6789:;<=>?@ABCDE#FGHIJ8KLPMNO#PQR#ST#UVWXY#SZ#[\#[]#S^_`abcdefghijklmnopqrstuvwxy z { | } ~                                                                                        distributed-process-0.4.2(Control.Distributed.Process.SerializableControl.Distributed.Process/Control.Distributed.Process.Internal.StrictList=Control.Distributed.Process.Internal.StrictContainerAccessors/Control.Distributed.Process.Internal.WeakTQueue/Control.Distributed.Process.Internal.StrictMVar+Control.Distributed.Process.Internal.CQueue*Control.Distributed.Process.Internal.Types*Control.Distributed.Process.Internal.Trace.Control.Distributed.Process.Internal.Messaging/Control.Distributed.Process.Internal.Primitives4Control.Distributed.Process.Internal.Closure.BuiltIn Control.Distributed.Process.Node/Control.Distributed.Process.Internal.Closure.THSystem.IO.UnsafeunsafePerformIOControl.Exceptioncatchescatchtrymask onExceptionbracketbracket_finallyControl.Categoryid Control.Arrow*** Control.Monadreturn>>>>=#Control.Distributed.Process.ClosurebaseGHC.Fingerprint.Type Fingerprintdistributed-static-0.2.1.1Control.Distributed.StaticclosureStatic RemoteTableClosuretransformers-0.3.0.0Control.Monad.IO.ClassliftIO StrictListAppendSnocNilConsappendfoldrmapMaybe mapDefaultTQueue newTQueue newTQueueIO writeTQueue readTQueue tryReadTQueue isEmptyTQueue mkWeakTQueue StrictMVar newEmptyMVarnewMVartakeMVarputMVarwithMVar modifyMVar_ modifyMVar mkWeakMVarMatchOn MatchChanMatchMsg BlockSpecTimeoutBlocking NonBlockingCQueue newCQueueenqueuedequeue mkWeakCQueue SerializableSerializableDictencodeFingerprintdecodeFingerprintsizeOfFingerprint fingerprintshowFingerprint ProcessSignalGetInfoExitKill NamedSendRegisterWhereIsSpawnDied UnmonitorMonitorUnlinkLinkNCMsg ctrlMsgSender ctrlMsgSignalProcessInfoNone ProcessInfoinfoNodeinfoRegisteredNamesinfoMessageQueueLength infoMonitors infoLinks RegisterReply WhereIsReplyDidSpawnSpawnRef DidUnlinkPort DidUnlinkNodeDidUnlinkProcess DidUnmonitor DiedReason DiedUnknownId DiedNodeDownDiedDisconnect DiedException DiedNormalProcessExitExceptionProcessRegistrationExceptionPortLinkExceptionNodeLinkExceptionProcessLinkExceptionPortMonitorNotificationNodeMonitorNotificationProcessMonitorNotification MonitorRefmonitorRefIdentmonitorRefCounterMessagemessageFingerprintmessageEncoding ReceivePort receiveSTMSendPort sendPortId TypedChannel SendPortIdsendPortProcessIdsendPortLocalIdLocalSendPortIdProcess unProcessLocalProcessState_monitorCounter _spawnCounter_channelCounter_typedChannels LocalProcess processQueue processWeakQ processId processState processThread processNodeLocalNodeState_localProcesses_localPidCounter_localPidUnique_localConnectionsImplicitReconnectNoImplicitReconnectWithImplicitReconnect LocalNode localNodeId localEndPoint localState localCtrlChan localTracer remoteTableTracerInactiveTracerLocalNodeTracerEventLogTracer LogFileTracer IdentifierSendPortIdentifierProcessIdentifierNodeIdentifier ProcessId processNodeIdprocessLocalIdLocalProcessId lpidUnique lpidCounterNodeId nodeAddressnodeOffirstNonReservedProcessId nullProcessIdrunLocalProcess createMessagemessageToPayloadpayloadToMessagelocalProcesseslocalPidCounterlocalPidUniquelocalConnectionslocalProcessWithIdlocalConnectionBetweenmonitorCounter spawnCounterchannelCounter typedChannelstypedChannelWithIdforever'TraceArgTraceTraceStr startTracing stopTracertrace traceFormat sendPayload sendBinary sendMessage disconnectcloseImplicitReconnectionsimpliesDeathOfHandlerProcessTerminationExceptionAbstractMessageforwardmaybeHandleMessageMatchsendexpectnewChansendChan receiveChanreceiveChanTimeoutmergePortsBiased mergePortsRR receiveWaitreceiveTimeout matchChanmatchmatchIfmatchAny matchAnyIf matchUnknown terminatediekillexit catchExit catchesExit getSelfPid getSelfNodegetProcessInfolinkmonitor withMonitorunlink unlinkNode unlinkPort unmonitor expectTimeout spawnAsync monitorNode monitorPortlinkNodelinkPortsayregister reregisterregisterRemoteAsyncreregisterRemoteAsync unregisterunregisterRemoteAsyncwhereiswhereisRemoteAsyncnsend nsendRemoteunStatic unClosure reconnect reconnectPortCP staticDecode sdictUnitsdictProcessId sdictSendPort sndStaticidCPsplitCPreturnCPseqCPbindCPcpLinkcpUnlinkcpSendcpExpect cpNewChancpDelayinitRemoteTable newLocalNodecloseLocalNode runProcess forkProcessspawn spawnLink spawnMonitorcallspawnSupervised spawnChannel spawnLocalspawnChannelLocal remotable remotableDeclmkStatic functionSDict functionTDict mkClosuremkStaticClosure GHC.Conc.Sync atomicallyghc-prim GHC.TypesTrue $fEqTQueue MatchChunks chunkMatches spanMatchMsg spanMatchChan Data.MaybeNothing$fSerializableaGHC.BaseString GHC.Exception Exceptionbinary-0.5.1.1 Data.BinaryBinaryFunctorControl.Applicative Applicative AlternativeMonad$fBinaryProcessInfoNone$fBinaryProcessInfo$fBinaryRegisterReply$fBinaryWhereIsReply$fBinaryIdentifier$fBinarySendPortId$fBinaryDidSpawn$fBinaryDiedReason$fBinaryProcessSignal$fBinaryMonitorRef $fBinaryNCMsg$fBinaryPortMonitorNotification$fBinaryNodeMonitorNotification"$fBinaryProcessMonitorNotification$fBinaryProcessId$fBinaryLocalProcessId'$fExceptionProcessRegistrationException$fExceptionPortLinkException$fExceptionNodeLinkException$fExceptionProcessLinkException$fShowProcessExitException$fExceptionProcessExitException $fShowMessage$fShowSendPortId$fShowIdentifier$fShowProcessId $fShowNodeId defaultTracerdefaultTracerAux logfileTracer sendTraceMsgsetupConnBetween connBetweenunmonitorAsync unlinkAsyncunlinkNodeAsyncunlinkPortAsynchandleRegistrationReplymonitor'link'unMatchabstractcatchesHandler registerImplgetMonitorRefFor getSpawnRef sendCtrlMsg$fFunctorHandler&$fExceptionProcessTerminationExceptiondelayreturnProcessStaticdecodeProcessIdStaticProcessKillExceptioncreateBareLocalNodestartServiceProcessesdestNidisLocalisValidLocalIdentifier splitNotifmodify'NCunNCNCState_links _monitors_registeredHere_registeredOnNodesConnectionState _incoming _incomingFromIncomingTargetToNodeToChanToProcUninitIncomingConnectioninitConnectionStateincoming incomingAt incomingFromhandleIncomingMessagesrunNodeController initNCStatetraceNotifyDiedtraceNcEventFmttraceEventFmtIOwithLocalTracernodeControllerncEffectMonitorncEffectUnlinkncEffectUnmonitor ncEffectDied ncEffectSpawnncEffectRegisterncEffectWhereIsncEffectNamedSend ncEffectKill ncEffectExitncEffectGetInfo notifyDied postAsMessage postMessagethrowException withLocalProclinksmonitorsregisteredHereregisteredOnNodeslinksFor monitorsForregisteredHereForregisteredOnNodesFor$fShowProcessKillException$fExceptionProcessKillExceptioncreateMetaData monomorphizegenerateStatic generateDictcomposestringEgetTypesfnDtemplate-haskellLanguage.Haskell.TH.LibfunD tyVarBndrNameshowFQN staticName sdictName tdictName generateDefs