-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | monad-control style typeclass and transformer instances for Process monad.
--   
--   This package provides typeclasses and functions for lifting functions
--   and control operations (such as spawnLocal) from the <tt>Process</tt>
--   monad into transformer stacks based on the Process monad. It uses
--   <a>MonadTransControl</a> and a new typeclass
--   <a>Control.Distributed.Process.Lifted.Class.MonadProcessBase</a> which
--   plays the same role as <a>MonadBaseControl</a>. Instances are provided
--   for all the <a>transformers</a> types - so stacks based on any of
--   these (e.g. <tt>ReaderT Config Process a</tt>) can be used seamlessly.
--   
--   The Control.Distributed.Process.Lifted module exports all the same
--   symbols as found in Control.Distributed.Process, but they are all
--   generalized. Where appropriate it re-exports the more general
--   functions from lifted-base (e.g. catch) rather than the versions
--   re-implemented for <tt>Process</tt>.
@package distributed-process-lifted
@version 0.3.0.1

module Control.Distributed.Process.Lifted.Class

-- | A class into instances of which Process operations can be lifted;
--   similar to MonadIO or MonadBase.
class (Monad m, MonadIO m, MonadBase IO m, MonadBaseControl IO m) => MonadProcess m

-- | lift a base <a>Process</a> computation into the current monad
liftP :: MonadProcess m => Process a -> m a

-- | A Clone of <a>MonadBaseControl</a> specialized to the Process monad.
--   This uses the <a>MonadTransControl</a> typeclass for transformer
--   default instances, so the core wrapping/unwrapping logic is not
--   duplicated. This class is needed because the MonadBaseControl instance
--   for Process has IO as the base.
class (MonadProcess m) => MonadProcessBase m where {
    type family StMP m a :: *;
}
liftBaseWithP :: MonadProcessBase m => (RunInBaseP m -> Process a) -> m a
restoreMP :: MonadProcessBase m => StMP m a -> m a

-- | A clone of <a>RunInBase</a> for MonadProcessBase.
type RunInBaseP m = forall a. m a -> Process (StMP m a)

-- | A clone of <a>ComposeSt</a> for MonadProcessBase.
type ComposeStP t m a = StMP m (StT t a)

-- | A clone of <a>RunInBaseDefault</a> for MonadProcessBase.
type RunInBaseDefaultP t m = forall a. t m a -> Process (ComposeStP t m a)

-- | A clone of <a>defaultLiftBaseWith</a> for MonadProcessBase. This
--   re-uses the MonadTransControl typeclass the same way as the original;
--   core wrapping/unwrapping logic for each transformer type is not
--   duplicated.
defaultLiftBaseWithP :: (MonadTransControl t, MonadProcessBase m) => (RunInBaseDefaultP t m -> Process a) -> t m a

-- | A clone of <a>defaultRestoreMP</a> for MonadProcessBase. This re-uses
--   the MonadTransControl typeclass the same way as the original; core
--   wrapping/unwrapping logic for each transformer type is not duplicated.
defaultRestoreMP :: (MonadTransControl t, MonadProcessBase m) => ComposeStP t m a -> t m a

-- | A clone of <a>control</a> for MonadProcessBase.
controlP :: MonadProcessBase m => (RunInBaseP m -> Process (StMP m a)) -> m a

-- | A clone of <a>liftBaseDiscard</a> for MonadProcessBase.
liftBaseDiscardP :: MonadProcessBase m => (Process () -> Process a) -> m () -> m a
instance Control.Distributed.Process.Lifted.Class.MonadProcessBase m => Control.Distributed.Process.Lifted.Class.MonadProcessBase (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Distributed.Process.Lifted.Class.MonadProcessBase m => Control.Distributed.Process.Lifted.Class.MonadProcessBase (Control.Monad.Trans.Maybe.MaybeT m)
instance Control.Distributed.Process.Lifted.Class.MonadProcessBase m => Control.Distributed.Process.Lifted.Class.MonadProcessBase (Control.Monad.Trans.List.ListT m)
instance Control.Distributed.Process.Lifted.Class.MonadProcessBase m => Control.Distributed.Process.Lifted.Class.MonadProcessBase (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Distributed.Process.Lifted.Class.MonadProcessBase m => Control.Distributed.Process.Lifted.Class.MonadProcessBase (Control.Monad.Trans.State.Strict.StateT s m)
instance Control.Distributed.Process.Lifted.Class.MonadProcessBase m => Control.Distributed.Process.Lifted.Class.MonadProcessBase (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Distributed.Process.Lifted.Class.MonadProcessBase m => Control.Distributed.Process.Lifted.Class.MonadProcessBase (Control.Monad.Trans.Except.ExceptT e m)
instance (GHC.Base.Monoid w, Control.Distributed.Process.Lifted.Class.MonadProcessBase m) => Control.Distributed.Process.Lifted.Class.MonadProcessBase (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance (GHC.Base.Monoid w, Control.Distributed.Process.Lifted.Class.MonadProcessBase m) => Control.Distributed.Process.Lifted.Class.MonadProcessBase (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monoid w, Control.Distributed.Process.Lifted.Class.MonadProcessBase m) => Control.Distributed.Process.Lifted.Class.MonadProcessBase (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance (GHC.Base.Monoid w, Control.Distributed.Process.Lifted.Class.MonadProcessBase m) => Control.Distributed.Process.Lifted.Class.MonadProcessBase (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance Control.Distributed.Process.Lifted.Class.MonadProcessBase Control.Distributed.Process.Internal.Types.Process
instance Control.Distributed.Process.Lifted.Class.MonadProcess Control.Distributed.Process.Internal.Types.Process
instance Control.Distributed.Process.Lifted.Class.MonadProcess m => Control.Distributed.Process.Lifted.Class.MonadProcess (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Distributed.Process.Lifted.Class.MonadProcess m => Control.Distributed.Process.Lifted.Class.MonadProcess (Control.Monad.Trans.Maybe.MaybeT m)
instance Control.Distributed.Process.Lifted.Class.MonadProcess m => Control.Distributed.Process.Lifted.Class.MonadProcess (Control.Monad.Trans.List.ListT m)
instance Control.Distributed.Process.Lifted.Class.MonadProcess m => Control.Distributed.Process.Lifted.Class.MonadProcess (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Distributed.Process.Lifted.Class.MonadProcess m => Control.Distributed.Process.Lifted.Class.MonadProcess (Control.Monad.Trans.State.Strict.StateT s m)
instance Control.Distributed.Process.Lifted.Class.MonadProcess m => Control.Distributed.Process.Lifted.Class.MonadProcess (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Distributed.Process.Lifted.Class.MonadProcess m => Control.Distributed.Process.Lifted.Class.MonadProcess (Control.Monad.Trans.Except.ExceptT e m)
instance (GHC.Base.Monoid w, Control.Distributed.Process.Lifted.Class.MonadProcess m) => Control.Distributed.Process.Lifted.Class.MonadProcess (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance (GHC.Base.Monoid w, Control.Distributed.Process.Lifted.Class.MonadProcess m) => Control.Distributed.Process.Lifted.Class.MonadProcess (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monoid w, Control.Distributed.Process.Lifted.Class.MonadProcess m) => Control.Distributed.Process.Lifted.Class.MonadProcess (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance (GHC.Base.Monoid w, Control.Distributed.Process.Lifted.Class.MonadProcess m) => Control.Distributed.Process.Lifted.Class.MonadProcess (Control.Monad.Trans.RWS.Lazy.RWST r w s m)

module Control.Distributed.Process.Lifted
(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d

-- | Generalized version of <a>spawnLocal</a>
spawnLocal :: (MonadProcessBase m) => m () -> m ProcessId

-- | Generalized version of <a>getSelfPid</a>
getSelfPid :: (MonadProcess m) => m ProcessId

-- | Generalized version of <a>expect</a>
expect :: (MonadProcess m) => forall a. Serializable a => m a

-- | Generalized version of <a>expectTimeout</a>
expectTimeout :: (MonadProcess m) => forall a. Serializable a => Int -> m (Maybe a)

-- | Generalized version of <a>register</a>
register :: (MonadProcess m) => String -> ProcessId -> m ()

-- | Generalized version of <a>whereis</a>
whereis :: (MonadProcess m) => String -> m (Maybe ProcessId)

-- | Generalized version of <a>catchesExit</a>
catchesExit :: forall m a. (MonadProcessBase m) => m a -> [ProcessId -> Message -> m (Maybe a)] -> m a

-- | Generalized version of <a>delegate</a>
delegate :: MonadProcess m => ProcessId -> (Message -> Bool) -> m ()

-- | Generalized version of <a>forward</a>
forward :: MonadProcess m => Message -> ProcessId -> m ()

-- | Generalized version of <a>getLocalNodeStats</a>
getLocalNodeStats :: MonadProcess m => m NodeStats

-- | Generalized version of <a>getNodeStats</a>
getNodeStats :: MonadProcess m => NodeId -> m (Either DiedReason NodeStats)

-- | Generalized version of <a>getProcessInfo</a>
getProcessInfo :: MonadProcess m => ProcessId -> m (Maybe ProcessInfo)

-- | Generalized version of <a>getSelfNode</a>
getSelfNode :: MonadProcess m => m NodeId

-- | Generalized version of <a>kill</a>
kill :: MonadProcess m => ProcessId -> String -> m ()

-- | Generalized version of <a>link</a>
link :: MonadProcess m => ProcessId -> m ()

-- | Generalized version of <a>linkNode</a>
linkNode :: MonadProcess m => NodeId -> m ()

-- | Generalized version of <a>linkPort</a>
linkPort :: MonadProcess m => SendPort a -> m ()

-- | Generalized version of <a>monitor</a>
monitor :: MonadProcess m => ProcessId -> m MonitorRef

-- | Generalized version of <a>monitorNode</a>
monitorNode :: MonadProcess m => NodeId -> m MonitorRef

-- | Generalized version of <a>receiveTimeout</a>
receiveTimeout :: MonadProcess m => Int -> [Match b] -> m (Maybe b)

-- | Generalized version of <a>receiveWait</a>
receiveWait :: MonadProcess m => [Match b] -> m b

-- | Generalized version of <a>reconnect</a>
reconnect :: MonadProcess m => ProcessId -> m ()

-- | Generalized version of <a>reconnectPort</a>
reconnectPort :: MonadProcess m => SendPort a -> m ()

-- | Generalized version of <a>registerRemoteAsync</a>
registerRemoteAsync :: MonadProcess m => NodeId -> String -> ProcessId -> m ()

-- | Generalized version of <a>relay</a>
relay :: MonadProcess m => ProcessId -> m ()

-- | Generalized version of <a>reregister</a>
reregister :: MonadProcess m => String -> ProcessId -> m ()

-- | Generalized version of <a>reregisterRemoteAsync</a>
reregisterRemoteAsync :: MonadProcess m => NodeId -> String -> ProcessId -> m ()

-- | Generalized version of <a>say</a>
say :: MonadProcess m => String -> m ()

-- | Generalized version of <a>spawn</a>
spawn :: MonadProcess m => NodeId -> Closure (Process ()) -> m ProcessId

-- | Generalized version of <a>spawnAsync</a>
spawnAsync :: MonadProcess m => NodeId -> Closure (Process ()) -> m SpawnRef

-- | Generalized version of <a>spawnLink</a>
spawnLink :: MonadProcess m => NodeId -> Closure (Process ()) -> m ProcessId

-- | Generalized version of <a>spawnMonitor</a>
spawnMonitor :: MonadProcess m => NodeId -> Closure (Process ()) -> m (ProcessId, MonitorRef)

-- | Generalized version of <a>spawnSupervised</a>
spawnSupervised :: MonadProcess m => NodeId -> Closure (Process ()) -> m (ProcessId, MonitorRef)

-- | Generalized version of <a>terminate</a>
terminate :: MonadProcess m => m a

-- | Generalized version of <a>unlink</a>
unlink :: MonadProcess m => ProcessId -> m ()

-- | Generalized version of <a>unlinkNode</a>
unlinkNode :: MonadProcess m => NodeId -> m ()

-- | Generalized version of <a>unlinkPort</a>
unlinkPort :: MonadProcess m => SendPort a -> m ()

-- | Generalized version of <a>unmonitor</a>
unmonitor :: MonadProcess m => MonitorRef -> m ()

-- | Generalized version of <a>unregister</a>
unregister :: MonadProcess m => String -> m ()

-- | Generalized version of <a>unregisterRemoteAsync</a>
unregisterRemoteAsync :: MonadProcess m => NodeId -> String -> m ()

-- | Generalized version of <a>whereisRemoteAsync</a>
whereisRemoteAsync :: MonadProcess m => NodeId -> String -> m ()

-- | Generalized version of <a>withMonitor</a>
withMonitor :: ProcessId -> (MonitorRef -> Process a) -> Process a

-- | Generalized version of <a>withMonitor_</a>
withMonitor_ :: MonadProcessBase m => ProcessId -> m a -> m a

-- | Generalized version of <a>call</a>
call :: (MonadProcess m, Serializable a) => Static (SerializableDict a) -> NodeId -> Closure (Process a) -> m a

-- | Generalized version of <a>catchExit</a>
catchExit :: (MonadProcessBase m, Show a, Serializable a) => m b -> (ProcessId -> a -> m b) -> m b

-- | Generalized version of <a>die</a>
die :: (MonadProcess m, Serializable a) => a -> m b

-- | Generalized version of <a>exit</a>
exit :: (MonadProcess m, Serializable a) => ProcessId -> a -> m ()

-- | Generalized version of <a>handleMessage</a>
handleMessage :: (MonadProcess m, Serializable a) => Message -> (a -> Process b) -> m (Maybe b)

-- | Generalized version of <a>handleMessageIf</a>
handleMessageIf :: (MonadProcess m, Serializable a) => Message -> (a -> Bool) -> (a -> Process b) -> m (Maybe b)

-- | Generalized version of <a>handleMessageIf_</a>
handleMessageIf_ :: (MonadProcess m, Serializable a) => Message -> (a -> Bool) -> (a -> Process ()) -> m ()

-- | Generalized version of <a>handleMessage_</a>
handleMessage_ :: (MonadProcess m, Serializable a) => Message -> (a -> Process ()) -> m ()

-- | Generalized version of <a>mergePortsBiased</a>
mergePortsBiased :: (MonadProcess m, Serializable a) => [ReceivePort a] -> m (ReceivePort a)

-- | Generalized version of <a>mergePortsRR</a>
mergePortsRR :: (MonadProcess m, Serializable a) => [ReceivePort a] -> m (ReceivePort a)

-- | Generalized version of <a>monitorPort</a>
monitorPort :: (MonadProcess m, Serializable a) => SendPort a -> m MonitorRef

-- | Generalized version of <a>newChan</a>
newChan :: (MonadProcess m, Serializable a) => m (SendPort a, ReceivePort a)

-- | Generalized version of <a>nsend</a>
nsend :: (MonadProcess m, Serializable a) => String -> a -> m ()

-- | Generalized version of <a>nsendRemote</a>
nsendRemote :: (MonadProcess m, Serializable a) => NodeId -> String -> a -> m ()

-- | Generalized version of <a>proxy</a>
proxy :: (MonadProcess m, Serializable a) => ProcessId -> (a -> Process Bool) -> m ()

-- | Generalized version of <a>receiveChan</a>
receiveChan :: (MonadProcess m, Serializable a) => ReceivePort a -> m a

-- | Generalized version of <a>receiveChanTimeout</a>
receiveChanTimeout :: (MonadProcess m, Serializable a) => Int -> ReceivePort a -> m (Maybe a)

-- | Generalized version of <a>send</a>
send :: (MonadProcess m, Serializable a) => ProcessId -> a -> m ()

-- | Generalized version of <a>sendChan</a>
sendChan :: (MonadProcess m, Serializable a) => SendPort a -> a -> m ()

-- | Generalized version of <a>spawnChannel</a>
spawnChannel :: (MonadProcess m, Serializable a) => Static (SerializableDict a) -> NodeId -> Closure (ReceivePort a -> Process ()) -> m (SendPort a)

-- | Generalized version of <a>spawnChannelLocal</a>
spawnChannelLocal :: (MonadProcess m, Serializable a) => (ReceivePort a -> Process ()) -> m (SendPort a)

-- | Generalized version of <a>unClosure</a>
unClosure :: (MonadProcess m, Typeable a) => Closure a -> m a

-- | Generalized version of <a>unStatic</a>
unStatic :: (MonadProcess m, Typeable a) => Static a -> m a

-- | Generalized version of <a>unsafeNSend</a>
unsafeNSend :: (MonadProcess m, Serializable a) => String -> a -> m ()

-- | Generalized version of <a>unsafeSend</a>
unsafeSend :: (MonadProcess m, Serializable a) => ProcessId -> a -> m ()

-- | Generalized version of <a>unsafeSendChan</a>
unsafeSendChan :: (MonadProcess m, Serializable a) => SendPort a -> a -> m ()

-- | Generalized version of <a>unwrapMessage</a>
unwrapMessage :: (MonadProcess m, Serializable a) => Message -> m (Maybe a)

module Control.Distributed.Process.Node.Lifted

-- | Generalized version of <a>putMVar</a>.
closeLocalNode :: MonadBase IO m => LocalNode -> m ()

-- | Generalized version of <a>forkProcess</a>.
forkProcess :: MonadBase IO m => LocalNode -> Process () -> m ProcessId

-- | Generalized version of <a>newLocalNode</a>.
newLocalNode :: MonadBase IO m => Transport -> RemoteTable -> m LocalNode

-- | Generalized version of <a>runProcess</a>
runProcess :: MonadBase IO m => LocalNode -> Process () -> m ()

-- | Local nodes
data LocalNode :: *
initRemoteTable :: RemoteTable

-- | <a>NodeId</a> of the node
localNodeId :: LocalNode -> NodeId


-- | Utility functions for working with Processes outside of the
--   <a>Process</a> monad.
module Control.Distributed.Process.Lifted.Extras

-- | A variant of <a>runProcess</a> which returns a value. This works just
--   like <a>runProcess</a> by forking a new process with a captured
--   <a>MVar</a>, but it will return the result of the computation. If the
--   computation throws an exception, it will be re-thrown by
--   <a>fromProcess</a> in the calling thread.
fromProcess :: forall a m. (MonadBase IO m) => LocalNode -> Process a -> m a

-- | Represents a handle to a process runner that communicates through a
--   <a>Chan</a>. Create with <a>spawnProxy</a> or <a>spawnProxyIO</a>. Use
--   this to call process actions (using <a>fromProxy</a> or
--   <a>inProxy</a>) from any IO that will be executed in a single process
--   that will have a persistent pid and mailbox across invocations.
--   Sharing a single proxy between threads may yield poor performance and
--   is not advised.
data ProcessProxy
proxyPid :: ProcessProxy -> ProcessId

-- | Spawn a new process and return a <a>ProcessProxy</a> handle for it.
spawnProxy :: Process ProcessProxy

-- | Same as spawnProxy but can be used from any IO
--   
--   spawnProxyIO node = fromProcess node spawnProxy
spawnProxyIO :: forall m. (MonadBase IO m) => LocalNode -> m ProcessProxy

-- | Use a <a>ProcessProxy</a> created with <a>spawnProxy</a> to run a
--   Process computation in the existing Process asynchronously.
inProxy :: forall m. (MonadBase IO m) => ProcessProxy -> Process () -> m ()

-- | Use a <a>ProcessProxy</a> created with <a>spawnProxy</a> to run a
--   Process computation in the existing Process and return the result in
--   any IO.
fromProxy :: forall a m. (MonadBase IO m) => ProcessProxy -> Process a -> m a
instance GHC.Show.Show Control.Distributed.Process.Lifted.Extras.ProcessProxy