!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  None Dequeue an element KThe timeout (if any) is applied only to waiting for incoming messages, not 0 to checking messages that have already arrived  Queue Blocking behaviour List of matches  only on timeout       NoneNone,Objects that can be sent across the network Reification of  (see #Control.Distributed.Process.Closure) +Encode type representation as a bytestring KDecode a bytestring into a fingerprint. Throws an IO exception on failure Size of a fingerprint 0The fingerprint of the typeRep of the argument *Show fingerprint (for debugging purposes)   None6$Signals to the node controller (see )) ) Messages to the node controller -(Asynchronous) reply from whereis /(Asynchronius) reply from spawn 11. are used to return pids of spawned processes 3%(Asynchronous) reply from unlinkPort 5%(Asynchronous) reply from unlinkNode 7!(Asynchronous) reply from unlink 9$(Asynchronous) reply from unmonitor ;Why did a process die? <Invalid (processnodechannel) identifier =The process node died >*We got disconnected from the process node ?%The process exited with an exception  (provided as  because  does not implement ) @Normal termination A3Exception thrown when a linked channel (port) dies C)Exception thrown when a linked node dies E-Exceptions thrown when a linked process dies G(Message sent by channel (port) monitors IMessage sent by node monitors K!Message sent by process monitors M:MonitorRef is opaque for regular Cloud Haskell processes O!ID of the entity to be monitored PDUnique to distinguish multiple monitor requests by the same process QAMessages consist of their typeRep fingerprint and their encoding U6The receive end of a typed channel (not serializable) V+A round-robin combination of receive ports W,A left-biased combination of receive ports XA single receive port Y0The 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 a Process-local ID of the channel cThe Cloud Haskell c type fLocal process state l$Processes running on our local node sLocal node state y Local nodes { of the node |0The network endpoint associated with this node }Local node state ~ Channel for the node controller -Runtime lookup table for supporting closures I TODO: this should be part of the CH state, not the local endpoint state #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 c# (not exported to the public API) )Turn any serialiable term into a message Serialize a message Deserialize a message  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~yz{|}~stuvwxlmnopqrfghijkcdeb^_`a\]YZ[UXWVQRSTMNOPKLIJGHEFCDAB;@?>=<9:78563412/0-.)*+,('&%$#"! E ('&%$#"! )*+,-./0123456789:;@?>=<ABCDEFGHIJKLMNOPQRSTUXWVYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     NoneNone1 Thrown by  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  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 "Remove any message from the queue 1Terminate (throws a ProcessTerminationException) Our own process ID "Get the node ID of our local node (Link to a remote process (asynchronous)  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) Remove a link (synchronous) !Remove a node link (synchronous) 0Remove a channel (send port) link (synchronous) Remove a monitor (synchronous) 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 Monitor a typed channel Link to a node Link to a channel (send port)  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). ?The process to be registered does not have to be local itself. :Register a process with a remote registry (asynchronous). LThe process to be registered does not have to live on the same remote node. 9Remove a process from the local registry (asynchronous). 8Remove a process from a remote registry (asynchronous). 0Query the local process registry (synchronous). .Query a remote process registry (synchronous) /Query a remote process registry (asynchronous) !Reply will come in the form of a - message >Named send to a process in the local registry (asynchronous) <Named send to a process in a remote registry (asynchronous) Deserialize 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. H 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 node. See  for more information. Reconnect to a sendport. See  for more information. 3222NoneCP 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 Y  version of   version of ()  version of   version of () (Not quite the)  version of ()  version of   version of   version of   version of   version of   NoneInitialize a new local node. 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 y{y{{NoneSpawn a process For more information about , see  #Control.Distributed.Process.Closure.  See also . 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 0Run 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 . HSpawn 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 U and return  the corresponding Y. "Spawn a process on the local node JCreate a new typed channel, spawn a process on the local node, passing it , the receive port, and return the send port `-./01;<=>?@ABCDEFGHIJKLMUY[^`ccc^``UY[[1EFCDABMKLIJGH;@?>=<-./0 NoneICreate the closure, decoder, and metadata definitions for the given list  of functions 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 $(functionSDict '"f) :: Static (SerializableDict T1). Be sure to pass f to . If f : T1 -> Process T2 is a monomorphic function  then $(functionTDict '"f) :: Static (SerializableDict T2). Be sure to pass f to . None !"#$%&'()*+,-./01234567889:;<=>?@ABCDEFGHIIJKLLMMNNOOPPQQRRSTUVWXYYZZ[[\\]]^^__`abbcdefghiijkkllmnoppqrrstuvwwxyz{|}}~         distributed-process-0.3.1(Control.Distributed.Process.SerializableControl.Distributed.Process+Control.Distributed.Process.Internal.CQueue/Control.Distributed.Process.Internal.StrictMVar*Control.Distributed.Process.Internal.Types)Control.Distributed.Process.Internal.Node/Control.Distributed.Process.Internal.Primitives4Control.Distributed.Process.Internal.Closure.BuiltIn Control.Distributed.Process.Node/Control.Distributed.Process.Internal.Closure.THControl.Exceptioncatchmask onExceptionbracketbracket_finallyControl.Categoryid Control.Arrow*** Control.Monadreturn>>>>=#Control.Distributed.Process.ClosurebaseGHC.Fingerprint.Type Fingerprintdistributed-static-0.2.0.0Control.Distributed.StaticclosureStatic RemoteTableClosuretransformers-0.3.0.0Control.Monad.IO.ClassliftIO BlockSpecTimeoutBlocking NonBlockingCQueue newCQueueenqueuedequeue StrictMVar newEmptyMVarnewMVartakeMVarputMVarwithMVar modifyMVar_ modifyMVar SerializableSerializableDictencodeFingerprintdecodeFingerprintsizeOfFingerprint fingerprintshowFingerprint ProcessSignal Reconnect NamedSendRegisterWhereIsSpawnDied UnmonitorMonitorUnlinkLinkNCMsg ctrlMsgSender ctrlMsgSignal WhereIsReplyDidSpawnSpawnRef DidUnlinkPort DidUnlinkNodeDidUnlinkProcess DidUnmonitor DiedReason DiedUnknownId DiedNodeDownDiedDisconnect DiedException DiedNormalPortLinkExceptionNodeLinkExceptionProcessLinkExceptionPortMonitorNotificationNodeMonitorNotificationProcessMonitorNotification MonitorRefmonitorRefIdentmonitorRefCounterMessagemessageFingerprintmessageEncoding ReceivePort ReceivePortRRReceivePortBiasedReceivePortSingleSendPort sendPortId TypedChannel SendPortIdsendPortProcessIdsendPortLocalIdLocalSendPortIdProcess unProcessLocalProcessState_monitorCounter _spawnCounter_channelCounter_typedChannels LocalProcess processQueue processId processState processThread processNodeLocalNodeState_localProcesses_localPidCounter_localPidUnique_localConnections LocalNode localNodeId localEndPoint localState localCtrlChan remoteTable IdentifierSendPortIdentifierProcessIdentifierNodeIdentifier ProcessId processNodeIdprocessLocalIdLocalProcessId lpidUnique lpidCounterNodeId nodeAddressnodeOfrunLocalProcess createMessagemessageToPayloadpayloadToMessagelocalProcesseslocalPidCounterlocalPidUniquelocalConnectionslocalProcessWithIdlocalConnectionBetweenmonitorCounter spawnCounterchannelCounter typedChannelstypedChannelWithId sendPayload sendBinary sendMessage reconnectProcessTerminationExceptionMatchsendexpectnewChansendChan receiveChanmergePortsBiased mergePortsRR receiveWaitreceiveTimeoutmatchmatchIf matchUnknown terminate getSelfPid getSelfNodelinkmonitorunlink unlinkNode unlinkPort unmonitor expectTimeout spawnAsync monitorNode monitorPortlinkNodelinkPortsayregisterregisterRemote unregisterunregisterRemotewhereis whereisRemotewhereisRemoteAsyncnsend nsendRemote unClosure reconnectNode reconnectPortCP staticDecode sdictUnitsdictProcessId sdictSendPort sndStaticidCPsplitCPreturnCPseqCPbindCPcpLinkcpUnlinkcpSendcpExpect cpNewChaninitRemoteTable newLocalNodecloseLocalNode runProcess forkProcessspawn spawnLink spawnMonitorcallspawnSupervised spawnChannel spawnLocalspawnChannelLocal remotablemkStatic functionSDict functionTDict mkClosure Data.MaybeNothing$fSerializableaGHC.BaseString GHC.Exception Exceptionbinary-0.5.1.0 Data.BinaryBinary$fBinaryWhereIsReply$fBinaryIdentifier$fBinarySendPortId$fBinaryDidSpawn$fBinaryDiedReason$fBinaryProcessSignal$fBinaryMonitorRef $fBinaryNCMsg$fBinaryPortMonitorNotification$fBinaryNodeMonitorNotification"$fBinaryProcessMonitorNotification$fBinaryProcessId$fBinaryLocalProcessId$fExceptionPortLinkException$fExceptionNodeLinkException$fExceptionProcessLinkException $fShowMessage$fShowSendPortId$fShowIdentifier$fShowProcessId $fShowNodeId&$fExceptionProcessTerminationException