B      !"#$%&'()*+,-./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       None,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 ((. are used to return pids of spawned processes *%(Asynchronous) reply from unlinkPort ,%(Asynchronous) reply from unlinkNode .!(Asynchronous) reply from unlink 0$(Asynchronous) reply from unmonitor 2Why did a process die? 3Invalid (processnodechannel) identifier 4The process node died 5*We got disconnected from the process node 6%The process exited with an exception  (provided as  because  does not implement ) 7Normal termination 83Exception 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) monitors @Message sent by node monitors B!Message sent by process monitors D:MonitorRef is opaque for regular Cloud Haskell processes F!ID of the entity to be monitored GDUnique to distinguish multiple monitor requests by the same process HAMessages consist of their typeRep fingerprint and their encoding L6The receive end of a typed channel (not serializable) M+A round-robin combination of receive ports N,A left-biased combination of receive ports OA single receive port P0The send send of a typed channel (serializable) R"The (unique) ID of this send port U+A send port is identified by a SendPortId. 7You cannot send directly to a SendPortId; instead, use newChan  to create a SendPort. WCThe ID of the process that will receive messages sent on this port X Process-local ID of the channel ZThe Cloud Haskell Z type ]Local process state c$Processes running on our local node jLocal node state p Local nodes r of the node s0The network endpoint associated with this node tLocal node state u Channel for the node controller v-Runtime lookup table for supporting closures I TODO: this should be part of the CH state, not the local endpoint state w#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 Z# (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{|}~{|}~wzyxpqrstuvjklmnocdefghi]^_`abZ[\YUVWXSTPQRLONMHIJKDEFGBC@A>?<=:;8927654301./,-*+()&'$% !"#E  !"#$%&'()*+,-./0127654389:;<=>?@ABCDEFGHIJKLONMPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwzyx{|}~NoneNone. 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 0///NoneCP 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 P  version of   version of ()  version of   version of () (Not quite the)  version of ()  version of   version of   version of   version of   version of  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 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 prprrNoneSpawn 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 L and return  the corresponding P. "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 ]$%&'(23456789:;<=>?@ABCDLPRUWZ{}`{}ZUW}WLPRR(<=:;89DBC@A>?276543$%&' !!"#$%&'()*+,-../0123456789:;<=>>?@AABBCCDDEEFFGGHIJKLMNNOOPPQQRRSSTTUVWWXYZ[\]^^_``aabcdeefgghijkllmnopqrrstuvwwxyz{|}~   | distributed-process-0.3.0(Control.Distributed.Process.SerializableControl.Distributed.Process+Control.Distributed.Process.Internal.CQueue*Control.Distributed.Process.Internal.Types)Control.Distributed.Process.Internal.Node/Control.Distributed.Process.Internal.Primitives4Control.Distributed.Process.Internal.Closure.BuiltIn/Control.Distributed.Process.Internal.Closure.TH Control.Distributed.Process.NodeControl.Exceptioncatchmask onExceptionbracketbracket_finallyControl.Categoryid Control.Arrow*** Control.Monadreturn>>>>=#Control.Distributed.Process.ClosurebaseGHC.Fingerprint.Type Fingerprintdistributed-static-0.1.0.0Control.Distributed.StaticStatic RemoteTableClosuretransformers-0.3.0.0Control.Monad.IO.ClassliftIO BlockSpecTimeoutBlocking NonBlockingCQueue newCQueueenqueuedequeue SerializableSerializableDictencodeFingerprintdecodeFingerprintsizeOfFingerprint fingerprintshowFingerprint ProcessSignal 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 sendMessageProcessTerminationExceptionMatchsendexpectnewChansendChan receiveChanmergePortsBiased mergePortsRR receiveWaitreceiveTimeoutmatchmatchIf matchUnknown terminate getSelfPid getSelfNodelinkmonitorunlink unlinkNode unlinkPort unmonitor expectTimeout spawnAsync monitorNode monitorPortlinkNodelinkPortsayregisterregisterRemote unregisterunregisterRemotewhereis whereisRemotewhereisRemoteAsyncnsend nsendRemote unClosureCP staticDecode sdictUnitsdictProcessId sdictSendPort sndStaticidCPsplitCPreturnCPseqCPbindCPcpLinkcpUnlinkcpSendcpExpect cpNewChan remotablemkStatic functionSDict functionTDict mkClosureinitRemoteTable newLocalNodecloseLocalNode runProcess forkProcessspawn spawnLink spawnMonitorcallspawnSupervised spawnChannel spawnLocalspawnChannelLocal 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