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


-- | Message passing concurrency as extensible-effect
--   
--   Please see the README on GitHub at
--   <a>https://github.com/sheyll/extensible-effects-concurrent#readme</a>
@package extensible-effects-concurrent
@version 0.14.2


-- | Add-ons to <a>Exception</a> and <a>Excepion</a>
module Control.Eff.ExceptionExtra

-- | Catch <a>Exception</a> thrown by an effect.
liftTry :: forall e r a. (HasCallStack, Exception e, Lifted IO r) => Eff r a -> Eff r (Either e a)

-- | Very similar to <a>liftEither</a> but for <a>Maybe</a>s. Unlike
--   <a>liftMaybe</a> this will throw the given value (instead of using
--   <a>Fail</a>).
maybeThrow :: Member (Exc x) e => x -> Maybe a -> Eff e a
instance Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff e) => Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff (Control.Eff.Reader.Lazy.Reader x : e))
instance Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff e) => Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff (Control.Eff.Reader.Lazy.Reader x : e))
instance Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff e) => Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff (Control.Eff.Reader.Lazy.Reader x : e))
instance Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff e) => Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff (Control.Eff.Reader.Strict.Reader x : e))
instance Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff e) => Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff (Control.Eff.Reader.Strict.Reader x : e))
instance Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff e) => Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff (Control.Eff.Reader.Strict.Reader x : e))
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff '[Control.Eff.Internal.Lift m])
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff '[Control.Eff.Internal.Lift m])
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff '[Control.Eff.Internal.Lift m])
instance Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff e) => Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff (Control.Eff.Exception.Exc x : e))
instance Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff e) => Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff (Control.Eff.Exception.Exc x : e))
instance Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff e) => Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff (Control.Eff.Exception.Exc x : e))


-- | A logging effect based on <a>MonadLog</a>.
module Control.Eff.Log.Handler

-- | Log a message. The message is reduced to normal form (strict).
logMsg :: (NFData m, Member (Logs m) e) => m -> Eff e ()

-- | Log a bunch of messages. This might be more efficient than calling
--   <a>logMsg</a> multiple times. The messages are reduced to normal form
--   (strict).
logMsgs :: (Traversable f, MonadPlus f, NFData1 f, NFData (f m), NFData m, Member (Logs m) e) => f m -> Eff e ()

-- | A constraint that combines constraints for logging into any log writer
--   monad.
type HasLogWriter message logWriterMonad effects = (Member (Reader (LogWriter message logWriterMonad)) effects, Member (Logs message) effects, NFData message, Monad logWriterMonad, Lifted logWriterMonad effects)

-- | Map a pure function over log messages.
mapLogMessages :: forall m r b. (NFData m, Member (Logs m) r) => (m -> m) -> Eff r b -> Eff r b

-- | Keep only those messages, for which a predicate holds.
--   
--   E.g. to keep only messages which begin with <tt><a>OMG</a></tt>:
--   
--   <pre>
--   filterLogMessages (\msg -&gt; case msg of
--                               'O':'M':'G':_ -&gt; True
--                                _            -&gt; False)
--                     (do logMsg "this message will not be logged"
--                         logMsg "OMG logged")
--   </pre>
filterLogMessages :: forall m r b. (NFData m, Member (Logs m) r) => (m -> Bool) -> Eff r b -> Eff r b

-- | Map an <a>Eff</a>ectful function over every bunch of log messages.
--   
--   For example, to attach the current time to each log message:
--   
--   <pre>
--   appendTimestamp
--    :: ( Member (Logs String) e
--       , Lifted IO e)
--    =&gt; Eff e a
--    -&gt; Eff e a
--   appendTimestamp = traverseLogMessages $ \ms -&gt; do
--     now &lt;- getCurrentTime
--     return (fmap (show now ++) ms)
--   </pre>
traverseLogMessages :: forall m r h b. (Member (Logs m) r, Monad h, Lifted h r, Member (Reader (LogWriter m h)) r) => (forall f. (MonadPlus f, Traversable f, NFData1 f) => f m -> h (f m)) -> Eff r b -> Eff r b

-- | Change the way log messages are *written*. Replaces the existing
--   <a>LogWriter</a> by a new one. The new <a>LogWriter</a> is constructed
--   from a function that gets a <i>bunch</i> of messages and returns an
--   <a>Eff</a>ect. That effect has a <a>Reader</a> for the previous
--   <a>LogWriter</a> and <a>Lift</a>s the log writer base monad.
changeLogWriter :: forall r m h a. (Monad h, Lifted h r, Member (Reader (LogWriter m h)) r) => (forall f. (Traversable f, NFData1 f, MonadPlus f) => f m -> Eff '[Reader (LogWriter m h), Lift h] ()) -> Eff r a -> Eff r a

-- | Throw away all log messages.
ignoreLogs :: forall message r a. Eff (Logs message : r) a -> Eff r a

-- | Trace all log messages using <a>traceM</a>. The message value is
--   converted to <a>String</a> using the given function.
traceLogs :: forall message r a. (message -> String) -> Eff (Logs message : r) a -> Eff r a

-- | A function that takes a log message and returns an effect that
--   <i>logs</i> the message.
data LogWriter message writerM

-- | Type alias for the <a>Reader</a> effect that writes logs
type LogWriterReader message writerM = Reader (LogWriter message writerM)

-- | Create a <a>LogWriter</a> from a function that can write a
--   <a>Traversable</a> container.
foldingLogWriter :: (forall f. (MonadPlus f, Traversable f, NFData1 f) => f message -> writerM ()) -> LogWriter message writerM

-- | Efficiently apply the <a>LogWriter</a> to a <a>Traversable</a>
--   container of log messages.
writeAllLogMessages :: (NFData1 f, MonadPlus f, Traversable f, Applicative writerM) => LogWriter message writerM -> f message -> writerM ()

-- | Create a <a>LogWriter</a> from a function that is applied to each
--   individual log message. NOTE: This is probably the simplest, but also
--   the most inefficient and annoying way to make a <a>LogWriter</a>.
--   Better use <a>foldingLogWriter</a> or even
--   <a>multiMessageLogWriter</a>.
singleMessageLogWriter :: Applicative writerM => (message -> writerM ()) -> LogWriter message writerM

-- | Create a <a>LogWriter</a> from a function that is applied to each
--   individual log message. Don't be scared by the type signature, here is
--   an example file appender that re-opens the log file everytime a bunch
--   of log messages are written:
--   
--   <pre>
--   fileAppender fn = multiMessageLogWriter
--     (\writeLogMessageWith -&gt;
--        withFile fn AppendMode (writeLogMessageWith . hPutStrLn))
--   </pre>
multiMessageLogWriter :: Applicative writerM => (((message -> writerM ()) -> writerM ()) -> writerM ()) -> LogWriter message writerM

-- | Get the current <a>LogWriter</a>
askLogWriter :: forall m h r. Member (Reader (LogWriter m h)) r => Eff r (LogWriter m h)

-- | This effect sends log messages. The logs are not sent one-by-one, but
--   always in batches of containers that must be <a>Traversable</a> and
--   <a>MonadPlus</a> instances. Log messages are consumed by
--   <a>LogWriter</a>s installed via <a>runLogs</a> or more high level
--   functions like <a>writeLogs</a>.
data Logs m v

-- | Handle log message effects by a monadic action, e.g. an IO action to
--   send logs to the console output or a log-server. The monadic log
--   writer action is wrapped in a newtype called <a>LogWriter</a>.
--   
--   Use the smart constructors below to create them, e.g.
--   <a>foldingLogWriter</a>, <a>singleMessageLogWriter</a> or
--   <tt>mulitMessageLogWriter</tt>.
writeLogs :: forall message writerM r a. (Applicative writerM, Lifted writerM r, NFData message) => LogWriter message writerM -> Eff (Logs message : (Reader (LogWriter message writerM) : r)) a -> Eff r a

-- | Install <a>Logs</a> handler that <a>ask</a>s for a <a>LogWriter</a>
--   for the message type and applies the log writer to the messages.
runLogs :: forall m h e b. (Applicative h, Lifted h e, Member (LogWriterReader m h) e, NFData m) => Eff (Logs m : e) b -> Eff e b
instance (Control.Monad.Base.MonadBase m m, Control.Eff.Lift.Lifted m r, Control.DeepSeq.NFData l, Control.Monad.Trans.Control.MonadBaseControl m (Control.Eff.Internal.Eff r)) => Control.Monad.Trans.Control.MonadBaseControl m (Control.Eff.Internal.Eff (Control.Eff.Log.Handler.Logs l : Control.Eff.Log.Handler.LogWriterReader l m : r))
instance (Control.DeepSeq.NFData l, Control.Eff.Lift.Lifted m e, Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff e)) => Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff (Control.Eff.Log.Handler.Logs l : Control.Eff.Log.Handler.LogWriterReader l m : e))
instance (Control.DeepSeq.NFData l, GHC.Base.Applicative m, Control.Eff.Lift.Lifted m e, Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff e)) => Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff (Control.Eff.Log.Handler.Logs l : Control.Eff.Log.Handler.LogWriterReader l m : e))
instance (Control.DeepSeq.NFData l, GHC.Base.Applicative m, Control.Eff.Lift.Lifted m e, Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff e)) => Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff (Control.Eff.Log.Handler.Logs l : Control.Eff.Log.Handler.LogWriterReader l m : e))
instance GHC.Base.Applicative w => Data.Default.Class.Default (Control.Eff.Log.Handler.LogWriter m w)


-- | Concurrent Logging
module Control.Eff.Log.Channel

-- | A log channel processes logs from the <a>Logs</a> effect by en-queuing
--   them in a shared queue read from a seperate processes. A channel can
--   contain log message filters.
data LogChannel message

-- | Fork a new process in which the given log message writer, will listen
--   on a message queue in a <a>LogChannel</a>, which is passed to the
--   second function. If the function returns or throws, the logging
--   process will be killed.
--   
--   Log messages are deeply evaluated before being sent to the logger
--   process, to prevent that lazy evaluation leads to heavy work being
--   done in the logger process instead of the caller process.
--   
--   Example usage, a super stupid log to file:
--   
--   <pre>
--   main =
--     withAsyncLogChannel
--        1000
--        (singleMessageLogWriter putStrLn)
--        (handleLoggingAndIO
--          (do logMsg "test 1"
--              logMsg "test 2"
--              logMsg "test 3"))
--   </pre>
withAsyncLogChannel :: forall message a len. (NFData message, Integral len) => len -> LogWriter message IO -> (LogChannel message -> IO a) -> IO a

-- | Fork an IO based log writer thread and set the <a>LogWriter</a> to an
--   action that will send all logs to that thread via a bounded queue.
--   When the queue is full, flush it
handleLoggingAndIO :: (NFData m, HasCallStack) => Eff '[Logs m, LogWriterReader m IO, Lift IO] a -> LogChannel m -> IO a

-- | Like <a>handleLoggingAndIO</a> but return <tt>()</tt>.
handleLoggingAndIO_ :: (NFData m, HasCallStack) => Eff '[Logs m, LogWriterReader m IO, Lift IO] a -> LogChannel m -> IO ()


-- | An RFC 5434 inspired log message and convenience functions for logging
--   them.
module Control.Eff.Log.Message

-- | A message data type inspired by the RFC-5424 Syslog Protocol
data LogMessage
LogMessage :: Facility -> Severity -> Maybe UTCTime -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> [StructuredDataElement] -> Maybe ThreadId -> Maybe SrcLoc -> String -> Int -> LogMessage
[_lmFacility] :: LogMessage -> Facility
[_lmSeverity] :: LogMessage -> Severity
[_lmTimestamp] :: LogMessage -> Maybe UTCTime
[_lmHostname] :: LogMessage -> Maybe String
[_lmAppname] :: LogMessage -> Maybe String
[_lmProcessId] :: LogMessage -> Maybe String
[_lmMessageId] :: LogMessage -> Maybe String
[_lmStructuredData] :: LogMessage -> [StructuredDataElement]
[_lmThreadId] :: LogMessage -> Maybe ThreadId
[_lmSrcLoc] :: LogMessage -> Maybe SrcLoc
[_lmMessage] :: LogMessage -> String
[_lmDistance] :: LogMessage -> Int

-- | A convenient alias for the constraints that enable logging of
--   <a>LogMessage</a>s in the monad, which is <a>Lift</a>ed into a given
--   <tt>Eff</tt> effect list.
type HasLogging writerM effect = (HasLogWriter LogMessage writerM effect)

-- | Render a <a>LogMessage</a> according to the rules in the given RFC,
--   except for the rules concerning unicode and ascii
renderRFC5424 :: LogMessage -> String

-- | Render a <a>LogMessage</a> but set the timestamp and thread id fields.
printLogMessage :: LogMessage -> IO ()

-- | Use <a>ioLogMessageWriter</a> to <i>handle</i> logging using
--   <tt>handleLogs</tt>.
ioLogMessageHandler :: (HasCallStack, Lifted IO e) => LogWriter String IO -> Eff (Logs LogMessage : (LogWriterReader LogMessage IO : e)) a -> Eff e a

-- | Set a timestamp (if not set), the thread id (if not set) using IO
--   actions then <i>write</i> the log message using the <a>IO</a> and
--   <a>String</a> based <a>LogWriter</a>.
ioLogMessageWriter :: HasCallStack => LogWriter String IO -> LogWriter LogMessage IO

-- | A <a>LogWriter</a> that applys <a>renderLogMessage</a> to the log
--   message and then traces it using <a>traceM</a>.
traceLogMessageWriter :: Monad m => LogWriter LogMessage m

-- | Render a <a>LogMessage</a> human readable.
renderLogMessage :: LogMessage -> String

-- | Increase the <i>distance</i> of log messages by one. Logs can be
--   filtered by their distance with <a>dropDistantLogMessages</a>
increaseLogMessageDistance :: (HasCallStack, HasLogWriter LogMessage h e) => Eff e a -> Eff e a

-- | Drop all log messages with an <a>lmDistance</a> greater than the given
--   value.
dropDistantLogMessages :: HasLogging m r => Int -> Eff r a -> Eff r a

-- | Log a <a>String</a> as <a>LogMessage</a> with a given <a>Severity</a>.
logWithSeverity :: (HasCallStack, Member (Logs LogMessage) e) => Severity -> String -> Eff e ()

-- | Log a <a>String</a> as <a>emergencySeverity</a>.
logEmergency :: (HasCallStack, Member (Logs LogMessage) e) => String -> Eff e ()

-- | Log a message with <a>alertSeverity</a>.
logAlert :: (HasCallStack, Member (Logs LogMessage) e) => String -> Eff e ()

-- | Log a <a>criticalSeverity</a> message.
logCritical :: (HasCallStack, Member (Logs LogMessage) e) => String -> Eff e ()

-- | Log a <a>errorSeverity</a> message.
logError :: (HasCallStack, Member (Logs LogMessage) e) => String -> Eff e ()

-- | Log a <a>warningSeverity</a> message.
logWarning :: (HasCallStack, Member (Logs LogMessage) e) => String -> Eff e ()

-- | Log a <a>noticeSeverity</a> message.
logNotice :: (HasCallStack, Member (Logs LogMessage) e) => String -> Eff e ()

-- | Log a <a>informationalSeverity</a> message.
logInfo :: (HasCallStack, Member (Logs LogMessage) e) => String -> Eff e ()

-- | Log a <a>debugSeverity</a> message.
logDebug :: (HasCallStack, Member (Logs LogMessage) e) => String -> Eff e ()

-- | Construct a <a>LogMessage</a> with <a>errorSeverity</a>
errorMessage :: HasCallStack => String -> LogMessage

-- | Construct a <a>LogMessage</a> with <a>informationalSeverity</a>
infoMessage :: HasCallStack => String -> LogMessage

-- | Construct a <a>LogMessage</a> with <a>debugSeverity</a>
debugMessage :: HasCallStack => String -> LogMessage

-- | Construct a <a>LogMessage</a> with <a>errorSeverity</a>
errorMessageIO :: (HasCallStack, MonadIO m) => String -> m LogMessage

-- | Construct a <a>LogMessage</a> with <a>informationalSeverity</a>
infoMessageIO :: (HasCallStack, MonadIO m) => String -> m LogMessage

-- | Construct a <a>LogMessage</a> with <a>debugSeverity</a>
debugMessageIO :: (HasCallStack, MonadIO m) => String -> m LogMessage

-- | An rfc 5424 severity
data Severity
emergencySeverity :: Severity
alertSeverity :: Severity
criticalSeverity :: Severity
errorSeverity :: Severity
warningSeverity :: Severity
noticeSeverity :: Severity
informationalSeverity :: Severity
debugSeverity :: Severity

-- | An rfc 5424 facility
data Facility
kernelMessages :: Facility
userLevelMessages :: Facility
mailSystem :: Facility
systemDaemons :: Facility
securityAuthorizationMessages4 :: Facility
linePrinterSubsystem :: Facility
networkNewsSubsystem :: Facility
uucpSubsystem :: Facility
clockDaemon :: Facility
securityAuthorizationMessages10 :: Facility
ftpDaemon :: Facility
ntpSubsystem :: Facility
logAuditFacility :: Facility
logAlertFacility :: Facility
clockDaemon2 :: Facility
local0 :: Facility
local1 :: Facility
local2 :: Facility
local3 :: Facility
local4 :: Facility
local5 :: Facility
local6 :: Facility
local7 :: Facility
lmFacility :: Lens' LogMessage Facility
lmSeverity :: Lens' LogMessage Severity
lmTimestamp :: Lens' LogMessage (Maybe UTCTime)
lmHostname :: Lens' LogMessage (Maybe String)
lmAppname :: Lens' LogMessage (Maybe String)
lmProcessId :: Lens' LogMessage (Maybe String)
lmMessageId :: Lens' LogMessage (Maybe String)
lmStructuredData :: Lens' LogMessage [StructuredDataElement]
lmSrcLoc :: Lens' LogMessage (Maybe SrcLoc)
lmThreadId :: Lens' LogMessage (Maybe ThreadId)
lmMessage :: Lens' LogMessage String
lmDistance :: Lens' LogMessage Int

-- | Put the source location of the given callstack in <a>lmSrcLoc</a>
setCallStack :: CallStack -> LogMessage -> LogMessage

-- | An IO action that sets the current UTC time (see
--   <tt>enableLogMessageTimestamps</tt>) in <a>lmTimestamp</a>.
setLogMessageTimestamp :: MonadIO m => LogMessage -> m LogMessage

-- | An IO action appends the the <a>ThreadId</a> of the calling process
--   (see <a>myThreadId</a>) to <a>lmMessage</a>.
setLogMessageThreadId :: MonadIO m => LogMessage -> m LogMessage

-- | RFC-5424 defines how structured data can be included in a log message.
data StructuredDataElement
SdElement :: String -> [SdParameter] -> StructuredDataElement
[_sdElementId] :: StructuredDataElement -> String
[_sdElementParameters] :: StructuredDataElement -> [SdParameter]
sdElementId :: Lens' StructuredDataElement String
sdElementParameters :: Lens' StructuredDataElement [SdParameter]
instance Data.Default.Class.Default Control.Eff.Log.Message.LogMessage
instance Data.String.IsString Control.Eff.Log.Message.LogMessage
instance Data.Default.Class.Default Control.Eff.Log.Message.Severity
instance Data.Default.Class.Default Control.Eff.Log.Message.Facility
instance GHC.Generics.Generic Control.Eff.Log.Message.LogMessage
instance GHC.Classes.Eq Control.Eff.Log.Message.LogMessage
instance Control.DeepSeq.NFData Control.Eff.Log.Message.Facility
instance GHC.Generics.Generic Control.Eff.Log.Message.Facility
instance GHC.Show.Show Control.Eff.Log.Message.Facility
instance GHC.Classes.Ord Control.Eff.Log.Message.Facility
instance GHC.Classes.Eq Control.Eff.Log.Message.Facility
instance Control.DeepSeq.NFData Control.Eff.Log.Message.Severity
instance GHC.Generics.Generic Control.Eff.Log.Message.Severity
instance GHC.Classes.Ord Control.Eff.Log.Message.Severity
instance GHC.Classes.Eq Control.Eff.Log.Message.Severity
instance GHC.Generics.Generic Control.Eff.Log.Message.StructuredDataElement
instance GHC.Classes.Ord Control.Eff.Log.Message.StructuredDataElement
instance GHC.Classes.Eq Control.Eff.Log.Message.StructuredDataElement
instance GHC.Generics.Generic Control.Eff.Log.Message.SdParameter
instance GHC.Classes.Ord Control.Eff.Log.Message.SdParameter
instance GHC.Classes.Eq Control.Eff.Log.Message.SdParameter
instance Control.DeepSeq.NFData Control.Eff.Log.Message.LogMessage
instance GHC.Show.Show Control.Eff.Log.Message.Severity
instance GHC.Show.Show Control.Eff.Log.Message.StructuredDataElement
instance Control.DeepSeq.NFData Control.Eff.Log.Message.StructuredDataElement
instance GHC.Show.Show Control.Eff.Log.Message.SdParameter
instance Control.DeepSeq.NFData Control.Eff.Log.Message.SdParameter


-- | A logging effect based on <a>MonadLog</a>.
module Control.Eff.Log


-- | The message passing effect.
--   
--   This module describes an abstract message passing effect, and a
--   process effect, mimicking Erlang's process and message semantics.
--   
--   Two <b>scheduler</b> implementations for the <a>Process</a> effect are
--   provided:
--   
--   <ul>
--   <li>A scheduler using <tt>forkIO</tt>, i.e. relying on the multi
--   threaded GHC runtime:
--   <a>Control.Eff.Concurrent.Process.ForkIOScheduler</a></li>
--   <li>And a <i>pure</i>(rer) coroutine based scheduler in:
--   <a>Control.Eff.Concurrent.Process.SingleThreadedScheduler</a></li>
--   </ul>
module Control.Eff.Concurrent.Process

-- | The process effect is the basis for message passing concurrency. This
--   effect describes an interface for concurrent, communicating isolated
--   processes identified uniquely by a process-id.
--   
--   Processes can raise exceptions that can be caught, exit gracefully or
--   with an error, or be killed by other processes, with the option of
--   ignoring the shutdown request.
--   
--   Process Scheduling is implemented in different modules. All scheduler
--   implementations should follow some basic rules:
--   
--   <ul>
--   <li>fair scheduling</li>
--   <li>sending a message does not block</li>
--   <li>receiving a message does block</li>
--   <li>spawning a child blocks only a very moment</li>
--   <li>a newly spawned process shall be scheduled before the parent
--   process after</li>
--   <li>the spawnRaw</li>
--   <li>when the first process exists, all process should be killed
--   immediately</li>
--   </ul>
data Process (r :: [Type -> Type]) b

-- | Remove all messages from the process' message queue
[FlushMessages] :: Process r (ResumeProcess [Dynamic])

-- | In cooperative schedulers, this will give processing time to the
--   scheduler. Every other operation implicitly serves the same purpose.
[YieldProcess] :: Process r (ResumeProcess ())

-- | Return the current <a>ProcessId</a>
[SelfPid] :: Process r (ResumeProcess ProcessId)

-- | Start a new process, the new process will execute an effect, the
--   function will return immediately with a <a>ProcessId</a>.
[Spawn] :: Eff (Process r : r) () -> Process r (ResumeProcess ProcessId)

-- | Start a new process, and <a>Link</a> to it .
[SpawnLink] :: Eff (Process r : r) () -> Process r (ResumeProcess ProcessId)

-- | Get the process state (or <a>Nothing</a> if the process is dead)
[GetProcessState] :: ProcessId -> Process r (ResumeProcess (Maybe ProcessState))

-- | Shutdown the process; irregardles of the exit reason, this function
--   never returns,
[Shutdown] :: ExitReason  'NoRecovery -> Process r a

-- | Raise an error, that can be handled.
[SendShutdown] :: ProcessId -> ExitReason  'NoRecovery -> Process r (ResumeProcess ())

-- | Request that another a process interrupts. The targeted process is
--   interrupted and gets an <a>Interrupted</a>, the target process may
--   decide to ignore the interrupt and continue as if nothing happened.
[SendInterrupt] :: ProcessId -> InterruptReason -> Process r (ResumeProcess ())

-- | Send a message to a process addressed by the <a>ProcessId</a>. Sending
--   a message should **always succeed** and return **immediately**, even
--   if the destination process does not exist, or does not accept messages
--   of the given type.
[SendMessage] :: ProcessId -> Dynamic -> Process r (ResumeProcess ())

-- | Receive a message that matches a criterium. This should block until an
--   a message was received. The message is returned as a
--   <tt>ProcessMessage</tt> value. The function should also return if an
--   exception was caught or a shutdown was requested.
[ReceiveSelectedMessage] :: forall r a. MessageSelector a -> Process r (ResumeProcess a)

-- | Generate a unique <a>Int</a> for the current process.
[MakeReference] :: Process r (ResumeProcess Int)

-- | Monitor another process. When the monitored process exits a
--   <a>ProcessDown</a> is sent to the calling process. The return value is
--   a unique identifier for that monitor. There can be multiple monitors
--   on the same process, and a message for each will be sent. If the
--   process is already dead, the <a>ProcessDown</a> message will be sent
--   immediately, w.thout exit reason
[Monitor] :: ProcessId -> Process r (ResumeProcess MonitorReference)

-- | Remove a monitor.
[Demonitor] :: MonitorReference -> Process r (ResumeProcess ())

-- | Connect the calling process to another process, such that if one of
--   the processes crashes (i.e. <a>isCrash</a> returns <a>True</a>), the
--   other is shutdown with the <tt>ProcessExitReaon</tt>
--   <a>LinkedProcessCrashed</a>.
[Link] :: ProcessId -> Process r (ResumeProcess ())

-- | Unlink the calling proccess from the other process.
[Unlink] :: ProcessId -> Process r (ResumeProcess ())

-- | Each process is identified by a single process id, that stays constant
--   throughout the life cycle of a process. Also, message sending relies
--   on these values to address messages to processes.
newtype ProcessId
ProcessId :: Int -> ProcessId
[_fromProcessId] :: ProcessId -> Int
fromProcessId :: Iso' ProcessId Int

-- | <i>Cons</i> <a>Process</a> onto a list of effects.
type ConsProcess r = Process r : r

-- | Every <a>Process</a> action returns it's actual result wrapped in this
--   type. It will allow to signal errors as well as pass on normal results
--   such as incoming messages.
data ResumeProcess v

-- | The current operation of the process was interrupted with a
--   <a>ExitReason</a>. If <a>isRecoverable</a> holds for the given reason,
--   the process may choose to continue.
[Interrupted] :: InterruptReason -> ResumeProcess v

-- | The process may resume to do work, using the given result.
[ResumeWith] :: a -> ResumeProcess a

-- | Every function for <a>Process</a> things needs such a proxy value for
--   the low-level effect list, i.e. the effects identified by
--   <tt><b>r</b></tt> in <tt><a>Process</a> r : r</tt>, this might be
--   dependent on the scheduler implementation.
data SchedulerProxy :: [Type -> Type] -> Type

-- | Tell the typechecker what effects we have below <a>Process</a>
[SchedulerProxy] :: SchedulerProxy q

-- | Like <a>SchedulerProxy</a> but shorter
[SP] :: SchedulerProxy q

-- | Like <a>SP</a> but different
[Scheduler] :: SchedulerProxy q

-- | A constraint for the implicit <a>SchedulerProxy</a> parameter. Use
--   <a>getSchedulerProxy</a> to query it. _EXPERIMENTAL_
type HasScheduler q = (?_schedulerProxy :: SchedulerProxy q)

-- | Get access to the <a>SchedulerProxy</a> for the current scheduler
--   effects. _EXPERIMENTAL_
getSchedulerProxy :: HasScheduler q => SchedulerProxy q

-- | Set the <a>SchedulerProxy</a> to use, this satisfies
--   <a>HasScheduler</a> . _EXPERIMENTAL_
withSchedulerProxy :: SchedulerProxy q -> (HasScheduler q => a) -> a

-- | Return a <a>SchedulerProxy</a> for a <a>Process</a> effect.
thisSchedulerProxy :: Eff (Process r : r) (SchedulerProxy r)

-- | The state that a <a>Process</a> is currently in.
data ProcessState

-- | The process has just been started but not called
--   <tt>handleProcess</tt> yet.
ProcessBooting :: ProcessState

-- | The process yielded it's timeslice
ProcessIdle :: ProcessState

-- | The process is busy with non-blocking
ProcessBusy :: ProcessState

-- | The process is busy with sending a message
ProcessBusySending :: ProcessState

-- | The process is busy with killing
ProcessBusySendingShutdown :: ProcessState

-- | The process is busy with killing
ProcessBusySendingInterrupt :: ProcessState

-- | The process blocked by a <a>receiveAnyMessage</a>
ProcessBusyReceiving :: ProcessState

-- | The process blocked by a <a>linkProcess</a>
ProcessBusyLinking :: ProcessState

-- | The process blocked by a <a>unlinkProcess</a>
ProcessBusyUnlinking :: ProcessState

-- | The process blocked by a <a>monitor</a>
ProcessBusyMonitoring :: ProcessState

-- | The process blocked by a <a>demonitor</a>
ProcessBusyDemonitoring :: ProcessState

-- | The process was interrupted
ProcessInterrupted :: ProcessState

-- | The process was shutdown or crashed
ProcessShuttingDown :: ProcessState

-- | Use <a>executeAndResumeOrExit</a> to execute <a>YieldProcess</a>.
--   Refer to <a>YieldProcess</a> for more information.
yieldProcess :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Eff r ()

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>.
sendMessage :: forall r q o. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r, Typeable o) => SchedulerProxy q -> ProcessId -> o -> Eff r ()

-- | Send a <a>Dynamic</a> value to a process addressed by the
--   <a>ProcessId</a>. See <a>SendMessage</a>.
sendAnyMessage :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Dynamic -> Eff r ()

-- | Exit a process addressed by the <a>ProcessId</a>. The process will
--   exit, it might do some cleanup, but is ultimately unrecoverable. See
--   <a>SendShutdown</a>.
sendShutdown :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> ExitReason  'NoRecovery -> Eff r ()

-- | Interrupts a process addressed by the <a>ProcessId</a>. The process
--   might exit, or it may continue. | Like <a>sendInterrupt</a>, but also
--   return <tt>True</tt> iff the process to exit exists.
sendInterrupt :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> InterruptReason -> Eff r ()

-- | Generate a unique <a>Int</a> for the current process.
makeReference :: (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Eff r Int

-- | Receive and cast the message to some <a>Typeable</a> instance. See
--   <a>ReceiveSelectedMessage</a> for more documentation. This will wait
--   for a message of the return type using <a>receiveSelectedMessage</a>
receiveMessage :: forall a r q. (HasCallStack, Typeable a, Show a, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Eff r a

-- | Block until a message was received, that is not <a>Nothing</a> after
--   applying a callback to it. See <a>ReceiveSelectedMessage</a> for more
--   documentation.
receiveSelectedMessage :: forall r q a. (HasCallStack, Show a, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> MessageSelector a -> Eff r a

-- | Remove and return all messages currently enqueued in the process
--   message queue.
flushMessages :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r, HasScheduler q) => Eff r [Dynamic]

-- | Block until a message was received. See <a>ReceiveSelectedMessage</a>
--   for more documentation.
receiveAnyMessage :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Eff r Dynamic

-- | Like <a>receiveSelectedLoop</a> but refined to casting to a specific
--   <a>Typeable</a> using <a>selectMessageLazy</a>.
receiveLoop :: forall r q a endOfLoopResult. (SetMember Process (Process q) r, HasCallStack, Typeable a) => SchedulerProxy q -> (Either InterruptReason a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Enter a loop to receive messages and pass them to a callback, until
--   the function returns <a>Just</a> a result. Only the messages of the
--   given type will be received. If the process is interrupted by an
--   exception of by a <a>SendShutdown</a> from another process, with an
--   exit reason that satisfies <a>isRecoverable</a>, then the callback
--   will be invoked with <tt><a>Left</a> <tt>ProcessExitReaon</tt></tt>,
--   otherwise the process will be exited with the same reason using
--   <a>exitBecause</a>. See also <a>ReceiveSelectedMessage</a> for more
--   documentation.
receiveSelectedLoop :: forall r q a endOfLoopResult. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> MessageSelector a -> (Either InterruptReason a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Like <a>receiveSelectedLoop</a> but <i>not selective</i>. See also
--   <a>selectAnyMessageLazy</a>, <a>receiveSelectedLoop</a>.
receiveAnyLoop :: forall r q endOfLoopResult. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> (Either InterruptReason Dynamic -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | A function that deciced if the next message will be received by
--   <a>ReceiveSelectedMessage</a>. It conveniently is an instance of
--   <a>Alternative</a> so the message selector can be combined: &gt; &gt;
--   selectInt :: MessageSelector Int &gt; selectInt = selectMessage &gt;
--   &gt; selectString :: MessageSelector String &gt; selectString =
--   selectMessage &gt; &gt; selectIntOrString :: MessageSelector (Either
--   Int String) &gt; selectIntOrString = &gt; Left <a>$</a>
--   selectTimeout<a>|</a> Right <a>$</a> selectString
data MessageSelector a

-- | Create a message selector for a value that can be obtained by
--   <a>fromDynamic</a>. It will also <a>force</a> the result.
selectMessage :: (NFData t, Typeable t) => MessageSelector t

-- | Create a message selector for a value that can be obtained by
--   <a>fromDynamic</a>. It will also <a>force</a> the result.
selectMessageLazy :: Typeable t => MessageSelector t

-- | Create a message selector for a value that can be obtained by
--   <a>fromDynamic</a> with a proxy argument. It will also <a>force</a>
--   the result.
selectMessageProxy :: forall proxy t. (NFData t, Typeable t) => proxy t -> MessageSelector t

-- | Create a message selector for a value that can be obtained by
--   <a>fromDynamic</a> with a proxy argument. It will also <a>force</a>
--   the result.
selectMessageProxyLazy :: forall proxy t. Typeable t => proxy t -> MessageSelector t

-- | Create a message selector from a predicate. It will <a>force</a> the
--   result.
filterMessage :: (Typeable a, NFData a) => (a -> Bool) -> MessageSelector a

-- | Create a message selector from a predicate. It will <a>force</a> the
--   result.
filterMessageLazy :: Typeable a => (a -> Bool) -> MessageSelector a

-- | Select a message of type <tt>a</tt> and apply the given function to
--   it. If the function returns <a>Just</a> The
--   <a>ReceiveSelectedMessage</a> function will return the result (sans
--   <tt>Maybe</tt>). It will <a>force</a> the result.
selectMessageWith :: (Typeable a, NFData b) => (a -> Maybe b) -> MessageSelector b

-- | Select a message of type <tt>a</tt> and apply the given function to
--   it. If the function returns <a>Just</a> The
--   <a>ReceiveSelectedMessage</a> function will return the result (sans
--   <tt>Maybe</tt>). It will <a>force</a> the result.
selectMessageWithLazy :: Typeable a => (a -> Maybe b) -> MessageSelector b

-- | Create a message selector. It will <a>force</a> the result.
selectDynamicMessage :: NFData a => (Dynamic -> Maybe a) -> MessageSelector a

-- | Create a message selector.
selectDynamicMessageLazy :: (Dynamic -> Maybe a) -> MessageSelector a

-- | Create a message selector that will match every message. This is
--   <i>lazy</i> because the result is not <a>force</a>ed.
selectAnyMessageLazy :: MessageSelector Dynamic

-- | Returns the <a>ProcessId</a> of the current process.
self :: (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r ProcessId

-- | Return <a>True</a> if the process is alive.
isProcessAlive :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r Bool

-- | Start a new process, the new process will execute an effect, the
--   function will return immediately with a <a>ProcessId</a>. If the new
--   process is interrupted, the process will <a>Shutdown</a> with the
--   <a>InterruptReason</a> wrapped in <tt>NotCovered</tt>. For specific
--   use cases it might be better to use <a>spawnRaw</a>.
spawn :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess q) () -> Eff r ProcessId

-- | Like <a>spawn</a> but return <tt>()</tt>.
spawn_ :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess q) () -> Eff r ()

-- | Start a new process, and immediately link to it.
spawnLink :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess q) () -> Eff r ProcessId

-- | Start a new process, the new process will execute an effect, the
--   function will return immediately with a <a>ProcessId</a>. The spawned
--   process has only the <i>raw</i> <a>ConsProcess</a> effects. For
--   non-library code <a>spawn</a> might be better suited.
spawnRaw :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (ConsProcess q) () -> Eff r ProcessId

-- | Like <a>spawnRaw</a> but return <tt>()</tt>.
spawnRaw_ :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (ConsProcess q) () -> Eff r ()

-- | Exit the process with a <tt>ProcessExitReaon</tt>.
exitBecause :: forall r q a. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ExitReason  'NoRecovery -> Eff r a

-- | Exit the process.
exitNormally :: forall r q a. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a

-- | Exit the process with an error.
exitWithError :: forall r q a. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> String -> Eff r a

-- | Connect the calling process to another process, such that if one of
--   the processes crashes (i.e. <a>isCrash</a> returns <a>True</a>), the
--   other is shutdown with the <tt>ProcessExitReaon</tt>
--   <a>LinkedProcessCrashed</a>.
linkProcess :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r ()

-- | Unlink the calling proccess from the other process.
unlinkProcess :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r ()

-- | Monitor another process. When the monitored process exits a
--   <a>ProcessDown</a> is sent to the calling process. The return value is
--   a unique identifier for that monitor. There can be multiple monitors
--   on the same process, and a message for each will be sent. If the
--   process is already dead, the <a>ProcessDown</a> message will be sent
--   immediately, w.thout exit reason
monitor :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r MonitorReference

-- | Remove a monitor created with <a>monitor</a>.
demonitor :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> MonitorReference -> Eff r ()

-- | A monitored process exited. This message is sent to a process by the
--   scheduler, when a process that was monitored via a
--   <tt>SchedulerCommand</tt> died.
data ProcessDown
ProcessDown :: !MonitorReference -> !SomeExitReason -> ProcessDown
[downReference] :: ProcessDown -> !MonitorReference
[downReason] :: ProcessDown -> !SomeExitReason

-- | A <tt>MesssageSelector</tt> for the <a>ProcessDown</a> message of a
--   specific process.
selectProcessDown :: MonitorReference -> MessageSelector ProcessDown

-- | Trigger an <tt>Interrupt</tt> for a <a>ProcessDown</a> message. The
--   reason will be <a>ProcessNotRunning</a>
becauseProcessIsDown :: ProcessDown -> InterruptReason

-- | A value that contains a unique reference of a process monitoring.
data MonitorReference
MonitorReference :: Int -> ProcessId -> MonitorReference
[monitorIndex] :: MonitorReference -> Int
[monitoredProcess] :: MonitorReference -> ProcessId

-- | <a>monitor</a> another process before while performing an action and
--   <a>demonitor</a> afterwards.
withMonitor :: (HasCallStack, Member Interrupts r, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> (MonitorReference -> Eff r a) -> Eff r a

-- | A <a>MessageSelector</a> for receiving either a monitor of the given
--   process or another message.
receiveWithMonitor :: (HasCallStack, Member Interrupts r, SetMember Process (Process q) r, Member Interrupts r, Typeable a, Show a) => SchedulerProxy q -> ProcessId -> MessageSelector a -> Eff r (Either ProcessDown a)

-- | Handle all <a>InterruptReason</a>s of an <a>InterruptableProcess</a>
--   by wrapping them up in <a>NotRecovered</a> and then do a process
--   <a>Shutdown</a>.
provideInterruptsShutdown :: forall e a. Eff (InterruptableProcess e) a -> Eff (ConsProcess e) a

-- | Handle <a>InterruptReason</a>s arising during process operations, e.g.
--   when a linked process crashes while we wait in a
--   <a>receiveSelectedMessage</a> via a call to <a>interrupt</a>.
handleInterrupts :: (HasCallStack, Member Interrupts r) => (InterruptReason -> Eff r a) -> Eff r a -> Eff r a

-- | Like <a>handleInterrupts</a>, but instead of passing the
--   <a>InterruptReason</a> to a handler function, <a>Either</a> is
--   returned.
tryUninterrupted :: (HasCallStack, Member Interrupts r) => Eff r a -> Eff r (Either InterruptReason a)

-- | Handle <a>InterruptReason</a>s arising during process operations, e.g.
--   when a linked process crashes while we wait in a
--   <a>receiveSelectedMessage</a> via a call to <a>interrupt</a>.
exitOnInterrupt :: (HasCallStack, Member Interrupts r, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a -> Eff r a

-- | Handle interrupts by logging them with <a>logProcessExit</a> and
--   otherwise ignoring them.
logInterrupts :: (HasCallStack, '[Interrupts, Logs LogMessage] <:: r) => Eff r () -> Eff r ()

-- | Handle <a>InterruptReason</a>s arising during process operations, e.g.
--   when a linked process crashes while we wait in a
--   <a>receiveSelectedMessage</a> via a call to <a>interrupt</a>.
provideInterrupts :: HasCallStack => Eff (Interrupts : r) a -> Eff r (Either InterruptReason a)

-- | Wrap all (left) <a>InterruptReason</a>s into <a>NotRecovered</a> and
--   return the (right) <a>NoRecovery</a> <a>ExitReason</a>s as is.
mergeEitherInterruptAndExitReason :: Either InterruptReason (ExitReason  'NoRecovery) -> ExitReason  'NoRecovery

-- | Throw an <a>InterruptReason</a>, can be handled by
--   <tt>recoverFromInterrupt</tt> or <a>exitOnInterrupt</a> or
--   <a>provideInterrupts</a>.
interrupt :: (HasCallStack, Member Interrupts r) => InterruptReason -> Eff r a

-- | Execute a and action and return the result; if the process is
--   interrupted by an error or exception, or an explicit shutdown from
--   another process, or through a crash of a linked process, i.e. whenever
--   the exit reason satisfies <a>isRecoverable</a>, return the exit
--   reason.
executeAndResume :: forall q r v. (SetMember Process (Process q) r, HasCallStack) => Process q (ResumeProcess v) -> Eff r (Either (ExitReason  'Recoverable) v)

-- | Execute a <a>Process</a> action and resume the process, exit the
--   process when an <a>Interrupts</a> was raised. Use
--   <a>executeAndResume</a> to catch interrupts.
executeAndResumeOrExit :: forall r q v. (SetMember Process (Process q) r, HasCallStack) => Process q (ResumeProcess v) -> Eff r v

-- | Execute a <a>Process</a> action and resume the process, exit the
--   process when an <a>Interrupts</a> was raised. Use
--   <a>executeAndResume</a> to catch interrupts.
executeAndResumeOrThrow :: forall q r v. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => Process q (ResumeProcess v) -> Eff r v

-- | A sum-type with reasons for why a process exists the scheduling loop,
--   this includes errors, that can occur when scheduleing messages.
data ExitReason (t :: ExitRecovery)

-- | A process has finished a unit of work and might exit or work on
--   something else. This is primarily used for interupting infinite server
--   loops, allowing for additional cleanup work before exitting (e.g. with
--   <a>ExitNormally</a>)
[ProcessFinished] :: ExitReason  'Recoverable

-- | A process that should be running was not running.
[ProcessNotRunning] :: ProcessId -> ExitReason  'Recoverable

-- | A linked process is down
[LinkedProcessCrashed] :: ProcessId -> ExitReason  'Recoverable

-- | An exit reason that has an error message but isn't <a>Recoverable</a>.
[ProcessError] :: String -> ExitReason  'Recoverable

-- | A process function returned or exited without any error.
[ExitNormally] :: ExitReason  'NoRecovery

-- | An unhandled <a>Recoverable</a> allows <a>NoRecovery</a>.
[NotRecovered] :: ExitReason  'Recoverable -> ExitReason  'NoRecovery

-- | An unexpected runtime exception was thrown, i.e. an exception derived
--   from <a>SomeException</a>
[UnexpectedException] :: String -> String -> ExitReason  'NoRecovery

-- | A process was cancelled (e.g. killed, in <a>cancel</a>)
[Killed] :: ExitReason  'NoRecovery

-- | This kind is used to indicate if a <a>ExitReason</a> can be treated
--   like a short interrupt which can be handled or ignored.
data ExitRecovery
Recoverable :: ExitRecovery
NoRecovery :: ExitRecovery

-- | <a>ExitReason</a>s which are recoverable are interrupts.
type InterruptReason = ExitReason  'Recoverable

-- | <a>Exc</a>eptions containing <a>InterruptReason</a>s. See
--   <a>handleInterrupts</a>, <a>exitOnInterrupt</a> or
--   <a>provideInterrupts</a>
type Interrupts = Exc InterruptReason

-- | This adds a layer of the <a>Interrupts</a> effect ontop of
--   <a>ConsProcess</a>
type InterruptableProcess e = Interrupts : ConsProcess e

-- | This value indicates wether a process exited in way consistent with
--   the planned behaviour or not.
data ExitSeverity
NormalExit :: ExitSeverity
Crash :: ExitSeverity

-- | An existential wrapper around <a>ExitReason</a>
data SomeExitReason
[SomeExitReason] :: ExitReason x -> SomeExitReason

-- | Get the <tt>ExitRecover</tt>y
toExitRecovery :: ExitReason r -> ExitRecovery

-- | A predicate for recoverable exit reasons. This predicate defines the
--   exit reasonson which functions such as <a>executeAndResume</a>
isRecoverable :: ExitReason x -> Bool

-- | Get the <a>ExitSeverity</a> of a <a>ExitReason</a>.
toExitSeverity :: ExitReason e -> ExitSeverity

-- | A predicate for linked process <b>crashes</b>.
isBecauseDown :: Maybe ProcessId -> ExitReason r -> Bool

-- | A predicate for crashes. A <i>crash</i> happens when a process exits
--   with an <a>ExitReason</a> other than <a>ExitNormally</a>
isCrash :: ExitReason x -> Bool

-- | Print a <a>ExitReason</a> to <a>Just</a> a formatted <a>String</a>
--   when <a>isCrash</a> is <a>True</a>. This can be useful in combination
--   with view patterns, e.g.:
--   
--   <pre>
--   logCrash :: ExitReason -&gt; Eff e ()
--   logCrash (toCrashReason -&gt; Just reason) = logError reason
--   logCrash _ = return ()
--   </pre>
--   
--   Though this can be improved to:
--   
--   <pre>
--   logCrash = traverse_ logError . toCrashReason
--   </pre>
toCrashReason :: ExitReason x -> Maybe String

-- | Partition a <a>SomeExitReason</a> back into either a <a>NoRecovery</a>
--   or a <a>Recoverable</a> <a>ExitReason</a>
fromSomeExitReason :: SomeExitReason -> Either (ExitReason  'NoRecovery) InterruptReason

-- | Log the <tt>ProcessExitReaons</tt>
logProcessExit :: (HasCallStack, Member (Logs LogMessage) e) => ExitReason x -> Eff e ()
instance GHC.Show.Show v => GHC.Show.Show (Control.Eff.Concurrent.Process.ResumeProcess v)
instance GHC.Generics.Generic1 Control.Eff.Concurrent.Process.ResumeProcess
instance GHC.Generics.Generic (Control.Eff.Concurrent.Process.ResumeProcess v)
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.ProcessDown
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.ProcessDown
instance GHC.Generics.Generic Control.Eff.Concurrent.Process.ProcessDown
instance GHC.Generics.Generic Control.Eff.Concurrent.Process.MonitorReference
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.MonitorReference
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.MonitorReference
instance GHC.Read.Read Control.Eff.Concurrent.Process.MonitorReference
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.ProcessId
instance GHC.Real.Real Control.Eff.Concurrent.Process.ProcessId
instance GHC.Real.Integral Control.Eff.Concurrent.Process.ProcessId
instance GHC.Enum.Enum Control.Eff.Concurrent.Process.ProcessId
instance GHC.Num.Num Control.Eff.Concurrent.Process.ProcessId
instance GHC.Enum.Bounded Control.Eff.Concurrent.Process.ProcessId
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.ProcessId
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.ProcessId
instance GHC.Generics.Generic Control.Eff.Concurrent.Process.ExitSeverity
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.ExitSeverity
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.ExitSeverity
instance GHC.Generics.Generic Control.Eff.Concurrent.Process.ExitRecovery
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.ExitRecovery
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.ExitRecovery
instance GHC.Generics.Generic Control.Eff.Concurrent.Process.ProcessState
instance GHC.Enum.Enum Control.Eff.Concurrent.Process.ProcessState
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.ProcessState
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.ProcessState
instance GHC.Show.Show Control.Eff.Concurrent.Process.ProcessState
instance GHC.Read.Read Control.Eff.Concurrent.Process.ProcessState
instance GHC.Base.Functor Control.Eff.Concurrent.Process.MessageSelector
instance GHC.Base.Semigroup a => GHC.Base.Monoid (Control.Eff.Concurrent.Process.MessageSelector a)
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Control.Eff.Concurrent.Process.MessageSelector a)
instance GHC.Show.Show (Control.Eff.Concurrent.Process.Process r b)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Control.Eff.Concurrent.Process.ResumeProcess a)
instance Control.DeepSeq.NFData1 Control.Eff.Concurrent.Process.ResumeProcess
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.ProcessDown
instance GHC.Show.Show Control.Eff.Concurrent.Process.ProcessDown
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.SomeExitReason
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.SomeExitReason
instance GHC.Show.Show Control.Eff.Concurrent.Process.SomeExitReason
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.SomeExitReason
instance GHC.Show.Show (Control.Eff.Concurrent.Process.ExitReason x)
instance GHC.Exception.Type.Exception (Control.Eff.Concurrent.Process.ExitReason 'Control.Eff.Concurrent.Process.Recoverable)
instance GHC.Exception.Type.Exception (Control.Eff.Concurrent.Process.ExitReason 'Control.Eff.Concurrent.Process.NoRecovery)
instance Control.DeepSeq.NFData (Control.Eff.Concurrent.Process.ExitReason x)
instance GHC.Classes.Ord (Control.Eff.Concurrent.Process.ExitReason x)
instance GHC.Classes.Eq (Control.Eff.Concurrent.Process.ExitReason x)
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.MonitorReference
instance GHC.Show.Show Control.Eff.Concurrent.Process.MonitorReference
instance GHC.Read.Read Control.Eff.Concurrent.Process.ProcessId
instance GHC.Show.Show Control.Eff.Concurrent.Process.ProcessId
instance GHC.Show.Show Control.Eff.Concurrent.Process.ExitSeverity
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.ExitSeverity
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.ExitRecovery
instance GHC.Show.Show Control.Eff.Concurrent.Process.ExitRecovery
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.ProcessState
instance Data.Default.Class.Default Control.Eff.Concurrent.Process.ProcessState
instance GHC.Base.Applicative Control.Eff.Concurrent.Process.MessageSelector
instance GHC.Base.Alternative Control.Eff.Concurrent.Process.MessageSelector


-- | Functions for timeouts when receiving messages.
--   
--   NOTE: If you use a single threaded scheduler, these functions will not
--   work as expected. (This is an open TODO)
module Control.Eff.Concurrent.Process.Timer

-- | A number of micro seconds.
data Timeout

-- | The reference to a timer started by <a>startTimer</a>, required to
--   stop a timer via <a>cancelTimer</a>.
data TimerReference

-- | A value to be sent when timer started with <a>startTimer</a> has
--   elapsed.
data TimerElapsed

-- | Send a message to a given process after waiting. The message is
--   created by applying the function parameter to the
--   <a>TimerReference</a>, such that the message can directly refer to the
--   timer.
sendAfter :: forall r q message. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable message, NFData message) => SchedulerProxy q -> ProcessId -> Timeout -> (TimerReference -> message) -> Eff r TimerReference

-- | Start a new timer, after the time has elapsed, <a>TimerElapsed</a> is
--   sent to calling process. The message also contains the
--   <a>TimerReference</a> returned by this function. Use
--   <a>cancelTimer</a> to cancel the timer. Use <a>selectTimerElapsed</a>
--   to receive the message using <a>receiveSelectedMessage</a>. To receive
--   messages with guarded with a timeout see <a>receiveAfter</a>.
startTimer :: forall r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Timeout -> Eff r TimerReference

-- | Cancel a timer started with <a>startTimer</a>.
cancelTimer :: forall r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> TimerReference -> Eff r ()

-- | A <a>MessageSelector</a> matching <a>TimerElapsed</a> messages created
--   by <a>startTimer</a>.
selectTimerElapsed :: TimerReference -> MessageSelector TimerElapsed

-- | Wait for a message of the given type for the given time. When no
--   message arrives in time, return <a>Nothing</a>. This is based on
--   <a>receiveSelectedAfter</a>.
receiveAfter :: forall a r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable a, NFData a, Show a) => SchedulerProxy q -> Timeout -> Eff r (Maybe a)

-- | Wait for a message of the given type for the given time. When no
--   message arrives in time, return <a>Left</a> <a>TimerElapsed</a>. This
--   is based on <a>selectTimerElapsed</a> and <a>startTimer</a>.
receiveSelectedAfter :: forall a r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Show a) => SchedulerProxy q -> MessageSelector a -> Timeout -> Eff r (Either TimerElapsed a)
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.Timer.TimerElapsed
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.Timer.TimerElapsed
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.Timer.TimerElapsed
instance GHC.Enum.Enum Control.Eff.Concurrent.Process.Timer.TimerReference
instance GHC.Real.Real Control.Eff.Concurrent.Process.Timer.TimerReference
instance GHC.Real.Integral Control.Eff.Concurrent.Process.Timer.TimerReference
instance GHC.Num.Num Control.Eff.Concurrent.Process.Timer.TimerReference
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.Timer.TimerReference
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.Timer.TimerReference
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.Timer.TimerReference
instance GHC.Enum.Enum Control.Eff.Concurrent.Process.Timer.Timeout
instance GHC.Real.Real Control.Eff.Concurrent.Process.Timer.Timeout
instance GHC.Real.Integral Control.Eff.Concurrent.Process.Timer.Timeout
instance GHC.Num.Num Control.Eff.Concurrent.Process.Timer.Timeout
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.Timer.Timeout
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.Timer.Timeout
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.Timer.Timeout
instance GHC.Show.Show Control.Eff.Concurrent.Process.Timer.TimerElapsed
instance GHC.Show.Show Control.Eff.Concurrent.Process.Timer.TimerReference
instance GHC.Show.Show Control.Eff.Concurrent.Process.Timer.Timeout


-- | A coroutine based, single threaded scheduler for <a>Process</a>es.
module Control.Eff.Concurrent.Process.SingleThreadedScheduler

-- | Handle the <a>Process</a> effect, as well as all lower effects using
--   an effect handler function.
--   
--   Execute the <b>main</b> <a>Process</a> and all the other processes
--   <a>spawn</a>ed by it in the current thread concurrently, using a
--   co-routine based, round-robin scheduler. If a process exits with
--   <a>exitNormally</a>, <a>exitWithError</a>, <tt>raiseError</tt> or is
--   killed by another process <tt>Left ...</tt> is returned. Otherwise,
--   the result will be wrapped in a <tt>Right</tt>.
--   
--   Every time a process _yields_ the effects are evaluated down to the a
--   value of type <tt>m (Either String a)</tt>.
--   
--   If the evaluator function runs the action down e.g. <tt>IO</tt> this
--   might improve memory consumption, for long running services, with
--   processes that loop endlessly.
scheduleM :: forall m r a. Monad m => (forall b. Eff r b -> m b) -> m () -> Eff (InterruptableProcess r) a -> m (Either (ExitReason  'NoRecovery) a)

-- | Like <tt>schedule</tt> but <i>pure</i>. The <tt>yield</tt> effect is
--   just <tt>return ()</tt>. <tt>schedulePure == runIdentity .
--   <a>scheduleM</a> (Identity . run) (return ())</tt>
schedulePure :: Eff (InterruptableProcess '[Logs LogMessage]) a -> Either (ExitReason  'NoRecovery) a

-- | Invoke <tt>schedule</tt> with <tt>lift <a>yield</a></tt> as yield
--   effect. <tt>scheduleIO runEff == <a>scheduleM</a> (runLift . runEff)
--   (liftIO <a>yield</a>)</tt>
scheduleIO :: MonadIO m => (forall b. Eff r b -> Eff '[Lift m] b) -> Eff (InterruptableProcess r) a -> m (Either (ExitReason  'NoRecovery) a)

-- | Invoke <tt>schedule</tt> with <tt>lift <a>yield</a></tt> as yield
--   effect. <tt>scheduleMonadIOEff == <a>scheduleM</a> id (liftIO
--   <a>yield</a>)</tt>
scheduleMonadIOEff :: MonadIO (Eff r) => Eff (InterruptableProcess r) a -> Eff r (Either (ExitReason  'NoRecovery) a)

-- | Run processes that have the <a>Logs</a> and the <a>Lift</a> effects.
--   The user must provide a log handler function.
--   
--   Log messages are evaluated strict.
--   
--   <pre>
--   scheduleIOWithLogging == <a>run</a> . <tt>captureLogs</tt> . <tt>schedule</tt> (return ())
--   </pre>
scheduleIOWithLogging :: NFData l => LogWriter l IO -> Eff (InterruptableProcess '[Logs l, LogWriterReader l IO, Lift IO]) a -> IO (Either (ExitReason  'NoRecovery) a)

-- | Execute a <a>Process</a> using <tt>schedule</tt> on top of <a>Lift</a>
--   <tt>IO</tt> and <a>Logs</a> <tt>String</tt> effects.
defaultMainSingleThreaded :: HasCallStack => Eff (InterruptableProcess '[Logs LogMessage, LogWriterReader LogMessage IO, Lift IO]) () -> IO ()

-- | A <a>SchedulerProxy</a> for <a>LoggingAndIo</a>.
singleThreadedIoScheduler :: SchedulerProxy LoggingAndIo
instance GHC.Show.Show (Control.Eff.Concurrent.Process.SingleThreadedScheduler.OnYield r a)
instance GHC.Show.Show (Control.Eff.Concurrent.Process.SingleThreadedScheduler.STS r m)


-- | Implement Erlang style message passing concurrency.
--   
--   This handles the <tt>MessagePassing</tt> and <a>Process</a> effects,
--   using <a>TQueue</a>s and <tt>forkIO</tt>.
--   
--   This aims to be a pragmatic implementation, so even logging is
--   supported.
--   
--   At the core is a <i>main process</i> that enters <a>schedule</a> and
--   creates all of the internal state stored in <a>TVar</a>s to manage
--   processes with message queues.
--   
--   The <a>Eff</a> handler for <a>Process</a> and <tt>MessagePassing</tt>
--   use are implemented and available through <a>spawn</a>.
module Control.Eff.Concurrent.Process.ForkIOScheduler

-- | This is the main entry point to running a message passing concurrency
--   application. This function takes a <a>Process</a> on top of the
--   <a>SchedulerIO</a> effect and a <a>LogChannel</a> for concurrent
--   logging.
schedule :: (HasLogging IO SchedulerIO, HasCallStack) => Eff InterruptableProcEff () -> Eff LoggingAndIO ()

-- | Start the message passing concurrency system then execute a
--   <a>Process</a> on top of <a>SchedulerIO</a> effect. All logging is
--   sent to standard output.
defaultMain :: HasCallStack => Eff InterruptableProcEff () -> IO ()

-- | Start the message passing concurrency system then execute a
--   <a>Process</a> on top of <a>SchedulerIO</a> effect. All logging is
--   sent to standard output.
defaultMainWithLogChannel :: HasCallStack => Eff InterruptableProcEff () -> LogChannel LogMessage -> IO ()

-- | The concrete list of <a>Eff</a>ects of processes compatible with this
--   scheduler. This builds upon <a>SchedulerIO</a>.
type ProcEff = ConsProcess SchedulerIO

-- | The concrete list of the effects, that the <a>Process</a> uses
type InterruptableProcEff = InterruptableProcess SchedulerIO

-- | The concrete list of <a>Eff</a>ects for this scheduler implementation.
type SchedulerIO = (Reader SchedulerState : LoggingAndIO)

-- | Type class constraint to indicate that an effect union contains the
--   effects required by every process and the scheduler implementation
--   itself.
type HasSchedulerIO r = (HasCallStack, Lifted IO r, SchedulerIO <:: r)

-- | A <a>SchedulerProxy</a> for <a>SchedulerIO</a>
forkIoScheduler :: SchedulerProxy SchedulerIO
instance GHC.Show.Show Control.Eff.Concurrent.Process.ForkIOScheduler.ProcessInfo
instance Data.Default.Class.Default Control.Eff.Concurrent.Process.ForkIOScheduler.MessageQ


-- | This module contains a mechanism to specify what kind of messages (aka
--   <i>requests</i>) a <a>Server</a> (<a>Process</a>) can handle, and if
--   the caller blocks and waits for an answer, which the server process
--   provides.
--   
--   The type magic in the <a>Api</a> type familiy allows to define a
--   related set of <i>requests</i> along with the corresponding responses.
--   
--   Request handling can be either blocking, if a response is requred, or
--   non-blocking.
--   
--   A process can <i>serve</i> a specific <a>Api</a> instance by using the
--   functions provided by the <a>Control.Eff.Concurrent.Api.Server</a>
--   module.
--   
--   To enable a process to use such a <i>service</i>, the functions
--   provided by the <a>Control.Eff.Concurrent.Api.Client</a> should be
--   used.
module Control.Eff.Concurrent.Api

-- | This data family defines an API, a communication interface description
--   between at least two processes. The processes act as <b>servers</b> or
--   <b>client(s)</b> regarding a specific instance of this type.
--   
--   The first parameter is usually a user defined phantom type that
--   identifies the <a>Api</a> instance.
--   
--   The second parameter specifies if a specific constructor of an
--   (GADT-like) <tt>Api</tt> instance is <a>Synchronous</a>, i.e. returns
--   a result and blocks the caller or if it is <a>Asynchronous</a>
--   
--   Example:
--   
--   <pre>
--   data BookShop deriving Typeable
--   
--   data instance Api BookShop r where
--     RentBook  :: BookId   -&gt; Api BookShop ('Synchronous (Either RentalError RentalId))
--     BringBack :: RentalId -&gt; Api BookShop 'Asynchronous
--   
--   type BookId = Int
--   type RentalId = Int
--   type RentalError = String
--   </pre>
data family Api (api :: Type) (reply :: Synchronicity)

-- | The (promoted) constructors of this type specify (at the type level)
--   the reply behavior of a specific constructor of an <tt>Api</tt>
--   instance.
data Synchronicity

-- | Specify that handling a request is a blocking operation with a
--   specific return type, e.g. <tt>('Synchronous (Either RentalError
--   RentalId))</tt>
Synchronous :: Type -> Synchronicity

-- | Non-blocking, asynchronous, request handling
Asynchronous :: Synchronicity

-- | This is a tag-type that wraps around a <a>ProcessId</a> and holds an
--   <a>Api</a> index type.
newtype Server api
Server :: ProcessId -> Server api
[_fromServer] :: Server api -> ProcessId
fromServer :: forall api_a17VQ api_a1868. Iso (Server api_a17VQ) (Server api_a1868) ProcessId ProcessId

-- | Tag a <a>ProcessId</a> with an <a>Api</a> type index to mark it a
--   <a>Server</a> process handling that API
proxyAsServer :: proxy api -> ProcessId -> Server api

-- | Tag a <a>ProcessId</a> with an <a>Api</a> type index to mark it a
--   <a>Server</a> process handling that API
asServer :: forall api. ProcessId -> Server api
instance forall k (api :: k). GHC.Classes.Ord (Control.Eff.Concurrent.Api.Server api)
instance forall k (api :: k). GHC.Classes.Eq (Control.Eff.Concurrent.Api.Server api)
instance forall k (api :: k). Data.Typeable.Internal.Typeable api => GHC.Show.Show (Control.Eff.Concurrent.Api.Server api)


-- | Functions to implement <a>Api</a> <b>servers</b>.
module Control.Eff.Concurrent.Api.Server

-- | Receive and process incoming requests until the process exits.
serve :: forall a effScheduler. (Servable a, SetMember Process (Process effScheduler) (ServerEff a), Member Interrupts (ServerEff a), HasCallStack) => SchedulerProxy effScheduler -> a -> Eff (ServerEff a) ()

-- | Spawn a new process, that will receive and process incoming requests
--   until the process exits.
spawnServer :: forall a effScheduler eff. (Servable a, ServerEff a ~ InterruptableProcess effScheduler, SetMember Process (Process effScheduler) eff, Member Interrupts eff, HasCallStack) => SchedulerProxy effScheduler -> a -> Eff eff (ServerPids a)

-- | Spawn a new process, that will receive and process incoming requests
--   until the process exits. Also handle all internal effects.
spawnServerWithEffects :: forall a effScheduler eff. (Servable a, SetMember Process (Process effScheduler) (ServerEff a), SetMember Process (Process effScheduler) eff, Member Interrupts eff, Member Interrupts (ServerEff a), HasCallStack) => SchedulerProxy effScheduler -> a -> (Eff (ServerEff a) () -> Eff (InterruptableProcess effScheduler) ()) -> Eff eff (ServerPids a)

-- | A record of callbacks, handling requests sent to a <i>server</i>
--   <a>Process</a>, all belonging to a specific <a>Api</a> family
--   instance. The values of this type can be <a>serve</a>ed or combined
--   via <a>Servable</a> or <a>ServerCallback</a>s.
data ApiHandler api eff
[ApiHandler] :: {_castCallback :: Maybe (Api api  'Asynchronous -> Eff eff ApiServerCmd) " A cast will not return a result directly. This is used for async methods. This returns an 'ApiServerCmd' to the server loop.", _callCallback :: forall reply. Maybe (Api api ( 'Synchronous reply) -> (reply -> Eff eff ()) -> Eff eff ApiServerCmd) " A call is a blocking operation, the caller is blocked until this handler calls the reply continuation. This returns an 'ApiServerCmd' to the server loop.", _terminateCallback :: Maybe (ExitReason  'Recoverable -> Eff eff ()) " This callback is called with @Nothing@ if one of these things happen:  * the process exits * '_callCallback' or '_castCallback' return 'StopApiServer'  If the process exist peacefully the parameter is 'NotServerCallbacking', otherwise @Just "error message..."@ if the process exits with an error.  The default behavior is defined in 'defaultTermination'."} -> ApiHandler api eff
castCallback :: forall api_a18Ad eff_a18Ae. Lens' (ApiHandler api_a18Ad eff_a18Ae) (Maybe (Api api_a18Ad  'Asynchronous -> Eff eff_a18Ae ApiServerCmd))
callCallback :: forall api_a18Ad eff_a18Ae reply_a18Ah. Getter (ApiHandler api_a18Ad eff_a18Ae) (Maybe (Api api_a18Ad ( 'Synchronous reply_a18Ah) -> (reply_a18Ah -> Eff eff_a18Ae ()) -> Eff eff_a18Ae ApiServerCmd))
terminateCallback :: forall api_a18Ad eff_a18Ae. Lens' (ApiHandler api_a18Ad eff_a18Ae) (Maybe (ExitReason  'Recoverable -> Eff eff_a18Ae ()))

-- | Create an <a>ApiHandler</a> with a <a>_castCallback</a>, a
--   <a>_callCallback</a> and a <a>_terminateCallback</a> implementation.
apiHandler :: (Api api  'Asynchronous -> Eff e ApiServerCmd) -> (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> (ExitReason  'Recoverable -> Eff e ()) -> ApiHandler api e

-- | Like <a>apiHandler</a> but the server will loop until an error is
--   raised or the process exits. The callback actions won't decide wether
--   to stop the server or not, instead the <a>ApiServerCmd</a>
--   <a>HandleNextRequest</a> is used.
apiHandlerForever :: (Api api  'Asynchronous -> Eff e ()) -> (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> (ExitReason  'Recoverable -> Eff e ()) -> ApiHandler api e

-- | Create an <a>ApiHandler</a> with only a <a>_castCallback</a>
--   implementation.
castHandler :: (Api api  'Asynchronous -> Eff eff ApiServerCmd) -> ApiHandler api eff

-- | Like <a>castHandler</a> but the server will loop until an error is
--   raised or the process exits. See <tt>apiHandlerForver</tt>.
castHandlerForever :: (Api api  'Asynchronous -> Eff eff ()) -> ApiHandler api eff

-- | Create an <a>ApiHandler</a> with only a <a>_callCallback</a>
--   implementation.
callHandler :: (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> ApiHandler api e

-- | Like <a>callHandler</a> but the server will loop until an error is
--   raised or the process exits. See <tt>apiHandlerForver</tt>.
callHandlerForever :: (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> ApiHandler api e

-- | Create an <a>ApiHandler</a> with only a <a>_castCallback</a> and
--   <a>_callCallback</a> implementation.
castAndCallHandler :: (Api api  'Asynchronous -> Eff e ApiServerCmd) -> (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> ApiHandler api e

-- | Like <a>castAndCallHandler</a> but the server will loop until an error
--   is raised or the process exits. See <tt>apiHandlerForver</tt>.
castAndCallHandlerForever :: (Api api  'Asynchronous -> Eff e ()) -> (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> ApiHandler api e

-- | A command to the server loop started e.g. by <tt>server</tt> or
--   <a>spawnServerWithEffects</a>. Typically returned by an
--   <a>ApiHandler</a> member to indicate if the server should continue or
--   stop.
data ApiServerCmd

-- | Tell the server to keep the server loop running
[HandleNextRequest] :: ApiServerCmd

-- | Tell the server to exit, this will make <a>serve</a> stop handling
--   requests without exitting the process. <a>_terminateCallback</a> will
--   be invoked with the given optional reason.
[StopApiServer] :: ExitReason  'Recoverable -> ApiServerCmd

-- | A default handler to use in <a>_callCallback</a> in <a>ApiHandler</a>.
--   It will call <tt>raiseError</tt> with a nice error message.
unhandledCallError :: forall p x r q. (Typeable p, HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Api p ( 'Synchronous x) -> (x -> Eff r ()) -> Eff r ApiServerCmd

-- | A default handler to use in <a>_castCallback</a> in <a>ApiHandler</a>.
--   It will call <tt>raiseError</tt> with a nice error message.
unhandledCastError :: forall p r q. (Typeable p, HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Api p  'Asynchronous -> Eff r ApiServerCmd

-- | Either do nothing, if the error message is <tt>Nothing</tt>, or call
--   <a>exitWithError</a> with the error message.
defaultTermination :: forall q r. (HasCallStack, SetMember Process (Process q) r, Member (Logs LogMessage) r) => SchedulerProxy q -> ExitReason  'Recoverable -> Eff r ()

-- | Helper type class to allow composition of <a>ApiHandler</a>.
class Servable a where {
    
    -- | The effect of the callbacks
    type family ServerEff a :: [Type -> Type];
    
    -- | The is used to let the spawn function return multiple <a>Server</a>
    --   <a>ProcessId</a>s in a type safe way, e.g. for a tuple instance of
    --   this class <tt>(Server a, Server b)</tt>
    type family ServerPids a;
}

-- | The is used to let the spawn function return multiple <a>Server</a>
--   <a>ProcessId</a>s in a type safe way.
toServerPids :: Servable a => proxy a -> ProcessId -> ServerPids a

-- | Convert the value to a <a>ServerCallback</a>
toServerCallback :: (Servable a, Member Interrupts (ServerEff a), SetMember Process (Process effScheduler) (ServerEff a)) => SchedulerProxy effScheduler -> a -> ServerCallback (ServerEff a)

-- | Building block for composition of <a>ApiHandler</a>. A wrapper for
--   <a>ApiHandler</a>. Use this to combine <a>ApiHandler</a>, allowing a
--   process to implement several <a>Api</a> instances. The termination
--   will be evenly propagated. Create this via e.g. <a>Servable</a>
--   instances To serve multiple apis use <a>&lt;&gt;</a> to combine server
--   callbacks, e.g.
--   
--   @@<tt> let f = apiHandlerServerCallback px $ ApiHandler ... g =
--   apiHandlerServerCallback px $ ApiHandler ... h = f &lt;&gt; g in serve
--   px h </tt>@@
data ServerCallback eff
ServerCallback :: MessageSelector (Eff eff ApiServerCmd) -> (ExitReason  'Recoverable -> Eff eff ()) -> ServerCallback eff
[_requestHandlerSelector] :: ServerCallback eff -> MessageSelector (Eff eff ApiServerCmd)
[_terminationHandler] :: ServerCallback eff -> ExitReason  'Recoverable -> Eff eff ()
requestHandlerSelector :: forall eff_a18Mt. Lens' (ServerCallback eff_a18Mt) (MessageSelector (Eff eff_a18Mt ApiServerCmd))
terminationHandler :: forall eff_a18Mt. Lens' (ServerCallback eff_a18Mt) (ExitReason  'Recoverable -> Eff eff_a18Mt ())
instance Control.Eff.Concurrent.Api.Server.Servable (Control.Eff.Concurrent.Api.Server.ServerCallback eff)
instance Data.Typeable.Internal.Typeable a => Control.Eff.Concurrent.Api.Server.Servable (Control.Eff.Concurrent.Api.Server.ApiHandler a eff)
instance (Control.Eff.Concurrent.Api.Server.ServerEff a Data.Type.Equality.~ Control.Eff.Concurrent.Api.Server.ServerEff b, Control.Eff.Concurrent.Api.Server.Servable a, Control.Eff.Concurrent.Api.Server.Servable b) => Control.Eff.Concurrent.Api.Server.Servable (a, b)
instance GHC.Base.Semigroup (Control.Eff.Concurrent.Api.Server.ServerCallback eff)
instance GHC.Base.Monoid (Control.Eff.Concurrent.Api.Server.ServerCallback eff)
instance GHC.Generics.Generic Control.Eff.Concurrent.Api.Server.ApiServerCmd
instance GHC.Show.Show Control.Eff.Concurrent.Api.Server.ApiServerCmd
instance Data.Default.Class.Default (Control.Eff.Concurrent.Api.Server.ApiHandler api eff)
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Api.Server.ApiServerCmd


-- | Functions for <a>Api</a> clients.
--   
--   This modules is required to write clients that consume an <a>Api</a>.
module Control.Eff.Concurrent.Api.Client

-- | Send an <a>Api</a> request that has no return value and return as fast
--   as possible. The type signature enforces that the corresponding
--   <a>Api</a> clause is <a>Asynchronous</a>. The operation never fails,
--   if it is important to know if the message was delivered, use
--   <a>call</a> instead.
cast :: forall r q o. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable o, Typeable (Api o  'Asynchronous)) => SchedulerProxy q -> Server o -> Api o  'Asynchronous -> Eff r ()

-- | Send an <a>Api</a> request and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Api</a> clause
--   is <a>Synchronous</a>.
call :: forall result api r q. (SetMember Process (Process q) r, Member Interrupts r, Typeable api, Typeable (Api api ( 'Synchronous result)), Typeable result, HasCallStack, NFData result, Show result) => SchedulerProxy q -> Server api -> Api api ( 'Synchronous result) -> Eff r result

-- | Like <a>cast</a> but take the <a>Server</a> from the reader provided
--   by <a>registerServer</a>.
castRegistered :: (Typeable o, ServesApi o r q, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Api o  'Asynchronous -> Eff r ()

-- | Like <a>call</a> but take the <a>Server</a> from the reader provided
--   by <a>registerServer</a>.
callRegistered :: (Typeable reply, ServesApi o r q, HasCallStack, NFData reply, Show reply, Member Interrupts r) => SchedulerProxy q -> Api o ( 'Synchronous reply) -> Eff r reply

-- | Instead of passing around a <a>Server</a> value and passing to
--   functions like <a>cast</a> or <a>call</a>, a <a>Server</a> can
--   provided by a <a>Reader</a> effect, if there is only a <b>single
--   server</b> for a given <a>Api</a> instance. This type alias is
--   convenience to express that an effect has <a>Process</a> and a reader
--   for a <a>Server</a>.
type ServesApi o r q = (Typeable o, SetMember Process (Process q) r, Member (ServerReader o) r)

-- | The reader effect for <a>ProcessId</a>s for <a>Api</a>s, see
--   <a>registerServer</a>
type ServerReader o = Reader (Server o)

-- | Get the <a>Server</a> registered with <a>registerServer</a>.
whereIsServer :: Member (ServerReader o) e => Eff e (Server o)

-- | Run a reader effect that contains <b>the one</b> server handling a
--   specific <a>Api</a> instance.
registerServer :: HasCallStack => Server o -> Eff (ServerReader o : r) a -> Eff r a


-- | This module provides support for executing <a>Process</a> actions from
--   <a>IO</a>.
--   
--   One use case is interacting with processes from the REPL, e.g.:
--   
--   <pre>
--   &gt;&gt;&gt; import Control.Eff.Concurrent.Process.SingleThreadedScheduler (defaultMain)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; import Control.Eff.Loop
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Dynamic
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Maybe
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; s &lt;- forkInteractiveScheduler Control.Eff.Concurrent.Process.SingleThreadedScheduler.defaultMain
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; fooPid &lt;- submit s (spawn (foreverCheap (receiveAnyMessage SP &gt;&gt;= (logMsg . fromMaybe "Huh!??" . fromDynamic))))
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; fooPid
--   &lt;0.1.0&gt;
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; submit s (sendMessageAs SP fooPid "test")
--   test
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; submit s (sendShutdown SP fooPid)
--   </pre>
module Control.Eff.Concurrent.Process.Interactive

-- | Contains the communication channels to interact with a scheduler
--   running in its' own thread.
data SchedulerSession r

-- | Fork a scheduler with a process that communicates with it via
--   <a>MVar</a>, which is also the reason for the <tt>Lift IO</tt>
--   constraint.
forkInteractiveScheduler :: forall r. SetMember Lift (Lift IO) r => (Eff (InterruptableProcess r) () -> IO ()) -> IO (SchedulerSession r)

-- | Exit the schedulder immediately using an asynchronous exception.
killInteractiveScheduler :: SchedulerSession r -> IO ()

-- | Send a <a>Process</a> effect to the main process of a scheduler, this
--   blocks until the effect is executed.
submit :: forall r a. SetMember Lift (Lift IO) r => SchedulerSession r -> Eff (InterruptableProcess r) a -> IO a

-- | Combination of <a>submit</a> and <a>cast</a>.
submitCast :: forall o r. (SetMember Lift (Lift IO) r, Typeable o, Member Interrupts r) => SchedulerSession r -> Server o -> Api o  'Asynchronous -> IO ()

-- | Combination of <a>submit</a> and <a>cast</a>.
submitCall :: forall o q r. (SetMember Lift (Lift IO) r, Typeable o, Typeable q, NFData q, Show q, Member Interrupts r) => SchedulerSession r -> Server o -> Api o ( 'Synchronous q) -> IO q


-- | Observer Effects
--   
--   This module supports the implementation of observers and observables.
--   One use case is event propagation. The tools in this module are
--   tailored towards <a>Api</a> servers/clients.
module Control.Eff.Concurrent.Api.Observer

-- | An <a>Api</a> index that support observation of the another <a>Api</a>
--   that is <a>Observable</a>.
class (Typeable p, Observable o) => Observer p o

-- | Wrap the <a>Observation</a> and the <a>ProcessId</a> (i.e. the
--   <a>Server</a>) that caused the observation into an <a>Api</a> value
--   that the <a>Observable</a> understands.
observationMessage :: Observer p o => Server o -> Observation o -> Api p  'Asynchronous

-- | An <a>Api</a> index that supports registration and de-registration of
--   <a>Observer</a>s.
class (Typeable o, Typeable (Observation o)) => Observable o where {
    
    -- | Type of observations visible on this observable
    data family Observation o;
}

-- | Return the <a>Api</a> value for the <tt>cast_</tt> that registeres an
--   observer
registerObserverMessage :: Observable o => SomeObserver o -> Api o  'Asynchronous

-- | Return the <a>Api</a> value for the <tt>cast_</tt> that de-registeres
--   an observer
forgetObserverMessage :: Observable o => SomeObserver o -> Api o  'Asynchronous

-- | Send an <a>Observation</a> to an <a>Observer</a>
notifyObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Observation o -> Eff r ()

-- | Send the <a>registerObserverMessage</a>
registerObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Eff r ()

-- | Send the <a>forgetObserverMessage</a>
forgetObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Eff r ()

-- | An existential wrapper around a <a>Server</a> of an <a>Observer</a>.
--   Needed to support different types of observers to observe the same
--   <a>Observable</a> in a general fashion.
data SomeObserver o
[SomeObserver] :: (Show (Server p), Typeable p, Observer p o) => Server p -> SomeObserver o

-- | Send an <a>Observation</a> to <a>SomeObserver</a>.
notifySomeObserver :: (SetMember Process (Process q) r, Observable o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server o -> Observation o -> SomeObserver o -> Eff r ()

-- | Internal state for <a>manageObservers</a>
data Observers o

-- | Alias for the effect that contains the observers managed by
--   <a>manageObservers</a>
type ObserverState o = State (Observers o)

-- | Keep track of registered <a>Observer</a>s Observers can be added and
--   removed, and an <a>Observation</a> can be sent to all registerd
--   observers at once.
manageObservers :: Eff (ObserverState o : r) a -> Eff r a

-- | Add an <a>Observer</a> to the <a>Observers</a> managed by
--   <a>manageObservers</a>.
addObserver :: (SetMember Process (Process q) r, Member (ObserverState o) r, Observable o) => SomeObserver o -> Eff r ()

-- | Delete an <a>Observer</a> from the <a>Observers</a> managed by
--   <a>manageObservers</a>.
removeObserver :: (SetMember Process (Process q) r, Member (ObserverState o) r, Observable o, Member Interrupts r) => SomeObserver o -> Eff r ()

-- | Send an <a>Observation</a> to all <a>SomeObserver</a>s in the
--   <a>Observers</a> state.
notifyObservers :: forall o r q. (Observable o, SetMember Process (Process q) r, Member (ObserverState o) r, Member Interrupts r) => SchedulerProxy q -> Observation o -> Eff r ()

-- | An <a>Observer</a> that schedules the observations to an effectful
--   callback.
data CallbackObserver o

-- | Start a new process for an <a>Observer</a> that schedules all
--   observations to an effectful callback.
spawnCallbackObserver :: forall o r q. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, Member (Logs LogMessage) q, Member Interrupts r, HasCallStack) => SchedulerProxy q -> (Server o -> Observation o -> Eff (InterruptableProcess q) ApiServerCmd) -> Eff r (Server (CallbackObserver o))

-- | Start a new process for an <a>Observer</a> that schedules all
--   observations to an effectful callback.
spawnLoggingObserver :: forall o r q. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, Member (Logs LogMessage) q, Member (Logs LogMessage) r, Member Interrupts r, HasCallStack) => SchedulerProxy q -> Eff r (Server (CallbackObserver o))
instance GHC.Show.Show (Control.Eff.Concurrent.Api.Observer.SomeObserver o)
instance GHC.Show.Show (Control.Eff.Concurrent.Api.Observer.Observation o) => GHC.Show.Show (Control.Eff.Concurrent.Api.Api (Control.Eff.Concurrent.Api.Observer.CallbackObserver o) r)
instance Control.Eff.Concurrent.Api.Observer.Observable o => Control.Eff.Concurrent.Api.Observer.Observer (Control.Eff.Concurrent.Api.Observer.CallbackObserver o) o
instance GHC.Classes.Ord (Control.Eff.Concurrent.Api.Observer.SomeObserver o)
instance GHC.Classes.Eq (Control.Eff.Concurrent.Api.Observer.SomeObserver o)


-- | Experimental new <a>Api</a> server handler.
module Control.Eff.Concurrent.Api.Server2

-- | <i>Serve</i> an <a>Api</a> in a newly spawned process.
spawnApiServer :: forall api eff. (ToServerPids api, HasCallStack) => MessageCallback api (InterruptableProcess eff) -> InterruptCallback (ConsProcess eff) -> Eff (InterruptableProcess eff) (ServerPids api)

-- | <i>Serve</i> an <a>Api</a> in a newly spawned -and linked - process.
spawnLinkApiServer :: forall api eff. (ToServerPids api, HasCallStack) => MessageCallback api (InterruptableProcess eff) -> InterruptCallback (ConsProcess eff) -> Eff (InterruptableProcess eff) (ServerPids api)

-- | <i>Server</i> an <a>Api</a> in a newly spawned process; the callbacks
--   have access to some state initialed by the function in the first
--   parameter.
spawnApiServerStateful :: forall api eff state. (HasCallStack, ToServerPids api) => Eff (InterruptableProcess eff) state -> MessageCallback api (State state : InterruptableProcess eff) -> InterruptCallback (State state : ConsProcess eff) -> Eff (InterruptableProcess eff) (ServerPids api)

-- | <i>Server</i> an <a>Api</a> in a newly spawned process; The caller
--   provides an effect handler for arbitrary effects used by the server
--   callbacks.
spawnApiServerEffectful :: forall api eff serverEff. (HasCallStack, ToServerPids api, Member Interrupts serverEff, SetMember Process (Process eff) serverEff) => (forall b. Eff serverEff b -> Eff (InterruptableProcess eff) b) -> MessageCallback api serverEff -> InterruptCallback serverEff -> Eff (InterruptableProcess eff) (ServerPids api)

-- | <i>Server</i> an <a>Api</a> in a newly spawned process; The caller
--   provides an effect handler for arbitrary effects used by the server
--   callbacks. Links to the calling process like <a>linkProcess</a> would.
spawnLinkApiServerEffectful :: forall api eff serverEff. (HasCallStack, ToServerPids api, Member Interrupts serverEff, SetMember Process (Process eff) serverEff) => (forall b. Eff serverEff b -> Eff (InterruptableProcess eff) b) -> MessageCallback api serverEff -> InterruptCallback serverEff -> Eff (InterruptableProcess eff) (ServerPids api)

-- | Receive loop for <a>Api</a> <tt>call</tt>s. This starts a receive loop
--   for a <a>MessageCallback</a>. It is used behind the scenes by
--   <a>spawnLinkApiServerEffectful</a> and <a>spawnApiServerEffectful</a>.
apiServerLoop :: forall api eff serverEff. (HasCallStack, ToServerPids api, Member Interrupts serverEff, SetMember Process (Process eff) serverEff) => MessageCallback api serverEff -> InterruptCallback serverEff -> Eff serverEff ()

-- | A command to the server loop started e.g. by <tt>server</tt> or
--   <tt>spawnServerWithEffects</tt>. Typically returned by an
--   <tt>ApiHandler</tt> member to indicate if the server should continue
--   or stop.
data CallbackResult

-- | Tell the server to keep the server loop running
[AwaitNext] :: CallbackResult

-- | Tell the server to exit, this will make <tt>serve</tt> stop handling
--   requests without exitting the process. <tt>_terminateCallback</tt>
--   will be invoked with the given optional reason.
[StopServer] :: InterruptReason -> CallbackResult

-- | An existential wrapper around a <a>MessageSelector</a> and a function
--   that handles the selected message. The <tt>api</tt> type parameter is
--   a phantom type.
--   
--   The return value if the handler function is a <a>CallbackResult</a>.
data MessageCallback api eff
[MessageCallback] :: MessageSelector a -> (a -> Eff eff CallbackResult) -> MessageCallback api eff

-- | A smart constructor for <a>MessageCallback</a>s
handleCasts :: forall api eff. (HasCallStack, Typeable api, Typeable (Api api  'Asynchronous)) => (Api api  'Asynchronous -> Eff eff CallbackResult) -> MessageCallback api eff

-- | A smart constructor for <a>MessageCallback</a>s
--   
--   <pre>
--   handleCalls SP
--     (\ (RentBook bookId customerId) runCall -&gt;
--        runCall $ do
--            rentalIdE &lt;- rentBook bookId customerId
--            case rentalIdE of
--              -- on fail we just don't send a reply, let the caller run into
--              -- timeout
--              Left err -&gt; return (Nothing, AwaitNext)
--              Right rentalId -&gt; return (Just rentalId, AwaitNext))
--   </pre>
handleCalls :: forall api eff effScheduler. (HasCallStack, Typeable api, SetMember Process (Process effScheduler) eff, Member Interrupts eff) => SchedulerProxy effScheduler -> (forall secret reply. (Typeable reply, Typeable (Api api ( 'Synchronous reply))) => Api api ( 'Synchronous reply) -> (Eff eff (Maybe reply, CallbackResult) -> secret) -> secret) -> MessageCallback api eff

-- | A smart constructor for <a>MessageCallback</a>s
handleCastsAndCalls :: forall api eff effScheduler. (HasCallStack, Typeable api, Typeable (Api api  'Asynchronous), SetMember Process (Process effScheduler) eff, Member Interrupts eff) => SchedulerProxy effScheduler -> (Api api  'Asynchronous -> Eff eff CallbackResult) -> (forall secret reply. (Typeable reply, Typeable (Api api ( 'Synchronous reply))) => Api api ( 'Synchronous reply) -> (Eff eff (Maybe reply, CallbackResult) -> secret) -> secret) -> MessageCallback api eff

-- | A variation of <a>handleCalls</a> that allows to defer a reply to a
--   call.
handleCallsDeferred :: forall api eff effScheduler. (HasCallStack, Typeable api, SetMember Process (Process effScheduler) eff, Member Interrupts eff) => SchedulerProxy effScheduler -> (forall reply. (Typeable reply, Typeable (Api api ( 'Synchronous reply))) => Api api ( 'Synchronous reply) -> (reply -> Eff eff ()) -> Eff eff CallbackResult) -> MessageCallback api eff

-- | A smart constructor for <a>MessageCallback</a>s
handleMessages :: forall eff a. (HasCallStack, NFData a, Typeable a) => (a -> Eff eff CallbackResult) -> MessageCallback '[] eff

-- | A smart constructor for <a>MessageCallback</a>s
handleSelectedMessages :: forall eff a. HasCallStack => MessageSelector a -> (a -> Eff eff CallbackResult) -> MessageCallback '[] eff

-- | A smart constructor for <a>MessageCallback</a>s
handleAnyMessages :: forall eff. HasCallStack => (Dynamic -> Eff eff CallbackResult) -> MessageCallback '[] eff

-- | A smart constructor for <a>MessageCallback</a>s
handleProcessDowns :: forall eff. HasCallStack => (MonitorReference -> Eff eff CallbackResult) -> MessageCallback '[] eff

-- | A <a>fallbackHandler</a> that drops the left-over messages.
dropUnhandledMessages :: forall eff. HasCallStack => MessageCallback '[] eff

-- | A <a>fallbackHandler</a> that terminates if there are unhandled
--   messages.
exitOnUnhandled :: forall eff. HasCallStack => MessageCallback '[] eff

-- | A <a>fallbackHandler</a> that drops the left-over messages.
logUnhandledMessages :: forall eff. (Member (Logs LogMessage) eff, HasCallStack) => MessageCallback '[] eff

-- | Compose two <a>Api</a>s to a type-leve pair of them.
--   
--   <pre>
--   handleCalls api1calls ^: handleCalls api2calls ^:
--   </pre>
(^:) :: forall (api1 :: Type) (apis2 :: [Type]) eff. HasCallStack => MessageCallback api1 eff -> MessageCallback apis2 eff -> MessageCallback (api1 : apis2) eff
infixr 5 ^:

-- | Make a fallback handler, i.e. a handler to which no other can be
--   composed to from the right.
fallbackHandler :: forall api eff. HasCallStack => MessageCallback api eff -> MessageCallback '[] eff

-- | Helper type class for the return values of <a>spawnApiServer</a> et
--   al.
class ToServerPids (t :: k) where {
    type family ServerPids t;
}
toServerPids :: ToServerPids t => proxy t -> ProcessId -> ServerPids t

-- | Just a wrapper around a function that will be applied to the result of
--   a <a>MessageCallback</a>s <a>StopServer</a> clause, or an
--   <a>InterruptReason</a> caught during the execution of <tt>receive</tt>
--   or a <a>MessageCallback</a>
data InterruptCallback eff
[InterruptCallback] :: (InterruptReason -> Eff eff CallbackResult) -> InterruptCallback eff

-- | A smart constructor for <a>InterruptCallback</a>s
stopServerOnInterrupt :: forall eff. HasCallStack => InterruptCallback eff

-- | Apply a given callback function to incoming <tt>Observeration</tt>s.
handleObservations :: Typeable o => (Server o -> Observation o -> Eff e CallbackResult) -> MessageCallback (Observing o) e

-- | An <a>Api</a> type for generic <a>Observer</a>s, see
--   <a>handleObservations</a>.
data Observing o
instance (Data.Typeable.Internal.Typeable o, Control.Eff.Concurrent.Api.Observer.Observable o) => Control.Eff.Concurrent.Api.Observer.Observer (Control.Eff.Concurrent.Api.Server2.Observing o) o
instance Data.Default.Class.Default (Control.Eff.Concurrent.Api.Server2.InterruptCallback eff)
instance Control.Eff.Concurrent.Api.Server2.ToServerPids '[]
instance (Control.Eff.Concurrent.Api.Server2.ToServerPids api1, Control.Eff.Concurrent.Api.Server2.ToServerPids api2) => Control.Eff.Concurrent.Api.Server2.ToServerPids (api1 : api2)
instance Control.Eff.Concurrent.Api.Server2.ToServerPids api1 => Control.Eff.Concurrent.Api.Server2.ToServerPids api1
instance forall k (api :: k) (eff :: [* -> *]). GHC.Base.Semigroup (Control.Eff.Concurrent.Api.Server2.MessageCallback api eff)
instance forall k (api :: k) (eff :: [* -> *]). GHC.Base.Monoid (Control.Eff.Concurrent.Api.Server2.MessageCallback api eff)
instance forall k (api :: k) (eff :: [* -> *]). Data.Default.Class.Default (Control.Eff.Concurrent.Api.Server2.MessageCallback api eff)


-- | Capture <a>Observation</a>s and enqueue then into an STM
--   <tt>TBQeueu</tt>.
module Control.Eff.Concurrent.Api.Observer.Queue

-- | Contains a <a>TBQueue</a> capturing observations received by
--   <a>enqueueObservationsRegistered</a> or <a>enqueueObservations</a>.
data ObservationQueue a

-- | A <a>Reader</a> for an <a>ObservationQueue</a>.
type ObservationQueueReader a = Reader (ObservationQueue a)

-- | Read queued observations captured by observing a <a>Server</a> that
--   implements an <a>Observable</a> <a>Api</a> using
--   <a>enqueueObservationsRegistered</a> or <a>enqueueObservations</a>.
--   This blocks until the next <a>Observation</a> received. For a
--   non-blocking variant use <a>tryReadObservationQueue</a> or
--   <a>flushObservationQueue</a>.
readObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r (Observation o)

-- | Read queued observations captured by observing a <a>Server</a> that
--   implements an <a>Observable</a> <a>Api</a> using
--   <a>enqueueObservationsRegistered</a> or <a>enqueueObservations</a>.
--   Return the next <a>Observation</a> immediately or <a>Nothing</a> if
--   the queue is empty. Use <a>readObservationQueue</a> to block until an
--   observation is observed.
tryReadObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r (Maybe (Observation o))

-- | Read all currently queued <a>Observation</a>s captured by
--   <a>enqueueObservations</a>. This returns immediately all currently
--   enqueued <a>Observation</a>s. For a blocking variant use
--   <a>readObservationQueue</a>.
flushObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r [Observation o]

-- | Observe a(the) registered <a>Server</a> that implements an
--   <a>Observable</a> <a>Api</a>. Based on <a>enqueueObservations</a>.
enqueueObservationsRegistered :: forall o r q a. (ServesApi o r q, SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, HasLogging IO q, HasLogging IO r, Member Interrupts r, Lifted IO r, HasCallStack) => SchedulerProxy q -> Int -> Eff (ObservationQueueReader o : r) a -> Eff r a

-- | Observe a <a>Server</a> that implements an <a>Observable</a>
--   <a>Api</a>, the <a>Observation</a>s can be obtained by
--   <a>readObservationQueue</a>. All observations are captured up to the
--   queue size limit, such that the first message received will be first
--   message returned by <a>readObservationQueue</a>.
--   
--   This function captures runtime exceptions and cleans up accordingly.
enqueueObservations :: forall o r q a. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, HasLogging IO r, HasLogging IO q, Member Interrupts r, Lifted IO q, HasCallStack) => SchedulerProxy q -> Server o -> Int -> Eff (ObservationQueueReader o : r) a -> Eff r a


-- | In rare occasions GHC optimizes innocent looking loops into
--   space-leaking monsters. See the discussion here: <a>GHC issue
--   13080</a> for more details, or <a>this blog post about space leaks in
--   nested loops</a>
--   
--   These functions in this module <b><i>might</i></b> help, at least in
--   conjunction with the <tt>-fno-full-laziness</tt> GHC option.
--   
--   There is a unit test in the sources of this module, which can be used
--   to do a comperative heap profiling of these function vs. their
--   counterparts in the <tt>base</tt> package.
--   
--   Here are the images of the profiling results, the images show that the
--   functions in this module do not leak space, compared to the original
--   functions (<a>forever</a> and <a>replicateM_</a>):
--   
module Control.Eff.Loop

-- | A version of <a>forever</a> that hopefully tricks GHC into
--   <b><i>not</i></b> creating a space leak. The intuition is, that we
--   want to do something that is <i>cheap</i>, and hence should be
--   <b>recomputed</b> instead of shared.
foreverCheap :: Monad m => m a -> m ()

-- | A version of <a>replicateM_</a> that hopefully tricks GHC into
--   <b><i>not</i></b> creating a space leak. The intuition is, that we
--   want to do something that is <i>cheap</i>, and hence should be
--   <b>recomputed</b> instead of shared.
replicateCheapM_ :: Monad m => Int -> m a -> m ()


-- | Erlang style processes with message passing concurrency based on
--   (more) <tt>extensible-effects</tt>.
module Control.Eff.Concurrent

-- | Each process is identified by a single process id, that stays constant
--   throughout the life cycle of a process. Also, message sending relies
--   on these values to address messages to processes.
newtype ProcessId
ProcessId :: Int -> ProcessId
[_fromProcessId] :: ProcessId -> Int

-- | A monitored process exited. This message is sent to a process by the
--   scheduler, when a process that was monitored via a
--   <tt>SchedulerCommand</tt> died.
data ProcessDown
ProcessDown :: !MonitorReference -> !SomeExitReason -> ProcessDown
[downReference] :: ProcessDown -> !MonitorReference
[downReason] :: ProcessDown -> !SomeExitReason

-- | A value that contains a unique reference of a process monitoring.
data MonitorReference
MonitorReference :: Int -> ProcessId -> MonitorReference
[monitorIndex] :: MonitorReference -> Int
[monitoredProcess] :: MonitorReference -> ProcessId

-- | An existential wrapper around <a>ExitReason</a>
data SomeExitReason
[SomeExitReason] :: ExitReason x -> SomeExitReason

-- | This adds a layer of the <a>Interrupts</a> effect ontop of
--   <a>ConsProcess</a>
type InterruptableProcess e = Interrupts : ConsProcess e

-- | <a>Exc</a>eptions containing <a>InterruptReason</a>s. See
--   <a>handleInterrupts</a>, <a>exitOnInterrupt</a> or
--   <a>provideInterrupts</a>
type Interrupts = Exc InterruptReason

-- | <a>ExitReason</a>s which are recoverable are interrupts.
type InterruptReason = ExitReason  'Recoverable

-- | A sum-type with reasons for why a process exists the scheduling loop,
--   this includes errors, that can occur when scheduleing messages.
data ExitReason (t :: ExitRecovery)

-- | A process has finished a unit of work and might exit or work on
--   something else. This is primarily used for interupting infinite server
--   loops, allowing for additional cleanup work before exitting (e.g. with
--   <a>ExitNormally</a>)
[ProcessFinished] :: ExitReason  'Recoverable

-- | A process that should be running was not running.
[ProcessNotRunning] :: ProcessId -> ExitReason  'Recoverable

-- | A linked process is down
[LinkedProcessCrashed] :: ProcessId -> ExitReason  'Recoverable

-- | An exit reason that has an error message but isn't <a>Recoverable</a>.
[ProcessError] :: String -> ExitReason  'Recoverable

-- | A process function returned or exited without any error.
[ExitNormally] :: ExitReason  'NoRecovery

-- | An unhandled <a>Recoverable</a> allows <a>NoRecovery</a>.
[NotRecovered] :: ExitReason  'Recoverable -> ExitReason  'NoRecovery

-- | An unexpected runtime exception was thrown, i.e. an exception derived
--   from <a>SomeException</a>
[UnexpectedException] :: String -> String -> ExitReason  'NoRecovery

-- | A process was cancelled (e.g. killed, in <a>cancel</a>)
[Killed] :: ExitReason  'NoRecovery

-- | This value indicates wether a process exited in way consistent with
--   the planned behaviour or not.
data ExitSeverity
NormalExit :: ExitSeverity
Crash :: ExitSeverity

-- | This kind is used to indicate if a <a>ExitReason</a> can be treated
--   like a short interrupt which can be handled or ignored.
data ExitRecovery
Recoverable :: ExitRecovery
NoRecovery :: ExitRecovery

-- | The state that a <a>Process</a> is currently in.
data ProcessState

-- | The process has just been started but not called
--   <tt>handleProcess</tt> yet.
ProcessBooting :: ProcessState

-- | The process yielded it's timeslice
ProcessIdle :: ProcessState

-- | The process is busy with non-blocking
ProcessBusy :: ProcessState

-- | The process is busy with sending a message
ProcessBusySending :: ProcessState

-- | The process is busy with killing
ProcessBusySendingShutdown :: ProcessState

-- | The process is busy with killing
ProcessBusySendingInterrupt :: ProcessState

-- | The process blocked by a <a>receiveAnyMessage</a>
ProcessBusyReceiving :: ProcessState

-- | The process blocked by a <a>linkProcess</a>
ProcessBusyLinking :: ProcessState

-- | The process blocked by a <a>unlinkProcess</a>
ProcessBusyUnlinking :: ProcessState

-- | The process blocked by a <a>monitor</a>
ProcessBusyMonitoring :: ProcessState

-- | The process blocked by a <a>demonitor</a>
ProcessBusyDemonitoring :: ProcessState

-- | The process was interrupted
ProcessInterrupted :: ProcessState

-- | The process was shutdown or crashed
ProcessShuttingDown :: ProcessState

-- | <i>Cons</i> <a>Process</a> onto a list of effects.
type ConsProcess r = Process r : r

-- | A constraint for the implicit <a>SchedulerProxy</a> parameter. Use
--   <a>getSchedulerProxy</a> to query it. _EXPERIMENTAL_
type HasScheduler q = (?_schedulerProxy :: SchedulerProxy q)

-- | Every function for <a>Process</a> things needs such a proxy value for
--   the low-level effect list, i.e. the effects identified by
--   <tt><b>r</b></tt> in <tt><a>Process</a> r : r</tt>, this might be
--   dependent on the scheduler implementation.
data SchedulerProxy :: [Type -> Type] -> Type

-- | Tell the typechecker what effects we have below <a>Process</a>
[SchedulerProxy] :: SchedulerProxy q

-- | Like <a>SchedulerProxy</a> but shorter
[SP] :: SchedulerProxy q

-- | Like <a>SP</a> but different
[Scheduler] :: SchedulerProxy q

-- | A function that deciced if the next message will be received by
--   <a>ReceiveSelectedMessage</a>. It conveniently is an instance of
--   <a>Alternative</a> so the message selector can be combined: &gt; &gt;
--   selectInt :: MessageSelector Int &gt; selectInt = selectMessage &gt;
--   &gt; selectString :: MessageSelector String &gt; selectString =
--   selectMessage &gt; &gt; selectIntOrString :: MessageSelector (Either
--   Int String) &gt; selectIntOrString = &gt; Left <a>$</a>
--   selectTimeout<a>|</a> Right <a>$</a> selectString
data MessageSelector a

-- | Every <a>Process</a> action returns it's actual result wrapped in this
--   type. It will allow to signal errors as well as pass on normal results
--   such as incoming messages.
data ResumeProcess v

-- | The current operation of the process was interrupted with a
--   <a>ExitReason</a>. If <a>isRecoverable</a> holds for the given reason,
--   the process may choose to continue.
[Interrupted] :: InterruptReason -> ResumeProcess v

-- | The process may resume to do work, using the given result.
[ResumeWith] :: a -> ResumeProcess a

-- | The process effect is the basis for message passing concurrency. This
--   effect describes an interface for concurrent, communicating isolated
--   processes identified uniquely by a process-id.
--   
--   Processes can raise exceptions that can be caught, exit gracefully or
--   with an error, or be killed by other processes, with the option of
--   ignoring the shutdown request.
--   
--   Process Scheduling is implemented in different modules. All scheduler
--   implementations should follow some basic rules:
--   
--   <ul>
--   <li>fair scheduling</li>
--   <li>sending a message does not block</li>
--   <li>receiving a message does block</li>
--   <li>spawning a child blocks only a very moment</li>
--   <li>a newly spawned process shall be scheduled before the parent
--   process after</li>
--   <li>the spawnRaw</li>
--   <li>when the first process exists, all process should be killed
--   immediately</li>
--   </ul>
data Process (r :: [Type -> Type]) b

-- | Remove all messages from the process' message queue
[FlushMessages] :: Process r (ResumeProcess [Dynamic])

-- | In cooperative schedulers, this will give processing time to the
--   scheduler. Every other operation implicitly serves the same purpose.
[YieldProcess] :: Process r (ResumeProcess ())

-- | Return the current <a>ProcessId</a>
[SelfPid] :: Process r (ResumeProcess ProcessId)

-- | Start a new process, the new process will execute an effect, the
--   function will return immediately with a <a>ProcessId</a>.
[Spawn] :: Eff (Process r : r) () -> Process r (ResumeProcess ProcessId)

-- | Start a new process, and <a>Link</a> to it .
[SpawnLink] :: Eff (Process r : r) () -> Process r (ResumeProcess ProcessId)

-- | Get the process state (or <a>Nothing</a> if the process is dead)
[GetProcessState] :: ProcessId -> Process r (ResumeProcess (Maybe ProcessState))

-- | Shutdown the process; irregardles of the exit reason, this function
--   never returns,
[Shutdown] :: ExitReason  'NoRecovery -> Process r a

-- | Raise an error, that can be handled.
[SendShutdown] :: ProcessId -> ExitReason  'NoRecovery -> Process r (ResumeProcess ())

-- | Request that another a process interrupts. The targeted process is
--   interrupted and gets an <a>Interrupted</a>, the target process may
--   decide to ignore the interrupt and continue as if nothing happened.
[SendInterrupt] :: ProcessId -> InterruptReason -> Process r (ResumeProcess ())

-- | Send a message to a process addressed by the <a>ProcessId</a>. Sending
--   a message should **always succeed** and return **immediately**, even
--   if the destination process does not exist, or does not accept messages
--   of the given type.
[SendMessage] :: ProcessId -> Dynamic -> Process r (ResumeProcess ())

-- | Receive a message that matches a criterium. This should block until an
--   a message was received. The message is returned as a
--   <tt>ProcessMessage</tt> value. The function should also return if an
--   exception was caught or a shutdown was requested.
[ReceiveSelectedMessage] :: forall r a. MessageSelector a -> Process r (ResumeProcess a)

-- | Generate a unique <a>Int</a> for the current process.
[MakeReference] :: Process r (ResumeProcess Int)

-- | Monitor another process. When the monitored process exits a
--   <a>ProcessDown</a> is sent to the calling process. The return value is
--   a unique identifier for that monitor. There can be multiple monitors
--   on the same process, and a message for each will be sent. If the
--   process is already dead, the <a>ProcessDown</a> message will be sent
--   immediately, w.thout exit reason
[Monitor] :: ProcessId -> Process r (ResumeProcess MonitorReference)

-- | Remove a monitor.
[Demonitor] :: MonitorReference -> Process r (ResumeProcess ())

-- | Connect the calling process to another process, such that if one of
--   the processes crashes (i.e. <a>isCrash</a> returns <a>True</a>), the
--   other is shutdown with the <tt>ProcessExitReaon</tt>
--   <a>LinkedProcessCrashed</a>.
[Link] :: ProcessId -> Process r (ResumeProcess ())

-- | Unlink the calling proccess from the other process.
[Unlink] :: ProcessId -> Process r (ResumeProcess ())

-- | Create a message selector for a value that can be obtained by
--   <a>fromDynamic</a>. It will also <a>force</a> the result.
selectMessage :: (NFData t, Typeable t) => MessageSelector t

-- | Create a message selector for a value that can be obtained by
--   <a>fromDynamic</a>. It will also <a>force</a> the result.
selectMessageLazy :: Typeable t => MessageSelector t

-- | Create a message selector from a predicate. It will <a>force</a> the
--   result.
filterMessage :: (Typeable a, NFData a) => (a -> Bool) -> MessageSelector a

-- | Create a message selector from a predicate. It will <a>force</a> the
--   result.
filterMessageLazy :: Typeable a => (a -> Bool) -> MessageSelector a

-- | Select a message of type <tt>a</tt> and apply the given function to
--   it. If the function returns <a>Just</a> The
--   <a>ReceiveSelectedMessage</a> function will return the result (sans
--   <tt>Maybe</tt>). It will <a>force</a> the result.
selectMessageWith :: (Typeable a, NFData b) => (a -> Maybe b) -> MessageSelector b

-- | Select a message of type <tt>a</tt> and apply the given function to
--   it. If the function returns <a>Just</a> The
--   <a>ReceiveSelectedMessage</a> function will return the result (sans
--   <tt>Maybe</tt>). It will <a>force</a> the result.
selectMessageWithLazy :: Typeable a => (a -> Maybe b) -> MessageSelector b

-- | Create a message selector. It will <a>force</a> the result.
selectDynamicMessage :: NFData a => (Dynamic -> Maybe a) -> MessageSelector a

-- | Create a message selector.
selectDynamicMessageLazy :: (Dynamic -> Maybe a) -> MessageSelector a

-- | Create a message selector that will match every message. This is
--   <i>lazy</i> because the result is not <a>force</a>ed.
selectAnyMessageLazy :: MessageSelector Dynamic

-- | Create a message selector for a value that can be obtained by
--   <a>fromDynamic</a> with a proxy argument. It will also <a>force</a>
--   the result.
selectMessageProxy :: forall proxy t. (NFData t, Typeable t) => proxy t -> MessageSelector t

-- | Create a message selector for a value that can be obtained by
--   <a>fromDynamic</a> with a proxy argument. It will also <a>force</a>
--   the result.
selectMessageProxyLazy :: forall proxy t. Typeable t => proxy t -> MessageSelector t

-- | Get access to the <a>SchedulerProxy</a> for the current scheduler
--   effects. _EXPERIMENTAL_
getSchedulerProxy :: HasScheduler q => SchedulerProxy q

-- | Set the <a>SchedulerProxy</a> to use, this satisfies
--   <a>HasScheduler</a> . _EXPERIMENTAL_
withSchedulerProxy :: SchedulerProxy q -> (HasScheduler q => a) -> a

-- | Return a <a>SchedulerProxy</a> for a <a>Process</a> effect.
thisSchedulerProxy :: Eff (Process r : r) (SchedulerProxy r)

-- | Get the <tt>ExitRecover</tt>y
toExitRecovery :: ExitReason r -> ExitRecovery

-- | Get the <a>ExitSeverity</a> of a <a>ExitReason</a>.
toExitSeverity :: ExitReason e -> ExitSeverity

-- | A predicate for linked process <b>crashes</b>.
isBecauseDown :: Maybe ProcessId -> ExitReason r -> Bool

-- | Handle all <a>InterruptReason</a>s of an <a>InterruptableProcess</a>
--   by wrapping them up in <a>NotRecovered</a> and then do a process
--   <a>Shutdown</a>.
provideInterruptsShutdown :: forall e a. Eff (InterruptableProcess e) a -> Eff (ConsProcess e) a

-- | Handle <a>InterruptReason</a>s arising during process operations, e.g.
--   when a linked process crashes while we wait in a
--   <a>receiveSelectedMessage</a> via a call to <a>interrupt</a>.
handleInterrupts :: (HasCallStack, Member Interrupts r) => (InterruptReason -> Eff r a) -> Eff r a -> Eff r a

-- | Like <a>handleInterrupts</a>, but instead of passing the
--   <a>InterruptReason</a> to a handler function, <a>Either</a> is
--   returned.
tryUninterrupted :: (HasCallStack, Member Interrupts r) => Eff r a -> Eff r (Either InterruptReason a)

-- | Handle interrupts by logging them with <a>logProcessExit</a> and
--   otherwise ignoring them.
logInterrupts :: (HasCallStack, '[Interrupts, Logs LogMessage] <:: r) => Eff r () -> Eff r ()

-- | Handle <a>InterruptReason</a>s arising during process operations, e.g.
--   when a linked process crashes while we wait in a
--   <a>receiveSelectedMessage</a> via a call to <a>interrupt</a>.
exitOnInterrupt :: (HasCallStack, Member Interrupts r, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a -> Eff r a

-- | Handle <a>InterruptReason</a>s arising during process operations, e.g.
--   when a linked process crashes while we wait in a
--   <a>receiveSelectedMessage</a> via a call to <a>interrupt</a>.
provideInterrupts :: HasCallStack => Eff (Interrupts : r) a -> Eff r (Either InterruptReason a)

-- | Wrap all (left) <a>InterruptReason</a>s into <a>NotRecovered</a> and
--   return the (right) <a>NoRecovery</a> <a>ExitReason</a>s as is.
mergeEitherInterruptAndExitReason :: Either InterruptReason (ExitReason  'NoRecovery) -> ExitReason  'NoRecovery

-- | Throw an <a>InterruptReason</a>, can be handled by
--   <tt>recoverFromInterrupt</tt> or <a>exitOnInterrupt</a> or
--   <a>provideInterrupts</a>.
interrupt :: (HasCallStack, Member Interrupts r) => InterruptReason -> Eff r a

-- | A predicate for crashes. A <i>crash</i> happens when a process exits
--   with an <a>ExitReason</a> other than <a>ExitNormally</a>
isCrash :: ExitReason x -> Bool

-- | A predicate for recoverable exit reasons. This predicate defines the
--   exit reasonson which functions such as <a>executeAndResume</a>
isRecoverable :: ExitReason x -> Bool

-- | Partition a <a>SomeExitReason</a> back into either a <a>NoRecovery</a>
--   or a <a>Recoverable</a> <a>ExitReason</a>
fromSomeExitReason :: SomeExitReason -> Either (ExitReason  'NoRecovery) InterruptReason

-- | Print a <a>ExitReason</a> to <a>Just</a> a formatted <a>String</a>
--   when <a>isCrash</a> is <a>True</a>. This can be useful in combination
--   with view patterns, e.g.:
--   
--   <pre>
--   logCrash :: ExitReason -&gt; Eff e ()
--   logCrash (toCrashReason -&gt; Just reason) = logError reason
--   logCrash _ = return ()
--   </pre>
--   
--   Though this can be improved to:
--   
--   <pre>
--   logCrash = traverse_ logError . toCrashReason
--   </pre>
toCrashReason :: ExitReason x -> Maybe String

-- | Log the <tt>ProcessExitReaons</tt>
logProcessExit :: (HasCallStack, Member (Logs LogMessage) e) => ExitReason x -> Eff e ()

-- | Execute a and action and return the result; if the process is
--   interrupted by an error or exception, or an explicit shutdown from
--   another process, or through a crash of a linked process, i.e. whenever
--   the exit reason satisfies <a>isRecoverable</a>, return the exit
--   reason.
executeAndResume :: forall q r v. (SetMember Process (Process q) r, HasCallStack) => Process q (ResumeProcess v) -> Eff r (Either (ExitReason  'Recoverable) v)

-- | Execute a <a>Process</a> action and resume the process, exit the
--   process when an <a>Interrupts</a> was raised. Use
--   <a>executeAndResume</a> to catch interrupts.
executeAndResumeOrExit :: forall r q v. (SetMember Process (Process q) r, HasCallStack) => Process q (ResumeProcess v) -> Eff r v

-- | Execute a <a>Process</a> action and resume the process, exit the
--   process when an <a>Interrupts</a> was raised. Use
--   <a>executeAndResume</a> to catch interrupts.
executeAndResumeOrThrow :: forall q r v. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => Process q (ResumeProcess v) -> Eff r v

-- | Use <a>executeAndResumeOrExit</a> to execute <a>YieldProcess</a>.
--   Refer to <a>YieldProcess</a> for more information.
yieldProcess :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Eff r ()

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>.
sendMessage :: forall r q o. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r, Typeable o) => SchedulerProxy q -> ProcessId -> o -> Eff r ()

-- | Send a <a>Dynamic</a> value to a process addressed by the
--   <a>ProcessId</a>. See <a>SendMessage</a>.
sendAnyMessage :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Dynamic -> Eff r ()

-- | Exit a process addressed by the <a>ProcessId</a>. The process will
--   exit, it might do some cleanup, but is ultimately unrecoverable. See
--   <a>SendShutdown</a>.
sendShutdown :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> ExitReason  'NoRecovery -> Eff r ()

-- | Interrupts a process addressed by the <a>ProcessId</a>. The process
--   might exit, or it may continue. | Like <a>sendInterrupt</a>, but also
--   return <tt>True</tt> iff the process to exit exists.
sendInterrupt :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> InterruptReason -> Eff r ()

-- | Start a new process, the new process will execute an effect, the
--   function will return immediately with a <a>ProcessId</a>. If the new
--   process is interrupted, the process will <a>Shutdown</a> with the
--   <a>InterruptReason</a> wrapped in <tt>NotCovered</tt>. For specific
--   use cases it might be better to use <a>spawnRaw</a>.
spawn :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess q) () -> Eff r ProcessId

-- | Like <a>spawn</a> but return <tt>()</tt>.
spawn_ :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess q) () -> Eff r ()

-- | Start a new process, and immediately link to it.
spawnLink :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess q) () -> Eff r ProcessId

-- | Start a new process, the new process will execute an effect, the
--   function will return immediately with a <a>ProcessId</a>. The spawned
--   process has only the <i>raw</i> <a>ConsProcess</a> effects. For
--   non-library code <a>spawn</a> might be better suited.
spawnRaw :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (ConsProcess q) () -> Eff r ProcessId

-- | Like <a>spawnRaw</a> but return <tt>()</tt>.
spawnRaw_ :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (ConsProcess q) () -> Eff r ()

-- | Return <a>True</a> if the process is alive.
isProcessAlive :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r Bool

-- | Block until a message was received. See <a>ReceiveSelectedMessage</a>
--   for more documentation.
receiveAnyMessage :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Eff r Dynamic

-- | Block until a message was received, that is not <a>Nothing</a> after
--   applying a callback to it. See <a>ReceiveSelectedMessage</a> for more
--   documentation.
receiveSelectedMessage :: forall r q a. (HasCallStack, Show a, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> MessageSelector a -> Eff r a

-- | Receive and cast the message to some <a>Typeable</a> instance. See
--   <a>ReceiveSelectedMessage</a> for more documentation. This will wait
--   for a message of the return type using <a>receiveSelectedMessage</a>
receiveMessage :: forall a r q. (HasCallStack, Typeable a, Show a, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Eff r a

-- | Remove and return all messages currently enqueued in the process
--   message queue.
flushMessages :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r, HasScheduler q) => Eff r [Dynamic]

-- | Enter a loop to receive messages and pass them to a callback, until
--   the function returns <a>Just</a> a result. Only the messages of the
--   given type will be received. If the process is interrupted by an
--   exception of by a <a>SendShutdown</a> from another process, with an
--   exit reason that satisfies <a>isRecoverable</a>, then the callback
--   will be invoked with <tt><a>Left</a> <tt>ProcessExitReaon</tt></tt>,
--   otherwise the process will be exited with the same reason using
--   <a>exitBecause</a>. See also <a>ReceiveSelectedMessage</a> for more
--   documentation.
receiveSelectedLoop :: forall r q a endOfLoopResult. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> MessageSelector a -> (Either InterruptReason a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Like <a>receiveSelectedLoop</a> but <i>not selective</i>. See also
--   <a>selectAnyMessageLazy</a>, <a>receiveSelectedLoop</a>.
receiveAnyLoop :: forall r q endOfLoopResult. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> (Either InterruptReason Dynamic -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Like <a>receiveSelectedLoop</a> but refined to casting to a specific
--   <a>Typeable</a> using <a>selectMessageLazy</a>.
receiveLoop :: forall r q a endOfLoopResult. (SetMember Process (Process q) r, HasCallStack, Typeable a) => SchedulerProxy q -> (Either InterruptReason a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Returns the <a>ProcessId</a> of the current process.
self :: (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r ProcessId

-- | Generate a unique <a>Int</a> for the current process.
makeReference :: (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Eff r Int

-- | Monitor another process. When the monitored process exits a
--   <a>ProcessDown</a> is sent to the calling process. The return value is
--   a unique identifier for that monitor. There can be multiple monitors
--   on the same process, and a message for each will be sent. If the
--   process is already dead, the <a>ProcessDown</a> message will be sent
--   immediately, w.thout exit reason
monitor :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r MonitorReference

-- | Remove a monitor created with <a>monitor</a>.
demonitor :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> MonitorReference -> Eff r ()

-- | <a>monitor</a> another process before while performing an action and
--   <a>demonitor</a> afterwards.
withMonitor :: (HasCallStack, Member Interrupts r, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> (MonitorReference -> Eff r a) -> Eff r a

-- | A <a>MessageSelector</a> for receiving either a monitor of the given
--   process or another message.
receiveWithMonitor :: (HasCallStack, Member Interrupts r, SetMember Process (Process q) r, Member Interrupts r, Typeable a, Show a) => SchedulerProxy q -> ProcessId -> MessageSelector a -> Eff r (Either ProcessDown a)

-- | Trigger an <tt>Interrupt</tt> for a <a>ProcessDown</a> message. The
--   reason will be <a>ProcessNotRunning</a>
becauseProcessIsDown :: ProcessDown -> InterruptReason

-- | A <tt>MesssageSelector</tt> for the <a>ProcessDown</a> message of a
--   specific process.
selectProcessDown :: MonitorReference -> MessageSelector ProcessDown

-- | Connect the calling process to another process, such that if one of
--   the processes crashes (i.e. <a>isCrash</a> returns <a>True</a>), the
--   other is shutdown with the <tt>ProcessExitReaon</tt>
--   <a>LinkedProcessCrashed</a>.
linkProcess :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r ()

-- | Unlink the calling proccess from the other process.
unlinkProcess :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r ()

-- | Exit the process with a <tt>ProcessExitReaon</tt>.
exitBecause :: forall r q a. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ExitReason  'NoRecovery -> Eff r a

-- | Exit the process.
exitNormally :: forall r q a. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a

-- | Exit the process with an error.
exitWithError :: forall r q a. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> String -> Eff r a
fromProcessId :: Iso' ProcessId Int

-- | A value to be sent when timer started with <a>startTimer</a> has
--   elapsed.
data TimerElapsed

-- | The reference to a timer started by <a>startTimer</a>, required to
--   stop a timer via <a>cancelTimer</a>.
data TimerReference

-- | A number of micro seconds.
data Timeout

-- | Wait for a message of the given type for the given time. When no
--   message arrives in time, return <a>Nothing</a>. This is based on
--   <a>receiveSelectedAfter</a>.
receiveAfter :: forall a r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable a, NFData a, Show a) => SchedulerProxy q -> Timeout -> Eff r (Maybe a)

-- | Wait for a message of the given type for the given time. When no
--   message arrives in time, return <a>Left</a> <a>TimerElapsed</a>. This
--   is based on <a>selectTimerElapsed</a> and <a>startTimer</a>.
receiveSelectedAfter :: forall a r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Show a) => SchedulerProxy q -> MessageSelector a -> Timeout -> Eff r (Either TimerElapsed a)

-- | A <a>MessageSelector</a> matching <a>TimerElapsed</a> messages created
--   by <a>startTimer</a>.
selectTimerElapsed :: TimerReference -> MessageSelector TimerElapsed

-- | Send a message to a given process after waiting. The message is
--   created by applying the function parameter to the
--   <a>TimerReference</a>, such that the message can directly refer to the
--   timer.
sendAfter :: forall r q message. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable message, NFData message) => SchedulerProxy q -> ProcessId -> Timeout -> (TimerReference -> message) -> Eff r TimerReference

-- | Start a new timer, after the time has elapsed, <a>TimerElapsed</a> is
--   sent to calling process. The message also contains the
--   <a>TimerReference</a> returned by this function. Use
--   <a>cancelTimer</a> to cancel the timer. Use <a>selectTimerElapsed</a>
--   to receive the message using <a>receiveSelectedMessage</a>. To receive
--   messages with guarded with a timeout see <a>receiveAfter</a>.
startTimer :: forall r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Timeout -> Eff r TimerReference

-- | This is a tag-type that wraps around a <a>ProcessId</a> and holds an
--   <a>Api</a> index type.
newtype Server api
Server :: ProcessId -> Server api
[_fromServer] :: Server api -> ProcessId

-- | The (promoted) constructors of this type specify (at the type level)
--   the reply behavior of a specific constructor of an <tt>Api</tt>
--   instance.
data Synchronicity

-- | Specify that handling a request is a blocking operation with a
--   specific return type, e.g. <tt>('Synchronous (Either RentalError
--   RentalId))</tt>
Synchronous :: Type -> Synchronicity

-- | Non-blocking, asynchronous, request handling
Asynchronous :: Synchronicity

-- | This data family defines an API, a communication interface description
--   between at least two processes. The processes act as <b>servers</b> or
--   <b>client(s)</b> regarding a specific instance of this type.
--   
--   The first parameter is usually a user defined phantom type that
--   identifies the <a>Api</a> instance.
--   
--   The second parameter specifies if a specific constructor of an
--   (GADT-like) <tt>Api</tt> instance is <a>Synchronous</a>, i.e. returns
--   a result and blocks the caller or if it is <a>Asynchronous</a>
--   
--   Example:
--   
--   <pre>
--   data BookShop deriving Typeable
--   
--   data instance Api BookShop r where
--     RentBook  :: BookId   -&gt; Api BookShop ('Synchronous (Either RentalError RentalId))
--     BringBack :: RentalId -&gt; Api BookShop 'Asynchronous
--   
--   type BookId = Int
--   type RentalId = Int
--   type RentalError = String
--   </pre>
data family Api (api :: Type) (reply :: Synchronicity)
fromServer :: forall api_a17VQ api_a1868. Iso (Server api_a17VQ) (Server api_a1868) ProcessId ProcessId

-- | Tag a <a>ProcessId</a> with an <a>Api</a> type index to mark it a
--   <a>Server</a> process handling that API
proxyAsServer :: proxy api -> ProcessId -> Server api

-- | Tag a <a>ProcessId</a> with an <a>Api</a> type index to mark it a
--   <a>Server</a> process handling that API
asServer :: forall api. ProcessId -> Server api

-- | The reader effect for <a>ProcessId</a>s for <a>Api</a>s, see
--   <a>registerServer</a>
type ServerReader o = Reader (Server o)

-- | Instead of passing around a <a>Server</a> value and passing to
--   functions like <a>cast</a> or <a>call</a>, a <a>Server</a> can
--   provided by a <a>Reader</a> effect, if there is only a <b>single
--   server</b> for a given <a>Api</a> instance. This type alias is
--   convenience to express that an effect has <a>Process</a> and a reader
--   for a <a>Server</a>.
type ServesApi o r q = (Typeable o, SetMember Process (Process q) r, Member (ServerReader o) r)

-- | Send an <a>Api</a> request that has no return value and return as fast
--   as possible. The type signature enforces that the corresponding
--   <a>Api</a> clause is <a>Asynchronous</a>. The operation never fails,
--   if it is important to know if the message was delivered, use
--   <a>call</a> instead.
cast :: forall r q o. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable o, Typeable (Api o  'Asynchronous)) => SchedulerProxy q -> Server o -> Api o  'Asynchronous -> Eff r ()

-- | Send an <a>Api</a> request and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Api</a> clause
--   is <a>Synchronous</a>.
call :: forall result api r q. (SetMember Process (Process q) r, Member Interrupts r, Typeable api, Typeable (Api api ( 'Synchronous result)), Typeable result, HasCallStack, NFData result, Show result) => SchedulerProxy q -> Server api -> Api api ( 'Synchronous result) -> Eff r result

-- | Run a reader effect that contains <b>the one</b> server handling a
--   specific <a>Api</a> instance.
registerServer :: HasCallStack => Server o -> Eff (ServerReader o : r) a -> Eff r a

-- | Get the <a>Server</a> registered with <a>registerServer</a>.
whereIsServer :: Member (ServerReader o) e => Eff e (Server o)

-- | Like <a>call</a> but take the <a>Server</a> from the reader provided
--   by <a>registerServer</a>.
callRegistered :: (Typeable reply, ServesApi o r q, HasCallStack, NFData reply, Show reply, Member Interrupts r) => SchedulerProxy q -> Api o ( 'Synchronous reply) -> Eff r reply

-- | Like <a>cast</a> but take the <a>Server</a> from the reader provided
--   by <a>registerServer</a>.
castRegistered :: (Typeable o, ServesApi o r q, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Api o  'Asynchronous -> Eff r ()

-- | A command to the server loop started e.g. by <tt>server</tt> or
--   <a>spawnServerWithEffects</a>. Typically returned by an
--   <a>ApiHandler</a> member to indicate if the server should continue or
--   stop.
data ApiServerCmd

-- | Tell the server to keep the server loop running
[HandleNextRequest] :: ApiServerCmd

-- | Tell the server to exit, this will make <a>serve</a> stop handling
--   requests without exitting the process. <a>_terminateCallback</a> will
--   be invoked with the given optional reason.
[StopApiServer] :: ExitReason  'Recoverable -> ApiServerCmd

-- | A record of callbacks, handling requests sent to a <i>server</i>
--   <a>Process</a>, all belonging to a specific <a>Api</a> family
--   instance. The values of this type can be <a>serve</a>ed or combined
--   via <a>Servable</a> or <a>ServerCallback</a>s.
data ApiHandler api eff
[ApiHandler] :: {_castCallback :: Maybe (Api api  'Asynchronous -> Eff eff ApiServerCmd) " A cast will not return a result directly. This is used for async methods. This returns an 'ApiServerCmd' to the server loop.", _callCallback :: forall reply. Maybe (Api api ( 'Synchronous reply) -> (reply -> Eff eff ()) -> Eff eff ApiServerCmd) " A call is a blocking operation, the caller is blocked until this handler calls the reply continuation. This returns an 'ApiServerCmd' to the server loop.", _terminateCallback :: Maybe (ExitReason  'Recoverable -> Eff eff ()) " This callback is called with @Nothing@ if one of these things happen:  * the process exits * '_callCallback' or '_castCallback' return 'StopApiServer'  If the process exist peacefully the parameter is 'NotServerCallbacking', otherwise @Just "error message..."@ if the process exits with an error.  The default behavior is defined in 'defaultTermination'."} -> ApiHandler api eff

-- | Create an <a>ApiHandler</a> with a <a>_castCallback</a>, a
--   <a>_callCallback</a> and a <a>_terminateCallback</a> implementation.
apiHandler :: (Api api  'Asynchronous -> Eff e ApiServerCmd) -> (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> (ExitReason  'Recoverable -> Eff e ()) -> ApiHandler api e

-- | Like <a>apiHandler</a> but the server will loop until an error is
--   raised or the process exits. The callback actions won't decide wether
--   to stop the server or not, instead the <a>ApiServerCmd</a>
--   <a>HandleNextRequest</a> is used.
apiHandlerForever :: (Api api  'Asynchronous -> Eff e ()) -> (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> (ExitReason  'Recoverable -> Eff e ()) -> ApiHandler api e

-- | Create an <a>ApiHandler</a> with only a <a>_castCallback</a>
--   implementation.
castHandler :: (Api api  'Asynchronous -> Eff eff ApiServerCmd) -> ApiHandler api eff

-- | Like <a>castHandler</a> but the server will loop until an error is
--   raised or the process exits. See <tt>apiHandlerForver</tt>.
castHandlerForever :: (Api api  'Asynchronous -> Eff eff ()) -> ApiHandler api eff

-- | Create an <a>ApiHandler</a> with only a <a>_callCallback</a>
--   implementation.
callHandler :: (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> ApiHandler api e

-- | Like <a>callHandler</a> but the server will loop until an error is
--   raised or the process exits. See <tt>apiHandlerForver</tt>.
callHandlerForever :: (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> ApiHandler api e

-- | Create an <a>ApiHandler</a> with only a <a>_castCallback</a> and
--   <a>_callCallback</a> implementation.
castAndCallHandler :: (Api api  'Asynchronous -> Eff e ApiServerCmd) -> (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> ApiHandler api e

-- | Like <a>castAndCallHandler</a> but the server will loop until an error
--   is raised or the process exits. See <tt>apiHandlerForver</tt>.
castAndCallHandlerForever :: (Api api  'Asynchronous -> Eff e ()) -> (forall r. Api api ( 'Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> ApiHandler api e

-- | Building block for composition of <a>ApiHandler</a>. A wrapper for
--   <a>ApiHandler</a>. Use this to combine <a>ApiHandler</a>, allowing a
--   process to implement several <a>Api</a> instances. The termination
--   will be evenly propagated. Create this via e.g. <a>Servable</a>
--   instances To serve multiple apis use <a>&lt;&gt;</a> to combine server
--   callbacks, e.g.
--   
--   @@<tt> let f = apiHandlerServerCallback px $ ApiHandler ... g =
--   apiHandlerServerCallback px $ ApiHandler ... h = f &lt;&gt; g in serve
--   px h </tt>@@
data ServerCallback eff
ServerCallback :: MessageSelector (Eff eff ApiServerCmd) -> (ExitReason  'Recoverable -> Eff eff ()) -> ServerCallback eff
[_requestHandlerSelector] :: ServerCallback eff -> MessageSelector (Eff eff ApiServerCmd)
[_terminationHandler] :: ServerCallback eff -> ExitReason  'Recoverable -> Eff eff ()
callCallback :: forall api_a18Ad eff_a18Ae reply_a18Ah. Getter (ApiHandler api_a18Ad eff_a18Ae) (Maybe (Api api_a18Ad ( 'Synchronous reply_a18Ah) -> (reply_a18Ah -> Eff eff_a18Ae ()) -> Eff eff_a18Ae ApiServerCmd))
castCallback :: forall api_a18Ad eff_a18Ae. Lens' (ApiHandler api_a18Ad eff_a18Ae) (Maybe (Api api_a18Ad  'Asynchronous -> Eff eff_a18Ae ApiServerCmd))
terminateCallback :: forall api_a18Ad eff_a18Ae. Lens' (ApiHandler api_a18Ad eff_a18Ae) (Maybe (ExitReason  'Recoverable -> Eff eff_a18Ae ()))
requestHandlerSelector :: forall eff_a18Mt. Lens' (ServerCallback eff_a18Mt) (MessageSelector (Eff eff_a18Mt ApiServerCmd))
terminationHandler :: forall eff_a18Mt. Lens' (ServerCallback eff_a18Mt) (ExitReason  'Recoverable -> Eff eff_a18Mt ())

-- | Receive and process incoming requests until the process exits.
serve :: forall a effScheduler. (Servable a, SetMember Process (Process effScheduler) (ServerEff a), Member Interrupts (ServerEff a), HasCallStack) => SchedulerProxy effScheduler -> a -> Eff (ServerEff a) ()

-- | Spawn a new process, that will receive and process incoming requests
--   until the process exits.
spawnServer :: forall a effScheduler eff. (Servable a, ServerEff a ~ InterruptableProcess effScheduler, SetMember Process (Process effScheduler) eff, Member Interrupts eff, HasCallStack) => SchedulerProxy effScheduler -> a -> Eff eff (ServerPids a)

-- | Spawn a new process, that will receive and process incoming requests
--   until the process exits. Also handle all internal effects.
spawnServerWithEffects :: forall a effScheduler eff. (Servable a, SetMember Process (Process effScheduler) (ServerEff a), SetMember Process (Process effScheduler) eff, Member Interrupts eff, Member Interrupts (ServerEff a), HasCallStack) => SchedulerProxy effScheduler -> a -> (Eff (ServerEff a) () -> Eff (InterruptableProcess effScheduler) ()) -> Eff eff (ServerPids a)

-- | A default handler to use in <a>_callCallback</a> in <a>ApiHandler</a>.
--   It will call <tt>raiseError</tt> with a nice error message.
unhandledCallError :: forall p x r q. (Typeable p, HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Api p ( 'Synchronous x) -> (x -> Eff r ()) -> Eff r ApiServerCmd

-- | A default handler to use in <a>_castCallback</a> in <a>ApiHandler</a>.
--   It will call <tt>raiseError</tt> with a nice error message.
unhandledCastError :: forall p r q. (Typeable p, HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Api p  'Asynchronous -> Eff r ApiServerCmd

-- | Either do nothing, if the error message is <tt>Nothing</tt>, or call
--   <a>exitWithError</a> with the error message.
defaultTermination :: forall q r. (HasCallStack, SetMember Process (Process q) r, Member (Logs LogMessage) r) => SchedulerProxy q -> ExitReason  'Recoverable -> Eff r ()

-- | An <a>Api</a> type for generic <a>Observer</a>s, see
--   <a>handleObservations</a>.
data Observing o

-- | Just a wrapper around a function that will be applied to the result of
--   a <a>MessageCallback</a>s <a>StopServer</a> clause, or an
--   <a>InterruptReason</a> caught during the execution of <tt>receive</tt>
--   or a <a>MessageCallback</a>
data InterruptCallback eff
[InterruptCallback] :: (InterruptReason -> Eff eff CallbackResult) -> InterruptCallback eff

-- | Helper type class for the return values of <a>spawnApiServer</a> et
--   al.
class ToServerPids (t :: k) where {
    type family ServerPids t;
}
toServerPids :: ToServerPids t => proxy t -> ProcessId -> ServerPids t

-- | An existential wrapper around a <a>MessageSelector</a> and a function
--   that handles the selected message. The <tt>api</tt> type parameter is
--   a phantom type.
--   
--   The return value if the handler function is a <a>CallbackResult</a>.
data MessageCallback api eff
[MessageCallback] :: MessageSelector a -> (a -> Eff eff CallbackResult) -> MessageCallback api eff

-- | A command to the server loop started e.g. by <tt>server</tt> or
--   <tt>spawnServerWithEffects</tt>. Typically returned by an
--   <tt>ApiHandler</tt> member to indicate if the server should continue
--   or stop.
data CallbackResult

-- | Tell the server to keep the server loop running
[AwaitNext] :: CallbackResult

-- | Tell the server to exit, this will make <tt>serve</tt> stop handling
--   requests without exitting the process. <tt>_terminateCallback</tt>
--   will be invoked with the given optional reason.
[StopServer] :: InterruptReason -> CallbackResult

-- | <i>Serve</i> an <a>Api</a> in a newly spawned process.
spawnApiServer :: forall api eff. (ToServerPids api, HasCallStack) => MessageCallback api (InterruptableProcess eff) -> InterruptCallback (ConsProcess eff) -> Eff (InterruptableProcess eff) (ServerPids api)

-- | <i>Server</i> an <a>Api</a> in a newly spawned process; the callbacks
--   have access to some state initialed by the function in the first
--   parameter.
spawnApiServerStateful :: forall api eff state. (HasCallStack, ToServerPids api) => Eff (InterruptableProcess eff) state -> MessageCallback api (State state : InterruptableProcess eff) -> InterruptCallback (State state : ConsProcess eff) -> Eff (InterruptableProcess eff) (ServerPids api)

-- | <i>Server</i> an <a>Api</a> in a newly spawned process; The caller
--   provides an effect handler for arbitrary effects used by the server
--   callbacks.
spawnApiServerEffectful :: forall api eff serverEff. (HasCallStack, ToServerPids api, Member Interrupts serverEff, SetMember Process (Process eff) serverEff) => (forall b. Eff serverEff b -> Eff (InterruptableProcess eff) b) -> MessageCallback api serverEff -> InterruptCallback serverEff -> Eff (InterruptableProcess eff) (ServerPids api)

-- | A smart constructor for <a>MessageCallback</a>s
handleMessages :: forall eff a. (HasCallStack, NFData a, Typeable a) => (a -> Eff eff CallbackResult) -> MessageCallback '[] eff

-- | A smart constructor for <a>MessageCallback</a>s
handleSelectedMessages :: forall eff a. HasCallStack => MessageSelector a -> (a -> Eff eff CallbackResult) -> MessageCallback '[] eff

-- | A smart constructor for <a>MessageCallback</a>s
handleAnyMessages :: forall eff. HasCallStack => (Dynamic -> Eff eff CallbackResult) -> MessageCallback '[] eff

-- | A smart constructor for <a>MessageCallback</a>s
handleCasts :: forall api eff. (HasCallStack, Typeable api, Typeable (Api api  'Asynchronous)) => (Api api  'Asynchronous -> Eff eff CallbackResult) -> MessageCallback api eff

-- | A smart constructor for <a>MessageCallback</a>s
--   
--   <pre>
--   handleCalls SP
--     (\ (RentBook bookId customerId) runCall -&gt;
--        runCall $ do
--            rentalIdE &lt;- rentBook bookId customerId
--            case rentalIdE of
--              -- on fail we just don't send a reply, let the caller run into
--              -- timeout
--              Left err -&gt; return (Nothing, AwaitNext)
--              Right rentalId -&gt; return (Just rentalId, AwaitNext))
--   </pre>
handleCalls :: forall api eff effScheduler. (HasCallStack, Typeable api, SetMember Process (Process effScheduler) eff, Member Interrupts eff) => SchedulerProxy effScheduler -> (forall secret reply. (Typeable reply, Typeable (Api api ( 'Synchronous reply))) => Api api ( 'Synchronous reply) -> (Eff eff (Maybe reply, CallbackResult) -> secret) -> secret) -> MessageCallback api eff

-- | A smart constructor for <a>MessageCallback</a>s
handleCastsAndCalls :: forall api eff effScheduler. (HasCallStack, Typeable api, Typeable (Api api  'Asynchronous), SetMember Process (Process effScheduler) eff, Member Interrupts eff) => SchedulerProxy effScheduler -> (Api api  'Asynchronous -> Eff eff CallbackResult) -> (forall secret reply. (Typeable reply, Typeable (Api api ( 'Synchronous reply))) => Api api ( 'Synchronous reply) -> (Eff eff (Maybe reply, CallbackResult) -> secret) -> secret) -> MessageCallback api eff

-- | A smart constructor for <a>MessageCallback</a>s
handleProcessDowns :: forall eff. HasCallStack => (MonitorReference -> Eff eff CallbackResult) -> MessageCallback '[] eff

-- | Compose two <a>Api</a>s to a type-leve pair of them.
--   
--   <pre>
--   handleCalls api1calls ^: handleCalls api2calls ^:
--   </pre>
(^:) :: forall (api1 :: Type) (apis2 :: [Type]) eff. HasCallStack => MessageCallback api1 eff -> MessageCallback apis2 eff -> MessageCallback (api1 : apis2) eff
infixr 5 ^:

-- | Make a fallback handler, i.e. a handler to which no other can be
--   composed to from the right.
fallbackHandler :: forall api eff. HasCallStack => MessageCallback api eff -> MessageCallback '[] eff

-- | A <a>fallbackHandler</a> that drops the left-over messages.
dropUnhandledMessages :: forall eff. HasCallStack => MessageCallback '[] eff

-- | A <a>fallbackHandler</a> that terminates if there are unhandled
--   messages.
exitOnUnhandled :: forall eff. HasCallStack => MessageCallback '[] eff

-- | A <a>fallbackHandler</a> that drops the left-over messages.
logUnhandledMessages :: forall eff. (Member (Logs LogMessage) eff, HasCallStack) => MessageCallback '[] eff

-- | A smart constructor for <a>InterruptCallback</a>s
stopServerOnInterrupt :: forall eff. HasCallStack => InterruptCallback eff

-- | Apply a given callback function to incoming <tt>Observeration</tt>s.
handleObservations :: Typeable o => (Server o -> Observation o -> Eff e CallbackResult) -> MessageCallback (Observing o) e

-- | An <a>Observer</a> that schedules the observations to an effectful
--   callback.
data CallbackObserver o

-- | Alias for the effect that contains the observers managed by
--   <a>manageObservers</a>
type ObserverState o = State (Observers o)

-- | Internal state for <a>manageObservers</a>
data Observers o

-- | An existential wrapper around a <a>Server</a> of an <a>Observer</a>.
--   Needed to support different types of observers to observe the same
--   <a>Observable</a> in a general fashion.
data SomeObserver o
[SomeObserver] :: (Show (Server p), Typeable p, Observer p o) => Server p -> SomeObserver o

-- | An <a>Api</a> index that supports registration and de-registration of
--   <a>Observer</a>s.
class (Typeable o, Typeable (Observation o)) => Observable o where {
    
    -- | Type of observations visible on this observable
    data family Observation o;
}

-- | Return the <a>Api</a> value for the <tt>cast_</tt> that registeres an
--   observer
registerObserverMessage :: Observable o => SomeObserver o -> Api o  'Asynchronous

-- | Return the <a>Api</a> value for the <tt>cast_</tt> that de-registeres
--   an observer
forgetObserverMessage :: Observable o => SomeObserver o -> Api o  'Asynchronous

-- | An <a>Api</a> index that support observation of the another <a>Api</a>
--   that is <a>Observable</a>.
class (Typeable p, Observable o) => Observer p o

-- | Wrap the <a>Observation</a> and the <a>ProcessId</a> (i.e. the
--   <a>Server</a>) that caused the observation into an <a>Api</a> value
--   that the <a>Observable</a> understands.
observationMessage :: Observer p o => Server o -> Observation o -> Api p  'Asynchronous

-- | Send an <a>Observation</a> to an <a>Observer</a>
notifyObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Observation o -> Eff r ()

-- | Send the <a>registerObserverMessage</a>
registerObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Eff r ()

-- | Send the <a>forgetObserverMessage</a>
forgetObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Eff r ()

-- | Send an <a>Observation</a> to <a>SomeObserver</a>.
notifySomeObserver :: (SetMember Process (Process q) r, Observable o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server o -> Observation o -> SomeObserver o -> Eff r ()

-- | Keep track of registered <a>Observer</a>s Observers can be added and
--   removed, and an <a>Observation</a> can be sent to all registerd
--   observers at once.
manageObservers :: Eff (ObserverState o : r) a -> Eff r a

-- | Add an <a>Observer</a> to the <a>Observers</a> managed by
--   <a>manageObservers</a>.
addObserver :: (SetMember Process (Process q) r, Member (ObserverState o) r, Observable o) => SomeObserver o -> Eff r ()

-- | Delete an <a>Observer</a> from the <a>Observers</a> managed by
--   <a>manageObservers</a>.
removeObserver :: (SetMember Process (Process q) r, Member (ObserverState o) r, Observable o, Member Interrupts r) => SomeObserver o -> Eff r ()

-- | Send an <a>Observation</a> to all <a>SomeObserver</a>s in the
--   <a>Observers</a> state.
notifyObservers :: forall o r q. (Observable o, SetMember Process (Process q) r, Member (ObserverState o) r, Member Interrupts r) => SchedulerProxy q -> Observation o -> Eff r ()

-- | Start a new process for an <a>Observer</a> that schedules all
--   observations to an effectful callback.
spawnCallbackObserver :: forall o r q. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, Member (Logs LogMessage) q, Member Interrupts r, HasCallStack) => SchedulerProxy q -> (Server o -> Observation o -> Eff (InterruptableProcess q) ApiServerCmd) -> Eff r (Server (CallbackObserver o))

-- | Start a new process for an <a>Observer</a> that schedules all
--   observations to an effectful callback.
spawnLoggingObserver :: forall o r q. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, Member (Logs LogMessage) q, Member (Logs LogMessage) r, Member Interrupts r, HasCallStack) => SchedulerProxy q -> Eff r (Server (CallbackObserver o))

-- | A <a>Reader</a> for an <a>ObservationQueue</a>.
type ObservationQueueReader a = Reader (ObservationQueue a)

-- | Contains a <a>TBQueue</a> capturing observations received by
--   <a>enqueueObservationsRegistered</a> or <a>enqueueObservations</a>.
data ObservationQueue a

-- | Read queued observations captured by observing a <a>Server</a> that
--   implements an <a>Observable</a> <a>Api</a> using
--   <a>enqueueObservationsRegistered</a> or <a>enqueueObservations</a>.
--   This blocks until the next <a>Observation</a> received. For a
--   non-blocking variant use <a>tryReadObservationQueue</a> or
--   <a>flushObservationQueue</a>.
readObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r (Observation o)

-- | Read queued observations captured by observing a <a>Server</a> that
--   implements an <a>Observable</a> <a>Api</a> using
--   <a>enqueueObservationsRegistered</a> or <a>enqueueObservations</a>.
--   Return the next <a>Observation</a> immediately or <a>Nothing</a> if
--   the queue is empty. Use <a>readObservationQueue</a> to block until an
--   observation is observed.
tryReadObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r (Maybe (Observation o))

-- | Read all currently queued <a>Observation</a>s captured by
--   <a>enqueueObservations</a>. This returns immediately all currently
--   enqueued <a>Observation</a>s. For a blocking variant use
--   <a>readObservationQueue</a>.
flushObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r [Observation o]

-- | Observe a(the) registered <a>Server</a> that implements an
--   <a>Observable</a> <a>Api</a>. Based on <a>enqueueObservations</a>.
enqueueObservationsRegistered :: forall o r q a. (ServesApi o r q, SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, HasLogging IO q, HasLogging IO r, Member Interrupts r, Lifted IO r, HasCallStack) => SchedulerProxy q -> Int -> Eff (ObservationQueueReader o : r) a -> Eff r a

-- | Observe a <a>Server</a> that implements an <a>Observable</a>
--   <a>Api</a>, the <a>Observation</a>s can be obtained by
--   <a>readObservationQueue</a>. All observations are captured up to the
--   queue size limit, such that the first message received will be first
--   message returned by <a>readObservationQueue</a>.
--   
--   This function captures runtime exceptions and cleans up accordingly.
enqueueObservations :: forall o r q a. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, HasLogging IO r, HasLogging IO q, Member Interrupts r, Lifted IO q, HasCallStack) => SchedulerProxy q -> Server o -> Int -> Eff (ObservationQueueReader o : r) a -> Eff r a

-- | The concrete list of <a>Eff</a>ects for this scheduler implementation.
type SchedulerIO = (Reader SchedulerState : LoggingAndIO)

-- | Type class constraint to indicate that an effect union contains the
--   effects required by every process and the scheduler implementation
--   itself.
type HasSchedulerIO r = (HasCallStack, Lifted IO r, SchedulerIO <:: r)

-- | The concrete list of the effects, that the <a>Process</a> uses
type InterruptableProcEff = InterruptableProcess SchedulerIO

-- | The concrete list of <a>Eff</a>ects of processes compatible with this
--   scheduler. This builds upon <a>SchedulerIO</a>.
type ProcEff = ConsProcess SchedulerIO

-- | Start the message passing concurrency system then execute a
--   <a>Process</a> on top of <a>SchedulerIO</a> effect. All logging is
--   sent to standard output.
defaultMain :: HasCallStack => Eff InterruptableProcEff () -> IO ()

-- | Start the message passing concurrency system then execute a
--   <a>Process</a> on top of <a>SchedulerIO</a> effect. All logging is
--   sent to standard output.
defaultMainWithLogChannel :: HasCallStack => Eff InterruptableProcEff () -> LogChannel LogMessage -> IO ()

-- | A <a>SchedulerProxy</a> for <a>SchedulerIO</a>
forkIoScheduler :: SchedulerProxy SchedulerIO

-- | This is the main entry point to running a message passing concurrency
--   application. This function takes a <a>Process</a> on top of the
--   <a>SchedulerIO</a> effect and a <a>LogChannel</a> for concurrent
--   logging.
schedule :: (HasLogging IO SchedulerIO, HasCallStack) => Eff InterruptableProcEff () -> Eff LoggingAndIO ()

-- | Like <tt>schedule</tt> but <i>pure</i>. The <tt>yield</tt> effect is
--   just <tt>return ()</tt>. <tt>schedulePure == runIdentity .
--   <a>scheduleM</a> (Identity . run) (return ())</tt>
schedulePure :: Eff (InterruptableProcess '[Logs LogMessage]) a -> Either (ExitReason  'NoRecovery) a

-- | A <a>SchedulerProxy</a> for <a>LoggingAndIo</a>.
singleThreadedIoScheduler :: SchedulerProxy LoggingAndIo

-- | Execute a <a>Process</a> using <tt>schedule</tt> on top of <a>Lift</a>
--   <tt>IO</tt> and <a>Logs</a> <tt>String</tt> effects.
defaultMainSingleThreaded :: HasCallStack => Eff (InterruptableProcess '[Logs LogMessage, LogWriterReader LogMessage IO, Lift IO]) () -> IO ()