!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                    None Strict list Reverse a strict list  reverseStrict' xs ys is 'reverse xs ++ ys' if they were lists     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   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.  None    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 !"#$%&'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 0*Show fingerprint (for debugging purposes) )*+,-./0 )*+,-./0 ),-/.0*+)*+,-./0None:1$Signals to the node controller (see ;) ; Messages to the node controller ?(Asynchronous) reply from whereis A(Asynchronius) reply from spawn CC. are used to return pids of spawned processes E%(Asynchronous) reply from unlinkPort G%(Asynchronous) reply from unlinkNode I!(Asynchronous) reply from unlink K$(Asynchronous) reply from unmonitor MWhy did a process die? NInvalid (processnodechannel) identifier OThe process node died P*We got disconnected from the process node Q%The process exited with an exception  (provided as  because  does not implement ) RNormal termination S3Exception thrown when a linked channel (port) dies U)Exception thrown when a linked node dies W-Exceptions thrown when a linked process dies Y(Message sent by channel (port) monitors [Message sent by node monitors ]!Message sent by process monitors _:MonitorRef is opaque for regular Cloud Haskell processes a!ID of the entity to be monitored bDUnique to distinguish multiple monitor requests by the same process cAMessages consist of their typeRep fingerprint and their encoding g6The receive end of a typed channel (not serializable) h+A round-robin combination of receive ports i,A left-biased combination of receive ports jA single receive port k0The send send of a typed channel (serializable) m"The (unique) ID of this send port p+A send port is identified by a SendPortId. 7You cannot send directly to a SendPortId; instead, use newChan  to create a SendPort. rCThe ID of the process that will receive messages sent on this port s Process-local ID of the channel uThe Cloud Haskell u type xLocal 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 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 u# (not exported to the public API) )Turn any serialiable term into a message Serialize a message Deserialize a message 123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./01234123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~xyz{|}uvwtpqrsnoklmgjihcdef_`ab]^[\YZWXUVSTMRQPONKLIJGHEFCDAB?@;<=>1:98765432H1 :98765432;<=>?@ABCDEFGHIJKLMRQPONSTUVWXYZ[\]^_`abcdefgjihklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./01234 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) 5656 None7 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 #Match against an arbitrary message "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 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 O 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  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) 7 Remove a monitor (asynchronous) Link to a node (asynchronous) !Link to a channel (asynchronous) 8%Remove a process link (asynchronous) 9"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). ?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). !Query the local process registry /Query a remote process registry (asynchronous) !Reply will come in the form of a ? 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 1 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. 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 sendport. See  for more information. ;Monitor a processnodechannel <Link to a processnodechannel A=>789:?@;<ANothing for the local node Message to send B55<=>789:?@;<AB 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 k  version of   version of ()  version of   version of () (Not quite the)  version of ()  version of   version of   version of   version of   version of  CDCD None Initialize a new local node. E@Create a new local node (without any service processes running) F4Start 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 G Unified: Table 8 H,Check if a process is local to our own node ILookup a local closure J6Check if an identifier refers to a valid local object KsplitNotif 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 6 * the notifications for processes on that node, and D * the notifications for typed channels to processes on that node. Similarly, if ident refers to a process, the should trigger set will  include 6 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. LModify and evaluate the state ;MNOPQRSTUVWXYZ[\]^E_F`abcdefghWho' s watching? Who's being watched?  to link ijklmnopWho to notify?  Who died? How did they die?  for linking GHIJqrstuvwxyzKL.MNOPQRSTUVWXY]\[Z^E_F`abcdefghijklmnopGHIJqrstuvwxyzKLNoneSpawn 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 g and return  the corresponding k. "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      c?@ABCMNOPQRSTUVWXYZ[\]^_gkmpru     fuprrgkmm CWXUVST_]^[\YZMRQPON?@    AB      NoneICreate the closure, decoder, and metadata definitions for the given list  of functions Like 5, 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 = ...  |]  ] 7 creates the function specified as well as the various ' dictionaries and static versions that  also creates.  8 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 $(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 . {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 3The name of a type variable binding occurrence {|}~{|}~None*+*+ !"#$%#$&#$'#$()*+,-./0123456789:;<<=>?@ABCDEFGHIJKLMNOOPQRSTUVWXYZ[\]^__`abbccddeeffgghhijklmnooppqqrrssttuuvwxxyz{|}~                                4I   !"#$%&'()*+,-./0123456789: ; < = > ? @ A B  C D E F G H I J K L M N O P Q Q R S S T U V W W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~          distributed-process-0.4.0(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.Messaging/Control.Distributed.Process.Internal.Primitives4Control.Distributed.Process.Internal.Closure.BuiltIn Control.Distributed.Process.Node/Control.Distributed.Process.Internal.Closure.THSystem.IO.UnsafeunsafePerformIOControl.Exceptioncatchmask onExceptionbracketbracket_finallyControl.Categoryid Control.Arrow*** Control.Monadreturn>>>>=#Control.Distributed.Process.ClosurebaseGHC.Fingerprint.Type Fingerprintdistributed-static-0.2.1Control.Distributed.StaticclosureStatic RemoteTableClosuretransformers-0.3.0.0Control.Monad.IO.ClassliftIO StrictListNilConslengthreversereverse'mapMaybe mapDefaultTQueue newTQueue newTQueueIO writeTQueue readTQueue tryReadTQueue isEmptyTQueue mkWeakTQueue StrictMVar newEmptyMVarnewMVartakeMVarputMVarwithMVar modifyMVar_ modifyMVar mkWeakMVar BlockSpecTimeoutBlocking NonBlockingCQueue newCQueueenqueuedequeue mkWeakCQueue 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 processWeakQ processId processState processThread processNodeLocalNodeState_localProcesses_localPidCounter_localPidUnique_localConnectionsImplicitReconnectNoImplicitReconnectWithImplicitReconnect LocalNode localNodeId localEndPoint localState localCtrlChan remoteTable IdentifierSendPortIdentifierProcessIdentifierNodeIdentifier ProcessId processNodeIdprocessLocalIdLocalProcessId lpidUnique lpidCounterNodeId nodeAddressnodeOffirstNonReservedProcessId nullProcessIdrunLocalProcess createMessagemessageToPayloadpayloadToMessagelocalProcesseslocalPidCounterlocalPidUniquelocalConnectionslocalProcessWithIdlocalConnectionBetweenmonitorCounter spawnCounterchannelCounter typedChannelstypedChannelWithId sendPayload sendBinary sendMessage disconnectcloseImplicitReconnectionsimpliesDeathOfProcessTerminationExceptionAbstractMessageforwardMatchsendexpectnewChansendChan receiveChanmergePortsBiased mergePortsRR receiveWaitreceiveTimeoutmatchmatchIfmatchAny matchUnknown terminate getSelfPid getSelfNodelinkmonitorunlink unlinkNode unlinkPort unmonitor expectTimeout spawnAsync monitorNode monitorPortlinkNodelinkPortsayregisterregisterRemote unregisterunregisterRemotewhereiswhereisRemoteAsyncnsend nsendRemoteunStatic unClosure reconnect reconnectPortCP staticDecode sdictUnitsdictProcessId sdictSendPort sndStaticidCPsplitCPreturnCPseqCPbindCPcpLinkcpUnlinkcpSendcpExpect cpNewChaninitRemoteTable newLocalNodecloseLocalNode runProcess forkProcessspawn spawnLink spawnMonitorcallspawnSupervised spawnChannel spawnLocalspawnChannelLocal remotable remotableDeclmkStatic functionSDict functionTDict mkClosure GHC.Conc.Sync atomicallyghc-prim GHC.TypesTrue $fEqTQueue Data.MaybeNothing$fSerializableaGHC.BaseString GHC.Exception Exceptionbinary-0.5.1.1 Data.BinaryBinary$fBinaryWhereIsReply$fBinaryIdentifier$fBinarySendPortId$fBinaryDidSpawn$fBinaryDiedReason$fBinaryProcessSignal$fBinaryMonitorRef $fBinaryNCMsg$fBinaryPortMonitorNotification$fBinaryNodeMonitorNotification"$fBinaryProcessMonitorNotification$fBinaryProcessId$fBinaryLocalProcessId$fExceptionPortLinkException$fExceptionNodeLinkException$fExceptionProcessLinkException $fShowMessage$fShowSendPortId$fShowIdentifier$fShowProcessId $fShowNodeIdsetupConnBetween connBetweenunmonitorAsync unlinkAsyncunlinkNodeAsyncunlinkPortAsyncmonitor'link'unMatchgetMonitorRefFor getSpawnRef sendCtrlMsg&$fExceptionProcessTerminationExceptionreturnProcessStaticdecodeProcessIdStaticcreateBareLocalNodestartServiceProcessesdestNidisLocalisValidLocalIdentifier splitNotifmodify'NCunNCNCState_links _monitors _registryConnectionState _incoming _incomingFromIncomingTargetToNodeToChanToProcUninitIncomingConnectionforever'initConnectionStateincoming incomingAt incomingFromhandleIncomingMessagesrunNodeController initNCStatenodeControllerncEffectMonitorncEffectUnlinkncEffectUnmonitor ncEffectDied ncEffectSpawnncEffectRegisterncEffectWhereIsncEffectNamedSend notifyDied postAsMessage postMessagethrowException withLocalProclinksmonitorsregistrylinksFor monitorsFor registryForcreateMetaData monomorphizegenerateStatic generateDictcomposestringEgetTypesfnDtemplate-haskellLanguage.Haskell.TH.LibfunD tyVarBndrName generateDefs staticName sdictName tdictName