|TT      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      Safe-InferredNone+;< 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  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  if the supplied  is empty.       Safe-Inferred Strict listNone;  !"  !"  !"  !"None;FHM,Enqueue an elementEnqueue is strict.-,Variant of enqueue for use in the STM monad..Dequeue an elementzThe timeout (if any) is applied only to waiting for incoming messages, not to checking messages that have already arrived/Weak reference to a CQueue#$%&'()*+,-.QueueBlocking behaviourList of matches only on timeout/ #$%&'()*+,-./ *&)('#%$+,-./ #%$&)('*+,-./None!"+240+Objects that can be sent across the network1Reification of .3Reification of 0 (see #Control.Distributed.Process.Closure)5*Encode type representation as a bytestring6IDecode a bytestring into a fingerprint. Throws an IO exception on failure7Size of a fingerprint8.The fingerprint of the typeRep of the argument9)Show fingerprint (for debugging purposes) 0123456789 0123456789 0568793412 0123456789 None !"+0:BMG:$Signals to the node controller (see K)KMessages to the node controllerQ+Provide information about a running process_(Asynchronous) reply from register and  unregistera(Asynchronous) reply from whereisc(Asynchronius) reply from spawnee- are used to return pids of spawned processesg$(Asynchronous) reply from unlinkPorti$(Asynchronous) reply from unlinkNodek (Asynchronous) reply from unlinkm#(Asynchronous) reply from unmonitoroWhy did a process die?pInvalid (processnodechannel) identifierqThe process node diedr)We got disconnected from the process nodes3The process exited with an exception (provided as ! because " does not implement #)tNormal terminationu(Internal exception thrown indirectly by exitwException thrown when a process attempts to register a process under an already-registered name or to unregister a name that hasn't been registeredy2Exception thrown when a linked channel (port) dies{(Exception thrown when a linked node dies},Exceptions thrown when a linked process dies'Message sent by channel (port) monitorsMessage sent by node monitors Message sent by process monitors8MonitorRef is opaque for regular Cloud Haskell processes ID of the entity to be monitoredCUnique to distinguish multiple monitor requests by the same process@Messages consist of their typeRep fingerprint and their encoding5The receive end of a typed channel (not serializable) Note that  implements $, %, & and '7. This is especially useful when merging receive ports./The 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.BThe ID of the process that will receive messages sent on this portProcess-local ID of the channelThe Cloud Haskell  typeLocal process state#Processes running on our local nodeLocal node stateProcesses running on this nodeCounter to assign PIDsThe uniqueP 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 nodeLocal node stateChannel for the node controllerInternal management event busuRuntime lookup table for supporting closures TODO: this should be part of the CH state, not the local endpoint state'Local system management event bus state5Process id of the management agent controller process,Configuration for the local trace controller;Weak reference to the management agent controller's mailbox2API for adding management agents to a running node'Provides access to the trace controller1Process id for the currently active trace handler1Weak reference to the tracer controller's mailbox!Union of all kinds of identifiersProcess identifier,The ID of the node the process is running on%Node-local identifier for the processA local process ID consists of a seed which distinguishes processes from different instances of the same local node and a counterNode identifierDeconstructor for ! (not exported to the public API)internal use only.(Turn any serialiable term into a message:Turn any serializable term into an unencoded/local messagerTurn any serializable term into an unencodede/local message, without evalutaing it! This is a dangerous business.Serialize a messageDeserialize a message:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~uv}~{|yzwxotsrqpmnklijghefcdab_`QRSTUVWOPXYZ[\]^KLMN:JIHGFEDCBA@?>=<;m:JIHGFEDCBA@?>=<;KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnotsrqpuvwxyz{|}~()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU None*+0:BM(Type of a management agent's event sink.GRepresents the actions a management agent can take when evaluating an  event sink.Monad for management agents.6A newtype wrapper for an agent id (which is a string). Gross 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.hs ;The class of things that we might be able to resolve to a  ProcessId (or not).  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.;notifies a trace listener that it has been disabled/removedEnotifies a trace listener that all subsequent traces will be sent to pida logging) event - used for debugging purposes onlya user defined trace event@fired when a network-transport connection is broken/disconnected>fired when a network-transport connection is first established7fired whenever a message is received by a local process5fired whenever a message is sent from a local processfired whenever a node dies. (i.e., the connection is broken/disconnected)fired whenever a process dies7fired whenever a process/name is unregistered (locally)5fired whenever a process/name is registered (locally))fired whenever a local process is spawned1     VWXY-     -          VWXY None a   b is true if the death of a. (for instance, a node) implies the death of b' (for instance, a process on that node) Z[ !Nothing for the local nodeMessage to send ! ! Z[ ! (c) Well-Typed / Tim WatsonBSD3 (see the file LICENSE)%Tim Watson <watson.timothy@gmail.com> experimental#non-portable (requires concurrency)None"<Named send to a process in the local registry (asynchronous)#Send a message$!Send a message on a typed channel%Create an unencoded Message for any  Serializable type."#$%"#$%#$"%"#$% None&&&& None !"+024:M' A generic ok% response from the trace coordinator.,Defines what0 will be traced. Flags that control tracing of Process events, take a 6Q controlling which processes should generate trace events in the target process.62Defines which processes will be traced by a given  TraceFlag, either by name, or  ProcessId . Choosing TraceAll is by farw the most efficient approach, as the tracer process therefore avoids deciding whether or not a trace event is viable.+\]'()*+,-./0123456789:;<=>?@ABCDEFGHI^_`abc#'()*+,-./0123456789:;<=>?@ABCDEFGHI#:<;6987,-./012345)+*'(>?@A=BCDEHFGI\]'()+*, -./0123456987:<;=>?@ABCDEFGHI^_`abcNone+:HMZJYou need this when using L Thrown by oNOpaque type used in Y and ZOSend a messagePUnsafe variant of O. This function makes no attempt to serialize and (in the case when the destination process resides on the same local node) therefore ensure that the payload is fully evaluated before it is delivered.Q%Wait for a message of a specific typeRCreate a new typed channelS!Send a message on a typed channelT7Send a message on a typed channel. This function makes no1 attempt to serialize and (in the case when the  ReceivePorto resides on the same local node) therefore ensure that the payload is fully evaluated before it is delivered.U%Wait for a message on a typed channelVLike UQ but with a timeout. If the timeout is 0, do a non-blocking check for a message.WMerge a list of typed channels.The result port is left-biased: if there are messages available on more than one port, the first available message is returned.XLike W=, but with a round-robin scheduler (rather than left-biased)Y;Test the matches in order against each message in the queueZLike Y but with a timeout.If the timeout is zero do a non-blocking check for matching messages. A 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 on a typed channel\!Match on an arbitrary STM action.This rather unusaul match primitivep allows us to compose arbitrary STM actions with checks against our process' mailbox and/or any typed channel  ReceivePorts we may hold.1This allows us to process multiple input streams along with our mailbox, in just the same way that [% supports checking both the mailbox and> an arbitrary set of typed channels in one atomic transaction.UNote there are no ordering guarnatees with respect to these disparate input sources.]+Match against any message of the right type^FMatch against any message of the right type that satisfies a predicate_HMatch against any message, regardless of the underlying (contained) type`TMatch against any message (regardless of underlying type) that satisfies a predicateaForward a raw  to the given .bWrap a 0 value in a  . Note that s are 0F - 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 d or e 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) c This is the unsafe variant of b. See ,Control.Distributed.Process.UnsafePrimitives for details.dAttempt to unwrap a raw j. 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)eAttempt 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 t and i primitives.fConditionally handle a raw . If the predicate  (a -> Bool) evaluates to True/, invokes the supplied handler, other returns Nothing to indicate failure. See e6 for further information about runtime type checking.gAs e] but ignores result, which is useful if you don't care whether or not the handler succeeded.hConditional version of g.i$Match against an arbitrary message. iT removes the first available message from the process mailbox. To handle arbitrary raw. messages once removed from the mailbox, see e and d.j:Match against an arbitrary message. Intended for use with e and d, 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  handleMessageF and friends is irrelevant here, i.e., if the condition evaluates to TrueW 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.k!Remove any message from the queuel'Receives messages and forwards them to pid if  p msg == True.m@A straight relay that forwards all messages to the supplied pid.nProxies pid and forwards messages whenever proc evaluates to True . Unlike l the predicate proc runs in the 1 monad, allowing for richer proxy behaviour. If proc returns False or the runtime type checkH fails, no action is taken and the proxy process will continue running.o<Terminate immediately (throws a ProcessTerminationException)pDie immediately - throws a u with the given reason.q*Forceful request to kill a process. Where r8 provides an exception that can be caught and handled, qR throws an unexposed exception type which cannot be handled explicitly (by type).r+Graceful request to exit a process. Throws u with the supplied reason encoded as a message. Any  exit signal1 raised in this manner can be handled using the s family of functions.sCatches um. The handler will not be applied unless its type matches the encoded data stored in the exception (see the reason argument given to the rP primitive). If the handler cannot be applied, the exception will be re-thrown. To handle u without regard for reason, see . To handle multiple reasons of differing types, see t.tLift  (almost).As u stores the exit reason as a typed, encoded message, a handler must accept inputs of the expected type. In order to handle a list of potentially different handlers (and therefore input types), a handler passed to t must accept  and return Maybe (i.e., Just p* if it handled the exit reason, otherwise Nothing).See maybeHandleMessage and  for more details.uOur own process IDv!Get the node ID of our local nodew'Get statistics about the specified nodex#Get statistics about our local nodey+Get information about the specified processz'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 when process B terminates (normally or abnormally), or when process A gets disconnected from process B. Although it is  technicallyu possible to catch these exceptions, chances are if you find yourself trying to do so you should probably be using { rather than z. In particular, code such as mlink pidB -- Link to process B expect -- Wait for a message from process B unlink pidB -- Unlink againXdoesn't quite do what one might expect: if process B sends a message to process A, and subsequently terminatesz, then process A might or might not be terminated too, depending on whether the exception is thrown before or after the }( (i.e., this code has a race condition).SLinking is all-or-nothing: A is either linked to B, or it's not. A second call to z has no effect. Note that z& provides unidirectional linking (see spawnSupervised`). 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 when process B terminates (normally or abnormally), or when process A gets disconnected from process B. You receive this message like any other (using Q'); the notification includes a reason (t, s, r, etc.).Every call to {! returns a new monitor reference ~; if multiple monitors are set up, multiple notifications will be delivered and monitors can be disabled individually using .|4Establishes temporary monitoring of another process.withMonitor pid code sets up monitoring of pid for the duration of code7. Note: although monitoring is no longer active when  withMonitorI returns, there might still be unreceived monitor messages in the queue.} Remove a linkThis is synchronous in the sense that once it returns you are guaranteed that no exception will be raised if the remote process dies. However, it is asynchronous in the sense that we do not wait for a response from the remote node.~Remove a node link5This has the same synchronous/asynchronous nature as }.!Remove a channel (send port) link5This has the same synchronous/asynchronous nature as }.Remove a monitor5This has the same synchronous/asynchronous nature as }.Lift Lift  Lift !Lift "Lift #Lift $Lift %Lift &Lift Like Q but with a timeoutAsynchronous version of spawn(spawn is defined in terms of  and Q)Monitor a node (asynchronous)&Monitor a typed channel (asynchronous)dRemove a monitor (asynchronous)Link to a node (asynchronous) Link to a channel (asynchronous)e$Remove a process link (asynchronous)f!Remove a node link (asynchronous)g0Remove 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 logger8. By default, this process simply sends the string to stderra. Individual Cloud Haskell backends might replace this with a different logger process, however.Register a process with the local registry (synchronous). The name must not already be registered. The process need not be on this node. A bad registration will result in a w>The process to be registered does not have to be local itself.Like R, but will replace an existing registration. The name must already be registered.9Register a process with a remote registry (asynchronous).mThe process to be registered does not have to live on the same remote node. Reply wil come in the form of a _ messageSee comments in Remove 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.hlDeal with the result from an attempted registration or unregistration by throwing an exception if necessary7Remove a process from a remote registry (asynchronous). Reply wil come in the form of a _ messageSee comments in  Query the local process registry.Query a remote process registry (asynchronous)!Reply will come in the form of a a 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 ).<Named send to a process in the local registry (asynchronous)SNamed send to a process in the local registry (asynchronous). This function makes no attempt to serialize and (in the case when the destination process resides on the same local node) therefore ensure that the payload is fully evaluated before it is delivered.;Named send to a process in a remote registry (asynchronous)Resolve a static valueResolve a closureCloud Haskell provides the illusion of connection-less, reliable, ordered message passing. However, when network connections get disrupted this illusion cannot always be maintained. Once a network connection breaks (even temporarily) no further communication on that connection will be possible. For example, if process A sends a message to process B, and A is then notified (by monitor notification) that it got disconnected from B, A will not be able to send any further messages to B, unlesse A explicitly 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 B might have been lost. For instance, if A sends messages m1 and m2 to B, then receives a monitor notification that its connection to B has been lost, calls M 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 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.iMonitor a processnodechanneljLink to a processnodechannelgJKLMNklOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~mdefgnhopqrijstgQRSTUVWXYZ[\]^u!JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~gOQRSUWXPTNYZ]^kij[\_`bcdefghalmnoLMpqrstuuvQRSTUVWyXYZ[\]^wxz}{|JKV~!cJKLMNklOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~mdefgnhopqrijstNoneHMCP a b! is a process with input of type a and output of type b8Static 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 Serialization dictionary for .Serialization dictionary for . version of '( version of ()*) version of +, version of (+-)(Not quite the)  version of (+.) version of z version of } version of O version of Q version of R version of mu 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. version of uvuvuNoneHMSpawn a processFor more information about , see #Control.Distributed.Process.Closure. See also .Spawn a process and link to it5Note that this is just the sequential composition of  and z. (The Unified\ semantics that underlies Cloud Haskell does not even support a synchronous link operation)Like !, but monitor the spawned process/Run a process remotely and wait for it to replyRWe monitor the remote process: if it dies before it can send a reply, we die too.For more information about , 3, and , see #Control.Distributed.Process.Closure. See also .ZSpawn a child process, have the child link to the parent and the parent monitor the child-Spawn a new process, supplying it with a new  and return the corresponding .NoneVCreate the closure, decoder, and metadata definitions for the given list of functionsLike a, 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.Construct a static value.If f : forall a1 .. an. T then +$(mkStatic 'f) :: forall a1 .. an. Static T. Be sure to pass f to .If  f : T1 -> T2! is a monomorphic function then 3$(functionSDict 'f) :: Static (SerializableDict T1).Be sure to pass f to .If f : T1 -> Process T2! is a monomorphic function then 3$(functionTDict 'f) :: Static (SerializableDict T2).Be sure to pass f to .If  f : T1 -> T2 then #$(mkClosure 'f) :: T1 -> Closure T2.dTODO: The current version of mkClosure is too polymorphic (@forall a. Binary a => a -> Closure T2).Make a ClosureO 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.w7Generate the code to add the metadata to the CH runtimex@Turn a polymorphic type into a monomorphic type using ANY and coyGenerate a static valuez.Generate a serialization dictionary with name n for type typ{Compose a set of expressions|Literal string as an expression}JLook up the "original name" (module:name) and type of a top-level function~ Variation on 7 which takes a single expression to define the function.The name of a type variable binding occurrence@Fully qualified name; that is, the name and the _current_ moduleqWe 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.wxyz{|}~wxyz{|}~None24 JConverts a list of identifiers (that can be mapped to process ids), to a 6./Turn tracing for for a subset of trace targets.Trace all targets.Trace no targets.'Enable tracing to the supplied process.6Enable tracing to the supplied process and wait for a TraceOk. response from the trace coordinator process.'Disable the currently configured trace.6Disable the currently configured trace and wait for a TraceOk. response from the trace coordinator process.+Set the given flags for the current tracer.:Set the given flags for the current tracer and wait for a TraceOk. response from the trace coordinator process.wSend a log message to the internal tracing facility. If tracing is enabled, this will create a custom trace log event.XSend a log message to the internal tracing facility, using the given list of printable ),s interspersed with the preceding delimiter.Send an arbitrary Message to the tracer process.==NoneMNone Remote Table. Starts a  trace relayZ process on the remote node, which forwards all trace events to the registered tracer on this (the calling process') node.5Set the given flags for a remote node (asynchronous).None+0HM(c) Well-Typed / Tim WatsonBSD3 (see the file LICENSE)%Tim Watson <watson.timothy@gmail.com> experimental#non-portable (requires concurrency)None *+024:FMPublishes 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 allh registered agents will gain access to the data structure once it is broadcast by the agent controller.Publish an arbitrary Message* as a property in the management database.For publishing  Serializable data, use  instead.Sets an arbitrary  Serializable< datum against a key in the management database. 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 some other, arbitrary process (or management agent!) that obtains and attempts to force the value later on.Fetches a property from the management database for the given key. If the property is not set, or does not match the expected type when typechecked (at runtime), returns Nothing.Clears a property from the management database using the given key. If the key does not exist in the database, this is a noop.GPurges a table in the management database of all its stored properties.-Deletes a table from the management database. Return the # for the currently executing agent.The  version of .Gracefully terminate an agent.=Continue executing (i.e., receiving and processing messages).Causes 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.?Continue exeucting, prioritising inputs from the process' own mailbox- ahead of data from the management event bus.]Continue exeucting, prioritising inputs from the management event bus over the process' own mailbox.Lift a Process action.Set the agent's local state.Update the agent's local state.Fetch the agent's local state. Create an  from an expression taking a  Serializable type m, that yields an  in the  monad.Activates a new agent.,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 ()Z - such that the agent's internal state remains accessible to the shutdown/cleanup code.)  )  NoneMA triple containing a configured tracer, weak pointer to the agent controller's mailbox (CQueue) and an expression used to instantiate new agents on the current node.Starts a management agent for the current node. The agent process must not crash or be killed, so we generally avoid publishing its  ProcessId where possible.cOur process is also responsible for forwarding messages to the trace controller, since having two special processes handled via the  LocalNodeh would be inelegant. We forward messages directly to the trace controller's message queue, just as the  MxEventBus that's set up on the  LocalNode forwards messages directly to us. This optimises the code path for tracing and avoids overloading the node node controller's internal control plane with additional routing, at the cost of a little more complexity and two cases where we break encapsulation./Forks a new process in which an mxAgent is run.Start the tracer controller."Start a dead letter (agent) queue.If no agents are registered on the system, the management event bus will fill up and its data won't be GC'ed until someone comes along and reads from the broadcast channel (via dupTChan of course). This is effectively a leak, so to mitigate it, we start a dead letter queue that drains the event bus continuously, thus ensuring if there are no other consumers that we won't use up heap space unnecessarily.None +BHM (Thrown in response to the user invoking kill` (see Primitives.hs). This 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)2Start and register the service processes on a nodeForce-close a local node3TODO: for now we just close the associated endpoint7Run 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 nodeLookup a local closure5Check if an identifier refers to a valid local objectsplitNotif identO 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.Modify and evaluate the stateMWho's watching?Who's being watched? to linkWho to notify? Who died?How did they die? for linking>(c) Well-Typed / Tim WatsonBSD3 (see the file LICENSE)%Tim Watson <watson.timothy@gmail.com> experimental#non-portable (requires concurrency)NoneHMnStarts a new tracer, using the supplied trace function. Only one tracer can be registered at a time, however thisO 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.  Evaluate proc with tracing enabled via handlerk, and immediately disable tracing thereafter, before giving the result (or exception in case of failure).  Evaluate procf with the supplied flags enabled. Any previously set trace flags are restored immediately afterwards. *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 F) have exited, subsequent calls to this function will have no effect.AIf the last tracer to have been registered was not started with ( then the behaviour of this function is  undefined.   ()*+,-./0123456789=   ()+*,-./0123456987  =    None !Spawn a process on the local node uCreate a new typed channel, spawn a process on the local node, passing it the receive port, and return the send port  QRSTUVWXYZ[\]^_`abcdeopqrstwxyz{|}~JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  OQRSUVWXPTcNYZ]^kij[\_`bdefghalmnopqrstLMwxeuvQRSTUVWyXYZ[\]^wxz}~{|}~{|yzotsrqpab_`JKcd    None!"+23468<=MWA RemoteRegister is a trasformer on a RemoteTable to register additional static values.vThis takes an explicit name and a value, and produces both a static reference to the name and a RemoteRegister for it.This takes an explicit name, a function of arity one, and creates a creates a function yielding a closure and a remote register for it.|This takes an explict name, a function of any arity, and creates a function yielding a closure and a remote register for it.<Works just like standard call, but with a simpler signature.      /None"34"34 0123453463473489:;<=>?@ABCDEFGHIJKLMMNOPQRSTUVWXYZ[\]^_`abcdeffgghijklmnopqrstuvwxyz{|}~~                                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 3 4 5 6 7 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R STTUUV/WXY0Z[\]^_`abcdefg1hijklmnopqrstuvwxyz{|}~ !"#$%&.LNRPHIK0   >  _0000000 0!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO P Q R S T U V W X Y Z [ \ ]^_`abcdVefghijklmnopqrstuvwxyz{|}~VWXYdistributed-process-0.5.5(Control.Distributed.Process.SerializableControl.Distributed.Process=Control.Distributed.Process.Internal.StrictContainerAccessors/Control.Distributed.Process.Internal.WeakTQueue/Control.Distributed.Process.Internal.StrictList/Control.Distributed.Process.Internal.StrictMVar+Control.Distributed.Process.Internal.CQueue*Control.Distributed.Process.Internal.Types5Control.Distributed.Process.Management.Internal.Types.Control.Distributed.Process.Internal.Messaging,Control.Distributed.Process.UnsafePrimitives3Control.Distributed.Process.Management.Internal.Bus;Control.Distributed.Process.Management.Internal.Trace.Types/Control.Distributed.Process.Internal.Primitives4Control.Distributed.Process.Internal.Closure.BuiltIn*Control.Distributed.Process.Internal.Spawn/Control.Distributed.Process.Internal.Closure.TH@Control.Distributed.Process.Management.Internal.Trace.Primitives>>>=#Control.Distributed.Process.ClosurebaseGHC.Fingerprint.Type Fingerprintdistributed-static-0.3.2.0Control.Distributed.StaticclosureStatic RemoteTableClosuretransformers-0.4.3.0Control.Monad.IO.ClassliftIOmapMaybe mapDefaultTQueue newTQueue newTQueueIO writeTQueue readTQueue tryReadTQueue isEmptyTQueue mkWeakTQueue StrictListAppendSnocNilConsappendfoldr StrictMVar newEmptyMVarnewMVartakeMVarputMVarreadMVarwithMVar modifyMVar_ modifyMVarmodifyMVarMasked mkWeakMVarMatchOn MatchChanMatchMsg BlockSpecTimeoutBlocking NonBlockingCQueue newCQueueenqueue enqueueSTMdequeue mkWeakCQueue Serializable TypeableDictSerializableDictencodeFingerprintdecodeFingerprintsizeOfFingerprint fingerprintshowFingerprint ProcessSignal GetNodeStats SigShutdownGetInfoExitKill LocalPortSend LocalSend NamedSendRegisterWhereIsSpawnDied UnmonitorMonitorUnlinkLinkNCMsg ctrlMsgSender ctrlMsgSignalProcessInfoNone ProcessInfoinfoNodeinfoRegisteredNamesinfoMessageQueueLength infoMonitors infoLinks NodeStats nodeStatsNodenodeStatsRegisteredNamesnodeStatsMonitorsnodeStatsLinksnodeStatsProcesses RegisterReply WhereIsReplyDidSpawnSpawnRef DidUnlinkPort DidUnlinkNodeDidUnlinkProcess DidUnmonitor DiedReason DiedUnknownId DiedNodeDownDiedDisconnect DiedException DiedNormalProcessExitExceptionProcessRegistrationExceptionPortLinkExceptionNodeLinkExceptionProcessLinkExceptionPortMonitorNotificationNodeMonitorNotificationProcessMonitorNotification MonitorRefmonitorRefIdentmonitorRefCounterMessageUnencodedMessagemessagePayloadEncodedMessagemessageFingerprintmessageEncoding 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 localEventBus remoteTable MxEventBusagenttracerevbussmxNewMxEventBusInitialisingTracer tracerPidweakQ IdentifierSendPortIdentifierProcessIdentifierNodeIdentifier ProcessId processNodeIdprocessLocalIdLocalProcessId lpidUnique lpidCounterNodeId nodeAddressnodeOffirstNonReservedProcessId nullProcessIdrunLocalProcess isEncoded createMessagecreateUnencodedMessageunsafeCreateUnencodedMessagemessageToPayloadpayloadToMessagelocalProcesseslocalPidCounterlocalPidUniquelocalConnectionslocalProcessWithIdlocalConnectionBetweenmonitorCounter spawnCounterchannelCounter typedChannelstypedChannelWithIdforever'MxSinkMxAction MxAgentSkip MxAgentReadyMxAgentPrioritiseMxAgentDeactivateChannelSelectorMailbox InputChan MxAgentStartmxAgentTableChanmxAgentIdStartMxAgentunAgent MxAgentState mxAgentIdmxBus mxSharedTable mxLocalState MxTableIdMxForPid MxForAgent MxAgentIdagentIdFork Addressable resolveToPidMxEventMxTraceDisableMxTraceTakeoverMxLogMxUserMxDisconnected MxConnected MxReceivedMxSent MxNodeDied MxProcessDiedMxUnRegistered MxRegistered MxSpawned sendPayload sendBinary sendMessage disconnectcloseImplicitReconnectionsimpliesDeathOf sendCtrlMsgnsendsendsendChan wrapMessage publishEventTraceOkTraceArgTraceTraceStr TraceFlags traceSpawned traceDiedtraceRegisteredtraceUnregistered traceSend traceRecv traceNodestraceConnections TraceSubject TraceNames TraceProcsTraceAllSetTrace TraceDisable TraceEnabledefaultTraceFlagstraceLog traceLogFmt traceEvent traceMessage enableTraceenableTraceSync disableTracedisableTraceSync setTraceFlagssetTraceFlagsSync getTraceFlagsgetCurrentTraceClientHandlerProcessTerminationExceptionMatch unsafeSendexpectnewChanunsafeSendChan receiveChanreceiveChanTimeoutmergePortsBiased mergePortsRR receiveWaitreceiveTimeout matchChanmatchSTMmatchmatchIf matchMessagematchMessageIfforwardunsafeWrapMessage unwrapMessage handleMessagehandleMessageIfhandleMessage_handleMessageIf_matchAny matchAnyIf matchUnknowndelegaterelayproxy terminatediekillexit catchExit catchesExit getSelfPid getSelfNode getNodeStatsgetLocalNodeStatsgetProcessInfolinkmonitor withMonitorunlink unlinkNode unlinkPort unmonitor expectTimeout spawnAsync monitorNode monitorPortlinkNodelinkPortsayregister reregisterregisterRemoteAsyncreregisterRemoteAsync unregisterunregisterRemoteAsyncwhereiswhereisRemoteAsync unsafeNSend nsendRemoteunStatic unClosure reconnect reconnectPortCP staticDecode sdictUnitsdictProcessId sdictSendPort sdictStatic sdictClosure sndStaticidCPsplitCPreturnCPseqCPbindCPdecodeProcessIdStaticcpLinkcpUnlinkcpSendcpExpect cpNewChancpRelaycpEnableTraceRemote cpDelayedspawn spawnLink spawnMonitorcallspawnSupervised spawnChannel remotable remotableDeclmkStatic functionSDict functionTDict mkClosuremkStaticClosure traceOnlytraceOntraceOffenableTraceAsyncdisableTraceAsyncsetTraceFlagsAsyncwithLocalTracerwithRegisteredTracer defaultTracersystemLoggerTracereventLogTracer logfileTracertraceControllerstartTraceRelaysetTraceFlagsRemoteMxTableRequestGetSetClearPurgeDeletemxTableCoordinatordeletepurgeclearsetfetchgetstartTableCoordinatormxNotify mxPublishmxSetmxGetmxClear mxPurgeTable mxDropTablemxGetId mxBroadcast mxDeactivatemxReadymxSkip mxReceive mxReceiveChanliftMX mxSetLocal mxUpdateLocal mxGetLocalmxSinkmxAgentmxAgentWithFinalize AgentConfigmxAgentController mxStartAgent startTracingstartDeadLetterQueueinitRemoteTable newLocalNodecloseLocalNode runProcess forkProcess startTracer withTracer withFlags stopTracer spawnLocalspawnChannelLocalMkTDictmkTDictRemoteRegister mkStaticValmkClosureValSingle mkClosureValcall' GHC.Conc.Sync atomicallyghc-prim GHC.TypesTrue $fEqTQueue MatchChunks chunkMatches spanMatchMsg spanMatchChan Data.MaybeNothingData.Typeable.InternalTypeable$fSerializableaGHC.BaseString GHC.Exception Exceptionbinary-0.7.1.0Data.Binary.ClassBinaryFunctorControl.Applicative Applicative AlternativeMonad$fBinaryProcessInfoNone$fBinaryNodeStats$fBinaryProcessInfo$fBinaryRegisterReply$fBinaryWhereIsReply$fBinaryIdentifier$fBinarySendPortId$fBinaryDidSpawn$fBinaryDiedReason$fBinaryProcessSignal$fBinaryMonitorRef $fBinaryNCMsg$fBinaryPortMonitorNotification$fBinaryNodeMonitorNotification"$fBinaryProcessMonitorNotification$fBinaryLocalProcessId$fBinaryMessage$fNFDataDiedReason'$fExceptionProcessRegistrationException$fExceptionPortLinkException$fExceptionNodeLinkException$fExceptionProcessLinkException$fShowProcessExitException$fExceptionProcessExitException$fNFDataMonitorRef$fHashableMonitorRef $fShowMessage$fNFDataMessage$fNFDataSendPort$fHashableSendPort$fBinarySendPort$fNFDataSendPortId$fShowSendPortId$fHashableSendPortId$fShowIdentifier$fNFDataIdentifier$fHashableIdentifier$fShowProcessId$fHashableProcessId$fNFDataProcessId$fBinaryProcessId$fHashableLocalProcessId $fShowNodeId$fHashableNodeId$fNFDataNodeId$fBinaryNodeId$fBinaryMxAgentStart$fBinaryMxTableId$fAddressableMxEvent$fBinaryMxEventsetupConnBetween connBetween Traceableuod $fTraceable[]$fTraceableProcessId$fBinaryTraceOk$fBinaryTraceFlags$fBinaryTraceSubject$fBinarySetTraceunmonitorAsync unlinkAsyncunlinkNodeAsyncunlinkPortAsynchandleRegistrationReplymonitor'link'unMatchcatchesHandler registerImpl sendLocal sendChanLocalgetMonitorRefFor getSpawnRef$fFunctorHandler&$fExceptionProcessTerminationExceptiondelayreturnProcessStaticcreateMetaData monomorphizegenerateStatic generateDictcomposestringEgetTypesfnDtemplate-haskellLanguage.Haskell.TH.LibfunD tyVarBndrNameshowFQN staticName sdictName tdictName generateDefswithLocalTracerSync TracerStateTracerSTclientflagsregNamesdefaultTracerAuxdefaultEventLogTracercheckEnv nullTracerapplyTraceFlags handleTracetraceEv sendTrace sendTraceMsgenableTraceRemoteMxTables MxTableState_name_entries safeFetchsendReqresolve tableHandlergetEntryentries$fBinaryMxTableRequest MxPipelineMxStopcurrentnextProcessKillExceptioncreateBareLocalNodestartServiceProcessesdestNidisLocalisValidLocalIdentifier splitNotifmodify'NCunNCNCState_links _monitors_registeredHere_registeredOnNodesConnectionState _incoming _incomingFromIncomingTargetToNodeToChanToProcUninitIncomingConnection startMxAgentstartDefaultTracerinitConnectionStateincoming incomingAt incomingFromhandleIncomingMessagesrunNodeController initNCStatetraceNotifyDiedtraceEventFmtIOtracenodeControllerncEffectMonitorncEffectUnlinkncEffectUnmonitor ncEffectDied ncEffectSpawnncEffectRegisterncEffectWhereIsncEffectNamedSendncEffectLocalSendncEffectLocalPortSend ncEffectKill ncEffectExitncEffectGetInfoncEffectGetNodeStats notifyDied postAsMessage postMessagethrowException withLocalProclinksmonitorsregisteredHereregisteredOnNodeslinksFor monitorsForregisteredHereForregisteredOnNodesFor$fShowProcessKillException$fExceptionProcessKillException traceProxy IsFunctionUncurryreify' Uncurry''reifyFunMoarDoneHFalseHTrueCurrycurryFun EndOfTupleuncurry'$fIsFunctionab$fIsFunction(->)b$fUncurry''argsfuncresult$fUncurryHFalseEndOfTupleaa$fUncurryHTrue(,)(->)r$fCurry(->)(->)$fCurry(->)(->)0$fBinaryEndOfTuple $fMkTDicta$fMkTDictProcess