G      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      NoneNone&Dynamically typed Kleisli composition        NoneDequeue 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 +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) None;%$Signals to the node controller (see /) / Messages to the node controller 3(Asynchronous) reply from whereis 5(Asynchronius) reply from spawn 77. are used to return pids of spawned processes 9%(Asynchronous) reply from unlinkPort ;%(Asynchronous) reply from unlinkNode =!(Asynchronous) reply from unlink ?$(Asynchronous) reply from unmonitor AWhy did a process die? BInvalid (processnodechannel) identifier CThe process node died D*We got disconnected from the process node E%The process exited with an exception  (provided as  because  does not implement ) FNormal termination G3Exception thrown when a linked channel (port) dies I)Exception thrown when a linked node dies K-Exceptions thrown when a linked process dies M(Message sent by channel (port) monitors OMessage sent by node monitors Q!Message sent by process monitors S:MonitorRef is opaque for regular Cloud Haskell processes U!ID of the entity to be monitored VDUnique to distinguish multiple monitor requests by the same process WAMessages consist of their typeRep fingerprint and their encoding [Reification of  (see #Control.Distributed.Process.Closure) ]Runtime dictionary for unstatic lookups `7A closure is a static value and an encoded environment bJA static value is top-level bound or the application of two static values h6The receive end of a typed channel (not serializable) i+A round-robin combination of receive ports j,A left-biased combination of receive ports kA single receive port l0The send send of a typed channel (serializable) n"The (unique) ID of this send port q+A send port is identified by a SendPortId. 7You cannot send directly to a SendPortId; instead, use newChan  to create a SendPort. sCThe ID of the process that will receive messages sent on this port t Process-local ID of the channel vThe Cloud Haskell v type yLocal process state $Processes running on our local node Local node state  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 Apply two static values  Co-monadic  duplicate for static values )Turn any serialiable term into a message Serialize a message Deserialize a message  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./012345 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~yz{|}~vwxuqrstoplmnhkjidgfebc`a]^_[\WXYZSTUVQROPMNKLIJGHAFEDCB?@=>;<9:785634/012%.-,+*)('&"#$ !S !"#$% .-,+*)('&/0123456789:;<=>?@AFEDCBGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdgfehkjilmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./012345NoneICreate 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 . ESerialization dictionary for a function argument (see module header) NoneStatic version of 6 Static version of 7 Static version of 8 Static version of 9 Static version of (:) Static version of  Static version of  Static version of () Static version of '()' Serialization dictionary for '()' Serialization dictionary for  Serialization dictionary for l 9Static decoder, given a static serialization dictionary. See module documentation of #Control.Distributed.Process.Closure for an  example. 'Convert a static value into a closure. -Convert a serializable value into a closure.  NoneCreate a closure If  f : T1 -> T2 is a  monomorphic function  then  $(mkClosure 'f) :: T1 -> Closure T2.  Be sure to pass f to  remotable.  None"" None NoneDeconstructor for v# (not exported to the public API)  None) 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) "Catch exceptions within a process 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 3 message >Named send to a process in the local registry (asynchronous) <Named send to a process in a remote registry (asynchronous) Deserialize a closure +;***;None'CP a b'6 represents the closure of a process parameterized by a and  returning b. 'CP a b'( forms a (restricted) generalized arrow  ( +http://www.cs.berkeley.edu/~megacz/garrows/)  introduction form  elimination form  Identity (` version of <) Left-to-right composition (` version of =) First Second  Split (Like ) Left cancellation Right cancellation Closure version of  Closure version of  Closure version of  Closure version of  Closure version of  Not-quite-monadic < Not-quite-monadic bind (>)  Monadic sequencing (?)     None)[\ )[\ None Initialize a new local node. JNote that proper Cloud Haskell initialization and configuration is still  to do.  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                 NoneSpawn a process 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 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 h and return  the corresponding l. U34567ABCDEFGHIJKLMNOPQRS]`bhlnqsvXvqsshlnn7KLIJGHSQROPMNAFEDCB`b]3456@ !"#$%&'()*+,-./01234567789::;<=>?@ABCDEFFGHIIJJKKLLMMNNOOPQRSTUVVWWXXYYZZ[[\\]^__`abbccdeeffghigjklmnnoppqqrstuuvwwxyz{||}~          !"#$%&'()*+,-./01234356 789:;<=distributed-process-0.2.1,Control.Distributed.Process.Internal.Dynamic3Control.Distributed.Process.Internal.Closure.Static/Control.Distributed.Process.Internal.Closure.CP(Control.Distributed.Process.SerializableControl.Distributed.Process+Control.Distributed.Process.Internal.CQueue*Control.Distributed.Process.Internal.Types/Control.Distributed.Process.Internal.Closure.TH6Control.Distributed.Process.Internal.Closure.MkClosure-Control.Distributed.Process.Internal.MessageT7Control.Distributed.Process.Internal.Closure.Resolution)Control.Distributed.Process.Internal.Node/Control.Distributed.Process.Internal.Primitives Control.Distributed.Process.Node,Control.Distributed.Process.Internal.TypeRep Control.Arrowfirstsecond***#Control.Distributed.Process.Closureghc-primGHC.Prim unsafeCoerce# __remoteTablebaseGHC.Fingerprint.Type Fingerprinttransformers-0.3.0.0Control.Monad.IO.ClassliftIODynamictoDynfromDyn fromDynamic dynTypeRepdynApplydynAppdynBinddynBind' dynKleisli BlockSpecTimeoutBlocking NonBlockingCQueue newCQueueenqueuedequeue SerializableencodeFingerprintdecodeFingerprintsizeOfFingerprint fingerprintshowFingerprint MessageStatemessageLocalNode_messageConnectionsMessageT unMessageT ProcessSignal NamedSendRegisterWhereIsSpawnDied UnmonitorMonitorUnlinkLinkNCMsg ctrlMsgSender ctrlMsgSignal WhereIsReplyDidSpawnSpawnRef DidUnlinkPort DidUnlinkNodeDidUnlinkProcess DidUnmonitor DiedReason DiedUnknownId DiedNodeDownDiedDisconnect DiedException DiedNormalPortLinkExceptionNodeLinkExceptionProcessLinkExceptionPortMonitorNotificationNodeMonitorNotificationProcessMonitorNotification MonitorRefmonitorRefIdentmonitorRefCounterMessagemessageFingerprintmessageEncodingSerializableDict RemoteTable_remoteTableLabelsClosureStatic StaticLabelStaticDuplicate StaticApply ReceivePort ReceivePortRRReceivePortBiasedReceivePortSingleSendPort sendPortId TypedChannel SendPortIdsendPortProcessIdsendPortLocalIdLocalSendPortIdProcess unProcessLocalProcessState_monitorCounter _spawnCounter_channelCounter_typedChannels LocalProcess processQueue processId processState processThreadLocalNodeState_localProcesses_localPidCounter_localPidUnique LocalNode localNodeId localEndPoint localState localCtrlChan remoteTable IdentifierSendPortIdentifierProcessIdentifierNodeIdentifier ProcessId processNodeIdprocessLocalIdLocalProcessId lpidUnique lpidCounterNodeId nodeAddressnodeOfprocMsg staticApplystaticDuplicate staticTypeOftypeOfStaticLabel createMessagemessageToPayloadpayloadToMessagelocalProcesseslocalPidCounterlocalPidUniquelocalProcessWithIdmonitorCounter spawnCounterchannelCounter typedChannelstypedChannelWithIdremoteTableLabelsremoteTableLabel remotablemkStatic functionSDict staticConst staticFlip staticFst staticSnd staticCompose staticFirst staticSecond staticSplit staticUnit sdictUnitsdictProcessId sdictSendPort staticDecode staticClosure toClosure mkClosure runMessageT getLocalNode sendPayload sendBinary sendMessageresolveClosurerunLocalProcessProcessTerminationExceptionMatchsendexpectnewChansendChan receiveChanmergePortsBiased mergePortsRR receiveWaitreceiveTimeoutmatchmatchIf matchUnknown terminate getSelfPid getSelfNodelinkmonitorunlink unlinkNode unlinkPort unmonitorcatch expectTimeout spawnAsync monitorNode monitorPortlinkNodelinkPortsayregisterregisterRemote unregisterunregisterRemotewhereis whereisRemotewhereisRemoteAsyncnsend nsendRemote unClosureCPcpIntrocpElimcpIdcpCompcpFirstcpSecondcpSplit cpCancelL cpCancelRcpLinkcpUnlinkcpSendcpExpect cpNewChancpReturncpBindcpSeqinitRemoteTable newLocalNodecloseLocalNode runProcess forkProcessspawn spawnLink spawnMonitorcallspawnSupervised spawnChannel $fBinaryTyCon$fBinaryTypeRep$fBinaryFingerprint $fShowDynamic Data.MaybeNothing$fSerializableaGHC.BaseString GHC.Exception Exceptionbinary-0.5.1.0 Data.BinaryBinary$fBinaryWhereIsReply$fBinaryStaticLabel$fBinaryIdentifier$fBinarySendPortId$fBinaryDidSpawn$fBinaryClosure$fBinaryDiedReason$fBinaryProcessSignal$fBinaryMonitorRef $fBinaryNCMsg$fBinaryPortMonitorNotification$fBinaryNodeMonitorNotification"$fBinaryProcessMonitorNotification$fBinaryProcessId$fBinaryLocalProcessId$fExceptionPortLinkException$fExceptionNodeLinkException$fExceptionProcessLinkException $fShowMessage$fShowSendPortId$fShowIdentifier$fShowProcessId$fShowLocalProcessId $fShowNodeIdconstflip Data.Tuplefstsnd.&$fExceptionProcessTerminationExceptionreturn Control.Monad>=>>>=>>