".G      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B CDEFNone/05T]A generic input channel that can be read from in the same fashion as a typed channel (i.e.,  ReceivePort3). To read from an input stream in isolation, see  . To compose an @ with reads on a process' mailbox (and/or typed channels), see  . Wrap any Typeable datum in a PCopyK. We hide the constructor to discourage arbitrary uses of the type, since PCopy7 is a specialised and potentially dangerous construct. Matches on PCopy m and returns the m within. This potentially allows us to bypass serialization (and the type constraints it enforces) for local message passing (i.e., with UnencodedMessage$ data), since PCopy is just a shim. Given a raw Message, attempt to unwrap a Typeable datum from an enclosing PCopy wrapper. Matches on a TypedChannel (PCopy a).  Create a new .  Read from an . This is a blocking operation.  Constructs a Match for a given  InputChannel.GHIJK    GHIJK None /0569;<=TGenerates unique q for messages and response pairs. Each process that depends, directly or indirectly, on the call mechanisms in 'Control.Distributed.Process.Global.CallH should have at most one TagPool on which to draw unique message tags.WTags provide uniqueness for messages, so that they can be matched with their response.Introduces a class that brings NFData into scope along with Serializable, such that we can force evaluation. Intended for use with the UnsafePrimitives module (which wraps ,Control.Distributed.Process.UnsafePrimitives-), and guarantees evaluatedness in terms of NFData. Please note that we cannot guarantee that an NFData( instance will behave the same way as a Binaryc one with regards evaluation, so it is still possible to introduce unexpected behaviour by using unsafe primitives in this way.?Create a new per-process source of unique message identifiers. Extract a new identifier from a .$Given when a server is unobtainable. (A simple means of mapping to a receiver.%?Class of things that you can route/send serializable message to&+Send a message to the target asynchronously' Send some NFDataB message to the target asynchronously, forcing evaluation (i.e., deepseq ) beforehand.(*Class of things that can be resolved to a L.)*Resolve the reference to a process id, or Nothing if resolution fails* Unresolvable  Addressable Message+;Class of things that can be killed (or instructed to exit).,/Kill (instruct to exit) generic process, using M primitive.-/Kill (instruct to exit) generic process, using N primitive..Class of things to which a Process can link itself./ Create a link with the supplied object.0 Provides a reason for process termination.1indicates normal exit2normal response to a 43abnormal (error) shutdown4 A ubiquitous shutdown signalm that can be used to maintain a consistent shutdown/stop protocol for any process that wishes to handle it.6DUsed internally in whereisOrStart. Sent as (RegisterSelf,ProcessId).8#Simple representation of a channel.9Wait cancellation message.<A synchronous version of O, this relies on P8 to perform the relevant monitoring of the remote node.=Tresolve the Resolvable or die with specified msg plus details of what didn't resolveB !"#$%&'()*+,-./0123456789:QRS;<T=>?@ABCDEFGHIJKLMNOPQRS% !"#$%&'()*+,-./0312456789:;<=%./+,-()*%&'$ !"#67<=9:8450123;1 !"#$%&'()*+,-./0123456789:QRS;<T=>?@ABCDEFGHIJKLMNOPQRS,(c) Tim Watson, Jeff Epstein, Alan ZimmermanBSD3 (see the file LICENSE) Tim Watson experimental#non-portable (requires concurrency)None05b)Send to a process when a timeout expires.d Represents a timeout! in terms of microseconds, where U stands for infinity and Just 0 , no-delay.eRepresents either a delay of i5, an infinite wait or no delay (i.e., non-blocking).iA time interval.j)Defines the time unit for a Timeout valueqconverts the supplied  TimeInterval to microsecondsr&Convenience for making timeouts; e.g., ?receiveTimeout (after 3 Seconds) [ match (\"ok" -> return ()) ]sConvenience for making i; e.g., "let ti = within 5 Seconds in .....tgiven a number, produces a  TimeInterval of microsecondsugiven a number, produces a  TimeInterval of millisecondsvgiven a number, produces a  TimeInterval of secondswgiven a number, produces a  TimeInterval of minutesxgiven a number, produces a  TimeInterval of hoursyconverts the supplied TimeUnit to microsecondszConstructs an inifinite d.{Constructs a no-wait d|Sends the calling process TimeoutNotification tag after time microseconds}given a  TimeInterval, provide an equivalent NominalDiffTim~given a NominalDiffTim, provide an equivalent  TimeInterval@given a Delay, provide an equivalent NominalDiffTimgiven a NominalDiffTim, provide an equivalent Delay@ Create a V from a number of microseconds.Allow (+) and (-) operations on DelaysAllow (+) and (-) operations on  TimeIntervals/bcdefghiWjklmnopqrstuvwxyXYZ[\z{|}~ bcdefghijklmnopqrstuvwxyz{|}~ tuvwxqrsyijklmnopefgh}~dbc|z{$bcdefghiWjklmnopqrstuvwxyXYZ[\z{|}~(c) Tim Watson 2013BSD3 (see the file LICENSE)%Tim Watson <watson.timothy@gmail.com> experimental#non-portable (requires concurrency)NoneCreate an unencoded Message for any  Serializable type.(c) Tim Watson 2012BSD3 (see the file LICENSE)%Tim Watson <watson.timothy@gmail.com> experimental#non-portable (requires concurrency)None05M represents a tick event that timers can generate]#cancellation message sent to timersan opaque reference to a timerblocks the calling Process for the specified TimeInterval. Note that this function assumes that a blocking receive is the most efficient approach to acheiving this, however the runtime semantics (particularly with regards scheduling) should not differ from threadDelay in practise.Literate way of saying sleepFor 3 Seconds.nstarts a timer which sends the supplied message to the destination process after the specified time interval.*runs the supplied process action(s) after t has elapsedcalls exit pid reason after t has elapsed"kills the specified process after t has elapsedstarts a timer that repeatedly sends the supplied message to the destination process each time the specified time interval elapses. To stop messages from being sent in future,  can be called.?runs the supplied process action(s) repeatedly at intervals of tresets a running timer. Note: Cancelling a timer does not guarantee that all its messages are prevented from being delivered to the target process. Also note that resetting an ongoing timer (started using the  or  functions) will only cause the current elapsed period to time out, after which the timer will continue running. To stop a long-running timer permanently, you should use  instead.permanently cancels a timercancels a running timer and flushes any viable timer messages from the process' message queue. This function should only be called by the process expecting to receive the timer's messages!sets up a timer that sends  repeatedly at intervals of t^_]`ab^_]`ab(c) Tim Watson 2012 - 2013BSD3 (see the file LICENSE)%Tim Watson <watson.timothy@gmail.com> experimentalSafe cde cdeSafe/ <(c) Tim Watson 2013, Parallel Scientific (Jeff Epstein) 2012BSD3 (see the file LICENSE)None /059;<=T  Monitor any  Resolvable object.Apply the supplied expression n timesLike  but sans space leakSpawn a new (local) process. This variant takes an initialisation action and a secondary expression from the result of the initialisation to  Process ()=. The spawn operation synchronises on the completion of the beforeT action, such that the calling process is guaranteed to only see the newly spawned  ProcessId5 once the initialisation has successfully completed.Node local version of f8. Note that this is just the sequential composition of g and h. (The Unified\ semantics that underlies Cloud Haskell does not even support a synchronous link operation)Like #, but monitors the spawned process.CH's h primitive, unlike Erlang's, will trigger when the target process dies for any reason. This function has semantics like Erlang's: it will trigger i& only when the target dies abnormally.Returns the pid of the process that has been registered under the given name. This refers to a local, per-node registration, not globalx registration. If that name is unregistered, a process is started. This is a handy way to start per-node named servers.A remote equivalent of . It deals with the node registry on the given node, and the process, if it needs to be started, will run on that node. If the node is inaccessible, Nothing will be returned.An alternative to jI that allows both predicate and action to be expressed in one parameter.?Safe (i.e., monitored) waiting on an expected response/message.klmn$%&'()*+,-./<$%&'()*./+,-<klmn Safe!"9;ATOpaque type of MultiMaps.dClass of things that can be inserted in a map or a set (of mapped values), for which instances of Eq and Hashable must be present.oO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).pqo pqo None3 !"#$%&'()*+,-./03124589:.$()*%&'./+,- !"#4501239:8 +(c) Parallel Scientific (Jeff Epstein) 2012BSD3 (see the file LICENSE)None0T!Sends a message of type a to the given process, to be handled by a corresponding callResponse... function, which will send back a message of type b. The tag is per-process unique identifier of the transaction. If the timeout expires or the target process dies, Nothing will be returned.Like C, but with no timeout. Returns Nothing if the target process dies.Like I, but sends the message to multiple recipients and collects the results.+Produces a Match that can be used with the r) family of message-receiving functions.  callResponse. will respond to a message of type a sent by *, and will respond with a value of type b.+Produces a Match that can be used with the ra family of message-receiving functions. When calllForward receives a message of type from from  (and similar), it will forward the message to another process, who will be responsible for responding to it. It is the user's responsibility to ensure that the forwarding process is linked to the destination process, so that if it fails, the sender will be notified.The message handling code is started in a separate thread. It's not automatically linked to the calling thread, so if you want it to be terminated when the message handling thread dies, you'll need to call link yourself.stuvwxyz{|} stuvwxyz{|} (c) Tim Watson 2013 - 2014BSD3 (see the file LICENSE)%Tim Watson <watson.timothy@gmail.com> experimental#non-portable (requires concurrency)None05VSent to subscribing processes when a dis-connection (from a remote node) is detected.RSent to subscribing processes when a connection (from a remote node) is detected.The  MxAgentId for the node monitoring agent.Start monitoring node connection/disconnection events. When a connection event occurs, the calling process will receive a message  NodeUp NodeId: in its mailbox. When a disconnect occurs, the corollary NodeDown NodeId# message will be delivered instead.No guaranatee is made about the timeliness of the delivery, nor can the receiver expect that the node (for which it is being notified) is still upconnected or downUdisconnected at the point when it receives a message from the node monitoring agent.Stop monitoring node connection/disconnection events. This does not flush the caller's mailbox, nor does it guarantee that any/all node up/down notifications will have been delivered before it is evaluated.-Starts the node monitoring agent. No call to  monitorNodes and unmonitorNodesN will have any effect unless the agent is already running. Note that we make no guarantees what-so-everN about the timeliness or ordering semantics of node monitoring notifications.~~ (c) Tim Watson 2013 - 2014BSD3 (see the file LICENSE)%Tim Watson <watson.timothy@gmail.com> experimental#non-portable (requires concurrency)None 059;<IMT',Start a system logger that writes to a file. This is a  very basic" file logging facility, that uses regular buffered file I/O (i.e., System.IO.hPutStrLne et al) under the covers. The handle is closed appropriately if/when the logging process terminates.See :Control.Distributed.Process.Management.mxAgentWithFinalizeA for futher details about management agents that use finalizers.(Start a  system logger process as a management agent.G      !"#$%&'('This expression does the actual logging1An expression used to clean up any residual state The initial  to use2An expression used to format logging messages/text)*+,-./01234567!      !"#$%&'(!     (&' !"#$%0      !"#$%&'()*+,-./01234567SafeATC Opaque lock. Take a lock. Release lock.D=Create exclusive lock. Only one process could take such lock.ETCreate quantity lock. A fixed number of processes can take this lock simultaniously.FRun action under a held lock.CDEFCDEFCDEFCDEF !"#$%&'()*+,-../0123456789:;<=>?@ABCCDDEFFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnnoppqrstuvwxyz{|}~G   G                                      ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?@ABCDDEFGHIGJKGJLGJMGNOPQRSTUVWXYsZ[\]^_``abcdGNeGNfGJgGHhGJijklm n o pGJq r r s s t u v w x y z { { | |  }  ~                   @7distributed-process-extras-0.3.0-5ahGQKqOeCgGhiWMTfJvHl2Control.Distributed.Process.Extras.Internal.Unsafe1Control.Distributed.Process.Extras.Internal.Types'Control.Distributed.Process.Extras.Time3Control.Distributed.Process.Extras.UnsafePrimitives(Control.Distributed.Process.Extras.Timer6Control.Distributed.Process.Extras.Internal.Queue.SeqQ;Control.Distributed.Process.Extras.Internal.Queue.PriorityQ6Control.Distributed.Process.Extras.Internal.Primitives?Control.Distributed.Process.Extras.Internal.Containers.MultiMap"Control.Distributed.Process.Extras'Control.Distributed.Process.Extras.Call-Control.Distributed.Process.Extras.Monitoring,Control.Distributed.Process.Extras.SystemLogControl.Concurrent.Utils Control.Monadforever InputStreamNullPCopyInvalidBinaryShimpCopymatchPpUnwrap matchChanPnewInputStreamreadInputStreammatchInputStream$fNFDataNullInputStream$fBinaryNullInputStream $fBinaryPCopy $fNFDataPCopy$fShowInvalidBinaryShim$fEqInvalidBinaryShim$fGenericPCopy$fGenericNullInputStream$fShowNullInputStream$fEqNullInputStreamTagPoolTagNFSerializable newTagPoolgetTag$fNFSerializableMessage$fNFSerializableSendPort$fNFSerializableProcessIdServerDisconnected RecipientPid RegisteredRemoteRegistered AddressableRoutablesendTo unsafeSendTo ResolvableresolveunresolvableMessageKillablekillProcexitProcLinkablelinkTo ExitReason ExitNormal ExitShutdown ExitOtherShutdown RegisterSelfChannel CancelWait __remoteTable whereisRemote resolveOrDie$fNFDataServerDisconnected$fBinaryServerDisconnected$fRoutableRecipient$fResolvableRecipient$fNFDataRecipient$fBinaryRecipient$fAddressableProcessId$fRoutable(->) $fRoutable(,) $fRoutable[]$fRoutableProcessId$fResolvable(,)$fResolvable[]$fResolvableProcessId$fNFDataExitReason$fBinaryExitReason$fNFDataShutdown$fBinaryShutdown$fNFDataRegisterSelf$fBinaryRegisterSelf$fNFDataCancelWait$fBinaryCancelWait$fEqCancelWait$fShowCancelWait$fGenericCancelWait$fGenericRegisterSelf$fGenericShutdown$fShowShutdown $fEqShutdown$fGenericExitReason$fEqExitReason$fShowExitReason$fGenericRecipient$fShowRecipient $fEqRecipient$fGenericServerDisconnectedTimeoutNotificationTimeoutDelayInfinityNoDelay TimeIntervalTimeUnitDaysHoursMinutesSecondsMillisMicros asTimeoutafterwithin microSeconds milliSecondssecondsminuteshours timeToMicros infiniteWaitnoWaittimeouttimeIntervalToDiffTimediffTimeToTimeIntervaldelayToDiffTimediffTimeToDelaymicrosecondsToNominalDiffTime $fNumDelay$fNumTimeInterval$fBinaryTimeoutNotification $fNFDataDelay $fBinaryDelay$fNFDataTimeInterval$fBinaryTimeInterval$fNFDataTimeUnit$fBinaryTimeUnit$fGenericTimeUnit $fEqTimeUnit$fShowTimeUnit$fGenericTimeInterval$fEqTimeInterval$fShowTimeInterval$fGenericDelay $fEqDelay $fShowDelaysendnsend sendToAddrsendChan wrapMessageTickTimerRefsleepsleepFor sendAfterrunAfter exitAfter killAfter startTimer periodically resetTimer cancelTimer flushTimerticker$fNFDataSleepingPill$fBinarySleepingPill$fNFSerializableTick $fNFDataTick $fBinaryTick$fNFSerializableTimerConfig$fNFDataTimerConfig$fBinaryTimerConfig$fGenericTimerConfig$fEqTimerConfig$fShowTimerConfig $fGenericTick$fEqTick $fShowTick$fGenericSleepingPill$fEqSleepingPill$fShowSleepingPillSeqQemptyisEmpty singletonenqueuedequeuepeek$fEqSeqQ $fShowSeqQ PriorityQqmonitor awaitExitdeliverisProcessAlivetimesforever'spawnSignalledspawnLinkLocalspawnMonitorLocal linkOnFailurewhereisOrStartwhereisOrStartRemote matchCond awaitResponseMultiMap Insertableinsertmemberlookupfilter filterWithKeytoList$fFoldableMultiMap $fInsertablea callTimeoutcallAt multicall callResponsecallResponseDeferIfcallResponseDefer callForwardcallResponseAsynccallResponseIf$fBinaryMulticallResponse$fBinaryMulticall$fEqMulticallResponseTypeNodeDownNodeUpnodeMonitorAgentId monitorNodesunmonitorNodes nodeMonitor$fNFDataNodeDown$fBinaryNodeDown$fNFDataNodeUp$fBinaryNodeUp$fNFDataUnRegister$fBinaryUnRegister$fNFDataRegister$fBinaryRegister$fGenericRegister$fGenericUnRegister$fGenericNodeUp $fShowNodeUp$fGenericNodeDown$fShowNodeDownLogger logMessageToLogtoLog LogClientLogTextLogChan LogFormatLogLevelDebugInfoNoticeWarningErrorCriticalAlert EmergencymxLogId logChannelreportclientdebuginfonoticewarningerrorcriticalalert emergencysendLog addFormatter systemLogFile systemLog$fLoggerLogChan$fLoggerLogClient$fToLogMessage $fToLog[]$fRoutableLogClient$fResolvableLogClient$fNFSerializable[]$fRoutableLogChan$fNFDataLogMessage$fBinaryLogMessage$fBinaryAddFormatter$fNFDataSetLevel$fBinarySetLevel$fNFDataLogLevel$fBinaryLogLevel$fGenericLogLevel $fEqLogLevel$fReadLogLevel$fShowLogLevel $fOrdLogLevel$fEnumLogLevel$fGenericSetLevel$fGenericAddFormatter$fNFDataAddFormatter$fGenericLogMessage$fShowLogMessageLockmkExclusiveLockmkQLockwithLockNullInputStreamReadChanReadSTM0distributed-process-0.6.6-GjAZoVDZxQXFMkc98xdpl1*Control.Distributed.Process.Internal.Types ProcessId/Control.Distributed.Process.Internal.Primitiveskillexitwhereis*Control.Distributed.Process.Internal.Spawncallwhereis__staticwhereis__sdictwhereis__tdictbaseAddressableErrorMessagebaseGHC.BaseNothing time-1.6.0.1Data.Time.Clock.UTCNominalDiffTime hoursPerDayminutesPerHoursecondsPerMinutemilliSecondsPerSecondmicroSecondsPerSecond TimerConfig SleepingPillResetCancelrunTimergetR spawnLinkspawnlinkProcessLinkExceptionmatchIf registerSelfregisterSelf__staticregisterSelf__sdictregisterSelf__tdict foldrWithKeyMhmap receiveWaitMulticallResponse MulticallMulticallResponseTypeMulticallAcceptMulticallForwardMulticallRejectcallResponseImpl maybeTimeoutmention UnRegisterRegisteragentLogChanT LogMessageLogDataLogStateoutputcleanup_level_format _formatters AddFormatterSetLevellogProcessNamebasicDataFormatlevelformat formattersacquirerelease