-- 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.29.1


-- | Add-ons to <a>Exception</a> and <a>Exception</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))


-- | 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
MkLogMessage :: !Facility -> !Severity -> Maybe UTCTime -> Maybe Text -> Maybe Text -> Maybe Text -> Maybe Text -> [StructuredDataElement] -> Maybe ThreadId -> Maybe SrcLoc -> Text -> LogMessage
[_lmFacility] :: LogMessage -> !Facility
[_lmSeverity] :: LogMessage -> !Severity
[_lmTimestamp] :: LogMessage -> Maybe UTCTime
[_lmHostname] :: LogMessage -> Maybe Text
[_lmAppName] :: LogMessage -> Maybe Text
[_lmProcessId] :: LogMessage -> Maybe Text
[_lmMessageId] :: LogMessage -> Maybe Text
[_lmStructuredData] :: LogMessage -> [StructuredDataElement]
[_lmThreadId] :: LogMessage -> Maybe ThreadId
[_lmSrcLoc] :: LogMessage -> Maybe SrcLoc
[_lmMessage] :: LogMessage -> Text

-- | A lens for the <a>Facility</a> of a <a>LogMessage</a>
lmFacility :: Functor f => (Facility -> f Facility) -> LogMessage -> f LogMessage

-- | A lens for the <a>Severity</a> of a <a>LogMessage</a>
lmSeverity :: Functor f => (Severity -> f Severity) -> LogMessage -> f LogMessage

-- | A lens for the UTC time of a <a>LogMessage</a> The function
--   <a>setLogMessageTimestamp</a> can be used to set the field.
lmTimestamp :: Functor f => (Maybe UTCTime -> f (Maybe UTCTime)) -> LogMessage -> f LogMessage

-- | A lens for the hostname of a <a>LogMessage</a> The function
--   <a>setLogMessageHostname</a> can be used to set the field.
lmHostname :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for the RFC 5424 <i>application</i> name of a <a>LogMessage</a>
--   
--   One useful pattern for using this field, is to implement log filters
--   that allow info and debug message from the application itself while
--   only allowing warning and error messages from third party libraries:
--   
--   <pre>
--   debugLogsForAppName myAppName lm =
--     view lmAppName lm == Just myAppName || lmSeverityIsAtLeast warningSeverity lm
--   </pre>
--   
--   This concept is also implemented in <a>discriminateByAppName</a>.
lmAppName :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for a user defined of <i>process</i> id of a <a>LogMessage</a>
lmProcessId :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for a user defined <i>message id</i> of a <a>LogMessage</a>
lmMessageId :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for the <a>StructuredDataElement</a> of a <a>LogMessage</a>
lmStructuredData :: Functor f => ([StructuredDataElement] -> f [StructuredDataElement]) -> LogMessage -> f LogMessage

-- | A lens for the <a>SrcLoc</a> of a <a>LogMessage</a>
lmSrcLoc :: Functor f => (Maybe SrcLoc -> f (Maybe SrcLoc)) -> LogMessage -> f LogMessage

-- | A lens for the <a>ThreadId</a> of a <a>LogMessage</a> The function
--   <a>setLogMessageThreadId</a> can be used to set the field.
lmThreadId :: Functor f => (Maybe ThreadId -> f (Maybe ThreadId)) -> LogMessage -> f LogMessage

-- | A lens for the user defined textual message of a <a>LogMessage</a>
lmMessage :: Functor f => (Text -> f Text) -> LogMessage -> f LogMessage

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

-- | Prefix the <a>lmMessage</a>.
prefixLogMessagesWith :: Text -> LogMessage -> LogMessage

-- | An IO action that sets the current UTC time in <a>lmTimestamp</a>.
setLogMessageTimestamp :: LogMessage -> IO LogMessage

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

-- | An IO action that sets the current hosts fully qualified hostname in
--   <a>lmHostname</a>.
setLogMessageHostname :: LogMessage -> IO LogMessage

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

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

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

-- | Things that can become a <a>LogMessage</a>
class ToLogMessage a

-- | Convert the value to a <a>LogMessage</a>
toLogMessage :: ToLogMessage a => a -> LogMessage

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

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

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

-- | The filter predicate for message that shall be logged.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
type LogPredicate = LogMessage -> Bool

-- | All messages.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
allLogMessages :: LogPredicate

-- | No messages.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
noLogMessages :: LogPredicate

-- | Match <a>LogMessage</a>s that have exactly the given severity. See
--   <a>lmSeverityIsAtLeast</a>.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
lmSeverityIs :: Severity -> LogPredicate

-- | Match <a>LogMessage</a>s that have the given severity <b>or worse</b>.
--   See <a>lmSeverityIs</a>.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
lmSeverityIsAtLeast :: Severity -> LogPredicate

-- | Match <a>LogMessage</a>s whose <a>lmMessage</a> starts with the given
--   string.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
lmMessageStartsWith :: Text -> LogPredicate

-- | Apply a <a>LogPredicate</a> based on the <a>lmAppName</a> and delegate
--   to one of two <a>LogPredicate</a>s.
--   
--   One useful application for this is to allow info and debug message
--   from one application, e.g. the current application itself, while at
--   the same time allowing only warning and error messages from third
--   party libraries.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
discriminateByAppName :: Text -> LogPredicate -> LogPredicate -> LogPredicate

-- | RFC-5424 defines how structured data can be included in a log message.
data StructuredDataElement
SdElement :: !Text -> ![SdParameter] -> StructuredDataElement
[_sdElementId] :: StructuredDataElement -> !Text
[_sdElementParameters] :: StructuredDataElement -> ![SdParameter]

-- | Component of an RFC-5424 <a>StructuredDataElement</a>
data SdParameter
MkSdParameter :: !Text -> !Text -> SdParameter

-- | A lens for the key or ID of a group of RFC 5424 key-value pairs.
sdElementId :: Functor f => (Text -> f Text) -> StructuredDataElement -> f StructuredDataElement

-- | A lens for <a>SdParameter</a>s
sdElementParameters :: Functor f => ([SdParameter] -> f [SdParameter]) -> StructuredDataElement -> f StructuredDataElement

-- | An rfc 5424 severity
data Severity

-- | Smart constructor for the RFC-5424 <b>emergency</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>0</b>. See
--   <a>lmSeverity</a>.
emergencySeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>alert</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>1</b>. See
--   <a>lmSeverity</a>.
alertSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>critical</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>2</b>. See
--   <a>lmSeverity</a>.
criticalSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>error</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>3</b>. See
--   <a>lmSeverity</a>.
errorSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>warning</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>4</b>. See
--   <a>lmSeverity</a>.
warningSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>notice</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>5</b>. See
--   <a>lmSeverity</a>.
noticeSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>informational</b>
--   <a>LogMessage</a> <a>Severity</a>. This corresponds to the severity
--   value <b>6</b>. See <a>lmSeverity</a>.
informationalSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>debug</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>7</b>. See
--   <a>lmSeverity</a>.
debugSeverity :: Severity

-- | An rfc 5424 facility
newtype Facility
Facility :: Int -> Facility
[fromFacility] :: Facility -> Int

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>kernelMessages</tt>. See <a>lmFacility</a>.
kernelMessages :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>userLevelMessages</tt>. See <a>lmFacility</a>.
userLevelMessages :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>mailSystem</tt>. See <a>lmFacility</a>.
mailSystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>systemDaemons</tt>. See <a>lmFacility</a>.
systemDaemons :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>securityAuthorizationMessages4</tt>. See <a>lmFacility</a>.
securityAuthorizationMessages4 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>linePrinterSubsystem</tt>. See <a>lmFacility</a>.
linePrinterSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>networkNewsSubsystem</tt>. See <a>lmFacility</a>.
networkNewsSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>uucpSubsystem</tt>. See <a>lmFacility</a>.
uucpSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>clockDaemon</tt>. See <a>lmFacility</a>.
clockDaemon :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>securityAuthorizationMessages10</tt>. See <a>lmFacility</a>.
securityAuthorizationMessages10 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>ftpDaemon</tt>. See <a>lmFacility</a>.
ftpDaemon :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>ntpSubsystem</tt>. See <a>lmFacility</a>.
ntpSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>logAuditFacility</tt>. See <a>lmFacility</a>.
logAuditFacility :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>logAlertFacility</tt>. See <a>lmFacility</a>.
logAlertFacility :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>clockDaemon2</tt>. See <a>lmFacility</a>.
clockDaemon2 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local0</tt>. See <a>lmFacility</a>.
local0 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local1</tt>. See <a>lmFacility</a>.
local1 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local2</tt>. See <a>lmFacility</a>.
local2 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local3</tt>. See <a>lmFacility</a>.
local3 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local4</tt>. See <a>lmFacility</a>.
local4 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local5</tt>. See <a>lmFacility</a>.
local5 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local6</tt>. See <a>lmFacility</a>.
local6 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local7</tt>. See <a>lmFacility</a>.
local7 :: Facility
instance Control.Eff.Log.Message.ToLogMessage Control.Eff.Log.Message.LogMessage
instance Control.Eff.Log.Message.ToLogMessage Data.Text.Internal.Text
instance Data.String.IsString Control.Eff.Log.Message.LogMessage
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.Show.Show Control.Eff.Log.Message.StructuredDataElement
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.Show.Show Control.Eff.Log.Message.SdParameter
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 Data.Default.Class.Default Control.Eff.Log.Message.LogMessage
instance GHC.Show.Show Control.Eff.Log.Message.LogMessage
instance Control.DeepSeq.NFData Control.Eff.Log.Message.LogMessage
instance Data.Default.Class.Default Control.Eff.Log.Message.Facility
instance GHC.Show.Show Control.Eff.Log.Message.Severity
instance Data.Default.Class.Default Control.Eff.Log.Message.Severity
instance Control.DeepSeq.NFData Control.Eff.Log.Message.StructuredDataElement
instance Control.DeepSeq.NFData Control.Eff.Log.Message.SdParameter


-- | Rendering functions for <a>LogMessage</a>s.
module Control.Eff.Log.MessageRenderer

-- | <a>LogMessage</a> rendering function
type LogMessageRenderer a = LogMessage -> a

-- | Render the <a>LogMessage</a> to contain the severity, message,
--   message-id, pid.
--   
--   Omit hostname, PID and timestamp.
--   
--   Render the header using <tt>renderSyslogSeverity</tt>
--   
--   Useful for logging to <tt><i>dev</i>log</tt>
renderLogMessageSyslog :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> human readable, for console logging
renderLogMessageConsoleLog :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-3164.
renderRFC3164 :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-3164 but
--   use RFC5424 time stamps.
renderRFC3164WithRFC5424Timestamps :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-3164 but
--   use the custom <a>LogMessageTimeRenderer</a>.
renderRFC3164WithTimestamp :: LogMessageTimeRenderer -> LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-5424.
--   
--   Equivalent to <tt><a>renderRFC5424Header</a> &lt;&gt; const " "
--   &lt;&gt; <a>renderLogMessageBody</a></tt>.
renderRFC5424 :: LogMessageRenderer Text

-- | Render the header and strucuted data of a <a>LogMessage</a> according
--   to the rules in the RFC-5424, but do not render the <a>lmMessage</a>.
renderRFC5424Header :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-5424,
--   like <a>renderRFC5424</a> but suppress the source location
--   information.
--   
--   Equivalent to <tt><a>renderRFC5424Header</a> &lt;&gt; const " "
--   &lt;&gt; <a>renderLogMessageBodyNoLocation</a></tt>.
renderRFC5424NoLocation :: LogMessageRenderer Text

-- | Render the severity and facility as described in RFC-3164
--   
--   Render e.g. as <tt>&lt;192&gt;</tt>.
--   
--   Useful as header for syslog compatible log output.
renderSyslogSeverityAndFacility :: LogMessageRenderer Text

-- | Render the source location as: <tt>at filepath:linenumber</tt>.
renderLogMessageSrcLoc :: LogMessageRenderer (Maybe Text)

-- | Render a field of a <a>LogMessage</a> using the corresponsing lens.
renderMaybeLogMessageLens :: Text -> Getter LogMessage (Maybe Text) -> LogMessageRenderer Text

-- | Print the thread id, the message and the source file location,
--   seperated by simple white space.
renderLogMessageBodyNoLocation :: LogMessageRenderer Text

-- | Print the thread id, the message and the source file location,
--   seperated by simple white space.
renderLogMessageBody :: LogMessageRenderer Text

-- | Print the <i>body</i> of a <a>LogMessage</a> with fix size fields (60)
--   for the message itself and 30 characters for the location
renderLogMessageBodyFixWidth :: LogMessageRenderer Text

-- | A rendering function for the <a>lmTimestamp</a> field.
data LogMessageTimeRenderer

-- | Make a <a>LogMessageTimeRenderer</a> using <a>formatTime</a> in the
--   <tt>defaultLocale</tt>.
mkLogMessageTimeRenderer :: String -> LogMessageTimeRenderer

-- | Don't render the time stamp
suppressTimestamp :: LogMessageTimeRenderer

-- | Render the time stamp using <tt>"%h %d %H:%M:%S"</tt>
rfc3164Timestamp :: LogMessageTimeRenderer

-- | Render the time stamp to <tt><a>iso8601DateFormat</a> (Just
--   "%H:%M:%S%6QZ")</tt>
rfc5424Timestamp :: LogMessageTimeRenderer

-- | Render the time stamp like <a>rfc5424Timestamp</a> does, but omit the
--   terminal <tt>Z</tt> character.
rfc5424NoZTimestamp :: LogMessageTimeRenderer


-- | The <a>LogWriter</a> type encapsulates an effectful function to write
--   <a>LogMessage</a>s.
--   
--   Used in conjunction with the <a>HandleLogWriter</a> class, it can be
--   used to write messages from within an effectful computation.
module Control.Eff.Log.Writer

-- | A function that takes a log message and returns an effect that
--   <i>logs</i> the message.
newtype LogWriter writerM
MkLogWriter :: (LogMessage -> LogWriterM writerM ()) -> LogWriter writerM
[runLogWriter] :: LogWriter writerM -> LogMessage -> LogWriterM writerM ()

-- | A Reader specialized for <a>LogWriter</a>s
--   
--   The existing <tt>Reader</tt> couldn't be used together with
--   <a>SetMember</a>, so this lazy reader was written, specialized to
--   reading <a>LogWriter</a>.
data LogWriterReader h v

-- | Modify the current <a>LogWriter</a>.
localLogWriterReader :: forall h e a. SetMember LogWriterReader (LogWriterReader h) e => (LogWriter h -> LogWriter h) -> Eff e a -> Eff e a

-- | Get the current <a>LogWriter</a>.
askLogWriter :: SetMember LogWriterReader (LogWriterReader h) e => Eff e (LogWriter h)

-- | Provide the <a>LogWriter</a>
--   
--   Exposed for custom extensions, if in doubt use <tt>withLogging</tt>.
runLogWriterReader :: LogWriter h -> Eff (LogWriterReader h : e) a -> Eff e a

-- | The instances of this class are the monads that define (side-)
--   effect(s) of writting logs.
class HandleLogWriter (writer :: Type -> Type) where {
    
    -- | The <a>Eff</a>ects required by the <a>handleLogWriterEffect</a>
    --   method.
    data family LogWriterM writer a;
}

-- | Run the side effect of a <a>LogWriter</a> in a compatible <a>Eff</a>.
handleLogWriterEffect :: (HandleLogWriter writer, Member writer e) => LogWriterM writer () -> Eff e ()

-- | Write a message using the <a>LogWriter</a> found in the environment.
--   
--   The semantics of this function are a combination of
--   <a>runLogWriter</a> and <a>handleLogWriterEffect</a>, with the
--   <a>LogWriter</a> read from a <a>LogWriterReader</a>.
liftWriteLogMessage :: (HandleLogWriter writer, SetMember LogWriterReader (LogWriterReader writer) e, Member writer e) => LogMessage -> Eff e ()

-- | This <a>LogWriter</a> will discard all messages.
--   
--   NOTE: This is just an alias for <a>def</a>
noOpLogWriter :: Applicative (LogWriterM m) => LogWriter m

-- | A <a>LogWriter</a> that applies a predicate to the <a>LogMessage</a>
--   and delegates to to the given writer of the predicate is satisfied.
filteringLogWriter :: Monad (LogWriterM e) => LogPredicate -> LogWriter e -> LogWriter e

-- | A <a>LogWriter</a> that applies a function to the <a>LogMessage</a>
--   and delegates the result to to the given writer.
mappingLogWriter :: (LogMessage -> LogMessage) -> LogWriter e -> LogWriter e

-- | Like <a>mappingLogWriter</a> allow the function that changes the
--   <a>LogMessage</a> to have effects.
mappingLogWriterM :: Monad (LogWriterM e) => (LogMessage -> LogWriterM e LogMessage) -> LogWriter e -> LogWriter e
instance GHC.Base.Monad (Control.Eff.Log.Writer.LogWriterM (Control.Eff.Internal.Lift GHC.Types.IO))
instance GHC.Base.Functor (Control.Eff.Log.Writer.LogWriterM (Control.Eff.Internal.Lift GHC.Types.IO))
instance GHC.Base.Applicative (Control.Eff.Log.Writer.LogWriterM (Control.Eff.Internal.Lift GHC.Types.IO))
instance GHC.Base.Monad (Control.Eff.Log.Writer.LogWriterM (Control.Eff.Writer.Strict.Writer Control.Eff.Log.Message.LogMessage))
instance GHC.Base.Applicative (Control.Eff.Log.Writer.LogWriterM (Control.Eff.Writer.Strict.Writer Control.Eff.Log.Message.LogMessage))
instance GHC.Base.Functor (Control.Eff.Log.Writer.LogWriterM (Control.Eff.Writer.Strict.Writer Control.Eff.Log.Message.LogMessage))
instance GHC.Base.Applicative (Control.Eff.Log.Writer.LogWriterM w) => Data.Default.Class.Default (Control.Eff.Log.Writer.LogWriter w)
instance Control.Eff.Internal.Handle (Control.Eff.Log.Writer.LogWriterReader h) e a (Control.Eff.Log.Writer.LogWriter h -> k)
instance (Control.Monad.Base.MonadBase m m, Control.Eff.Internal.LiftedBase m r) => Control.Monad.Trans.Control.MonadBaseControl m (Control.Eff.Internal.Eff (Control.Eff.Log.Writer.LogWriterReader h : r))
instance (Control.Eff.Internal.LiftedBase m e, Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff e)) => Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff (Control.Eff.Log.Writer.LogWriterReader h : e))
instance (GHC.Base.Applicative m, Control.Eff.Internal.LiftedBase m e, Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff e)) => Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff (Control.Eff.Log.Writer.LogWriterReader h : e))
instance (GHC.Base.Applicative m, Control.Eff.Internal.LiftedBase m e, Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff e)) => Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff (Control.Eff.Log.Writer.LogWriterReader h : e))
instance Control.Eff.Log.Writer.HandleLogWriter (Control.Eff.Internal.Lift GHC.Types.IO)
instance Control.Eff.Log.Writer.HandleLogWriter (Control.Eff.Writer.Strict.Writer Control.Eff.Log.Message.LogMessage)


-- | A memory efficient, streaming, logging effect with support for
--   efficiently not logging when no logs are required.
--   
--   Good support for logging to a file or to the network, as well as
--   asynchronous logging in another thread.
module Control.Eff.Log.Handler

-- | Log a message.
--   
--   All logging goes through this function.
--   
--   This function is the only place where the <a>LogPredicate</a> is
--   applied.
--   
--   Also, <a>LogMessage</a>s are evaluated using <a>deepseq</a>,
--   <b>after</b> they pass the <a>LogPredicate</a>.
logMsg :: forall e. (HasCallStack, Member Logs e) => LogMessage -> Eff e ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Include <a>LogMessage</a>s that match a <a>LogPredicate</a>.
--   
--   <tt>excludeLogMessages p</tt> allows log message to be logged if <tt>p
--   m</tt>
--   
--   Although it is enough if the previous predicate holds. See
--   <a>excludeLogMessages</a> and <a>modifyLogPredicate</a>.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
includeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a

-- | Exclude <a>LogMessage</a>s that match a <a>LogPredicate</a>.
--   
--   <tt>excludeLogMessages p</tt> discards logs if <tt>p m</tt>
--   
--   Also the previous predicate must also hold for a message to be logged.
--   See <a>excludeLogMessages</a> and <a>modifyLogPredicate</a>.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
excludeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a

-- | Keep only those messages, for which a predicate holds.
--   
--   E.g. to keep only messages which begin with <tt><a>OMG</a></tt>:
--   
--   <pre>
--   exampleLogPredicate :: IO Int
--   exampleLogPredicate =
--       runLift
--     $ withLogging consoleLogWriter
--     $ do logMsg "test"
--          setLogPredicate (\ msg -&gt; case view lmMessage msg of
--                                     'O':'M':'G':_ -&gt; True
--                                     _             -&gt; False)
--                            (do logMsg "this message will not be logged"
--                                logMsg "OMG logged"
--                                return 42)
--   </pre>
--   
--   In order to also delegate to the previous predicate, use
--   <a>modifyLogPredicate</a>
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
setLogPredicate :: forall r b. (Member Logs r, HasCallStack) => LogPredicate -> Eff r b -> Eff r b

-- | Change the <a>LogPredicate</a>.
--   
--   Other than <a>setLogPredicate</a> this function allows to include the
--   previous predicate, too.
--   
--   For to discard all messages currently no satisfying the predicate and
--   also all messages that are to long:
--   
--   <pre>
--   modifyLogPredicate (previousPredicate msg -&gt; previousPredicate msg &amp;&amp; length (lmMessage msg) &lt; 29 )
--                      (do logMsg "this message will not be logged"
--                          logMsg "this message might be logged")
--   </pre>
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
modifyLogPredicate :: forall e b. (Member Logs e, HasCallStack) => (LogPredicate -> LogPredicate) -> Eff e b -> Eff e b

-- | Get the current <a>Logs</a> filter/transformer function.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
askLogPredicate :: forall e. Member Logs e => Eff e LogPredicate

-- | Replace the current <a>LogWriter</a>. To add an additional log message
--   consumer use <a>addLogWriter</a>
setLogWriter :: forall h e a. LogsTo h e => LogWriter h -> Eff e a -> Eff e a

-- | Combine the effects of a given <a>LogWriter</a> and the existing one.
--   
--   <pre>
--   import Data.Text    as T
--   import Data.Text.IO as T
--   
--   exampleAddLogWriter :: IO ()
--   exampleAddLogWriter = go &gt;&gt;= T.putStrLn
--    where go = fmap (unlines . map renderLogMessageConsoleLog . snd)
--                 $  runLift
--                 $  runCaptureLogWriter
--                 $  withLogging captureLogWriter
--                 $  addLogWriter (mappingLogWriter (lmMessage %~ ("CAPTURED "++)) captureLogWriter)
--                 $  addLogWriter (filteringLogWriter severeMessages (mappingLogWriter (lmMessage %~ ("TRACED "++)) debugTraceLogWriter))
--                 $  do
--                       logEmergency "test emergencySeverity 1"
--                       logCritical "test criticalSeverity 2"
--                       logAlert "test alertSeverity 3"
--                       logError "test errorSeverity 4"
--                       logWarning "test warningSeverity 5"
--                       logInfo "test informationalSeverity 6"
--                       logDebug "test debugSeverity 7"
--          severeMessages = view (lmSeverity . to (&lt;= errorSeverity))
--   </pre>
addLogWriter :: forall h e a. (HasCallStack, LogsTo h e, Monad (LogWriterM h)) => LogWriter h -> Eff e a -> Eff e a

-- | Change the current <a>LogWriter</a>.
modifyLogWriter :: forall h e a. LogsTo h e => (LogWriter h -> LogWriter h) -> Eff e a -> Eff e a

-- | Modify the the <a>LogMessage</a>s written in the given sub-expression.
--   
--   Note: This is equivalent to <tt><a>modifyLogWriter</a> .
--   <a>mappingLogWriter</a></tt>
censorLogs :: LogsTo h e => (LogMessage -> LogMessage) -> Eff e a -> Eff e a

-- | Modify the the <a>LogMessage</a>s written in the given sub-expression,
--   as in <a>censorLogs</a> but with a effectful function.
--   
--   Note: This is equivalent to <tt><a>modifyLogWriter</a> .
--   <a>mappingLogWriterM</a></tt>
censorLogsM :: (LogsTo h e, Monad (LogWriterM h)) => (LogMessage -> LogWriterM h LogMessage) -> Eff e a -> Eff e a

-- | This effect sends <a>LogMessage</a>s and is a reader for a
--   <a>LogPredicate</a>.
--   
--   Logs are sent via <a>logMsg</a>; for more information about log
--   predicates, see <a>Control.Eff.Log#LogPredicate</a>
--   
--   This effect is handled via <a>withLogging</a>.
data Logs v

-- | A constraint alias for effects that requires a <a>LogWriterReader</a>,
--   as well as that the contained <a>LogWriterReader</a> has a
--   <a>HandleLogWriter</a> instance.
--   
--   The requirements of this constraint are provided by:
--   
--   <ul>
--   <li><tt>withIoLogging</tt></li>
--   <li><a>withLogging</a></li>
--   <li><a>withSomeLogging</a></li>
--   </ul>
type LogsTo h e = (Member Logs e, HandleLogWriter h, Member h e, SetMember LogWriterReader (LogWriterReader h) e)

-- | A constraint that required <tt><a>LogsTo</a> <a>IO</a> e</tt> and
--   <tt><a>Lifted</a> <a>IO</a> e</tt>.
type LogIo e = (LogsTo (Lift IO) e, Lifted IO e)

-- | Handle the <a>Logs</a> and <a>LogWriterReader</a> effects.
--   
--   It installs the given <a>LogWriter</a>, which determines the
--   underlying <a>LogWriter</a> type parameter.
--   
--   Example:
--   
--   <pre>
--   exampleWithLogging :: IO ()
--   exampleWithLogging =
--       runLift
--     $ withLogging consoleLogWriter
--     $ logDebug "Oh, hi there"
--   </pre>
withLogging :: forall h e a. (Applicative (LogWriterM h), LogsTo h (Logs : (LogWriterReader h : e))) => LogWriter h -> Eff (Logs : (LogWriterReader h : e)) a -> Eff e a

-- | Handles the <a>Logs</a> and <a>LogWriterReader</a> effects.
--   
--   By default it uses the <a>noOpLogWriter</a>, but using
--   <a>setLogWriter</a> the <a>LogWriter</a> can be replaced.
--   
--   This is like <a>withLogging</a> applied to <a>noOpLogWriter</a>
--   
--   Example:
--   
--   <pre>
--   exampleWithSomeLogging :: ()
--   exampleWithSomeLogging =
--       run
--     $ withSomeLogging @PureLogWriter
--     $ logDebug "Oh, hi there"
--   </pre>
withSomeLogging :: forall h e a. (Applicative (LogWriterM h), LogsTo h (Logs : (LogWriterReader h : e))) => Eff (Logs : (LogWriterReader h : e)) a -> Eff e a

-- | Raw handling of the <a>Logs</a> effect. Exposed for custom extensions,
--   if in doubt use <a>withLogging</a>.
runLogs :: forall h e b. LogsTo h (Logs : e) => LogPredicate -> Eff (Logs : e) b -> Eff e b

-- | Consume log messages.
--   
--   Exposed for custom extensions, if in doubt use <a>withLogging</a>.
--   
--   Respond to all <a>LogMessage</a>s logged from the given action, up to
--   any <a>MonadBaseControl</a> liftings.
--   
--   Note that all logging is done through <a>logMsg</a> and that means
--   only messages passing the <a>LogPredicate</a> are received.
--   
--   The <a>LogMessage</a>s are <b>consumed</b> once they are passed to the
--   given callback function, previous <a>respondToLogMessage</a>
--   invocations further up in the call stack will not get the messages
--   anymore.
--   
--   Use <a>interceptLogMessages</a> if the messages shall be passed any
--   previous handler.
--   
--   NOTE: The effects of this function are <b>lost</b> when using
--   <a>MonadBaseControl</a>, <a>MonadMask</a>, <a>MonadCatch</a> and
--   <a>MonadThrow</a>.
--   
--   In contrast the functions based on modifying the <a>LogWriter</a>,
--   such as <a>addLogWriter</a> or <a>censorLogs</a>, are save to use in
--   combination with the aforementioned liftings.
respondToLogMessage :: forall r b. Member Logs r => (LogMessage -> Eff r ()) -> Eff r b -> Eff r b

-- | Change the <a>LogMessage</a>s using an effectful function.
--   
--   Exposed for custom extensions, if in doubt use <a>withLogging</a>.
--   
--   This differs from <a>respondToLogMessage</a> in that the intercepted
--   messages will be written either way, albeit in altered form.
--   
--   NOTE: The effects of this function are <b>lost</b> when using
--   <a>MonadBaseControl</a>, <a>MonadMask</a>, <a>MonadCatch</a> and
--   <a>MonadThrow</a>.
--   
--   In contrast the functions based on modifying the <a>LogWriter</a>,
--   such as <a>addLogWriter</a> or <a>censorLogs</a>, are save to use in
--   combination with the aforementioned liftings.
interceptLogMessages :: forall r b. Member Logs r => (LogMessage -> Eff r LogMessage) -> Eff r b -> Eff r b
instance GHC.Base.Functor (Control.Eff.Log.Writer.LogWriterM Control.Eff.Log.Handler.Logs)
instance (Control.Monad.Base.MonadBase m m, Control.Eff.Internal.LiftedBase m e, Control.Eff.Log.Handler.LogsTo (Control.Eff.Internal.Lift m) (Control.Eff.Log.Handler.Logs : e)) => Control.Monad.Trans.Control.MonadBaseControl m (Control.Eff.Internal.Eff (Control.Eff.Log.Handler.Logs : e))
instance (GHC.Base.Applicative m, Control.Eff.Internal.LiftedBase m e, Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff e), Control.Eff.Log.Handler.LogsTo (Control.Eff.Internal.Lift m) (Control.Eff.Log.Handler.Logs : e)) => Control.Monad.Catch.MonadCatch (Control.Eff.Internal.Eff (Control.Eff.Log.Handler.Logs : e))
instance (GHC.Base.Applicative m, Control.Eff.Internal.LiftedBase m e, Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff e), Control.Eff.Log.Handler.LogsTo (Control.Eff.Internal.Lift m) (Control.Eff.Log.Handler.Logs : e)) => Control.Monad.Catch.MonadMask (Control.Eff.Internal.Eff (Control.Eff.Log.Handler.Logs : e))
instance Control.Eff.Internal.Handle Control.Eff.Log.Handler.Logs e a (Control.Eff.Log.Message.LogPredicate -> k)
instance (Control.Eff.Internal.LiftedBase m e, Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff e)) => Control.Monad.Catch.MonadThrow (Control.Eff.Internal.Eff (Control.Eff.Log.Handler.Logs : e))
instance Control.Eff.Log.Writer.HandleLogWriter Control.Eff.Log.Handler.Logs
instance GHC.Base.Applicative (Control.Eff.Log.Writer.LogWriterM Control.Eff.Log.Handler.Logs)
instance GHC.Base.Monad (Control.Eff.Log.Writer.LogWriterM Control.Eff.Log.Handler.Logs)


-- | 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 [StrictDynamic])

-- | 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] :: ProcessTitle -> Eff (Process r : r) () -> Process r (ResumeProcess ProcessId)

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

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

-- | Shutdown another process immediately, the other process has no way of
--   handling this!
[SendShutdown] :: ProcessId -> Interrupt  '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 -> Interrupt  'Recoverable -> Process r (ResumeProcess ())

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

-- | Receive a message that matches a criteria. This should block until an
--   a message was received. The message is returned as a
--   <a>ResumeProcess</a> 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, without 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 <a>Interrupt</a>
--   <a>LinkedProcessCrashed</a>.
[Link] :: ProcessId -> Process r (ResumeProcess ())

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

-- | Update the <a>ProcessDetails</a> of a process
[UpdateProcessDetails] :: ProcessDetails -> Process r (ResumeProcess ())

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

-- | <i>Cons</i> <a>Process</a> onto a list of effects. This is called
--   <tt>SafeProcesses</tt> because the the actions cannot be interrupted
--   in.
type SafeProcesses r = Process r : r

-- | This adds a layer of the <a>Interrupts</a> effect on top of
--   <a>Processes</a>
type Processes e = Interrupts : SafeProcesses e

-- | A constraint for an effect set that requires the presence of
--   <a>Processes</a>.
--   
--   This constrains the effect list to look like this: <tt>[e1 ... eN,
--   <a>Interrupts</a>, <a>Process</a> [e(N+1) .. e(N+k)], e(N+1) ..
--   e(N+k)]</tt>
--   
--   It contrains <tt>e</tt> beyond <a>HasSafeProcesses</a> to encompass
--   <a>Interrupts</a>.
type HasProcesses e inner = (HasSafeProcesses e inner, Member Interrupts e)

-- | A constraint for an effect set that requires the presence of
--   <a>SafeProcesses</a>.
--   
--   This constrains the effect list to look like this: <tt>[e1 ... eN,
--   <a>Process</a> [e(N+1) .. e(N+k)], e(N+1) .. e(N+k)]</tt>
--   
--   It contrains <tt>e</tt> to support the (only) <a>Process</a> effect.
--   
--   This is more relaxed that <a>HasProcesses</a> since it does not
--   require <a>Interrupts</a>.
type HasSafeProcesses e inner = (SetMember Process (Process inner) e)

-- | A short title for a <a>Process</a> for logging purposes.
newtype ProcessTitle
MkProcessTitle :: Text -> ProcessTitle
[_fromProcessTitle] :: ProcessTitle -> Text

-- | An isomorphism lens for the <a>ProcessTitle</a>
fromProcessTitle :: Lens' ProcessTitle Text

-- | A multi-line text describing the <b>current</b> state of a process for
--   debugging purposes.
newtype ProcessDetails
MkProcessDetails :: Text -> ProcessDetails
[_fromProcessDetails] :: ProcessDetails -> Text

-- | An isomorphism lens for the <a>ProcessDetails</a>
fromProcessDetails :: Lens' ProcessDetails Text

-- | Data flows between <a>Process</a>es via these messages.
--   
--   This is just a newtype wrapper around <a>Dynamic</a>. The reason this
--   type exists is to force construction through the code in this module,
--   which always evaluates a message to <i>normal form</i> <b>before</b>
--   sending it to another process.
data StrictDynamic

-- | Deeply evaluate the given value and wrap it into a
--   <a>StrictDynamic</a>.
toStrictDynamic :: (Typeable a, NFData a) => a -> StrictDynamic

-- | Convert a <a>StrictDynamic</a> back to a value.
fromStrictDynamic :: Typeable a => StrictDynamic -> Maybe a

-- | Convert a <a>StrictDynamic</a> back to an unwrapped <a>Dynamic</a>.
unwrapStrictDynamic :: StrictDynamic -> Dynamic

-- | Serialize a <tt>message</tt> into a <a>StrictDynamic</a> value to be
--   sent via <a>sendAnyMessage</a>.
--   
--   This indirection allows, among other things, the composition of
--   <a>Server</a>s.
newtype Serializer message
MkSerializer :: (message -> StrictDynamic) -> Serializer message
[runSerializer] :: Serializer message -> message -> StrictDynamic

-- | 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

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

-- | The process has just been started but not scheduled yet.
ProcessBooting :: ProcessState

-- | The process yielded it's time slice
ProcessIdle :: ProcessState

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

-- | The process is busy with <a>UpdateProcessDetails</a>
ProcessBusyUpdatingDetails :: 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. (HasProcesses r q, HasCallStack) => Eff r ()

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>.
--   
--   The message will be reduced to normal form (<a>rnf</a>) by/in the
--   caller process.
sendMessage :: forall r q o. (HasProcesses r q, HasCallStack, Typeable o, NFData o) => 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. (HasCallStack, HasProcesses r q) => ProcessId -> StrictDynamic -> Eff r ()

-- | Generate a unique <a>Int</a> for the current process.
makeReference :: (HasCallStack, HasProcesses r 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, NFData a, Show a, HasProcesses r 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, HasProcesses r q) => MessageSelector a -> Eff r a

-- | Remove and return all messages currently enqueued in the process
--   message queue.
flushMessages :: forall r q. (HasCallStack, HasProcesses r q) => Eff r [StrictDynamic]

-- | Block until a message was received. See <a>ReceiveSelectedMessage</a>
--   for more documentation.
receiveAnyMessage :: forall r q. (HasCallStack, HasProcesses r q) => Eff r StrictDynamic

-- | Like <a>receiveSelectedLoop</a> but refined to casting to a specific
--   <a>Typeable</a> using <a>selectMessage</a>.
receiveLoop :: forall r q a endOfLoopResult. (HasSafeProcesses r q, HasCallStack, NFData a, Typeable a) => (Either (Interrupt  'Recoverable) 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> <a>Interrupt</a></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. (HasSafeProcesses r q, HasCallStack) => MessageSelector a -> (Either (Interrupt  'Recoverable) a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Like <a>receiveSelectedLoop</a> but <i>not selective</i>. See also
--   <a>selectAnyMessage</a>, <a>receiveSelectedLoop</a>.
receiveAnyLoop :: forall r q endOfLoopResult. (HasSafeProcesses r q, HasCallStack) => (Either (Interrupt  'Recoverable) StrictDynamic -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | A function that decided 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>fromStrictDynamic</a>.
selectMessage :: Typeable t => MessageSelector t

-- | Create a message selector from a predicate.
filterMessage :: 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>).
selectMessageWith :: Typeable a => (a -> Maybe b) -> MessageSelector b

-- | Create a message selector.
selectDynamicMessage :: (StrictDynamic -> 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.
selectAnyMessage :: MessageSelector StrictDynamic

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

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

-- | Return the <a>ProcessTitle</a>, <a>ProcessDetails</a> and
--   <a>ProcessState</a>, for the given process, if the process is alive.
getProcessState :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r (Maybe (ProcessTitle, ProcessDetails, ProcessState))

-- | Replace the <a>ProcessDetails</a> of the process.
updateProcessDetails :: forall r q. (HasCallStack, HasProcesses r q) => ProcessDetails -> 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>Interrupt</a> wrapped in <a>interruptToExit</a>. For specific use
--   cases it might be better to use <a>spawnRaw</a>.
spawn :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ProcessId

-- | Like <a>spawn</a> but return <tt>()</tt>.
spawn_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ()

-- | Start a new process, and immediately link to it.
spawnLink :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes 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>SafeProcesses</a> effects. For
--   non-library code <a>spawn</a> might be better suited.
spawnRaw :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff r ProcessId

-- | Like <a>spawnRaw</a> but return <tt>()</tt>.
spawnRaw_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff 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>Interrupt</a>. If <a>isRecoverable</a> holds for the given reason,
--   the process may choose to continue.
[Interrupted] :: Interrupt  'Recoverable -> ResumeProcess v

-- | The process may resume to do work, using the given result.
[ResumeWith] :: a -> ResumeProcess 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. (HasSafeProcesses r q, HasCallStack) => Process q (ResumeProcess v) -> Eff r (Either (Interrupt  '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. (HasSafeProcesses r q, 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. (HasProcesses r q, HasCallStack) => Process q (ResumeProcess v) -> Eff r v

-- | Throw an <a>Interrupt</a>, can be handled by <a>handleInterrupts</a>
--   or <a>exitOnInterrupt</a> or <a>provideInterrupts</a>.
interrupt :: (HasCallStack, Member Interrupts r) => Interrupt  'Recoverable -> Eff r a

-- | 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. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt  'Recoverable -> Eff r ()

-- | Exit the process with a <a>Interrupt</a>.
exitBecause :: forall r q a. (HasCallStack, HasSafeProcesses r q) => Interrupt  'NoRecovery -> Eff r a

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

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

-- | 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. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt  'NoRecovery -> Eff r ()

-- | 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 <a>Interrupt</a>
--   <a>LinkedProcessCrashed</a>.
linkProcess :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r ()

-- | Unlink the calling process from the other process.
unlinkProcess :: forall r q. (HasCallStack, HasProcesses r 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, without exit reason
monitor :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r MonitorReference

-- | Remove a monitor created with <a>monitor</a>.
demonitor :: forall r q. (HasCallStack, HasProcesses r q) => MonitorReference -> Eff r ()

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

-- | A <a>MessageSelector</a> for the <a>ProcessDown</a> message of a
--   specific process.
--   
--   The parameter is the value obtained by <a>monitor</a>.
selectProcessDown :: MonitorReference -> MessageSelector ProcessDown

-- | A <a>MessageSelector</a> for the <a>ProcessDown</a> message. of a
--   specific process.
--   
--   In contrast to <a>selectProcessDown</a> this function matches the
--   <a>ProcessId</a>.
selectProcessDownByProcessId :: ProcessId -> MessageSelector ProcessDown

-- | Make an <a>Interrupt</a> for a <a>ProcessDown</a> message.
--   
--   For example: <tt>doSomething &gt;&gt;= either (interrupt .
--   becauseProcessIsDown) return</tt>
becauseProcessIsDown :: ProcessDown -> Interrupt  'Recoverable

-- | 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, HasProcesses r 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, HasProcesses r q, Typeable a, Show a) => ProcessId -> MessageSelector a -> Eff r (Either ProcessDown a)

-- | A sum-type with reasons for why a process operation, such as receiving
--   messages, is interrupted in the scheduling loop.
--   
--   This includes errors, that can occur when scheduling messages.
data Interrupt (t :: ExitRecovery)

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

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

-- | A <a>Recoverable</a> timeout has occurred.
[TimeoutInterrupt] :: String -> Interrupt  'Recoverable

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

-- | An exit reason that has an error message and is <a>Recoverable</a>.
[ErrorInterrupt] :: String -> Interrupt  'Recoverable

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

-- | An error causes the process to exit immediately. For example an
--   unexpected runtime exception was thrown, i.e. an exception derived
--   from <a>SomeException</a> Or a <a>Recoverable</a> Interrupt was not
--   recovered.
[ExitUnhandledError] :: Text -> Interrupt  'NoRecovery

-- | A process shall exit immediately, without any cleanup was cancelled
--   (e.g. killed, in <a>cancel</a>)
[ExitProcessCancelled] :: Interrupt  'NoRecovery

-- | <a>Exc</a>eptions containing <a>Interrupt</a>s. See
--   <a>handleInterrupts</a>, <a>exitOnInterrupt</a> or
--   <a>provideInterrupts</a>
type Interrupts = Exc (Interrupt  'Recoverable)

-- | Return either <a>ExitNormally</a> or <a>interruptToExit</a> from a
--   <a>Recoverable</a> <a>Interrupt</a>;
--   
--   If the <a>Interrupt</a> is <a>NormalExitRequested</a> then return
--   <a>ExitNormally</a>
interruptToExit :: Interrupt  'Recoverable -> Interrupt  'NoRecovery

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

-- | <a>Interrupt</a>s which are <a>Recoverable</a>.
type RecoverableInterrupt = Interrupt  'Recoverable

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

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

-- | Get the <a>ExitRecovery</a>
toExitRecovery :: Interrupt r -> ExitRecovery

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

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

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

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

-- | Print a <a>Interrupt</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 :: Interrupt -&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 :: Interrupt x -> Maybe Text

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

-- | Log the <a>Interrupt</a>s
logProcessExit :: forall e x. (Member Logs e, HasCallStack) => Interrupt x -> Eff e ()

-- | Handle all <a>Interrupt</a>s of an <a>Processes</a> by wrapping them
--   up in <a>interruptToExit</a> and then do a process <a>Shutdown</a>.
provideInterruptsShutdown :: forall e a. Eff (Processes e) a -> Eff (SafeProcesses e) a

-- | Handle <a>Interrupt</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) => (Interrupt  'Recoverable -> Eff r a) -> Eff r a -> Eff r a

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

-- | Handle <a>Interrupt</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, HasProcesses r q) => Eff r a -> Eff r a

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

-- | Handle <a>Interrupt</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 (Interrupt  'Recoverable) a)

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

-- | Serialize and send a message to the process in a <a>Receiver</a>.
--   
--   EXPERIMENTAL
sendToReceiver :: (NFData o, HasProcesses r q) => Receiver o -> o -> Eff r ()

-- | A <a>ProcessId</a> and a <a>Serializer</a>. EXPERIMENTAL
--   
--   See <a>sendToReceiver</a>.
data Receiver a
Receiver :: ProcessId -> (a -> out) -> Receiver a
[_receiverPid] :: Receiver a -> ProcessId
[_receiverSerializer] :: Receiver a -> a -> out
receiverPid :: forall a_aHxu. Lens' (Receiver a_aHxu) ProcessId
instance Control.DeepSeq.NFData (Control.Eff.Concurrent.Process.Receiver o)
instance GHC.Classes.Eq (Control.Eff.Concurrent.Process.Receiver o)
instance GHC.Classes.Ord (Control.Eff.Concurrent.Process.Receiver o)
instance Data.Functor.Contravariant.Contravariant Control.Eff.Concurrent.Process.Receiver
instance Data.Typeable.Internal.Typeable protocol => GHC.Show.Show (Control.Eff.Concurrent.Process.Receiver protocol)
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.Base.Monoid Control.Eff.Concurrent.Process.ProcessDetails
instance GHC.Base.Semigroup Control.Eff.Concurrent.Process.ProcessDetails
instance Data.String.IsString Control.Eff.Concurrent.Process.ProcessDetails
instance GHC.Generics.Generic Control.Eff.Concurrent.Process.ProcessDetails
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.ProcessDetails
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.ProcessDetails
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.ProcessDetails
instance GHC.Base.Monoid Control.Eff.Concurrent.Process.ProcessTitle
instance GHC.Base.Semigroup Control.Eff.Concurrent.Process.ProcessTitle
instance Data.String.IsString Control.Eff.Concurrent.Process.ProcessTitle
instance GHC.Generics.Generic Control.Eff.Concurrent.Process.ProcessTitle
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.ProcessTitle
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.ProcessTitle
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.ProcessTitle
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.Interrupt x)
instance GHC.Exception.Type.Exception (Control.Eff.Concurrent.Process.Interrupt 'Control.Eff.Concurrent.Process.Recoverable)
instance GHC.Exception.Type.Exception (Control.Eff.Concurrent.Process.Interrupt 'Control.Eff.Concurrent.Process.NoRecovery)
instance Control.DeepSeq.NFData (Control.Eff.Concurrent.Process.Interrupt x)
instance GHC.Classes.Ord (Control.Eff.Concurrent.Process.Interrupt x)
instance GHC.Classes.Eq (Control.Eff.Concurrent.Process.Interrupt 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
instance Control.DeepSeq.NFData (Control.Eff.Concurrent.Process.Serializer message)
instance Data.Typeable.Internal.Typeable message => GHC.Show.Show (Control.Eff.Concurrent.Process.Serializer message)
instance Data.Functor.Contravariant.Contravariant Control.Eff.Concurrent.Process.Serializer
instance Control.DeepSeq.NFData Control.Eff.Concurrent.Process.StrictDynamic
instance GHC.Show.Show Control.Eff.Concurrent.Process.StrictDynamic
instance GHC.Show.Show Control.Eff.Concurrent.Process.ProcessDetails
instance GHC.Show.Show Control.Eff.Concurrent.Process.ProcessTitle


-- | Types and functions for type-safe(er) interaction between processes.
--   
--   All messages sent between processes are eventually converted to
--   <a>Dynamic</a> values which carry little type information.
--   
--   A step towards a more controlled and type safe process interaction
--   model is done with the facilities defined in this module.
--   
--   The metaphor for communication is a <i>stateless protocol</i> that
--   describes the messages handled by a process.
--   
--   A <i>protocol</i> is represented by a custom data type, often a
--   <i>phantom</i> type, which is then used to form specific instances of
--   type classes data/type families, to determine the messages, the
--   replies, the servers and clients, associated with specific task, that
--   needs to be executed concurrently.
--   
--   This module contains a mechanism to specify what kind of messages (aka
--   <i>requests</i>) an <a>Endpoint</a> can handle.
--   
--   The Endpoint wraps a <a>ProcessId</a> and carries the protocol
--   phantom-type, to indicate the messages that a process repsonds to.
--   
--   The associated data type <a>Pdu</a> defines the messages or
--   <i>requests</i> along with the corresponding responses.
--   
--   Request handling can be either blocking, if a response is required, or
--   non-blocking.
--   
--   A process can <i>serve</i> a specific protocol by using the functions
--   provided by the <a>Control.Eff.Concurrent.Protocol.EffectfulServer</a>
--   and <a>Control.Eff.Concurrent.Protocol.EffectfulServer</a> modules.
--   
--   To enable a process to use such a <i>service</i>, the functions
--   provided in <a>Control.Eff.Concurrent.Protocol.Client</a> should be
--   used.
module Control.Eff.Concurrent.Protocol

-- | This type class and the associated data family defines the <b>protocol
--   data units</b> (PDU) of a <i>protocol</i>.
--   
--   A Protocol in the sense of a communication interface description
--   between processes.
--   
--   The first parameter is usually a user defined type that identifies the
--   protocol that uses the <a>Pdu</a>s are. It maybe a <i>phantom</i>
--   type.
--   
--   The second parameter specifies if a specific constructor of an
--   (GADT-like) <tt>Pdu</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
--   
--   instance Typeable r =&gt; HasPdu BookShop r where
--     data instance Pdu BookShop r where
--       RentBook  :: BookId   -&gt; Pdu BookShop ('Synchronous (Either RentalError RentalId))
--       BringBack :: RentalId -&gt; Pdu BookShop 'Asynchronous
--       deriving Typeable
--   
--   type BookId = Int
--   type RentalId = Int
--   type RentalError = String
--   </pre>
class Typeable protocol => HasPdu (protocol :: Type) where {
    
    -- | A type level list Protocol phantom types included in the associated
    --   <a>Pdu</a> instance.
    --   
    --   This is just a helper for better compiler error messages. It relies on
    --   <a>Embeds</a> to add the constraint <a>HasPduPrism</a>.
    type family EmbeddedPduList protocol :: [Type];
    
    -- | The <b>protocol data unit</b> type for the given protocol.
    data family Pdu protocol (reply :: Synchronicity);
    type EmbeddedPduList protocol = '[];
}

-- | Deserialize a <a>Pdu</a> from a <a>Dynamic</a> i.e. from a message
--   received by a process.
deserializePdu :: Typeable (Pdu protocol reply) => Dynamic -> Maybe (Pdu protocol reply)

-- | A constraint that requires that the <tt>outer</tt> <a>Pdu</a> has a
--   clause to embed values from the <tt>inner</tt> <a>Pdu</a>.
--   
--   Also, this constraint requires a <a>HasPduPrism</a> instance, as a
--   proof for a possible conversion of an embedded <a>Pdu</a> value into
--   to the enclosing <a>Pdu</a>.
--   
--   This generates better compiler error messages, when an embedding of a
--   <a>Pdu</a> into another.
--   
--   This is provided by <a>HasPdu</a> instances. The instances are
--   required to provide a list of embedded <a>Pdu</a> values in
--   <a>EmbeddedPduList</a>.
--   
--   Note that every type embeds itself, so <tt>Embeds x x</tt> always
--   holds.
type Embeds outer inner = (HasPduPrism outer inner, CheckEmbeds outer inner, HasPdu outer)

-- | The (promoted) constructors of this type specify (at the type level)
--   the reply behavior of a specific constructor of an <tt>Pdu</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 type function takes an <a>Pdu</a> and analysis the reply type,
--   i.e. the <a>Synchronicity</a> and evaluates to either <tt>t</tt> for
--   an <tt>Pdu x (<a>Synchronous</a> t)</tt> or to '()' for an <tt>Pdu x
--   <a>Asynchronous</a></tt>.
type family ProtocolReply (s :: Synchronicity)

-- | A set of constraints for types that can evaluated via <a>NFData</a>,
--   compared via <a>Ord</a> and presented dynamically via <a>Typeable</a>,
--   and represented both as values via <a>Show</a>.
type Tangible i = (NFData i, Typeable i, Show i)

-- | A <a>Constraint</a> that bundles the requirements for the <a>Pdu</a>
--   values of a protocol.
--   
--   This ensures that <a>Pdu</a>s can be strictly and deeply evaluated and
--   shown such that for example logging is possible.
type TangiblePdu p r = (Typeable p, Typeable r, Tangible (Pdu p r), HasPdu p)

-- | A server process for <i>protocol</i>.
--   
--   Protocols are represented by phantom types, which are used in
--   different places to index type families and type class instances.
--   
--   A <a>Process</a> can send and receive any messages. An <a>Endpoint</a>
--   wraps around a <a>ProcessId</a> and carries a phantom type to indicate
--   the kinds of messages accepted by the process.
--   
--   As a metaphor, communication between processes can be thought of
--   waiting for and sending <b>protocol data units</b> belonging to some
--   protocol.
newtype Endpoint protocol
Endpoint :: ProcessId -> Endpoint protocol
[_fromEndpoint] :: Endpoint protocol -> ProcessId
fromEndpoint :: forall protocol_aTMy protocol_aUUM. Iso (Endpoint protocol_aTMy) (Endpoint protocol_aUUM) ProcessId ProcessId

-- | Tag a <a>ProcessId</a> with an <a>Pdu</a> type index to mark it a
--   <a>Endpoint</a> process handling that API
proxyAsEndpoint :: proxy protocol -> ProcessId -> Endpoint protocol

-- | Tag a <a>ProcessId</a> with an <a>Pdu</a> type index to mark it a
--   <a>Endpoint</a> process handling that API
asEndpoint :: forall protocol. ProcessId -> Endpoint protocol

-- | A class for <a>Pdu</a> instances that embed other <a>Pdu</a>.
--   
--   This is a part of <a>Embeds</a> provide instances for your <a>Pdu</a>s
--   but in client code use the <a>Embeds</a> constraint.
--   
--   Instances of this class serve as proof to <a>Embeds</a> that a
--   conversion into another <a>Pdu</a> actually exists.
--   
--   A <a>Prism</a> for the embedded <a>Pdu</a> is the center of this class
--   
--   Laws: <tt>embeddedPdu = prism' embedPdu fromPdu</tt>
class (Typeable protocol, Typeable embeddedProtocol) => HasPduPrism protocol embeddedProtocol

-- | A <a>Prism</a> for the embedded <a>Pdu</a>s.
embeddedPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Prism' (Pdu protocol result) (Pdu embeddedProtocol result)

-- | Embed the <a>Pdu</a> value of an embedded protocol into the
--   corresponding <a>Pdu</a> value.
embedPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Pdu embeddedProtocol result -> Pdu protocol result

-- | Examine a <a>Pdu</a> value from the outer protocol, and return it, if
--   it embeds a <a>Pdu</a> of embedded protocol, otherwise return
--   <a>Nothing</a>/
fromPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Pdu protocol result -> Maybe (Pdu embeddedProtocol result)

-- | Convert an <a>Endpoint</a> to an endpoint for an embedded protocol.
--   
--   See <a>Embeds</a>, <a>fromEmbeddedEndpoint</a>.
toEmbeddedEndpoint :: forall inner outer. Embeds outer inner => Endpoint outer -> Endpoint inner

-- | Convert an <a>Endpoint</a> to an endpoint for a server, that embeds
--   the protocol.
--   
--   See <a>Embeds</a>, <a>toEmbeddedEndpoint</a>.
fromEmbeddedEndpoint :: forall outer inner. HasPduPrism outer inner => Endpoint inner -> Endpoint outer
instance forall k (protocol :: k). Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Endpoint protocol)
instance forall k (protocol :: k). GHC.Classes.Ord (Control.Eff.Concurrent.Protocol.Endpoint protocol)
instance forall k (protocol :: k). GHC.Classes.Eq (Control.Eff.Concurrent.Protocol.Endpoint protocol)
instance Data.Typeable.Internal.Typeable a => Control.Eff.Concurrent.Protocol.HasPduPrism a a
instance (Data.Typeable.Internal.Typeable a1, Data.Typeable.Internal.Typeable a2) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2) a1
instance (Data.Typeable.Internal.Typeable a1, Data.Typeable.Internal.Typeable a2) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2) a2
instance (Data.Typeable.Internal.Typeable a1, Data.Typeable.Internal.Typeable a2, Data.Typeable.Internal.Typeable a3) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3) a1
instance (Data.Typeable.Internal.Typeable a1, Data.Typeable.Internal.Typeable a2, Data.Typeable.Internal.Typeable a3) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3) a2
instance (Data.Typeable.Internal.Typeable a1, Data.Typeable.Internal.Typeable a2, Data.Typeable.Internal.Typeable a3) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3) a3
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3, Control.Eff.Concurrent.Protocol.HasPdu a4) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3, a4) a1
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3, Control.Eff.Concurrent.Protocol.HasPdu a4) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3, a4) a2
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3, Control.Eff.Concurrent.Protocol.HasPdu a4) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3, a4) a3
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3, Control.Eff.Concurrent.Protocol.HasPdu a4) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3, a4) a4
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3, Control.Eff.Concurrent.Protocol.HasPdu a4, Control.Eff.Concurrent.Protocol.HasPdu a5) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3, a4, a5) a1
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3, Control.Eff.Concurrent.Protocol.HasPdu a4, Control.Eff.Concurrent.Protocol.HasPdu a5) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3, a4, a5) a2
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3, Control.Eff.Concurrent.Protocol.HasPdu a4, Control.Eff.Concurrent.Protocol.HasPdu a5) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3, a4, a5) a3
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3, Control.Eff.Concurrent.Protocol.HasPdu a4, Control.Eff.Concurrent.Protocol.HasPdu a5) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3, a4, a5) a4
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3, Control.Eff.Concurrent.Protocol.HasPdu a4, Control.Eff.Concurrent.Protocol.HasPdu a5) => Control.Eff.Concurrent.Protocol.HasPduPrism (a1, a2, a3, a4, a5) a5
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2) => Control.Eff.Concurrent.Protocol.HasPdu (a1, a2)
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3) => Control.Eff.Concurrent.Protocol.HasPdu (a1, a2, a3)
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3, Control.Eff.Concurrent.Protocol.HasPdu a4) => Control.Eff.Concurrent.Protocol.HasPdu (a1, a2, a3, a4)
instance (Control.Eff.Concurrent.Protocol.HasPdu a1, Control.Eff.Concurrent.Protocol.HasPdu a2, Control.Eff.Concurrent.Protocol.HasPdu a3, Control.Eff.Concurrent.Protocol.HasPdu a4, Control.Eff.Concurrent.Protocol.HasPdu a5) => Control.Eff.Concurrent.Protocol.HasPdu (a1, a2, a3, a4, a5)
instance (Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a1 r), Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a2 r)) => Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu (a1, a2) r)
instance (GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a1 r), GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a2 r)) => GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu (a1, a2) r)
instance (Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a1 r), Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a2 r), Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a3 r)) => Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu (a1, a2, a3) r)
instance (GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a1 r), GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a2 r), GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a3 r)) => GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu (a1, a2, a3) r)
instance (Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a1 r), Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a2 r), Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a3 r), Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a4 r)) => Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu (a1, a2, a3, a4) r)
instance (GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a1 r), GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a2 r), GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a3 r), GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a4 r)) => GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu (a1, a2, a3, a4) r)
instance (Data.Typeable.Internal.Typeable r, Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a1 r), Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a2 r), Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a3 r), Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a4 r), Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu a5 r)) => Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu (a1, a2, a3, a4, a5) r)
instance (GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a1 r), GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a2 r), GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a3 r), GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a4 r), GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu a5 r)) => GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu (a1, a2, a3, a4, a5) r)
instance forall k (protocol :: k). Data.Typeable.Internal.Typeable protocol => GHC.Show.Show (Control.Eff.Concurrent.Protocol.Endpoint protocol)


-- | Proxies and containers for casts and calls.
module Control.Eff.Concurrent.Protocol.Wrapper

-- | A wrapper sum type for calls and casts for the <a>Pdu</a>s of a
--   protocol
data Request protocol
[Call] :: forall protocol reply. (Tangible reply, TangiblePdu protocol ( 'Synchronous reply)) => RequestOrigin protocol reply -> Pdu protocol ( 'Synchronous reply) -> Request protocol
[Cast] :: forall protocol. (TangiblePdu protocol  'Asynchronous, NFData (Pdu protocol  'Asynchronous)) => Pdu protocol  'Asynchronous -> Request protocol

-- | Answer a <a>Call</a> by sending the reply value to the client process.
--   
--   The <a>ProcessId</a>, the <a>RequestOrigin</a> and the <a>Reply</a>
--   <a>Serializer</a> are stored in the <a>ReplyTarget</a>.
sendReply :: (HasProcesses eff q, Tangible reply, Typeable protocol) => ReplyTarget protocol reply -> reply -> Eff eff ()

-- | Target of a <a>Call</a> reply.
--   
--   This combines a <a>RequestOrigin</a> with a <a>Serializer</a> for a
--   <a>Reply</a> using <a>Arg</a>. There are to smart constructors for
--   this type: <a>replyTarget</a> and <a>embeddedReplyTarget</a>.
--   
--   Because of <a>Arg</a> the <a>Eq</a> and <a>Ord</a> instances are
--   implemented via the <a>RequestOrigin</a> instances.
newtype ReplyTarget p r
MkReplyTarget :: Arg (RequestOrigin p r) (Serializer (Reply p r)) -> ReplyTarget p r

-- | Smart constructor for a <a>ReplyTarget</a>.
--   
--   To build a <tt>ReplyTarget</tt> for an <a>Embeds</a> instance use
--   <a>embeddedReplyTarget</a>.
replyTarget :: Serializer (Reply p reply) -> RequestOrigin p reply -> ReplyTarget p reply

-- | A simple <a>Lens</a> for the <a>RequestOrigin</a> of a
--   <a>ReplyTarget</a>.
replyTargetOrigin :: Lens' (ReplyTarget p reply) (RequestOrigin p reply)

-- | A simple <a>Lens</a> for the <a>Reply</a> <a>Serializer</a> of a
--   <a>ReplyTarget</a>.
replyTargetSerializer :: Lens' (ReplyTarget p reply) (Serializer (Reply p reply))

-- | Smart constructor for an <i>embedded</i> <a>ReplyTarget</a>.
--   
--   This combines <a>replyTarget</a> and <a>toEmbeddedReplyTarget</a>.
embeddedReplyTarget :: Embeds outer inner => Serializer (Reply outer reply) -> RequestOrigin outer reply -> ReplyTarget inner reply

-- | Convert a <a>ReplyTarget</a> to be usable for <i>embedded</i> replies.
--   
--   This combines a <a>toEmbeddedOrigin</a> with
--   <a>embedReplySerializer</a> to produce a <a>ReplyTarget</a> that can
--   be passed to functions defined soley on an embedded protocol.
toEmbeddedReplyTarget :: Embeds outer inner => ReplyTarget outer reply -> ReplyTarget inner reply

-- | Wraps the source <a>ProcessId</a> and a unique identifier for a
--   <a>Call</a>.
data RequestOrigin (proto :: Type) reply
RequestOrigin :: !ProcessId -> !Int -> RequestOrigin reply
[_requestOriginPid] :: RequestOrigin reply -> !ProcessId
[_requestOriginCallRef] :: RequestOrigin reply -> !Int

-- | Turn an <i>embedded</i> <a>RequestOrigin</a> to a <a>RequestOrigin</a>
--   for the <i>bigger</i> request.
--   
--   This is the inverse of <a>toEmbeddedOrigin</a>.
--   
--   This function is strict in all parameters.
embedRequestOrigin :: forall outer inner reply. Embeds outer inner => RequestOrigin inner reply -> RequestOrigin outer reply

-- | Turn an <a>RequestOrigin</a> to an origin for an embedded request (See
--   <a>Embeds</a>).
--   
--   This is useful of a server delegates the <tt>calls</tt> and
--   <tt>casts</tt> for an embedded protocol to functions, that require the
--   <a>Serializer</a> and <a>RequestOrigin</a> in order to call
--   <a>sendReply</a>.
--   
--   See also <a>embedReplySerializer</a>.
toEmbeddedOrigin :: forall outer inner reply. Embeds outer inner => RequestOrigin outer reply -> RequestOrigin inner reply

-- | The wrapper around replies to <a>Call</a>s.
data Reply protocol reply
[Reply] :: Tangible reply => {_replyTo :: RequestOrigin protocol reply, _replyValue :: reply} -> Reply protocol reply

-- | Turn a <a>Serializer</a> for a <a>Pdu</a> instance that contains
--   embedded <a>Pdu</a> values into a <a>Reply</a> <a>Serializer</a> for
--   the embedded <a>Pdu</a>.
--   
--   This is useful of a server delegates the <tt>calls</tt> and
--   <tt>casts</tt> for an embedded protocol to functions, that require the
--   <a>Serializer</a> and <a>RequestOrigin</a> in order to call
--   <a>sendReply</a>.
--   
--   See also <a>toEmbeddedOrigin</a>.
embedReplySerializer :: forall outer inner reply. Embeds outer inner => Serializer (Reply outer reply) -> Serializer (Reply inner reply)

-- | Create a new, unique <a>RequestOrigin</a> value for the current
--   process.
makeRequestOrigin :: (Typeable r, NFData r, HasProcesses e q0) => Eff e (RequestOrigin p r)
instance GHC.Classes.Ord (Control.Eff.Concurrent.Protocol.Wrapper.ReplyTarget p r)
instance GHC.Classes.Eq (Control.Eff.Concurrent.Protocol.Wrapper.ReplyTarget p r)
instance forall proto k (reply :: k). GHC.Classes.Ord (Control.Eff.Concurrent.Protocol.Wrapper.RequestOrigin proto reply)
instance forall proto k (reply :: k). GHC.Classes.Eq (Control.Eff.Concurrent.Protocol.Wrapper.RequestOrigin proto reply)
instance forall proto k (reply :: k). GHC.Generics.Generic (Control.Eff.Concurrent.Protocol.Wrapper.RequestOrigin proto reply)
instance GHC.Show.Show (Control.Eff.Concurrent.Protocol.Wrapper.ReplyTarget p r)
instance Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Wrapper.ReplyTarget p r)
instance GHC.Show.Show (Control.Eff.Concurrent.Protocol.Wrapper.Request protocol)
instance Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Wrapper.Request protocol)
instance Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Wrapper.Reply p r)
instance GHC.Show.Show r => GHC.Show.Show (Control.Eff.Concurrent.Protocol.Wrapper.Reply p r)
instance forall k p (r :: k). GHC.Show.Show (Control.Eff.Concurrent.Protocol.Wrapper.RequestOrigin p r)
instance forall k p (r :: k). Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Wrapper.RequestOrigin p r)


-- | 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.
newtype Timeout
TimeoutMicros :: Int -> Timeout
[fromTimeoutMicros] :: Timeout -> Int

-- | 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, HasProcesses r q, Typeable message, NFData message) => 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, HasProcesses r q) => Timeout -> Eff r TimerReference

-- | Cancel a timer started with <a>startTimer</a>.
cancelTimer :: forall r q. (Lifted IO q, HasCallStack, HasProcesses r 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, HasProcesses r q, Typeable a, NFData a, Show a) => 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, HasProcesses r q, Show a) => MessageSelector a -> Timeout -> Eff r (Either TimerElapsed a)

-- | Like <a>receiveWithMonitor</a> combined with
--   <a>receiveSelectedAfter</a>.
receiveSelectedWithMonitorAfter :: forall a r q. (Lifted IO q, HasCallStack, HasProcesses r q, Show a) => ProcessId -> MessageSelector a -> Timeout -> Eff r (Either (Either ProcessDown 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


-- | Logging via <tt>extensible-effects</tt>
--   
--   Logging consist of <b>two</b> effects:
--   
--   <ul>
--   <li><b>Receiving</b> log messages sent by the code using e.g.
--   <a>logInfo</a>; this also include deep evaluation and dropping
--   messages not satisfying the current <a>LogPredicate</a>.</li>
--   <li><b>Writing</b> log message to disk, network, ... etc; this also
--   includes rendering log messages and setting fields like the hostname,
--   timestamp, etc</li>
--   </ul>
--   
--   <h2>Example</h2>
--   
--   <pre>
--   exampleLogging :: IO ()
--   exampleLogging =
--       runLift
--     $ withLogging consoleLogWriter
--     $ do
--         logDebug "test 1.1"
--         logError "test 1.2"
--         censorLogs (prefixLogMessagesWith "NESTED: ")
--          $ do
--               addLogWriter debugTraceLogWriter
--                $ setLogPredicate (\m -&gt; (view lmMessage m) /= "not logged")
--                $ do
--                     logInfo "not logged"
--                     logMsg "test 2.1"
--               logWarning "test 2.2"
--         logCritical "test 1.3"
--   </pre>
--   
--   <h2>Log Message Data Type</h2>
--   
--   A singular <i>logging event</i> is contained in a
--   <b><a>LogMessage</a>s</b> value.
--   
--   The <a>LogMessage</a> is modelled along RFC-5424.
--   
--   There is the <a>ToLogMessage</a> class for converting to
--   <a>LogMessage</a>. <i>Although the author is not clear on how to
--   pursue the approach.</i>
--   
--   <h2>Receiving and Filtering</h2>
--   
--   <a>LogMessage</a>s are sent using <a>logMsg</a> and friends, see
--   <a>Control.Eff.Log#SendingLogs</a>
--   
--   <h3>Log Message Predicates</h3>
--   
--   There is a single global <a>LogPredicate</a> that can be used to
--   suppress logs before they are passed to any <a>LogWriter</a>.
--   
--   This is done by the <a>logMsg</a> function.
--   
--   Also, <a>LogMessage</a>s are evaluated using <a>deepseq</a>,
--   <b>after</b> they pass the <a>LogPredicate</a>, also inside
--   <a>logMsg</a>.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
--   
--   <h2>Writing and Rendering</h2>
--   
--   Writing is done through a <a>LogWriter</a>; the current
--   <a>LogWriter</a> value to use is held by the <a>LogWriterReader</a>
--   effect.
--   
--   <h3>Log Message Rendering</h3>
--   
--   Message are rendered by <a>LogMessageRenderer</a>s found in the
--   <a>Control.Eff.Log.MessageRenderer</a>.
--   
--   <h3><a>LogWriter</a>s</h3>
--   
--   <ul>
--   <li>Logging in a <a>withAsync</a> spawned thread is done using
--   <tt>withAsyncLogging</tt>.</li>
--   </ul>
module Control.Eff.Log

-- | Log a message.
--   
--   All logging goes through this function.
--   
--   This function is the only place where the <a>LogPredicate</a> is
--   applied.
--   
--   Also, <a>LogMessage</a>s are evaluated using <a>deepseq</a>,
--   <b>after</b> they pass the <a>LogPredicate</a>.
logMsg :: forall e. (HasCallStack, Member Logs e) => LogMessage -> Eff e ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Include <a>LogMessage</a>s that match a <a>LogPredicate</a>.
--   
--   <tt>excludeLogMessages p</tt> allows log message to be logged if <tt>p
--   m</tt>
--   
--   Although it is enough if the previous predicate holds. See
--   <a>excludeLogMessages</a> and <a>modifyLogPredicate</a>.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
includeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a

-- | Exclude <a>LogMessage</a>s that match a <a>LogPredicate</a>.
--   
--   <tt>excludeLogMessages p</tt> discards logs if <tt>p m</tt>
--   
--   Also the previous predicate must also hold for a message to be logged.
--   See <a>excludeLogMessages</a> and <a>modifyLogPredicate</a>.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
excludeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a

-- | Keep only those messages, for which a predicate holds.
--   
--   E.g. to keep only messages which begin with <tt><a>OMG</a></tt>:
--   
--   <pre>
--   exampleLogPredicate :: IO Int
--   exampleLogPredicate =
--       runLift
--     $ withLogging consoleLogWriter
--     $ do logMsg "test"
--          setLogPredicate (\ msg -&gt; case view lmMessage msg of
--                                     'O':'M':'G':_ -&gt; True
--                                     _             -&gt; False)
--                            (do logMsg "this message will not be logged"
--                                logMsg "OMG logged"
--                                return 42)
--   </pre>
--   
--   In order to also delegate to the previous predicate, use
--   <a>modifyLogPredicate</a>
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
setLogPredicate :: forall r b. (Member Logs r, HasCallStack) => LogPredicate -> Eff r b -> Eff r b

-- | Change the <a>LogPredicate</a>.
--   
--   Other than <a>setLogPredicate</a> this function allows to include the
--   previous predicate, too.
--   
--   For to discard all messages currently no satisfying the predicate and
--   also all messages that are to long:
--   
--   <pre>
--   modifyLogPredicate (previousPredicate msg -&gt; previousPredicate msg &amp;&amp; length (lmMessage msg) &lt; 29 )
--                      (do logMsg "this message will not be logged"
--                          logMsg "this message might be logged")
--   </pre>
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
modifyLogPredicate :: forall e b. (Member Logs e, HasCallStack) => (LogPredicate -> LogPredicate) -> Eff e b -> Eff e b

-- | Get the current <a>Logs</a> filter/transformer function.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
askLogPredicate :: forall e. Member Logs e => Eff e LogPredicate

-- | Replace the current <a>LogWriter</a>. To add an additional log message
--   consumer use <a>addLogWriter</a>
setLogWriter :: forall h e a. LogsTo h e => LogWriter h -> Eff e a -> Eff e a

-- | Combine the effects of a given <a>LogWriter</a> and the existing one.
--   
--   <pre>
--   import Data.Text    as T
--   import Data.Text.IO as T
--   
--   exampleAddLogWriter :: IO ()
--   exampleAddLogWriter = go &gt;&gt;= T.putStrLn
--    where go = fmap (unlines . map renderLogMessageConsoleLog . snd)
--                 $  runLift
--                 $  runCaptureLogWriter
--                 $  withLogging captureLogWriter
--                 $  addLogWriter (mappingLogWriter (lmMessage %~ ("CAPTURED "++)) captureLogWriter)
--                 $  addLogWriter (filteringLogWriter severeMessages (mappingLogWriter (lmMessage %~ ("TRACED "++)) debugTraceLogWriter))
--                 $  do
--                       logEmergency "test emergencySeverity 1"
--                       logCritical "test criticalSeverity 2"
--                       logAlert "test alertSeverity 3"
--                       logError "test errorSeverity 4"
--                       logWarning "test warningSeverity 5"
--                       logInfo "test informationalSeverity 6"
--                       logDebug "test debugSeverity 7"
--          severeMessages = view (lmSeverity . to (&lt;= errorSeverity))
--   </pre>
addLogWriter :: forall h e a. (HasCallStack, LogsTo h e, Monad (LogWriterM h)) => LogWriter h -> Eff e a -> Eff e a

-- | Change the current <a>LogWriter</a>.
modifyLogWriter :: forall h e a. LogsTo h e => (LogWriter h -> LogWriter h) -> Eff e a -> Eff e a

-- | Modify the the <a>LogMessage</a>s written in the given sub-expression.
--   
--   Note: This is equivalent to <tt><a>modifyLogWriter</a> .
--   <a>mappingLogWriter</a></tt>
censorLogs :: LogsTo h e => (LogMessage -> LogMessage) -> Eff e a -> Eff e a

-- | Modify the the <a>LogMessage</a>s written in the given sub-expression,
--   as in <a>censorLogs</a> but with a effectful function.
--   
--   Note: This is equivalent to <tt><a>modifyLogWriter</a> .
--   <a>mappingLogWriterM</a></tt>
censorLogsM :: (LogsTo h e, Monad (LogWriterM h)) => (LogMessage -> LogWriterM h LogMessage) -> Eff e a -> Eff e a

-- | This effect sends <a>LogMessage</a>s and is a reader for a
--   <a>LogPredicate</a>.
--   
--   Logs are sent via <a>logMsg</a>; for more information about log
--   predicates, see <a>Control.Eff.Log#LogPredicate</a>
--   
--   This effect is handled via <a>withLogging</a>.
data Logs v

-- | A constraint alias for effects that requires a <a>LogWriterReader</a>,
--   as well as that the contained <a>LogWriterReader</a> has a
--   <a>HandleLogWriter</a> instance.
--   
--   The requirements of this constraint are provided by:
--   
--   <ul>
--   <li><tt>withIoLogging</tt></li>
--   <li><a>withLogging</a></li>
--   <li><a>withSomeLogging</a></li>
--   </ul>
type LogsTo h e = (Member Logs e, HandleLogWriter h, Member h e, SetMember LogWriterReader (LogWriterReader h) e)

-- | A constraint that required <tt><a>LogsTo</a> <a>IO</a> e</tt> and
--   <tt><a>Lifted</a> <a>IO</a> e</tt>.
type LogIo e = (LogsTo (Lift IO) e, Lifted IO e)

-- | Handle the <a>Logs</a> and <a>LogWriterReader</a> effects.
--   
--   It installs the given <a>LogWriter</a>, which determines the
--   underlying <a>LogWriter</a> type parameter.
--   
--   Example:
--   
--   <pre>
--   exampleWithLogging :: IO ()
--   exampleWithLogging =
--       runLift
--     $ withLogging consoleLogWriter
--     $ logDebug "Oh, hi there"
--   </pre>
withLogging :: forall h e a. (Applicative (LogWriterM h), LogsTo h (Logs : (LogWriterReader h : e))) => LogWriter h -> Eff (Logs : (LogWriterReader h : e)) a -> Eff e a

-- | Handles the <a>Logs</a> and <a>LogWriterReader</a> effects.
--   
--   By default it uses the <a>noOpLogWriter</a>, but using
--   <a>setLogWriter</a> the <a>LogWriter</a> can be replaced.
--   
--   This is like <a>withLogging</a> applied to <a>noOpLogWriter</a>
--   
--   Example:
--   
--   <pre>
--   exampleWithSomeLogging :: ()
--   exampleWithSomeLogging =
--       run
--     $ withSomeLogging @PureLogWriter
--     $ logDebug "Oh, hi there"
--   </pre>
withSomeLogging :: forall h e a. (Applicative (LogWriterM h), LogsTo h (Logs : (LogWriterReader h : e))) => Eff (Logs : (LogWriterReader h : e)) a -> Eff e a

-- | Raw handling of the <a>Logs</a> effect. Exposed for custom extensions,
--   if in doubt use <a>withLogging</a>.
runLogs :: forall h e b. LogsTo h (Logs : e) => LogPredicate -> Eff (Logs : e) b -> Eff e b

-- | Consume log messages.
--   
--   Exposed for custom extensions, if in doubt use <a>withLogging</a>.
--   
--   Respond to all <a>LogMessage</a>s logged from the given action, up to
--   any <a>MonadBaseControl</a> liftings.
--   
--   Note that all logging is done through <a>logMsg</a> and that means
--   only messages passing the <a>LogPredicate</a> are received.
--   
--   The <a>LogMessage</a>s are <b>consumed</b> once they are passed to the
--   given callback function, previous <a>respondToLogMessage</a>
--   invocations further up in the call stack will not get the messages
--   anymore.
--   
--   Use <a>interceptLogMessages</a> if the messages shall be passed any
--   previous handler.
--   
--   NOTE: The effects of this function are <b>lost</b> when using
--   <a>MonadBaseControl</a>, <a>MonadMask</a>, <a>MonadCatch</a> and
--   <a>MonadThrow</a>.
--   
--   In contrast the functions based on modifying the <a>LogWriter</a>,
--   such as <a>addLogWriter</a> or <a>censorLogs</a>, are save to use in
--   combination with the aforementioned liftings.
respondToLogMessage :: forall r b. Member Logs r => (LogMessage -> Eff r ()) -> Eff r b -> Eff r b

-- | Change the <a>LogMessage</a>s using an effectful function.
--   
--   Exposed for custom extensions, if in doubt use <a>withLogging</a>.
--   
--   This differs from <a>respondToLogMessage</a> in that the intercepted
--   messages will be written either way, albeit in altered form.
--   
--   NOTE: The effects of this function are <b>lost</b> when using
--   <a>MonadBaseControl</a>, <a>MonadMask</a>, <a>MonadCatch</a> and
--   <a>MonadThrow</a>.
--   
--   In contrast the functions based on modifying the <a>LogWriter</a>,
--   such as <a>addLogWriter</a> or <a>censorLogs</a>, are save to use in
--   combination with the aforementioned liftings.
interceptLogMessages :: forall r b. Member Logs r => (LogMessage -> Eff r LogMessage) -> Eff r b -> Eff r b


-- | Utilities to implement <i>effectful server-loops</i>.
module Control.Eff.Concurrent.Protocol.EffectfulServer

-- | A type class for effectful server loops.
--   
--   This type class serves as interface for other abstractions, for
--   example <i>process supervision</i>
--   
--   The methods of this class handle <a>Event</a>s <a>Request</a>s for
--   <a>Pdu</a> instance.
--   
--   Instances can by <i>index types</i> for <a>Pdu</a> family directly, or
--   indirectly via the <a>ServerPdu</a> type family.
--   
--   To builder servers serving multiple protocols, use the generic
--   <a>Pdu</a> instances, for which <a>Embeds</a> instances exist, like
--   2-,3-,4-, or 5-tuple.
class Server (a :: Type) (e :: [Type -> Type]) where {
    
    -- | The value that defines what is required to initiate a <a>Server</a>
    --   loop.
    data family Init a e;
    
    -- | The index type of the <a>Event</a>s that this server processes. This
    --   is the first parameter to the <a>Request</a> and therefore of the
    --   <a>Pdu</a> family.
    type family ServerPdu a :: Type;
    
    -- | Effects of the implementation
    type family ServerEffects a e :: [Type -> Type];
    type ServerPdu a = a;
    type ServerEffects a e = e;
}

-- | Return the <a>ProcessTitle</a>.
--   
--   Usually you should rely on the default implementation
serverTitle :: Server a e => Init a e -> ProcessTitle

-- | Return the <a>ProcessTitle</a>.
--   
--   Usually you should rely on the default implementation
serverTitle :: (Server a e, Typeable (ServerPdu a)) => Init a e -> ProcessTitle

-- | Process the effects of the implementation
runEffects :: Server a e => Endpoint (ServerPdu a) -> Init a e -> Eff (ServerEffects a e) x -> Eff e x

-- | Process the effects of the implementation
runEffects :: (Server a e, ServerEffects a e ~ e) => Endpoint (ServerPdu a) -> Init a e -> Eff (ServerEffects a e) x -> Eff e x

-- | Update the <tt>Model</tt> based on the <a>Event</a>.
onEvent :: Server a e => Endpoint (ServerPdu a) -> Init a e -> Event (ServerPdu a) -> Eff (ServerEffects a e) ()

-- | Update the <tt>Model</tt> based on the <a>Event</a>.
onEvent :: (Server a e, Show (Init a e), Member Logs (ServerEffects a e)) => Endpoint (ServerPdu a) -> Init a e -> Event (ServerPdu a) -> Eff (ServerEffects a e) ()

-- | This event sum-type is used to communicate incoming messages and other
--   events to the instances of <a>Server</a>.
data Event a

-- | A <a>Synchronous</a> message was received. If an implementation wants
--   to delegate nested <a>Pdu</a>s, it can use
--   <a>toEmbeddedReplyTarget</a> to convert a <a>ReplyTarget</a> safely to
--   the embedded protocol.
[OnCall] :: forall a r. (Tangible r, TangiblePdu a ( 'Synchronous r)) => ReplyTarget a r -> Pdu a ( 'Synchronous r) -> Event a
[OnCast] :: forall a. TangiblePdu a  'Asynchronous => Pdu a  'Asynchronous -> Event a
[OnInterrupt] :: Interrupt  'Recoverable -> Event a
[OnDown] :: ProcessDown -> Event a
[OnTimeOut] :: TimerElapsed -> Event a
[OnMessage] :: StrictDynamic -> Event a

-- | Execute the server loop.
start :: forall a r q h. (Server a (Processes q), Typeable a, Typeable (ServerPdu a), LogsTo h (Processes q), HasProcesses (ServerEffects a (Processes q)) q, HasProcesses r q, HasCallStack) => Init a (Processes q) -> Eff r (Endpoint (ServerPdu a))

-- | Execute the server loop.
startLink :: forall a r q h. (Typeable a, Typeable (ServerPdu a), Server a (Processes q), LogsTo h (Processes q), HasProcesses (ServerEffects a (Processes q)) q, HasProcesses r q, HasCallStack) => Init a (Processes q) -> Eff r (Endpoint (ServerPdu a))

-- | Execute the server loop.
protocolServerLoop :: forall q h a. (Server a (Processes q), LogsTo h (Processes q), HasProcesses (ServerEffects a (Processes q)) q, Typeable a, Typeable (ServerPdu a)) => Init a (Processes q) -> Eff (Processes q) ()
instance GHC.Show.Show (Control.Eff.Concurrent.Protocol.EffectfulServer.Event a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.EffectfulServer.Event a)


-- | Utilities to implement <i>server-loops</i> with builtin state and
--   <i>TEA</i>-like naming.
module Control.Eff.Concurrent.Protocol.StatefulServer

-- | A type class for server loops.
--   
--   This class serves as interface for other mechanisms, for example
--   <i>process supervision</i>
--   
--   The methods of this class handle <tt>Event</tt>s and <tt>Request</tt>s
--   for <a>Pdu</a> instances.
--   
--   Instances can by <i>index types</i> for <a>Pdu</a> family directly, or
--   indirectly via the <tt>ServerPdu</tt> type family.
--   
--   To builder servers serving multiple protocols, use the generic
--   <a>Pdu</a> instances, for which <a>Embeds</a> instances exist, like
--   2-,3-,4-, or 5-tuple.
--   
--   The naming is inspired by The Elm Architecture, without the
--   <tt>view</tt> callback.
--   
--   This class is based on
--   <a>Control.Eff.Concurrent.Protocol.EffectfulServer</a> and adds a
--   default <a>State</a> and <a>Reader</a> effect.
class (Typeable (Protocol a)) => Server (a :: Type) q where {
    
    -- | The value that defines what is required to initiate a <a>Server</a>
    --   loop.
    data family StartArgument a q;
    
    -- | The index type of the <tt>Event</tt>s that this server processes. This
    --   is the first parameter to the <tt>Request</tt> and therefore of the
    --   <a>Pdu</a> family.
    type family Protocol a :: Type;
    
    -- | Type of the <i>model</i> data, given to every invocation of
    --   <a>update</a> via the <a>ModelState</a> effect. The <i>model</i> of a
    --   server loop is changed through incoming <tt>Event</tt>s. It is
    --   initially calculated by <a>setup</a>.
    type family Model a :: Type;
    
    -- | Type of read-only state.
    type family Settings a :: Type;
    type Protocol a = a;
    type Model a = ();
    type Settings a = ();
}

-- | Return an initial <a>Model</a> and <a>Settings</a>
setup :: Server a q => Endpoint (Protocol a) -> StartArgument a q -> Eff q (Model a, Settings a)

-- | Return an initial <a>Model</a> and <a>Settings</a>
setup :: (Server a q, Default (Model a), Default (Settings a)) => Endpoint (Protocol a) -> StartArgument a q -> Eff q (Model a, Settings a)

-- | Update the <a>Model</a> based on the <tt>Event</tt>.
update :: Server a q => Endpoint (Protocol a) -> StartArgument a q -> Event (Protocol a) -> Eff (ModelState a : (SettingsReader a : q)) ()

-- | Execute the server loop.
start :: forall a r q h. (HasCallStack, Typeable a, LogsTo h (Processes q), Server (Stateful a) (Processes q), Server a (Processes q), HasProcesses r q) => StartArgument a (Processes q) -> Eff r (Endpoint (Protocol a))

-- | Execute the server loop.
startLink :: forall a r q h. (HasCallStack, Typeable a, LogsTo h (Processes q), Server (Stateful a) (Processes q), Server a (Processes q), HasProcesses r q) => StartArgument a (Processes q) -> Eff r (Endpoint (Protocol a))

-- | The <a>Eff</a>ect type of mutable <a>Model</a> in a <a>Server</a>
--   instance.
type ModelState a = State (Model a)

-- | Modify the <a>Model</a> of a <a>Server</a>.
modifyModel :: forall a e. Member (ModelState a) e => (Model a -> Model a) -> Eff e ()

-- | Modify the <a>Model</a> of a <a>Server</a> and return the old value.
getAndModifyModel :: forall a e. Member (ModelState a) e => (Model a -> Model a) -> Eff e (Model a)

-- | Modify the <a>Model</a> of a <a>Server</a> and return the new value.
modifyAndGetModel :: forall a e. Member (ModelState a) e => (Model a -> Model a) -> Eff e (Model a)

-- | Return the <a>Model</a> of a <a>Server</a>.
getModel :: forall a e. Member (ModelState a) e => Eff e (Model a)

-- | Overwrite the <a>Model</a> of a <a>Server</a>.
putModel :: forall a e. Member (ModelState a) e => Model a -> Eff e ()

-- | Overwrite the <a>Model</a> of a <a>Server</a>, return the old value.
getAndPutModel :: forall a e. Member (ModelState a) e => Model a -> Eff e (Model a)

-- | Return a element selected by a <a>Lens</a> of the <a>Model</a> of a
--   <a>Server</a>.
useModel :: forall a b e. Member (ModelState a) e => Getting b (Model a) b -> Eff e b

-- | Run an action that modifies portions of the <a>Model</a> of a
--   <a>Server</a> defined by the given <a>Lens</a>.
zoomModel :: forall a b c e. Member (ModelState a) e => Lens' (Model a) b -> Eff (State b : e) c -> Eff e c

-- | The <a>Eff</a>ect type of readonly <a>Settings</a> in a <a>Server</a>
--   instance.
type SettingsReader a = Reader (Settings a)

-- | Return the read-only <a>Settings</a> of a <a>Server</a>
askSettings :: forall a e. Member (SettingsReader a) e => Eff e (Settings a)

-- | Return the read-only <a>Settings</a> of a <a>Server</a> as viewed
--   through a <a>Lens</a>
viewSettings :: forall a b e. Member (SettingsReader a) e => Getting b (Settings a) b -> Eff e b

-- | This event sum-type is used to communicate incoming messages and other
--   events to the instances of <a>Server</a>.
data Event a

-- | A <a>Synchronous</a> message was received. If an implementation wants
--   to delegate nested <a>Pdu</a>s, it can use
--   <a>toEmbeddedReplyTarget</a> to convert a <a>ReplyTarget</a> safely to
--   the embedded protocol.
[OnCall] :: forall a r. (Tangible r, TangiblePdu a ( 'Synchronous r)) => ReplyTarget a r -> Pdu a ( 'Synchronous r) -> Event a
[OnCast] :: forall a. TangiblePdu a  'Asynchronous => Pdu a  'Asynchronous -> Event a
[OnInterrupt] :: Interrupt  'Recoverable -> Event a
[OnDown] :: ProcessDown -> Event a
[OnTimeOut] :: TimerElapsed -> Event a
[OnMessage] :: StrictDynamic -> Event a
instance Control.Eff.Concurrent.Protocol.StatefulServer.Server a q => Control.Eff.Concurrent.Protocol.EffectfulServer.Server (Control.Eff.Concurrent.Protocol.StatefulServer.Stateful a) q


-- | Functions for protocol clients.
--   
--   This modules is required to write clients that send<a>Pdu</a>s.
module Control.Eff.Concurrent.Protocol.Client

-- | Send a request <a>Pdu</a> that has no reply and return immediately.
--   
--   The type signature enforces that the corresponding <a>Pdu</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.
--   
--   The message will be reduced to normal form (<tt>rnf</tt>) in the
--   caller process.
cast :: forall destination protocol r q. (HasCallStack, HasProcesses r q, HasPdu destination, HasPdu protocol, Tangible (Pdu destination  'Asynchronous), Embeds destination protocol) => Endpoint destination -> Pdu protocol  'Asynchronous -> Eff r ()

-- | Send a request <a>Pdu</a> and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Pdu</a> clause
--   is <a>Synchronous</a>.
--   
--   <b>Always prefer <a>callWithTimeout</a> over <a>call</a></b>
call :: forall result destination protocol r q. (HasProcesses r q, TangiblePdu destination ( 'Synchronous result), TangiblePdu protocol ( 'Synchronous result), Tangible result, Embeds destination protocol, HasCallStack) => Endpoint destination -> Pdu protocol ( 'Synchronous result) -> Eff r result

-- | Send an request <a>Pdu</a> and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Pdu</a> clause
--   is <a>Synchronous</a>.
--   
--   If the server that was called dies, this function interrupts the
--   process with <a>ProcessDown</a>. If the server takes longer to reply
--   than the given timeout, this function interrupts the process with
--   <a>TimeoutInterrupt</a>.
--   
--   <b>Always prefer this function over <a>call</a></b>
callWithTimeout :: forall result destination protocol r q. (HasProcesses r q, TangiblePdu destination ( 'Synchronous result), TangiblePdu protocol ( 'Synchronous result), Tangible result, Member Logs r, Lifted IO q, Lifted IO r, HasCallStack, Embeds destination protocol) => Endpoint destination -> Pdu protocol ( 'Synchronous result) -> Timeout -> Eff r result

-- | Like <a>castEndpointReader</a>, but uses <a>embedPdu</a> to embed the
--   value.
--   
--   This function makes use of AmbigousTypes and TypeApplications.
--   
--   When not working with an embedded <a>Pdu</a> use
--   <a>castEndpointReader</a>.
castSingleton :: forall outer inner q e. (HasCallStack, Member (EndpointReader outer) e, Tangible (Pdu outer  'Asynchronous), HasProcesses e q, HasPdu outer, HasPdu inner, Embeds outer inner, Embeds outer outer) => Pdu inner  'Asynchronous -> Eff e ()

-- | Like <a>cast</a> but take the <a>Endpoint</a> from the reader provided
--   by <a>runEndpointReader</a>.
--   
--   When working with an embedded <a>Pdu</a> use <a>castSingleton</a>.
castEndpointReader :: forall o r q. (HasEndpointReader o r, HasProcesses r q, Tangible (Pdu o  'Asynchronous), HasCallStack, HasPdu o, Embeds o o) => Pdu o  'Asynchronous -> Eff r ()

-- | Like <a>callEndpointReader</a>, uses <a>embedPdu</a> to embed the
--   value.
--   
--   This function makes use of AmbigousTypes and TypeApplications.
--   
--   When not working with an embedded <a>Pdu</a> use
--   <a>callEndpointReader</a>.
callSingleton :: forall outer inner reply q e. (HasCallStack, Member (EndpointReader outer) e, Embeds outer inner, Embeds outer outer, HasProcesses e q, TangiblePdu outer ( 'Synchronous reply), TangiblePdu inner ( 'Synchronous reply), Tangible reply) => Pdu inner ( 'Synchronous reply) -> Eff e reply

-- | Like <a>call</a> but take the <a>Endpoint</a> from the reader provided
--   by <a>runEndpointReader</a>.
--   
--   When working with an embedded <a>Pdu</a> use <a>callSingleton</a>.
callEndpointReader :: forall reply o r q. (HasEndpointReader o r, HasCallStack, Tangible reply, TangiblePdu o ( 'Synchronous reply), HasProcesses r q, Embeds o o) => Pdu o ( 'Synchronous reply) -> Eff r reply

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

-- | The reader effect for <a>ProcessId</a>s for <a>Pdu</a>s, see
--   <a>runEndpointReader</a>
type EndpointReader o = Reader (Endpoint o)

-- | Get the <a>Endpoint</a> registered with <a>runEndpointReader</a>.
askEndpoint :: Member (EndpointReader o) e => Eff e (Endpoint o)

-- | Run a reader effect that contains <b>the one</b> server handling a
--   specific <a>Pdu</a> instance.
runEndpointReader :: HasCallStack => Endpoint o -> Eff (EndpointReader o : r) a -> Eff r a


-- | A process supervisor spawns and monitors child processes.
--   
--   The child processes are mapped to symbolic identifier values:
--   Child-IDs.
--   
--   This is the barest, most minimal version of a supervisor. Children can
--   be started, but not restarted.
--   
--   Children can efficiently be looked-up by an id-value, and when the
--   supervisor is shutdown, all children will be shutdown these are
--   actually all the features of this supervisor implementation.
--   
--   Also, this minimalist supervisor only knows how to spawn a single kind
--   of child process.
--   
--   When a supervisor spawns a new child process, it expects the child
--   process to return a <a>ProcessId</a>. The supervisor will
--   <a>monitor</a> the child process.
--   
--   This is in stark contrast to how Erlang/OTP handles things; In the OTP
--   Supervisor, the child has to link to the parent. This allows the child
--   spec to be more flexible in that no <tt>pid</tt> has to be passed from
--   the child start function to the supervisor process, and also, a child
--   may break free from the supervisor by unlinking.
--   
--   Now while this seems nice at first, this might actually cause
--   surprising results, since it is usually expected that stopping a
--   supervisor also stops the children, or that a child exit shows up in
--   the logging originating from the former supervisor.
--   
--   The approach here is to allow any child to link to the supervisor to
--   realize when the supervisor was violently killed, and otherwise give
--   the child no chance to unlink itself from its supervisor.
--   
--   This module is far simpler than the Erlang/OTP counter part, of a
--   <tt>simple_one_for_one</tt> supervisor.
--   
--   The future of this supervisor might not be a-lot more than it
--   currently is. The ability to restart processes might be implemented
--   outside of this supervisor module.
--   
--   One way to do that is to implement the restart logic in a separate
--   module, since the child-id can be reused when a child exits.
module Control.Eff.Concurrent.Protocol.Supervisor

-- | The index type of <a>Server</a> supervisors.
--   
--   A <tt><a>Sup</a> p</tt> manages the life cycle of the processes,
--   running the <tt><a>Server</a> p</tt> methods of that specific type.
--   
--   The supervisor maps an identifier value of type <tt><a>ChildId</a>
--   p</tt> to an <tt><a>Endpoint</a> p</tt>.
data Sup (p :: Type)

-- | The type of value used to index running <a>Server</a> processes
--   managed by a <a>Sup</a>.
--   
--   Note, that the type you provide must be <a>Tangible</a>.
type family ChildId p

-- | The value that defines what is required to initiate a <a>Server</a>
--   loop.
data family StartArgument a q
supConfigChildStopTimeout :: StartArgument (Sup p) (Processes q) -> Timeout

-- | Runtime-Errors occurring when spawning child-processes.
data SpawnErr p
AlreadyStarted :: ChildId p -> Endpoint (Protocol p) -> SpawnErr p

-- | Start and link a new supervisor process with the given
--   <tt>SpawnFun</tt>unction.
--   
--   To spawn new child processes use <a>spawnChild</a>.
startSupervisor :: forall p e. (HasCallStack, LogIo (Processes e), TangibleSup p, Server (Sup p) (Processes e)) => StartArgument (Sup p) (Processes e) -> Eff (Processes e) (Endpoint (Sup p))

-- | Stop the supervisor and shutdown all processes.
--   
--   Block until the supervisor has finished.
stopSupervisor :: (HasCallStack, HasProcesses e q, Member Logs e, Lifted IO e, TangibleSup p) => Endpoint (Sup p) -> Eff e ()

-- | Check if a supervisor process is still alive.
isSupervisorAlive :: forall p q0 e. (HasCallStack, Member Logs e, Typeable p, HasProcesses e q0) => Endpoint (Sup p) -> Eff e Bool

-- | Monitor a supervisor process.
monitorSupervisor :: forall p q0 e. (HasCallStack, Member Logs e, HasProcesses e q0, TangibleSup p) => Endpoint (Sup p) -> Eff e MonitorReference

-- | Return a <a>Text</a> describing the current state of the supervisor.
getDiagnosticInfo :: forall p e q0. (HasCallStack, HasProcesses e q0, TangibleSup p) => Endpoint (Sup p) -> Eff e Text

-- | Start, link and monitor a new child process using the
--   <tt>SpawnFun</tt> passed to <a>startSupervisor</a>.
spawnChild :: forall p q0 e. (HasCallStack, Member Logs e, HasProcesses e q0, TangibleSup p, Typeable (Protocol p)) => Endpoint (Sup p) -> ChildId p -> Eff e (Either (SpawnErr p) (Endpoint (Protocol p)))

-- | Lookup the given child-id and return the output value of the
--   <tt>SpawnFun</tt> if the client process exists.
lookupChild :: forall p e q0. (HasCallStack, Member Logs e, HasProcesses e q0, TangibleSup p, Typeable (Protocol p)) => Endpoint (Sup p) -> ChildId p -> Eff e (Maybe (Endpoint (Protocol p)))

-- | Stop a child process, and block until the child has exited.
--   
--   Return <a>True</a> if a process with that ID was found, <a>False</a>
--   if no process with the given ID was running.
stopChild :: forall p e q0. (HasCallStack, Member Logs e, HasProcesses e q0, TangibleSup p) => Endpoint (Sup p) -> ChildId p -> Eff e Bool
instance GHC.Generics.Generic (Control.Eff.Concurrent.Protocol.Supervisor.SpawnErr p)
instance GHC.Classes.Eq (Control.Eff.Concurrent.Protocol.Supervisor.ChildId p) => GHC.Classes.Eq (Control.Eff.Concurrent.Protocol.Supervisor.SpawnErr p)
instance GHC.Classes.Ord (Control.Eff.Concurrent.Protocol.Supervisor.ChildId p) => GHC.Classes.Ord (Control.Eff.Concurrent.Protocol.Supervisor.SpawnErr p)
instance (Data.Typeable.Internal.Typeable (Control.Eff.Concurrent.Protocol.StatefulServer.Protocol p), GHC.Show.Show (Control.Eff.Concurrent.Protocol.Supervisor.ChildId p)) => GHC.Show.Show (Control.Eff.Concurrent.Protocol.Supervisor.SpawnErr p)
instance Data.Typeable.Internal.Typeable p => Control.Eff.Concurrent.Protocol.HasPdu (Control.Eff.Concurrent.Protocol.Supervisor.Sup p)
instance (Control.Eff.Log.Handler.LogIo q, Control.Eff.Concurrent.Protocol.Supervisor.TangibleSup p, Control.Eff.Concurrent.Protocol.Tangible (Control.Eff.Concurrent.Protocol.Supervisor.ChildId p), Control.Eff.Concurrent.Protocol.StatefulServer.Server p (Control.Eff.Concurrent.Process.Processes q)) => Control.Eff.Concurrent.Protocol.StatefulServer.Server (Control.Eff.Concurrent.Protocol.Supervisor.Sup p) (Control.Eff.Concurrent.Process.Processes q)
instance Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Supervisor.ChildId p) => Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Supervisor.SpawnErr p)
instance GHC.Show.Show (Control.Eff.Concurrent.Protocol.Supervisor.ChildId p) => GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu (Control.Eff.Concurrent.Protocol.Supervisor.Sup p) ('Control.Eff.Concurrent.Protocol.Synchronous r))
instance Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Supervisor.ChildId p) => Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu (Control.Eff.Concurrent.Protocol.Supervisor.Sup p) ('Control.Eff.Concurrent.Protocol.Synchronous r))


-- | Observer Effects
--   
--   This module supports the implementation of observerRegistry and
--   observables. Expected use case is event propagation.
--   
--   The observable event sources and the observers are usually server
--   processes for a protocol that embeds the <a>ObserverRegistry</a> and
--   <a>Observer</a> <a>Pdu</a>s respectively.
--   
--   A generic FIFO queue based observer can be found in
--   <a>Control.Eff.Concurrent.Protocol.Observer.Queue</a>.
module Control.Eff.Concurrent.Protocol.Observer

-- | A <i>protocol</i> to communicate <a>Observed</a> events from a sources
--   to many sinks.
--   
--   A sink is any process that serves a protocol with a <a>Pdu</a>
--   instance that embeds the <a>Observer</a> Pdu via an <a>HasPduPrism</a>
--   instance.
--   
--   This type has <i>dual use</i>, for one it serves as type-index for
--   <a>Pdu</a>, i.e. <a>HasPdu</a> respectively, and secondly it contains
--   an <a>ObservationSink</a> and a <a>MonitorReference</a>.
--   
--   The <a>ObservationSink</a> is used to serialize and send the
--   <a>Observed</a> events, while the <a>ProcessId</a> serves as key for
--   internal maps.
newtype Observer event
MkObserver :: Arg ProcessId (ObservationSink event) -> Observer event

-- | The Information necessary to wrap an <a>Observed</a> event to a
--   process specific message, e.g. the embedded <a>Observer</a> <a>Pdu</a>
--   instance, and the <a>MonitorReference</a> of the destination process.
data ObservationSink event

-- | Convenience type alias.
type IsObservable eventSource event = (Tangible event, Embeds eventSource (ObserverRegistry event), HasPdu eventSource)

-- | Convenience type alias.
type CanObserve eventSink event = (Tangible event, Embeds eventSink (Observer event), HasPdu eventSink)

-- | The <b>protocol data unit</b> type for the given protocol.
data family Pdu protocol (reply :: Synchronicity)

-- | And an <a>Observer</a> to the set of recipients for all observations
--   reported by <a>observerRegistryNotify</a>. Note that the
--   observerRegistry are keyed by the observing process, i.e. a previous
--   entry for the process contained in the <a>Observer</a> is overwritten.
--   If you want multiple entries for a single process, just combine
--   several filter functions.
registerObserver :: forall event eventSink eventSource r q. (HasCallStack, HasProcesses r q, IsObservable eventSource event, Tangible (Pdu eventSource  'Asynchronous), Tangible (Pdu eventSink  'Asynchronous), CanObserve eventSink event) => Endpoint eventSource -> Endpoint eventSink -> Eff r ()

-- | Send the <a>ForgetObserver</a> message
forgetObserver :: forall event eventSink eventSource r q. (HasProcesses r q, HasCallStack, Tangible (Pdu eventSource  'Asynchronous), Tangible (Pdu eventSink  'Asynchronous), IsObservable eventSource event, CanObserve eventSink event) => Endpoint eventSource -> Endpoint eventSink -> Eff r ()

-- | Send the <a>ForgetObserver</a> message, use a raw <a>ProcessId</a> as
--   parameter.
forgetObserverUnsafe :: forall event eventSource r q. (HasProcesses r q, HasCallStack, Tangible (Pdu eventSource  'Asynchronous), IsObservable eventSource event) => Endpoint eventSource -> ProcessId -> Eff r ()

-- | A protocol for managing <a>Observer</a>s, encompassing registration
--   and de-registration of <a>Observer</a>s.
data ObserverRegistry (event :: Type)
MkObserverRegistry :: Map ProcessId (ObservationSink event) -> ObserverRegistry
[_observerRegistry] :: ObserverRegistry -> Map ProcessId (ObservationSink event)

-- | Alias for the effect that contains the observers managed by
--   <a>evalObserverRegistryState</a>
type ObserverRegistryState event = State (ObserverRegistry event)

-- | Report an observation to all observers. The process needs to
--   <a>evalObserverRegistryState</a> and to
--   <a>observerRegistryHandlePdu</a>.
observerRegistryNotify :: forall event r q. (HasProcesses r q, Member (ObserverRegistryState event) r, Tangible event, HasCallStack) => event -> Eff r ()

-- | Keep track of registered <a>Observer</a>s.
--   
--   Handle the <a>ObserverRegistryState</a> effect, i.e. run
--   <a>evalState</a> on an <a>emptyObserverRegistry</a>.
evalObserverRegistryState :: HasCallStack => Eff (ObserverRegistryState event : r) a -> Eff r a

-- | The empty <a>ObserverRegistryState</a>
emptyObserverRegistry :: ObserverRegistry event

-- | Provide the implementation for the <a>ObserverRegistry</a> Protocol,
--   this handled <a>RegisterObserver</a> and <a>ForgetObserver</a>
--   messages. It also adds the <a>ObserverRegistryState</a> constraint to
--   the effect list.
observerRegistryHandlePdu :: forall event q r. (HasCallStack, Typeable event, HasProcesses r q, Member (ObserverRegistryState event) r, Member Logs r) => Pdu (ObserverRegistry event)  'Asynchronous -> Eff r ()

-- | Remove the entry in the <a>ObserverRegistry</a> for the
--   <a>ProcessId</a> and return <a>True</a> if there was an entry,
--   <a>False</a> otherwise.
observerRegistryRemoveProcess :: forall event q r. (HasCallStack, Typeable event, HasProcesses r q, Member (ObserverRegistryState event) r, Member Logs r) => ProcessId -> Eff r Bool
instance forall k (event :: k). GHC.Classes.Ord (Control.Eff.Concurrent.Protocol.Observer.Observer event)
instance forall k (event :: k). GHC.Classes.Eq (Control.Eff.Concurrent.Protocol.Observer.Observer event)
instance forall k (event :: k). GHC.Generics.Generic (Control.Eff.Concurrent.Protocol.Observer.ObservationSink event)
instance Control.Eff.Concurrent.Protocol.Tangible event => Control.Eff.Concurrent.Protocol.HasPdu (Control.Eff.Concurrent.Protocol.Observer.ObserverRegistry event)
instance Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu (Control.Eff.Concurrent.Protocol.Observer.ObserverRegistry event) r)
instance Data.Typeable.Internal.Typeable event => GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu (Control.Eff.Concurrent.Protocol.Observer.ObserverRegistry event) r)
instance forall k (event :: k). Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Observer.Observer event)
instance forall k (event :: k). Data.Typeable.Internal.Typeable event => GHC.Show.Show (Control.Eff.Concurrent.Protocol.Observer.Observer event)
instance Control.Eff.Concurrent.Protocol.Tangible event => Control.Eff.Concurrent.Protocol.HasPdu (Control.Eff.Concurrent.Protocol.Observer.Observer event)
instance Control.DeepSeq.NFData event => Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Pdu (Control.Eff.Concurrent.Protocol.Observer.Observer event) r)
instance GHC.Show.Show event => GHC.Show.Show (Control.Eff.Concurrent.Protocol.Pdu (Control.Eff.Concurrent.Protocol.Observer.Observer event) r)
instance forall k (event :: k). Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.Observer.ObservationSink event)


-- | A small process to capture and _share_ observation's by enqueueing
--   them into an STM <a>TBQueue</a>.
module Control.Eff.Concurrent.Protocol.Observer.Queue

-- | Contains a <a>TBQueue</a> capturing observations. See <a>observe</a>.
newtype ObservationQueue a
ObservationQueue :: TBQueue a -> ObservationQueue a

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

-- | Listen to, and capture observations in an <a>ObservationQueue</a>.
--   
--   Fork an <a>Observer</a> process that runs only while the body
--   expression is executed. Register the observer to the observable
--   process passed to this function.
--   
--   The captured observations can be obtained by <a>await</a>,
--   <a>tryRead</a> and <a>flush</a>.
--   
--   The queue size is limited to the given number.
--   
--   <h4><b>Example</b></h4>
--   
--   <pre>
--   import qualified Control.Eff.Concurrent.Observer.Queue as OQ
--   
--   foo =
--     do
--       observed &lt;- start SomeObservable
--       OQ.observe 100 observed $ do
--         ...
--         cast observed DoSomething
--         evt &lt;- OQ.await @TestEvent
--         ...
--   </pre>
observe :: forall event eventSource e q len b. (HasCallStack, HasProcesses e q, LogIo q, LogIo e, IsObservable eventSource event, Integral len, Server (ObservationQueue event) (Processes q), Tangible (Pdu eventSource  'Asynchronous)) => len -> Endpoint eventSource -> Eff (ObservationQueueReader event : e) b -> Eff e b

-- | Read queued observations captured and enqueued in the shared
--   <a>ObservationQueue</a> by <a>observe</a>.
--   
--   This blocks until something was captured or an interrupt or exceptions
--   was thrown. For a non-blocking variant use <a>tryRead</a> or
--   <a>flush</a>.
await :: forall event r. (Member (ObservationQueueReader event) r, HasCallStack, MonadIO (Eff r), Typeable event, Member Logs r) => Eff r event

-- | Read queued observations captured and enqueued in the shared
--   <a>ObservationQueue</a> by <a>observe</a>.
--   
--   Return the oldest enqueued observation immediately or <a>Nothing</a>
--   if the queue is empty. Use <a>await</a> to block until an observation
--   is observerRegistryNotify.
tryRead :: forall event r. (Member (ObservationQueueReader event) r, HasCallStack, MonadIO (Eff r), Typeable event, Member Logs r) => Eff r (Maybe event)

-- | Read at once all currently queued observations captured and enqueued
--   in the shared <a>ObservationQueue</a> by <a>observe</a>.
--   
--   This returns immediately all currently enqueued observations. For a
--   blocking variant use <a>await</a>.
flush :: forall event r. (Member (ObservationQueueReader event) r, HasCallStack, MonadIO (Eff r), Typeable event, Member Logs r) => Eff r [event]
instance (Data.Typeable.Internal.Typeable event, Control.Eff.Internal.Lifted GHC.Types.IO q, Data.OpenUnion.Member Control.Eff.Log.Handler.Logs q) => Control.Eff.Concurrent.Protocol.StatefulServer.Server (Control.Eff.Concurrent.Protocol.Observer.Queue.ObservationQueue event) (Control.Eff.Concurrent.Process.Processes q)


-- | 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 (Processes r) () -> IO ()) -> IO (SchedulerSession r)

-- | Exit the scheduler 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 (Processes r) a -> IO a

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

-- | Combination of <a>submit</a> and <a>cast</a>.
submitCall :: forall o q r. (SetMember Lift (Lift IO) r, Member Interrupts r, Tangible (Pdu o ( 'Synchronous q)), HasPdu o, Tangible q) => SchedulerSession r -> Endpoint o -> Pdu o ( 'Synchronous q) -> IO q


-- | Build a <a>Control.Eff.Concurrent.EffectfulServer</a> from callbacks.
--   
--   This module contains in instance of <a>Server</a> that delegates to
--   callback functions.
module Control.Eff.Concurrent.Protocol.CallbackServer

-- | Execute the server loop, that dispatches incoming events to either a
--   set of <a>Callbacks</a> or <a>CallbacksEff</a>.
start :: forall (tag :: Type) eLoop q h e. (HasCallStack, TangibleCallbacks tag eLoop q, Server (Server tag eLoop) (Processes q), LogsTo h (Processes q), HasProcesses e q) => CallbacksEff tag eLoop q -> Eff e (Endpoint tag)

-- | Execute the server loop, that dispatches incoming events to either a
--   set of <a>Callbacks</a> or <a>CallbacksEff</a>.
startLink :: forall (tag :: Type) eLoop q h e. (HasCallStack, TangibleCallbacks tag eLoop q, Server (Server tag eLoop) (Processes q), LogsTo h (Processes q), HasProcesses e q) => CallbacksEff tag eLoop q -> Eff e (Endpoint tag)

-- | Phantom type to indicate a callback based <a>Server</a> instance.
data Server tag eLoop

-- | The name/id of a <a>Server</a> for logging purposes.
newtype ServerId (tag :: Type)
MkServerId :: Text -> ServerId
[_fromServerId] :: ServerId -> Text

-- | This event sum-type is used to communicate incoming messages and other
--   events to the instances of <a>Server</a>.
data Event a

-- | A <a>Synchronous</a> message was received. If an implementation wants
--   to delegate nested <a>Pdu</a>s, it can use
--   <a>toEmbeddedReplyTarget</a> to convert a <a>ReplyTarget</a> safely to
--   the embedded protocol.
[OnCall] :: forall a r. (Tangible r, TangiblePdu a ( 'Synchronous r)) => ReplyTarget a r -> Pdu a ( 'Synchronous r) -> Event a
[OnCast] :: forall a. TangiblePdu a  'Asynchronous => Pdu a  'Asynchronous -> Event a
[OnInterrupt] :: Interrupt  'Recoverable -> Event a
[OnDown] :: ProcessDown -> Event a
[OnTimeOut] :: TimerElapsed -> Event a
[OnMessage] :: StrictDynamic -> Event a

-- | The constraints for a <i>tangible</i> <a>Server</a> instance.
type TangibleCallbacks tag eLoop e = (HasProcesses eLoop e, Typeable e, Typeable eLoop, Typeable tag)

-- | A convenience type alias for callbacks that do not need a custom
--   effect.
type Callbacks tag e = CallbacksEff tag (Processes e) e

-- | A smart constructor for <a>Callbacks</a>.
callbacks :: forall tag q h. (HasCallStack, TangibleCallbacks tag (Processes q) q, Server (Server tag (Processes q)) (Processes q), LogsTo h q) => (Endpoint tag -> Event tag -> Eff (Processes q) ()) -> ServerId tag -> Callbacks tag q

-- | A simple smart constructor for <a>Callbacks</a>.
onEvent :: forall tag q h. (HasCallStack, TangibleCallbacks tag (Processes q) q, Server (Server tag (Processes q)) (Processes q), LogsTo h q) => (Event tag -> Eff (Processes q) ()) -> ServerId (tag :: Type) -> Callbacks tag q

-- | A convenience type alias for <b>effectful</b> callback based
--   <a>Server</a> instances.
--   
--   See <a>Callbacks</a>.
type CallbacksEff tag eLoop e = Init (Server tag eLoop) (Processes e)

-- | A smart constructor for <a>CallbacksEff</a>.
callbacksEff :: forall tag eLoop q h. (HasCallStack, TangibleCallbacks tag eLoop q, Server (Server tag eLoop) (Processes q), LogsTo h q) => (forall x. Endpoint tag -> Eff eLoop x -> Eff (Processes q) x) -> (Endpoint tag -> Event tag -> Eff eLoop ()) -> ServerId tag -> CallbacksEff tag eLoop q

-- | A simple smart constructor for <a>CallbacksEff</a>.
onEventEff :: (HasCallStack, TangibleCallbacks tag eLoop q, Server (Server tag eLoop) (Processes q), LogsTo h q) => (forall a. Eff eLoop a -> Eff (Processes q) a) -> (Event tag -> Eff eLoop ()) -> ServerId (tag :: Type) -> CallbacksEff tag eLoop q
instance Data.String.IsString (Control.Eff.Concurrent.Protocol.CallbackServer.ServerId tag)
instance GHC.Classes.Eq (Control.Eff.Concurrent.Protocol.CallbackServer.ServerId tag)
instance GHC.Classes.Ord (Control.Eff.Concurrent.Protocol.CallbackServer.ServerId tag)
instance Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.CallbackServer.ServerId tag)
instance Data.Typeable.Internal.Typeable tag => GHC.Show.Show (Control.Eff.Concurrent.Protocol.CallbackServer.ServerId tag)
instance Control.Eff.Concurrent.Protocol.CallbackServer.TangibleCallbacks tag eLoop e => Control.Eff.Concurrent.Protocol.EffectfulServer.Server (Control.Eff.Concurrent.Protocol.CallbackServer.Server tag eLoop) (Control.Eff.Concurrent.Process.Processes e)
instance Control.Eff.Concurrent.Protocol.CallbackServer.TangibleCallbacks tag eLoop e => Control.DeepSeq.NFData (Control.Eff.Concurrent.Protocol.EffectfulServer.Init (Control.Eff.Concurrent.Protocol.CallbackServer.Server tag eLoop) (Control.Eff.Concurrent.Process.Processes e))
instance Control.Eff.Concurrent.Protocol.CallbackServer.TangibleCallbacks tag eLoop e => GHC.Show.Show (Control.Eff.Concurrent.Protocol.EffectfulServer.Init (Control.Eff.Concurrent.Protocol.CallbackServer.Server tag eLoop) (Control.Eff.Concurrent.Process.Processes e))


-- | Capture <a>LogMessage</a>s to a <a>Writer</a>.
--   
--   See <a>exampleLogCapture</a>
module Control.Eff.LogWriter.Capture

-- | A <a>LogWriter</a> monad that provides pure logging by capturing via
--   the <a>Writer</a> effect.
--   
--   See <a>exampleLogCapture</a>
captureLogWriter :: LogWriter CaptureLogWriter

-- | A <a>LogWriter</a> monad that provides pure logging by capturing via
--   the <a>Writer</a> effect.
type CaptureLogs a = LogWriterM CaptureLogWriter a

-- | Alias for the <a>Writer</a> that contains the captured
--   <a>LogMessage</a>s from <a>CaptureLogs</a>.
type CaptureLogWriter = Writer LogMessage

-- | Run a <a>Writer</a> for <a>LogMessage</a>s.
--   
--   Such a <a>Writer</a> is needed to handle <a>CaptureLogWriter</a>
runCaptureLogWriter :: Eff (CaptureLogWriter : e) a -> Eff e (a, [LogMessage])


-- | Functions for generic, IO-based <a>LogWriter</a>s.
--   
--   This module is more low-level than the others in this directory.
module Control.Eff.LogWriter.IO

-- | A <a>LogWriter</a> that uses an <a>IO</a> action to write the message.
--   
--   This is just an alias for <a>MkLogWriter</a> but with <tt>IO</tt> as
--   parameter. This reduces the need to apply something to the extra type
--   argument <tt>@IO</tt>.
--   
--   Example use cases for this function are the <tt>consoleLogWriter</tt>
--   and the <a>ioHandleLogWriter</a>.
mkLogWriterIO :: HasCallStack => (LogMessage -> IO ()) -> LogWriter (Lift IO)

-- | A <a>LogWriter</a> that renders <a>LogMessage</a>s to strings via
--   <a>renderLogMessageConsoleLog</a> and prints them to an <a>Handle</a>
--   using <tt>hPutStrLn</tt>.
ioHandleLogWriter :: HasCallStack => Handle -> LogWriter (Lift IO)

-- | Decorate an IO based <a>LogWriter</a> to fill out these fields in
--   <a>LogMessage</a>s:
--   
--   <ul>
--   <li>The messages will carry the given application name in the
--   <a>lmAppName</a> field.</li>
--   <li>The <a>lmTimestamp</a> field contains the UTC time of the log
--   event</li>
--   <li>The <a>lmHostname</a> field contains the FQDN of the current
--   host</li>
--   <li>The <a>lmFacility</a> field contains the given
--   <a>Facility</a></li>
--   </ul>
--   
--   It works by using <a>mappingLogWriterM</a>.
defaultIoLogWriter :: Text -> Facility -> LogWriter (Lift IO) -> LogWriter (Lift IO)

-- | Enable logging to IO using the <a>defaultIoLogWriter</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithIoLogging :: IO ()
--   exampleWithIoLogging =
--       runLift
--     $ withIoLogging debugTraceLogWriter
--                     "my-app"
--                     local7
--                     (lmSeverityIsAtLeast informationalSeverity)
--     $ logInfo "Oh, hi there"
--   </pre>
withIoLogging :: Lifted IO e => LogWriter (Lift IO) -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | The concrete list of <a>Eff</a>ects for logging with an IO based
--   <a>LogWriter</a>, and a <a>LogWriterReader</a>.
type LoggingAndIo = '[Logs, LogWriterReader (Lift IO), Lift IO]

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


-- | This helps to setup logging to a <i>file</i>.
module Control.Eff.LogWriter.File

-- | Enable logging to a file, with some <a>LogMessage</a> fields preset as
--   described in <a>withIoLogging</a>.
--   
--   If the file or its directory does not exist, it will be created.
--   
--   Example:
--   
--   <pre>
--   exampleWithFileLogging :: IO ()
--   exampleWithFileLogging =
--       runLift
--     $ withFileLogging "/var/log/my-app.log" "my-app" local7 allLogMessages
--     $ logInfo "Oh, hi there"
--   </pre>
--   
--   To vary the <a>LogWriter</a> use <a>withIoLogging</a>.
withFileLogging :: (Lifted IO e, MonadBaseControl IO (Eff e)) => FilePath -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Enable logging to a file.
--   
--   If the file or its directory does not exist, it will be created.
--   Example:
--   
--   <pre>
--   exampleWithFileLogWriter :: IO ()
--   exampleWithFileLogWriter =
--       runLift
--     $ withSomeLogging @IO
--     $ withFileLogWriter "test.log"
--     $ logInfo "Oh, hi there"
--   </pre>
withFileLogWriter :: (LogIo e, MonadBaseControl IO (Eff e)) => FilePath -> Eff e b -> Eff e b


-- | This helps to setup logging via <a>Debug.Trace</a>.
module Control.Eff.LogWriter.DebugTrace

-- | Enable logging via <a>traceM</a> using the <a>debugTraceLogWriter</a>.
--   The logging monad type can be <i>any</i> type with a <a>Monad</a>
--   instance.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithTraceLogWriter :: IO ()
--   exampleWithTraceLogWriter =
--       runLift
--     $ withSomeLogging @IO
--     $ withTraceLogWriter
--     $ logInfo "Oh, hi there"
--   </pre>
withTraceLogWriter :: forall h e a. (Monad (LogWriterM h), LogsTo h e) => Eff e a -> Eff e a

-- | Enable logging via <a>traceM</a> using the <a>debugTraceLogWriter</a>,
--   with some <a>LogMessage</a> fields preset as in <a>withIoLogging</a>.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithTraceLogging :: IO ()
--   exampleWithTraceLogging =
--       runLift
--     $ withTraceLogging "my-app" local7 allLogMessages
--     $ logInfo "Oh, hi there"
--   </pre>
withTraceLogging :: Lifted IO e => Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Write <a>LogMessage</a>s via <a>traceM</a>.
debugTraceLogWriter :: forall h. Monad (LogWriterM h) => LogMessageRenderer Text -> LogWriter h


-- | This helps to setup logging to <i>standard ouput</i>.
module Control.Eff.LogWriter.Console

-- | Enable logging to <tt>standard output</tt> using the
--   <a>consoleLogWriter</a>.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithConsoleLogWriter :: IO ()
--   exampleWithConsoleLogWriter =
--       runLift
--     $ withSomeLogging @IO
--     $ withConsoleLogWriter
--     $ logInfo "Oh, hi there"
--   </pre>
withConsoleLogWriter :: LogIo e => Eff e a -> Eff e a

-- | Enable logging to <tt>standard output</tt> using the
--   <a>consoleLogWriter</a>, with some <a>LogMessage</a> fields preset as
--   in <a>withIoLogging</a>.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithConsoleLogging :: IO ()
--   exampleWithConsoleLogging =
--       runLift
--     $ withConsoleLogging "my-app" local7 allLogMessages
--     $ logInfo "Oh, hi there"
--   </pre>
--   
--   To vary the <a>LogWriter</a> use <a>withIoLogging</a>.
withConsoleLogging :: Lifted IO e => Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Write <a>LogMessage</a>s to standard output, formatted with
--   <a>printLogMessage</a>.
--   
--   It uses <a>stdoutLogWriter</a> with <a>renderLogMessageConsoleLog</a>.
consoleLogWriter :: LogWriter (Lift IO)

-- | A <a>LogWriter</a> that uses a <a>LogMessageRenderer</a> to render,
--   and <a>putStrLn</a> to print it.
stdoutLogWriter :: LogMessageRenderer Text -> LogWriter (Lift IO)


-- | This module only exposes a <a>LogWriter</a> for asynchronous logging;
module Control.Eff.LogWriter.Async

-- | <i>Move</i> the current <a>LogWriter</a> into its own thread.
--   
--   A bounded queue is used to forward logs to the process.
--   
--   If an exception is received, 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:
--   
--   <pre>
--   exampleAsyncLogWriter :: IO ()
--   exampleAsyncLogWriter =
--       runLift
--     $ withLogging consoleLogWriter
--     $ withAsyncLogWriter (1000::Int)
--     $ do logMsg "test 1"
--          logMsg "test 2"
--          logMsg "test 3"
--   </pre>
withAsyncLogWriter :: (LogIo e, MonadBaseControl IO (Eff e), Integral len) => len -> Eff e a -> Eff e a

-- | This is a wrapper around <a>withAsyncLogWriter</a> and
--   <a>withIoLogging</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithAsyncLogging :: IO ()
--   exampleWithAsyncLogging =
--       runLift
--     $ withAsyncLogWriter consoleLogWriter (1000::Int) "my-app" local0 allLogMessages
--     $ do logMsg "test 1"
--          logMsg "test 2"
--          logMsg "test 3"
--   </pre>
withAsyncLogging :: (Lifted IO e, MonadBaseControl IO (Eff e), Integral len) => LogWriter (Lift IO) -> len -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a


-- | 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 eg.g
--   <a>exitNormally</a> or <a>exitWithError</a> 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 (Processes r) a -> m (Either (Interrupt  'NoRecovery) a)

-- | Invoke <a>scheduleM</a> 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 (Processes r) a -> Eff r (Either (Interrupt  '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>scheduleIO</a> . <a>withLogging</a>
--   </pre>
scheduleIOWithLogging :: HasCallStack => LogWriter (Lift IO) -> Eff EffectsIo a -> IO (Either (Interrupt  'NoRecovery) a)

-- | Like <a>scheduleIO</a> 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 (Processes '[Logs, LogWriterReader Logs]) a -> Either (Interrupt  'NoRecovery) a

-- | The effect list for <a>Process</a> effects in the single threaded pure
--   scheduler.
--   
--   See <a>PureBaseEffects</a> and <a>Processes</a>
type PureEffects = Processes PureBaseEffects

-- | The effect list for <a>Process</a> effects in the single threaded pure
--   scheduler. This is like <a>SafeProcesses</a>, no <a>Interrupts</a> are
--   present.
--   
--   See <a>PureBaseEffects</a> and <a>SafeProcesses</a>
type PureSafeEffects = SafeProcesses PureBaseEffects

-- | The effect list for a pure, single threaded scheduler contains only
--   <a>Logs</a> and the <a>LogWriterReader</a> for <tt>PureLogWriter</tt>.
type PureBaseEffects = '[Logs, LogWriterReader Logs]

-- | Constraint for the existence of the underlying scheduler effects.
--   
--   See <a>PureBaseEffects</a>
type HasPureBaseEffects e = (HasCallStack, PureBaseEffects <:: e)

-- | Execute a <a>Process</a> using <a>scheduleM</a> on top of <a>Lift</a>
--   <tt>IO</tt>. All logging is written to the console using
--   <a>consoleLogWriter</a>.
--   
--   To use another <a>LogWriter</a> use <a>defaultMainWithLogWriter</a>
--   instead.
defaultMain :: HasCallStack => Eff EffectsIo () -> IO ()

-- | Execute a <a>Process</a> using <a>scheduleM</a> on top of <a>Lift</a>
--   <tt>IO</tt>. All logging is written using the given <a>LogWriter</a>.
defaultMainWithLogWriter :: HasCallStack => LogWriter (Lift IO) -> Eff EffectsIo () -> IO ()

-- | Invoke <a>scheduleM</a> 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 (Processes r) a -> m (Either (Interrupt  'NoRecovery) a)

-- | The effect list for <a>Process</a> effects in the single threaded
--   scheduler.
--   
--   See <a>BaseEffectsIo</a>
type EffectsIo = Processes BaseEffectsIo

-- | The effect list for <a>Process</a> effects in the single threaded
--   scheduler. This is like <a>SafeProcesses</a>, no <a>Interrupts</a> are
--   present.
--   
--   See <a>BaseEffectsIo</a>.
type SafeEffectsIo = SafeProcesses BaseEffectsIo

-- | The effect list for the underlying scheduler.
--   
--   See <a>LoggingAndIo</a>
type BaseEffectsIo = LoggingAndIo

-- | Constraint for the existence of the underlying scheduler effects.
type HasBaseEffectsIo e = (HasCallStack, Lifted IO e, LoggingAndIo <:: e)
instance GHC.Show.Show (Control.Eff.Concurrent.Process.SingleThreadedScheduler.OnYield r a)
instance GHC.Show.Show (Control.Eff.Concurrent.Process.SingleThreadedScheduler.STS r m)
instance GHC.Show.Show Control.Eff.Concurrent.Process.SingleThreadedScheduler.ProcessInfo


-- | Implement Erlang style message passing concurrency.
--   
--   This module contains <a>spawn</a> which handles the <a>Process</a>
--   effects, using <a>TQueue</a>s and <a>withAsync</a>.
--   
--   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.
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>BaseEffects</a> effect for concurrent logging.
schedule :: HasCallStack => Eff Effects () -> Eff LoggingAndIo ()

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

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

-- | The concrete list of <a>Eff</a>ects of processes compatible with this
--   scheduler. This builds upon <a>BaseEffects</a>.
type SafeEffects = SafeProcesses BaseEffects

-- | The <a>Eff</a>ects for interruptable, concurrent processes, scheduled
--   via <tt>forkIO</tt>.
type Effects = Processes BaseEffects

-- | The concrete list of <a>Eff</a>ects for this scheduler implementation.
type BaseEffects = 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 HasBaseEffects r = (HasCallStack, Lifted IO r, BaseEffects <:: r)
instance GHC.Show.Show Control.Eff.Concurrent.Process.ForkIOScheduler.ProcessInfo
instance Data.Default.Class.Default Control.Eff.Concurrent.Process.ForkIOScheduler.MessageQ


-- | This helps to setup logging to <i>standard ouput</i>.
module Control.Eff.LogWriter.UDP

-- | Enable logging to a (remote-) host via UDP.
--   
--   See <a>exampleUdpRFC3164Logging</a>
withUDPLogWriter :: (LogIo e, MonadBaseControl IO (Eff e), HasCallStack) => (LogMessage -> Text) -> String -> String -> Eff e b -> Eff e b

-- | Enable logging to a remote host via <b>UDP</b>, with some
--   <a>LogMessage</a> fields preset as in <a>withIoLogging</a>.
--   
--   See <a>exampleUdpRFC3164Logging</a>
withUDPLogging :: (HasCallStack, MonadBaseControl IO (Eff e), Lifted IO e) => (LogMessage -> Text) -> String -> String -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a


-- | This helps to setup logging to <i>standard ouput</i>.
module Control.Eff.LogWriter.UnixSocket

-- | Enable logging to a (remote-) host via UnixSocket.
--   
--   See <a>exampleDevLogSyslogLogging</a>
withUnixSocketLogWriter :: (LogIo e, MonadBaseControl IO (Eff e), HasCallStack) => LogMessageRenderer Text -> FilePath -> Eff e b -> Eff e b

-- | Enable logging to a <i>unix domain socket</i>, with some
--   <a>LogMessage</a> fields preset as in <a>withIoLogging</a>.
--   
--   See <a>exampleDevLogSyslogLogging</a>
withUnixSocketLogging :: (HasCallStack, MonadBaseControl IO (Eff e), Lifted IO e) => LogMessageRenderer Text -> FilePath -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a


-- | Examples for Logging.
module Control.Eff.Log.Examples

-- | Example code for:
--   
--   <ul>
--   <li><a>withConsoleLogging</a></li>
--   <li><a>mkLogWriterIO</a> See <a>loggingExampleClient</a></li>
--   </ul>
exampleLogging :: HasCallStack => IO ()

-- | Example code for:
--   
--   <ul>
--   <li><a>withLogging</a></li>
--   <li><a>consoleLogWriter</a></li>
--   </ul>
exampleWithLogging :: HasCallStack => IO ()

-- | Example code for:
--   
--   <ul>
--   <li><a>withSomeLogging</a></li>
--   <li><a>logDebug</a></li>
--   </ul>
exampleWithSomeLogging :: HasCallStack => ()

-- | Example code for:
--   
--   <ul>
--   <li><a>setLogPredicate</a></li>
--   <li><a>modifyLogPredicate</a></li>
--   <li><a>lmMessageStartsWith</a></li>
--   <li><a>lmSeverityIs</a></li>
--   <li><a>lmSeverityIsAtLeast</a></li>
--   <li><a>includeLogMessages</a></li>
--   <li><a>excludeLogMessages</a></li>
--   </ul>
exampleLogPredicate :: HasCallStack => IO Int

-- | Example code for:
--   
--   <ul>
--   <li><a>runCaptureLogWriter</a></li>
--   <li><a>captureLogWriter</a></li>
--   <li><a>mappingLogWriter</a></li>
--   <li><a>filteringLogWriter</a></li>
--   </ul>
exampleLogCapture :: IO ()

-- | Example code for:
--   
--   <ul>
--   <li><a>withAsyncLogging</a></li>
--   </ul>
exampleAsyncLogging :: IO ()

-- | Example code for RFC5424 formatted logs.
exampleRFC5424Logging :: IO Int

-- | Example code for RFC3164 with RFC5424 time stamp formatted logs.
exampleRFC3164WithRFC5424TimestampsLogging :: IO Int

-- | Example code logging via a unix domain socket to
--   <tt><i>dev</i>log</tt>.
exampleDevLogSyslogLogging :: IO Int

-- | Example code logging via a unix domain socket to
--   <tt><i>dev</i>log</tt>.
exampleDevLogRFC5424Logging :: IO Int

-- | Example code logging RFC5424 via UDP port 514 on localhost.
exampleUdpRFC5424Logging :: IO Int

-- | Example code logging RFC5424 via UDP port 514 on localhost.
exampleUdpRFC3164Logging :: IO Int

-- | Example logging client code
--   
--   <ul>
--   <li><a>addLogWriter</a></li>
--   <li><a>debugTraceLogWriter</a></li>
--   <li><a>setLogPredicate</a></li>
--   <li><a>prefixLogMessagesWith</a></li>
--   <li><a>renderRFC3164</a></li>
--   <li><a>logMsg</a></li>
--   <li><a>logDebug</a></li>
--   <li><a>logError</a></li>
--   <li><a>logInfo</a></li>
--   <li><a>logWarning</a></li>
--   <li><a>logCritical</a></li>
--   <li><a>lmMessage</a></li>
--   </ul>
loggingExampleClient :: (HasCallStack, Monad (LogWriterM h), LogsTo h e) => Eff e ()

-- | Example logging client code using many <a>LogPredicate</a>s.
--   
--   <ul>
--   <li><a>setLogPredicate</a></li>
--   <li><a>modifyLogPredicate</a></li>
--   <li><a>lmMessageStartsWith</a></li>
--   <li><a>lmSeverityIs</a></li>
--   <li><a>lmSeverityIsAtLeast</a></li>
--   <li><a>includeLogMessages</a></li>
--   <li><a>excludeLogMessages</a></li>
--   </ul>
logPredicatesExampleClient :: (HasCallStack, Monad (LogWriterM h), LogsTo h e) => Eff e Int


-- | 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 comparative 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>.
--   
--   This module re-exports most of the library.
--   
--   There are several <i>scheduler</i> implementations to choose from.
--   
--   This module re-exports
--   <a>Control.Eff.Concurrent.Process.ForkIOScheduler</a>.
--   
--   To use another scheduler implementation, don't import this module, but
--   instead import one of:
--   
--   <ul>
--   <li><a>Control.Eff.Concurrent.Pure</a></li>
--   <li><a>Control.Eff.Concurrent.SingleThreaded</a></li>
--   </ul>
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 died.
data ProcessDown
ProcessDown :: !MonitorReference -> !SomeExitReason -> !ProcessId -> ProcessDown
[downReference] :: ProcessDown -> !MonitorReference
[downReason] :: ProcessDown -> !SomeExitReason
[downProcess] :: ProcessDown -> !ProcessId

-- | 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>Interrupt</a>
data SomeExitReason
[SomeExitReason] :: Interrupt x -> SomeExitReason

-- | <a>Exc</a>eptions containing <a>Interrupt</a>s. See
--   <a>handleInterrupts</a>, <a>exitOnInterrupt</a> or
--   <a>provideInterrupts</a>
type Interrupts = Exc (Interrupt  'Recoverable)

-- | A constraint for an effect set that requires the presence of
--   <a>SafeProcesses</a>.
--   
--   This constrains the effect list to look like this: <tt>[e1 ... eN,
--   <a>Process</a> [e(N+1) .. e(N+k)], e(N+1) .. e(N+k)]</tt>
--   
--   It contrains <tt>e</tt> to support the (only) <a>Process</a> effect.
--   
--   This is more relaxed that <a>HasProcesses</a> since it does not
--   require <a>Interrupts</a>.
type HasSafeProcesses e inner = (SetMember Process (Process inner) e)

-- | <i>Cons</i> <a>Process</a> onto a list of effects. This is called
--   <tt>SafeProcesses</tt> because the the actions cannot be interrupted
--   in.
type SafeProcesses r = Process r : r

-- | A constraint for an effect set that requires the presence of
--   <a>Processes</a>.
--   
--   This constrains the effect list to look like this: <tt>[e1 ... eN,
--   <a>Interrupts</a>, <a>Process</a> [e(N+1) .. e(N+k)], e(N+1) ..
--   e(N+k)]</tt>
--   
--   It contrains <tt>e</tt> beyond <a>HasSafeProcesses</a> to encompass
--   <a>Interrupts</a>.
type HasProcesses e inner = (HasSafeProcesses e inner, Member Interrupts e)

-- | This adds a layer of the <a>Interrupts</a> effect on top of
--   <a>Processes</a>
type Processes e = Interrupts : SafeProcesses e

-- | <a>Interrupt</a>s which are <a>Recoverable</a>.
type RecoverableInterrupt = Interrupt  'Recoverable

-- | A sum-type with reasons for why a process operation, such as receiving
--   messages, is interrupted in the scheduling loop.
--   
--   This includes errors, that can occur when scheduling messages.
data Interrupt (t :: ExitRecovery)

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

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

-- | A <a>Recoverable</a> timeout has occurred.
[TimeoutInterrupt] :: String -> Interrupt  'Recoverable

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

-- | An exit reason that has an error message and is <a>Recoverable</a>.
[ErrorInterrupt] :: String -> Interrupt  'Recoverable

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

-- | An error causes the process to exit immediately. For example an
--   unexpected runtime exception was thrown, i.e. an exception derived
--   from <a>SomeException</a> Or a <a>Recoverable</a> Interrupt was not
--   recovered.
[ExitUnhandledError] :: Text -> Interrupt  'NoRecovery

-- | A process shall exit immediately, without any cleanup was cancelled
--   (e.g. killed, in <a>cancel</a>)
[ExitProcessCancelled] :: Interrupt  'NoRecovery

-- | This value indicates whether 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>Interrupt</a> can be treated
--   like a short interrupt which can be handled or ignored.
data ExitRecovery
Recoverable :: ExitRecovery
NoRecovery :: ExitRecovery

-- | A function that decided 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>Interrupt</a>. If <a>isRecoverable</a> holds for the given reason,
--   the process may choose to continue.
[Interrupted] :: Interrupt  'Recoverable -> ResumeProcess v

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

-- | Serialize a <tt>message</tt> into a <a>StrictDynamic</a> value to be
--   sent via <a>sendAnyMessage</a>.
--   
--   This indirection allows, among other things, the composition of
--   <a>Server</a>s.
newtype Serializer message
MkSerializer :: (message -> StrictDynamic) -> Serializer message
[runSerializer] :: Serializer message -> message -> StrictDynamic

-- | Data flows between <a>Process</a>es via these messages.
--   
--   This is just a newtype wrapper around <a>Dynamic</a>. The reason this
--   type exists is to force construction through the code in this module,
--   which always evaluates a message to <i>normal form</i> <b>before</b>
--   sending it to another process.
data StrictDynamic

-- | A multi-line text describing the <b>current</b> state of a process for
--   debugging purposes.
newtype ProcessDetails
MkProcessDetails :: Text -> ProcessDetails
[_fromProcessDetails] :: ProcessDetails -> Text

-- | A short title for a <a>Process</a> for logging purposes.
newtype ProcessTitle
MkProcessTitle :: Text -> ProcessTitle
[_fromProcessTitle] :: ProcessTitle -> Text

-- | 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 [StrictDynamic])

-- | 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] :: ProcessTitle -> Eff (Process r : r) () -> Process r (ResumeProcess ProcessId)

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

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

-- | Shutdown another process immediately, the other process has no way of
--   handling this!
[SendShutdown] :: ProcessId -> Interrupt  '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 -> Interrupt  'Recoverable -> Process r (ResumeProcess ())

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

-- | Receive a message that matches a criteria. This should block until an
--   a message was received. The message is returned as a
--   <a>ResumeProcess</a> 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, without 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 <a>Interrupt</a>
--   <a>LinkedProcessCrashed</a>.
[Link] :: ProcessId -> Process r (ResumeProcess ())

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

-- | Update the <a>ProcessDetails</a> of a process
[UpdateProcessDetails] :: ProcessDetails -> Process r (ResumeProcess ())

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

-- | An isomorphism lens for the <a>ProcessTitle</a>
fromProcessTitle :: Lens' ProcessTitle Text

-- | An isomorphism lens for the <a>ProcessDetails</a>
fromProcessDetails :: Lens' ProcessDetails Text

-- | Deeply evaluate the given value and wrap it into a
--   <a>StrictDynamic</a>.
toStrictDynamic :: (Typeable a, NFData a) => a -> StrictDynamic

-- | Convert a <a>StrictDynamic</a> back to a value.
fromStrictDynamic :: Typeable a => StrictDynamic -> Maybe a

-- | Convert a <a>StrictDynamic</a> back to an unwrapped <a>Dynamic</a>.
unwrapStrictDynamic :: StrictDynamic -> Dynamic

-- | Create a message selector for a value that can be obtained by
--   <a>fromStrictDynamic</a>.
selectMessage :: Typeable t => MessageSelector t

-- | Create a message selector from a predicate.
filterMessage :: 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>).
selectMessageWith :: Typeable a => (a -> Maybe b) -> MessageSelector b

-- | Create a message selector.
selectDynamicMessage :: (StrictDynamic -> 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.
selectAnyMessage :: MessageSelector StrictDynamic

-- | Get the <a>ExitRecovery</a>
toExitRecovery :: Interrupt r -> ExitRecovery

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

-- | Return either <a>ExitNormally</a> or <a>interruptToExit</a> from a
--   <a>Recoverable</a> <a>Interrupt</a>;
--   
--   If the <a>Interrupt</a> is <a>NormalExitRequested</a> then return
--   <a>ExitNormally</a>
interruptToExit :: Interrupt  'Recoverable -> Interrupt  'NoRecovery

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

-- | Handle all <a>Interrupt</a>s of an <a>Processes</a> by wrapping them
--   up in <a>interruptToExit</a> and then do a process <a>Shutdown</a>.
provideInterruptsShutdown :: forall e a. Eff (Processes e) a -> Eff (SafeProcesses e) a

-- | Handle <a>Interrupt</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) => (Interrupt  'Recoverable -> Eff r a) -> Eff r a -> Eff r a

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

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

-- | Handle <a>Interrupt</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, HasProcesses r q) => Eff r a -> Eff r a

-- | Handle <a>Interrupt</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 (Interrupt  'Recoverable) a)

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

-- | Throw an <a>Interrupt</a>, can be handled by <a>handleInterrupts</a>
--   or <a>exitOnInterrupt</a> or <a>provideInterrupts</a>.
interrupt :: (HasCallStack, Member Interrupts r) => Interrupt  'Recoverable -> Eff r a

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

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

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

-- | Print a <a>Interrupt</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 :: Interrupt -&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 :: Interrupt x -> Maybe Text

-- | Log the <a>Interrupt</a>s
logProcessExit :: forall e x. (Member Logs e, HasCallStack) => Interrupt 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. (HasSafeProcesses r q, HasCallStack) => Process q (ResumeProcess v) -> Eff r (Either (Interrupt  '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. (HasSafeProcesses r q, 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. (HasProcesses r q, HasCallStack) => 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. (HasProcesses r q, HasCallStack) => Eff r ()

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>.
--   
--   The message will be reduced to normal form (<a>rnf</a>) by/in the
--   caller process.
sendMessage :: forall r q o. (HasProcesses r q, HasCallStack, Typeable o, NFData o) => 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. (HasCallStack, HasProcesses r q) => ProcessId -> StrictDynamic -> 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. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt  '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. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt  'Recoverable -> 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>Interrupt</a> wrapped in <a>interruptToExit</a>. For specific use
--   cases it might be better to use <a>spawnRaw</a>.
spawn :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ProcessId

-- | Like <a>spawn</a> but return <tt>()</tt>.
spawn_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ()

-- | Start a new process, and immediately link to it.
spawnLink :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes 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>SafeProcesses</a> effects. For
--   non-library code <a>spawn</a> might be better suited.
spawnRaw :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff r ProcessId

-- | Like <a>spawnRaw</a> but return <tt>()</tt>.
spawnRaw_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff r ()

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

-- | Return the <a>ProcessTitle</a>, <a>ProcessDetails</a> and
--   <a>ProcessState</a>, for the given process, if the process is alive.
getProcessState :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r (Maybe (ProcessTitle, ProcessDetails, ProcessState))

-- | Replace the <a>ProcessDetails</a> of the process.
updateProcessDetails :: forall r q. (HasCallStack, HasProcesses r q) => ProcessDetails -> Eff r ()

-- | Block until a message was received. See <a>ReceiveSelectedMessage</a>
--   for more documentation.
receiveAnyMessage :: forall r q. (HasCallStack, HasProcesses r q) => Eff r StrictDynamic

-- | 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, HasProcesses r 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, NFData a, Show a, HasProcesses r q) => Eff r a

-- | Remove and return all messages currently enqueued in the process
--   message queue.
flushMessages :: forall r q. (HasCallStack, HasProcesses r q) => Eff r [StrictDynamic]

-- | 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> <a>Interrupt</a></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. (HasSafeProcesses r q, HasCallStack) => MessageSelector a -> (Either (Interrupt  'Recoverable) a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Like <a>receiveSelectedLoop</a> but <i>not selective</i>. See also
--   <a>selectAnyMessage</a>, <a>receiveSelectedLoop</a>.
receiveAnyLoop :: forall r q endOfLoopResult. (HasSafeProcesses r q, HasCallStack) => (Either (Interrupt  'Recoverable) StrictDynamic -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Like <a>receiveSelectedLoop</a> but refined to casting to a specific
--   <a>Typeable</a> using <a>selectMessage</a>.
receiveLoop :: forall r q a endOfLoopResult. (HasSafeProcesses r q, HasCallStack, NFData a, Typeable a) => (Either (Interrupt  'Recoverable) a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

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

-- | Generate a unique <a>Int</a> for the current process.
makeReference :: (HasCallStack, HasProcesses r 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, without exit reason
monitor :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r MonitorReference

-- | Remove a monitor created with <a>monitor</a>.
demonitor :: forall r q. (HasCallStack, HasProcesses r q) => MonitorReference -> Eff r ()

-- | <a>monitor</a> another process before while performing an action and
--   <a>demonitor</a> afterwards.
withMonitor :: (HasCallStack, HasProcesses r 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, HasProcesses r q, Typeable a, Show a) => ProcessId -> MessageSelector a -> Eff r (Either ProcessDown a)

-- | Make an <a>Interrupt</a> for a <a>ProcessDown</a> message.
--   
--   For example: <tt>doSomething &gt;&gt;= either (interrupt .
--   becauseProcessIsDown) return</tt>
becauseProcessIsDown :: ProcessDown -> Interrupt  'Recoverable

-- | A <a>MessageSelector</a> for the <a>ProcessDown</a> message of a
--   specific process.
--   
--   The parameter is the value obtained by <a>monitor</a>.
selectProcessDown :: MonitorReference -> MessageSelector ProcessDown

-- | A <a>MessageSelector</a> for the <a>ProcessDown</a> message. of a
--   specific process.
--   
--   In contrast to <a>selectProcessDown</a> this function matches the
--   <a>ProcessId</a>.
selectProcessDownByProcessId :: ProcessId -> 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 <a>Interrupt</a>
--   <a>LinkedProcessCrashed</a>.
linkProcess :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r ()

-- | Unlink the calling process from the other process.
unlinkProcess :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r ()

-- | Exit the process with a <a>Interrupt</a>.
exitBecause :: forall r q a. (HasCallStack, HasSafeProcesses r q) => Interrupt  'NoRecovery -> Eff r a

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

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

-- | A <a>ProcessId</a> and a <a>Serializer</a>. EXPERIMENTAL
--   
--   See <a>sendToReceiver</a>.
data Receiver a
Receiver :: ProcessId -> (a -> out) -> Receiver a
[_receiverPid] :: Receiver a -> ProcessId
[_receiverSerializer] :: Receiver a -> a -> out
fromProcessId :: Iso' ProcessId Int

-- | Serialize and send a message to the process in a <a>Receiver</a>.
--   
--   EXPERIMENTAL
sendToReceiver :: (NFData o, HasProcesses r q) => Receiver o -> o -> Eff r ()
receiverPid :: forall a_aHxu. Lens' (Receiver a_aHxu) ProcessId

-- | The concrete list of <a>Eff</a>ects for this scheduler implementation.
type BaseEffects = 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 HasBaseEffects r = (HasCallStack, Lifted IO r, BaseEffects <:: r)

-- | The <a>Eff</a>ects for interruptable, concurrent processes, scheduled
--   via <tt>forkIO</tt>.
type Effects = Processes BaseEffects

-- | The concrete list of <a>Eff</a>ects of processes compatible with this
--   scheduler. This builds upon <a>BaseEffects</a>.
type SafeEffects = SafeProcesses BaseEffects

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

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

-- | 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>BaseEffects</a> effect for concurrent logging.
schedule :: HasCallStack => Eff Effects () -> Eff LoggingAndIo ()

-- | 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, HasProcesses r q, Typeable a, NFData a, Show a) => 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, HasProcesses r q, Show a) => MessageSelector a -> Timeout -> Eff r (Either TimerElapsed a)

-- | Like <a>receiveWithMonitor</a> combined with
--   <a>receiveSelectedAfter</a>.
receiveSelectedWithMonitorAfter :: forall a r q. (Lifted IO q, HasCallStack, HasProcesses r q, Show a) => ProcessId -> MessageSelector a -> Timeout -> Eff r (Either (Either ProcessDown 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, HasProcesses r q, Typeable message, NFData message) => 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, HasProcesses r q) => Timeout -> Eff r TimerReference

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

-- | A class for <a>Pdu</a> instances that embed other <a>Pdu</a>.
--   
--   This is a part of <a>Embeds</a> provide instances for your <a>Pdu</a>s
--   but in client code use the <a>Embeds</a> constraint.
--   
--   Instances of this class serve as proof to <a>Embeds</a> that a
--   conversion into another <a>Pdu</a> actually exists.
--   
--   A <a>Prism</a> for the embedded <a>Pdu</a> is the center of this class
--   
--   Laws: <tt>embeddedPdu = prism' embedPdu fromPdu</tt>
class (Typeable protocol, Typeable embeddedProtocol) => HasPduPrism protocol embeddedProtocol

-- | A <a>Prism</a> for the embedded <a>Pdu</a>s.
embeddedPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Prism' (Pdu protocol result) (Pdu embeddedProtocol result)

-- | Embed the <a>Pdu</a> value of an embedded protocol into the
--   corresponding <a>Pdu</a> value.
embedPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Pdu embeddedProtocol result -> Pdu protocol result

-- | Examine a <a>Pdu</a> value from the outer protocol, and return it, if
--   it embeds a <a>Pdu</a> of embedded protocol, otherwise return
--   <a>Nothing</a>/
fromPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Pdu protocol result -> Maybe (Pdu embeddedProtocol result)

-- | This type function takes an <a>Pdu</a> and analysis the reply type,
--   i.e. the <a>Synchronicity</a> and evaluates to either <tt>t</tt> for
--   an <tt>Pdu x (<a>Synchronous</a> t)</tt> or to '()' for an <tt>Pdu x
--   <a>Asynchronous</a></tt>.
type family ProtocolReply (s :: Synchronicity)

-- | The (promoted) constructors of this type specify (at the type level)
--   the reply behavior of a specific constructor of an <tt>Pdu</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

-- | A <a>Constraint</a> that bundles the requirements for the <a>Pdu</a>
--   values of a protocol.
--   
--   This ensures that <a>Pdu</a>s can be strictly and deeply evaluated and
--   shown such that for example logging is possible.
type TangiblePdu p r = (Typeable p, Typeable r, Tangible (Pdu p r), HasPdu p)

-- | A set of constraints for types that can evaluated via <a>NFData</a>,
--   compared via <a>Ord</a> and presented dynamically via <a>Typeable</a>,
--   and represented both as values via <a>Show</a>.
type Tangible i = (NFData i, Typeable i, Show i)

-- | A constraint that requires that the <tt>outer</tt> <a>Pdu</a> has a
--   clause to embed values from the <tt>inner</tt> <a>Pdu</a>.
--   
--   Also, this constraint requires a <a>HasPduPrism</a> instance, as a
--   proof for a possible conversion of an embedded <a>Pdu</a> value into
--   to the enclosing <a>Pdu</a>.
--   
--   This generates better compiler error messages, when an embedding of a
--   <a>Pdu</a> into another.
--   
--   This is provided by <a>HasPdu</a> instances. The instances are
--   required to provide a list of embedded <a>Pdu</a> values in
--   <a>EmbeddedPduList</a>.
--   
--   Note that every type embeds itself, so <tt>Embeds x x</tt> always
--   holds.
type Embeds outer inner = (HasPduPrism outer inner, CheckEmbeds outer inner, HasPdu outer)

-- | This type class and the associated data family defines the <b>protocol
--   data units</b> (PDU) of a <i>protocol</i>.
--   
--   A Protocol in the sense of a communication interface description
--   between processes.
--   
--   The first parameter is usually a user defined type that identifies the
--   protocol that uses the <a>Pdu</a>s are. It maybe a <i>phantom</i>
--   type.
--   
--   The second parameter specifies if a specific constructor of an
--   (GADT-like) <tt>Pdu</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
--   
--   instance Typeable r =&gt; HasPdu BookShop r where
--     data instance Pdu BookShop r where
--       RentBook  :: BookId   -&gt; Pdu BookShop ('Synchronous (Either RentalError RentalId))
--       BringBack :: RentalId -&gt; Pdu BookShop 'Asynchronous
--       deriving Typeable
--   
--   type BookId = Int
--   type RentalId = Int
--   type RentalError = String
--   </pre>
class Typeable protocol => HasPdu (protocol :: Type) where {
    
    -- | A type level list Protocol phantom types included in the associated
    --   <a>Pdu</a> instance.
    --   
    --   This is just a helper for better compiler error messages. It relies on
    --   <a>Embeds</a> to add the constraint <a>HasPduPrism</a>.
    type family EmbeddedPduList protocol :: [Type];
    
    -- | The <b>protocol data unit</b> type for the given protocol.
    data family Pdu protocol (reply :: Synchronicity);
    type EmbeddedPduList protocol = '[];
}

-- | A server process for <i>protocol</i>.
--   
--   Protocols are represented by phantom types, which are used in
--   different places to index type families and type class instances.
--   
--   A <a>Process</a> can send and receive any messages. An <a>Endpoint</a>
--   wraps around a <a>ProcessId</a> and carries a phantom type to indicate
--   the kinds of messages accepted by the process.
--   
--   As a metaphor, communication between processes can be thought of
--   waiting for and sending <b>protocol data units</b> belonging to some
--   protocol.
newtype Endpoint protocol
Endpoint :: ProcessId -> Endpoint protocol
[_fromEndpoint] :: Endpoint protocol -> ProcessId

-- | Tag a <a>ProcessId</a> with an <a>Pdu</a> type index to mark it a
--   <a>Endpoint</a> process handling that API
proxyAsEndpoint :: proxy protocol -> ProcessId -> Endpoint protocol

-- | Tag a <a>ProcessId</a> with an <a>Pdu</a> type index to mark it a
--   <a>Endpoint</a> process handling that API
asEndpoint :: forall protocol. ProcessId -> Endpoint protocol

-- | Convert an <a>Endpoint</a> to an endpoint for an embedded protocol.
--   
--   See <a>Embeds</a>, <a>fromEmbeddedEndpoint</a>.
toEmbeddedEndpoint :: forall inner outer. Embeds outer inner => Endpoint outer -> Endpoint inner

-- | Convert an <a>Endpoint</a> to an endpoint for a server, that embeds
--   the protocol.
--   
--   See <a>Embeds</a>, <a>toEmbeddedEndpoint</a>.
fromEmbeddedEndpoint :: forall outer inner. HasPduPrism outer inner => Endpoint inner -> Endpoint outer
fromEndpoint :: forall protocol_aTMy protocol_aUUM. Iso (Endpoint protocol_aTMy) (Endpoint protocol_aUUM) ProcessId ProcessId

-- | The reader effect for <a>ProcessId</a>s for <a>Pdu</a>s, see
--   <a>runEndpointReader</a>
type EndpointReader o = Reader (Endpoint o)

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

-- | Send a request <a>Pdu</a> that has no reply and return immediately.
--   
--   The type signature enforces that the corresponding <a>Pdu</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.
--   
--   The message will be reduced to normal form (<tt>rnf</tt>) in the
--   caller process.
cast :: forall destination protocol r q. (HasCallStack, HasProcesses r q, HasPdu destination, HasPdu protocol, Tangible (Pdu destination  'Asynchronous), Embeds destination protocol) => Endpoint destination -> Pdu protocol  'Asynchronous -> Eff r ()

-- | Send a request <a>Pdu</a> and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Pdu</a> clause
--   is <a>Synchronous</a>.
--   
--   <b>Always prefer <a>callWithTimeout</a> over <a>call</a></b>
call :: forall result destination protocol r q. (HasProcesses r q, TangiblePdu destination ( 'Synchronous result), TangiblePdu protocol ( 'Synchronous result), Tangible result, Embeds destination protocol, HasCallStack) => Endpoint destination -> Pdu protocol ( 'Synchronous result) -> Eff r result

-- | Send an request <a>Pdu</a> and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Pdu</a> clause
--   is <a>Synchronous</a>.
--   
--   If the server that was called dies, this function interrupts the
--   process with <a>ProcessDown</a>. If the server takes longer to reply
--   than the given timeout, this function interrupts the process with
--   <a>TimeoutInterrupt</a>.
--   
--   <b>Always prefer this function over <a>call</a></b>
callWithTimeout :: forall result destination protocol r q. (HasProcesses r q, TangiblePdu destination ( 'Synchronous result), TangiblePdu protocol ( 'Synchronous result), Tangible result, Member Logs r, Lifted IO q, Lifted IO r, HasCallStack, Embeds destination protocol) => Endpoint destination -> Pdu protocol ( 'Synchronous result) -> Timeout -> Eff r result

-- | Run a reader effect that contains <b>the one</b> server handling a
--   specific <a>Pdu</a> instance.
runEndpointReader :: HasCallStack => Endpoint o -> Eff (EndpointReader o : r) a -> Eff r a

-- | Get the <a>Endpoint</a> registered with <a>runEndpointReader</a>.
askEndpoint :: Member (EndpointReader o) e => Eff e (Endpoint o)

-- | Like <a>call</a> but take the <a>Endpoint</a> from the reader provided
--   by <a>runEndpointReader</a>.
--   
--   When working with an embedded <a>Pdu</a> use <a>callSingleton</a>.
callEndpointReader :: forall reply o r q. (HasEndpointReader o r, HasCallStack, Tangible reply, TangiblePdu o ( 'Synchronous reply), HasProcesses r q, Embeds o o) => Pdu o ( 'Synchronous reply) -> Eff r reply

-- | Like <a>cast</a> but take the <a>Endpoint</a> from the reader provided
--   by <a>runEndpointReader</a>.
--   
--   When working with an embedded <a>Pdu</a> use <a>castSingleton</a>.
castEndpointReader :: forall o r q. (HasEndpointReader o r, HasProcesses r q, Tangible (Pdu o  'Asynchronous), HasCallStack, HasPdu o, Embeds o o) => Pdu o  'Asynchronous -> Eff r ()

-- | Like <a>callEndpointReader</a>, uses <a>embedPdu</a> to embed the
--   value.
--   
--   This function makes use of AmbigousTypes and TypeApplications.
--   
--   When not working with an embedded <a>Pdu</a> use
--   <a>callEndpointReader</a>.
callSingleton :: forall outer inner reply q e. (HasCallStack, Member (EndpointReader outer) e, Embeds outer inner, Embeds outer outer, HasProcesses e q, TangiblePdu outer ( 'Synchronous reply), TangiblePdu inner ( 'Synchronous reply), Tangible reply) => Pdu inner ( 'Synchronous reply) -> Eff e reply

-- | Like <a>castEndpointReader</a>, but uses <a>embedPdu</a> to embed the
--   value.
--   
--   This function makes use of AmbigousTypes and TypeApplications.
--   
--   When not working with an embedded <a>Pdu</a> use
--   <a>castEndpointReader</a>.
castSingleton :: forall outer inner q e. (HasCallStack, Member (EndpointReader outer) e, Tangible (Pdu outer  'Asynchronous), HasProcesses e q, HasPdu outer, HasPdu inner, Embeds outer inner, Embeds outer outer) => Pdu inner  'Asynchronous -> Eff e ()

-- | Target of a <a>Call</a> reply.
--   
--   This combines a <a>RequestOrigin</a> with a <a>Serializer</a> for a
--   <a>Reply</a> using <a>Arg</a>. There are to smart constructors for
--   this type: <a>replyTarget</a> and <a>embeddedReplyTarget</a>.
--   
--   Because of <a>Arg</a> the <a>Eq</a> and <a>Ord</a> instances are
--   implemented via the <a>RequestOrigin</a> instances.
newtype ReplyTarget p r
MkReplyTarget :: Arg (RequestOrigin p r) (Serializer (Reply p r)) -> ReplyTarget p r

-- | Wraps the source <a>ProcessId</a> and a unique identifier for a
--   <a>Call</a>.
data RequestOrigin (proto :: Type) reply
RequestOrigin :: !ProcessId -> !Int -> RequestOrigin reply
[_requestOriginPid] :: RequestOrigin reply -> !ProcessId
[_requestOriginCallRef] :: RequestOrigin reply -> !Int

-- | The wrapper around replies to <a>Call</a>s.
data Reply protocol reply
[Reply] :: Tangible reply => {_replyTo :: RequestOrigin protocol reply, _replyValue :: reply} -> Reply protocol reply

-- | A wrapper sum type for calls and casts for the <a>Pdu</a>s of a
--   protocol
data Request protocol
[Call] :: forall protocol reply. (Tangible reply, TangiblePdu protocol ( 'Synchronous reply)) => RequestOrigin protocol reply -> Pdu protocol ( 'Synchronous reply) -> Request protocol
[Cast] :: forall protocol. (TangiblePdu protocol  'Asynchronous, NFData (Pdu protocol  'Asynchronous)) => Pdu protocol  'Asynchronous -> Request protocol

-- | Create a new, unique <a>RequestOrigin</a> value for the current
--   process.
makeRequestOrigin :: (Typeable r, NFData r, HasProcesses e q0) => Eff e (RequestOrigin p r)

-- | Turn an <a>RequestOrigin</a> to an origin for an embedded request (See
--   <a>Embeds</a>).
--   
--   This is useful of a server delegates the <tt>calls</tt> and
--   <tt>casts</tt> for an embedded protocol to functions, that require the
--   <a>Serializer</a> and <a>RequestOrigin</a> in order to call
--   <a>sendReply</a>.
--   
--   See also <a>embedReplySerializer</a>.
toEmbeddedOrigin :: forall outer inner reply. Embeds outer inner => RequestOrigin outer reply -> RequestOrigin inner reply

-- | Turn an <i>embedded</i> <a>RequestOrigin</a> to a <a>RequestOrigin</a>
--   for the <i>bigger</i> request.
--   
--   This is the inverse of <a>toEmbeddedOrigin</a>.
--   
--   This function is strict in all parameters.
embedRequestOrigin :: forall outer inner reply. Embeds outer inner => RequestOrigin inner reply -> RequestOrigin outer reply

-- | Turn a <a>Serializer</a> for a <a>Pdu</a> instance that contains
--   embedded <a>Pdu</a> values into a <a>Reply</a> <a>Serializer</a> for
--   the embedded <a>Pdu</a>.
--   
--   This is useful of a server delegates the <tt>calls</tt> and
--   <tt>casts</tt> for an embedded protocol to functions, that require the
--   <a>Serializer</a> and <a>RequestOrigin</a> in order to call
--   <a>sendReply</a>.
--   
--   See also <a>toEmbeddedOrigin</a>.
embedReplySerializer :: forall outer inner reply. Embeds outer inner => Serializer (Reply outer reply) -> Serializer (Reply inner reply)

-- | Answer a <a>Call</a> by sending the reply value to the client process.
--   
--   The <a>ProcessId</a>, the <a>RequestOrigin</a> and the <a>Reply</a>
--   <a>Serializer</a> are stored in the <a>ReplyTarget</a>.
sendReply :: (HasProcesses eff q, Tangible reply, Typeable protocol) => ReplyTarget protocol reply -> reply -> Eff eff ()

-- | Smart constructor for a <a>ReplyTarget</a>.
--   
--   To build a <tt>ReplyTarget</tt> for an <a>Embeds</a> instance use
--   <a>embeddedReplyTarget</a>.
replyTarget :: Serializer (Reply p reply) -> RequestOrigin p reply -> ReplyTarget p reply

-- | A simple <a>Lens</a> for the <a>RequestOrigin</a> of a
--   <a>ReplyTarget</a>.
replyTargetOrigin :: Lens' (ReplyTarget p reply) (RequestOrigin p reply)

-- | A simple <a>Lens</a> for the <a>Reply</a> <a>Serializer</a> of a
--   <a>ReplyTarget</a>.
replyTargetSerializer :: Lens' (ReplyTarget p reply) (Serializer (Reply p reply))

-- | Smart constructor for an <i>embedded</i> <a>ReplyTarget</a>.
--   
--   This combines <a>replyTarget</a> and <a>toEmbeddedReplyTarget</a>.
embeddedReplyTarget :: Embeds outer inner => Serializer (Reply outer reply) -> RequestOrigin outer reply -> ReplyTarget inner reply

-- | Convert a <a>ReplyTarget</a> to be usable for <i>embedded</i> replies.
--   
--   This combines a <a>toEmbeddedOrigin</a> with
--   <a>embedReplySerializer</a> to produce a <a>ReplyTarget</a> that can
--   be passed to functions defined soley on an embedded protocol.
toEmbeddedReplyTarget :: Embeds outer inner => ReplyTarget outer reply -> ReplyTarget inner reply

-- | The <b>protocol data unit</b> type for the given protocol.
data family Pdu protocol (reply :: Synchronicity)

-- | Alias for the effect that contains the observers managed by
--   <a>evalObserverRegistryState</a>
type ObserverRegistryState event = State (ObserverRegistry event)

-- | A protocol for managing <a>Observer</a>s, encompassing registration
--   and de-registration of <a>Observer</a>s.
data ObserverRegistry (event :: Type)
MkObserverRegistry :: Map ProcessId (ObservationSink event) -> ObserverRegistry
[_observerRegistry] :: ObserverRegistry -> Map ProcessId (ObservationSink event)

-- | Convenience type alias.
type CanObserve eventSink event = (Tangible event, Embeds eventSink (Observer event), HasPdu eventSink)

-- | Convenience type alias.
type IsObservable eventSource event = (Tangible event, Embeds eventSource (ObserverRegistry event), HasPdu eventSource)

-- | The Information necessary to wrap an <a>Observed</a> event to a
--   process specific message, e.g. the embedded <a>Observer</a> <a>Pdu</a>
--   instance, and the <a>MonitorReference</a> of the destination process.
data ObservationSink event

-- | A <i>protocol</i> to communicate <a>Observed</a> events from a sources
--   to many sinks.
--   
--   A sink is any process that serves a protocol with a <a>Pdu</a>
--   instance that embeds the <a>Observer</a> Pdu via an <a>HasPduPrism</a>
--   instance.
--   
--   This type has <i>dual use</i>, for one it serves as type-index for
--   <a>Pdu</a>, i.e. <a>HasPdu</a> respectively, and secondly it contains
--   an <a>ObservationSink</a> and a <a>MonitorReference</a>.
--   
--   The <a>ObservationSink</a> is used to serialize and send the
--   <a>Observed</a> events, while the <a>ProcessId</a> serves as key for
--   internal maps.
newtype Observer event
MkObserver :: Arg ProcessId (ObservationSink event) -> Observer event

-- | And an <a>Observer</a> to the set of recipients for all observations
--   reported by <a>observerRegistryNotify</a>. Note that the
--   observerRegistry are keyed by the observing process, i.e. a previous
--   entry for the process contained in the <a>Observer</a> is overwritten.
--   If you want multiple entries for a single process, just combine
--   several filter functions.
registerObserver :: forall event eventSink eventSource r q. (HasCallStack, HasProcesses r q, IsObservable eventSource event, Tangible (Pdu eventSource  'Asynchronous), Tangible (Pdu eventSink  'Asynchronous), CanObserve eventSink event) => Endpoint eventSource -> Endpoint eventSink -> Eff r ()

-- | Send the <a>ForgetObserver</a> message
forgetObserver :: forall event eventSink eventSource r q. (HasProcesses r q, HasCallStack, Tangible (Pdu eventSource  'Asynchronous), Tangible (Pdu eventSink  'Asynchronous), IsObservable eventSource event, CanObserve eventSink event) => Endpoint eventSource -> Endpoint eventSink -> Eff r ()

-- | Send the <a>ForgetObserver</a> message, use a raw <a>ProcessId</a> as
--   parameter.
forgetObserverUnsafe :: forall event eventSource r q. (HasProcesses r q, HasCallStack, Tangible (Pdu eventSource  'Asynchronous), IsObservable eventSource event) => Endpoint eventSource -> ProcessId -> Eff r ()

-- | Provide the implementation for the <a>ObserverRegistry</a> Protocol,
--   this handled <a>RegisterObserver</a> and <a>ForgetObserver</a>
--   messages. It also adds the <a>ObserverRegistryState</a> constraint to
--   the effect list.
observerRegistryHandlePdu :: forall event q r. (HasCallStack, Typeable event, HasProcesses r q, Member (ObserverRegistryState event) r, Member Logs r) => Pdu (ObserverRegistry event)  'Asynchronous -> Eff r ()

-- | Remove the entry in the <a>ObserverRegistry</a> for the
--   <a>ProcessId</a> and return <a>True</a> if there was an entry,
--   <a>False</a> otherwise.
observerRegistryRemoveProcess :: forall event q r. (HasCallStack, Typeable event, HasProcesses r q, Member (ObserverRegistryState event) r, Member Logs r) => ProcessId -> Eff r Bool

-- | Keep track of registered <a>Observer</a>s.
--   
--   Handle the <a>ObserverRegistryState</a> effect, i.e. run
--   <a>evalState</a> on an <a>emptyObserverRegistry</a>.
evalObserverRegistryState :: HasCallStack => Eff (ObserverRegistryState event : r) a -> Eff r a

-- | The empty <a>ObserverRegistryState</a>
emptyObserverRegistry :: ObserverRegistry event

-- | Report an observation to all observers. The process needs to
--   <a>evalObserverRegistryState</a> and to
--   <a>observerRegistryHandlePdu</a>.
observerRegistryNotify :: forall event r q. (HasProcesses r q, Member (ObserverRegistryState event) r, Tangible event, HasCallStack) => event -> Eff r ()


-- | Concurrent, communicating processes, executed using a single-threaded
--   scheduler, with support for <a>IO</a> and <a>Logs</a>.
--   
--   This module re-exports most of the library.
--   
--   There are several <i>scheduler</i> implementations to choose from.
--   
--   This module re-exports the impure parts of
--   <a>Control.Eff.Concurrent.Process.SingleThreadedScheduler</a>.
--   
--   To use another scheduler implementation, don't import this module, but
--   instead import one of:
--   
--   <ul>
--   <li><a>Control.Eff.Concurrent</a></li>
--   <li><a>Control.Eff.Concurrent.Pure</a></li>
--   </ul>
module Control.Eff.Concurrent.SingleThreaded

-- | An rfc 5424 facility
newtype Facility
Facility :: Int -> Facility
[fromFacility] :: Facility -> Int

-- | An rfc 5424 severity
data Severity

-- | Component of an RFC-5424 <a>StructuredDataElement</a>
data SdParameter
MkSdParameter :: !Text -> !Text -> SdParameter

-- | RFC-5424 defines how structured data can be included in a log message.
data StructuredDataElement
SdElement :: !Text -> ![SdParameter] -> StructuredDataElement
[_sdElementId] :: StructuredDataElement -> !Text
[_sdElementParameters] :: StructuredDataElement -> ![SdParameter]

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

-- | Smart constructor for the RFC-5424 <b>emergency</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>0</b>. See
--   <a>lmSeverity</a>.
emergencySeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>alert</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>1</b>. See
--   <a>lmSeverity</a>.
alertSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>critical</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>2</b>. See
--   <a>lmSeverity</a>.
criticalSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>error</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>3</b>. See
--   <a>lmSeverity</a>.
errorSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>warning</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>4</b>. See
--   <a>lmSeverity</a>.
warningSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>notice</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>5</b>. See
--   <a>lmSeverity</a>.
noticeSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>informational</b>
--   <a>LogMessage</a> <a>Severity</a>. This corresponds to the severity
--   value <b>6</b>. See <a>lmSeverity</a>.
informationalSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>debug</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>7</b>. See
--   <a>lmSeverity</a>.
debugSeverity :: Severity

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>kernelMessages</tt>. See <a>lmFacility</a>.
kernelMessages :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>userLevelMessages</tt>. See <a>lmFacility</a>.
userLevelMessages :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>mailSystem</tt>. See <a>lmFacility</a>.
mailSystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>systemDaemons</tt>. See <a>lmFacility</a>.
systemDaemons :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>securityAuthorizationMessages4</tt>. See <a>lmFacility</a>.
securityAuthorizationMessages4 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>linePrinterSubsystem</tt>. See <a>lmFacility</a>.
linePrinterSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>networkNewsSubsystem</tt>. See <a>lmFacility</a>.
networkNewsSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>uucpSubsystem</tt>. See <a>lmFacility</a>.
uucpSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>clockDaemon</tt>. See <a>lmFacility</a>.
clockDaemon :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>securityAuthorizationMessages10</tt>. See <a>lmFacility</a>.
securityAuthorizationMessages10 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>ftpDaemon</tt>. See <a>lmFacility</a>.
ftpDaemon :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>ntpSubsystem</tt>. See <a>lmFacility</a>.
ntpSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>logAuditFacility</tt>. See <a>lmFacility</a>.
logAuditFacility :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>logAlertFacility</tt>. See <a>lmFacility</a>.
logAlertFacility :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>clockDaemon2</tt>. See <a>lmFacility</a>.
clockDaemon2 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local0</tt>. See <a>lmFacility</a>.
local0 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local1</tt>. See <a>lmFacility</a>.
local1 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local2</tt>. See <a>lmFacility</a>.
local2 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local3</tt>. See <a>lmFacility</a>.
local3 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local4</tt>. See <a>lmFacility</a>.
local4 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local5</tt>. See <a>lmFacility</a>.
local5 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local6</tt>. See <a>lmFacility</a>.
local6 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local7</tt>. See <a>lmFacility</a>.
local7 :: Facility

-- | A lens for the key or ID of a group of RFC 5424 key-value pairs.
sdElementId :: Functor f => (Text -> f Text) -> StructuredDataElement -> f StructuredDataElement

-- | A lens for <a>SdParameter</a>s
sdElementParameters :: Functor f => ([SdParameter] -> f [SdParameter]) -> StructuredDataElement -> f StructuredDataElement

-- | The filter predicate for message that shall be logged.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
type LogPredicate = LogMessage -> Bool

-- | Things that can become a <a>LogMessage</a>
class ToLogMessage a

-- | Convert the value to a <a>LogMessage</a>
toLogMessage :: ToLogMessage a => a -> LogMessage

-- | A lens for the RFC 5424 <i>application</i> name of a <a>LogMessage</a>
--   
--   One useful pattern for using this field, is to implement log filters
--   that allow info and debug message from the application itself while
--   only allowing warning and error messages from third party libraries:
--   
--   <pre>
--   debugLogsForAppName myAppName lm =
--     view lmAppName lm == Just myAppName || lmSeverityIsAtLeast warningSeverity lm
--   </pre>
--   
--   This concept is also implemented in <a>discriminateByAppName</a>.
lmAppName :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for the <a>Facility</a> of a <a>LogMessage</a>
lmFacility :: Functor f => (Facility -> f Facility) -> LogMessage -> f LogMessage

-- | A lens for the hostname of a <a>LogMessage</a> The function
--   <a>setLogMessageHostname</a> can be used to set the field.
lmHostname :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for the user defined textual message of a <a>LogMessage</a>
lmMessage :: Functor f => (Text -> f Text) -> LogMessage -> f LogMessage

-- | A lens for a user defined <i>message id</i> of a <a>LogMessage</a>
lmMessageId :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for a user defined of <i>process</i> id of a <a>LogMessage</a>
lmProcessId :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for the <a>Severity</a> of a <a>LogMessage</a>
lmSeverity :: Functor f => (Severity -> f Severity) -> LogMessage -> f LogMessage

-- | A lens for the <a>SrcLoc</a> of a <a>LogMessage</a>
lmSrcLoc :: Functor f => (Maybe SrcLoc -> f (Maybe SrcLoc)) -> LogMessage -> f LogMessage

-- | A lens for the <a>StructuredDataElement</a> of a <a>LogMessage</a>
lmStructuredData :: Functor f => ([StructuredDataElement] -> f [StructuredDataElement]) -> LogMessage -> f LogMessage

-- | A lens for the <a>ThreadId</a> of a <a>LogMessage</a> The function
--   <a>setLogMessageThreadId</a> can be used to set the field.
lmThreadId :: Functor f => (Maybe ThreadId -> f (Maybe ThreadId)) -> LogMessage -> f LogMessage

-- | A lens for the UTC time of a <a>LogMessage</a> The function
--   <a>setLogMessageTimestamp</a> can be used to set the field.
lmTimestamp :: Functor f => (Maybe UTCTime -> f (Maybe UTCTime)) -> LogMessage -> f LogMessage

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

-- | Prefix the <a>lmMessage</a>.
prefixLogMessagesWith :: Text -> LogMessage -> LogMessage

-- | An IO action that sets the current UTC time in <a>lmTimestamp</a>.
setLogMessageTimestamp :: LogMessage -> IO LogMessage

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

-- | An IO action that sets the current hosts fully qualified hostname in
--   <a>lmHostname</a>.
setLogMessageHostname :: LogMessage -> IO LogMessage

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

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

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

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

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

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

-- | All messages.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
allLogMessages :: LogPredicate

-- | No messages.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
noLogMessages :: LogPredicate

-- | Match <a>LogMessage</a>s that have exactly the given severity. See
--   <a>lmSeverityIsAtLeast</a>.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
lmSeverityIs :: Severity -> LogPredicate

-- | Match <a>LogMessage</a>s that have the given severity <b>or worse</b>.
--   See <a>lmSeverityIs</a>.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
lmSeverityIsAtLeast :: Severity -> LogPredicate

-- | Match <a>LogMessage</a>s whose <a>lmMessage</a> starts with the given
--   string.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
lmMessageStartsWith :: Text -> LogPredicate

-- | Apply a <a>LogPredicate</a> based on the <a>lmAppName</a> and delegate
--   to one of two <a>LogPredicate</a>s.
--   
--   One useful application for this is to allow info and debug message
--   from one application, e.g. the current application itself, while at
--   the same time allowing only warning and error messages from third
--   party libraries.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
discriminateByAppName :: Text -> LogPredicate -> LogPredicate -> LogPredicate

-- | A rendering function for the <a>lmTimestamp</a> field.
data LogMessageTimeRenderer

-- | <a>LogMessage</a> rendering function
type LogMessageRenderer a = LogMessage -> a

-- | Make a <a>LogMessageTimeRenderer</a> using <a>formatTime</a> in the
--   <tt>defaultLocale</tt>.
mkLogMessageTimeRenderer :: String -> LogMessageTimeRenderer

-- | Don't render the time stamp
suppressTimestamp :: LogMessageTimeRenderer

-- | Render the time stamp using <tt>"%h %d %H:%M:%S"</tt>
rfc3164Timestamp :: LogMessageTimeRenderer

-- | Render the time stamp to <tt><a>iso8601DateFormat</a> (Just
--   "%H:%M:%S%6QZ")</tt>
rfc5424Timestamp :: LogMessageTimeRenderer

-- | Render the time stamp like <a>rfc5424Timestamp</a> does, but omit the
--   terminal <tt>Z</tt> character.
rfc5424NoZTimestamp :: LogMessageTimeRenderer

-- | Print the thread id, the message and the source file location,
--   seperated by simple white space.
renderLogMessageBody :: LogMessageRenderer Text

-- | Print the thread id, the message and the source file location,
--   seperated by simple white space.
renderLogMessageBodyNoLocation :: LogMessageRenderer Text

-- | Print the <i>body</i> of a <a>LogMessage</a> with fix size fields (60)
--   for the message itself and 30 characters for the location
renderLogMessageBodyFixWidth :: LogMessageRenderer Text

-- | Render a field of a <a>LogMessage</a> using the corresponsing lens.
renderMaybeLogMessageLens :: Text -> Getter LogMessage (Maybe Text) -> LogMessageRenderer Text

-- | Render the source location as: <tt>at filepath:linenumber</tt>.
renderLogMessageSrcLoc :: LogMessageRenderer (Maybe Text)

-- | Render the severity and facility as described in RFC-3164
--   
--   Render e.g. as <tt>&lt;192&gt;</tt>.
--   
--   Useful as header for syslog compatible log output.
renderSyslogSeverityAndFacility :: LogMessageRenderer Text

-- | Render the <a>LogMessage</a> to contain the severity, message,
--   message-id, pid.
--   
--   Omit hostname, PID and timestamp.
--   
--   Render the header using <tt>renderSyslogSeverity</tt>
--   
--   Useful for logging to <tt><i>dev</i>log</tt>
renderLogMessageSyslog :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> human readable, for console logging
renderLogMessageConsoleLog :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-3164.
renderRFC3164 :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-3164 but
--   use RFC5424 time stamps.
renderRFC3164WithRFC5424Timestamps :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-3164 but
--   use the custom <a>LogMessageTimeRenderer</a>.
renderRFC3164WithTimestamp :: LogMessageTimeRenderer -> LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-5424.
--   
--   Equivalent to <tt><a>renderRFC5424Header</a> &lt;&gt; const " "
--   &lt;&gt; <a>renderLogMessageBody</a></tt>.
renderRFC5424 :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-5424,
--   like <a>renderRFC5424</a> but suppress the source location
--   information.
--   
--   Equivalent to <tt><a>renderRFC5424Header</a> &lt;&gt; const " "
--   &lt;&gt; <a>renderLogMessageBodyNoLocation</a></tt>.
renderRFC5424NoLocation :: LogMessageRenderer Text

-- | Render the header and strucuted data of a <a>LogMessage</a> according
--   to the rules in the RFC-5424, but do not render the <a>lmMessage</a>.
renderRFC5424Header :: LogMessageRenderer Text

-- | The instances of this class are the monads that define (side-)
--   effect(s) of writting logs.
class HandleLogWriter (writer :: Type -> Type) where {
    
    -- | The <a>Eff</a>ects required by the <a>handleLogWriterEffect</a>
    --   method.
    data family LogWriterM writer a;
}

-- | Run the side effect of a <a>LogWriter</a> in a compatible <a>Eff</a>.
handleLogWriterEffect :: (HandleLogWriter writer, Member writer e) => LogWriterM writer () -> Eff e ()

-- | Write a message using the <a>LogWriter</a> found in the environment.
--   
--   The semantics of this function are a combination of
--   <a>runLogWriter</a> and <a>handleLogWriterEffect</a>, with the
--   <a>LogWriter</a> read from a <a>LogWriterReader</a>.
liftWriteLogMessage :: (HandleLogWriter writer, SetMember LogWriterReader (LogWriterReader writer) e, Member writer e) => LogMessage -> Eff e ()

-- | A Reader specialized for <a>LogWriter</a>s
--   
--   The existing <tt>Reader</tt> couldn't be used together with
--   <a>SetMember</a>, so this lazy reader was written, specialized to
--   reading <a>LogWriter</a>.
data LogWriterReader h v

-- | A function that takes a log message and returns an effect that
--   <i>logs</i> the message.
newtype LogWriter writerM
MkLogWriter :: (LogMessage -> LogWriterM writerM ()) -> LogWriter writerM
[runLogWriter] :: LogWriter writerM -> LogMessage -> LogWriterM writerM ()

-- | Provide the <a>LogWriter</a>
--   
--   Exposed for custom extensions, if in doubt use <tt>withLogging</tt>.
runLogWriterReader :: LogWriter h -> Eff (LogWriterReader h : e) a -> Eff e a

-- | Get the current <a>LogWriter</a>.
askLogWriter :: SetMember LogWriterReader (LogWriterReader h) e => Eff e (LogWriter h)

-- | Modify the current <a>LogWriter</a>.
localLogWriterReader :: forall h e a. SetMember LogWriterReader (LogWriterReader h) e => (LogWriter h -> LogWriter h) -> Eff e a -> Eff e a

-- | This <a>LogWriter</a> will discard all messages.
--   
--   NOTE: This is just an alias for <a>def</a>
noOpLogWriter :: Applicative (LogWriterM m) => LogWriter m

-- | A <a>LogWriter</a> that applies a predicate to the <a>LogMessage</a>
--   and delegates to to the given writer of the predicate is satisfied.
filteringLogWriter :: Monad (LogWriterM e) => LogPredicate -> LogWriter e -> LogWriter e

-- | A <a>LogWriter</a> that applies a function to the <a>LogMessage</a>
--   and delegates the result to to the given writer.
mappingLogWriter :: (LogMessage -> LogMessage) -> LogWriter e -> LogWriter e

-- | Like <a>mappingLogWriter</a> allow the function that changes the
--   <a>LogMessage</a> to have effects.
mappingLogWriterM :: Monad (LogWriterM e) => (LogMessage -> LogWriterM e LogMessage) -> LogWriter e -> LogWriter e

-- | A constraint that required <tt><a>LogsTo</a> <a>IO</a> e</tt> and
--   <tt><a>Lifted</a> <a>IO</a> e</tt>.
type LogIo e = (LogsTo (Lift IO) e, Lifted IO e)

-- | A constraint alias for effects that requires a <a>LogWriterReader</a>,
--   as well as that the contained <a>LogWriterReader</a> has a
--   <a>HandleLogWriter</a> instance.
--   
--   The requirements of this constraint are provided by:
--   
--   <ul>
--   <li><tt>withIoLogging</tt></li>
--   <li><a>withLogging</a></li>
--   <li><a>withSomeLogging</a></li>
--   </ul>
type LogsTo h e = (Member Logs e, HandleLogWriter h, Member h e, SetMember LogWriterReader (LogWriterReader h) e)

-- | This effect sends <a>LogMessage</a>s and is a reader for a
--   <a>LogPredicate</a>.
--   
--   Logs are sent via <a>logMsg</a>; for more information about log
--   predicates, see <a>Control.Eff.Log#LogPredicate</a>
--   
--   This effect is handled via <a>withLogging</a>.
data Logs v

-- | Handle the <a>Logs</a> and <a>LogWriterReader</a> effects.
--   
--   It installs the given <a>LogWriter</a>, which determines the
--   underlying <a>LogWriter</a> type parameter.
--   
--   Example:
--   
--   <pre>
--   exampleWithLogging :: IO ()
--   exampleWithLogging =
--       runLift
--     $ withLogging consoleLogWriter
--     $ logDebug "Oh, hi there"
--   </pre>
withLogging :: forall h e a. (Applicative (LogWriterM h), LogsTo h (Logs : (LogWriterReader h : e))) => LogWriter h -> Eff (Logs : (LogWriterReader h : e)) a -> Eff e a

-- | Handles the <a>Logs</a> and <a>LogWriterReader</a> effects.
--   
--   By default it uses the <a>noOpLogWriter</a>, but using
--   <a>setLogWriter</a> the <a>LogWriter</a> can be replaced.
--   
--   This is like <a>withLogging</a> applied to <a>noOpLogWriter</a>
--   
--   Example:
--   
--   <pre>
--   exampleWithSomeLogging :: ()
--   exampleWithSomeLogging =
--       run
--     $ withSomeLogging @PureLogWriter
--     $ logDebug "Oh, hi there"
--   </pre>
withSomeLogging :: forall h e a. (Applicative (LogWriterM h), LogsTo h (Logs : (LogWriterReader h : e))) => Eff (Logs : (LogWriterReader h : e)) a -> Eff e a

-- | Raw handling of the <a>Logs</a> effect. Exposed for custom extensions,
--   if in doubt use <a>withLogging</a>.
runLogs :: forall h e b. LogsTo h (Logs : e) => LogPredicate -> Eff (Logs : e) b -> Eff e b

-- | Log a message.
--   
--   All logging goes through this function.
--   
--   This function is the only place where the <a>LogPredicate</a> is
--   applied.
--   
--   Also, <a>LogMessage</a>s are evaluated using <a>deepseq</a>,
--   <b>after</b> they pass the <a>LogPredicate</a>.
logMsg :: forall e. (HasCallStack, Member Logs e) => LogMessage -> Eff e ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Get the current <a>Logs</a> filter/transformer function.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
askLogPredicate :: forall e. Member Logs e => Eff e LogPredicate

-- | Keep only those messages, for which a predicate holds.
--   
--   E.g. to keep only messages which begin with <tt><a>OMG</a></tt>:
--   
--   <pre>
--   exampleLogPredicate :: IO Int
--   exampleLogPredicate =
--       runLift
--     $ withLogging consoleLogWriter
--     $ do logMsg "test"
--          setLogPredicate (\ msg -&gt; case view lmMessage msg of
--                                     'O':'M':'G':_ -&gt; True
--                                     _             -&gt; False)
--                            (do logMsg "this message will not be logged"
--                                logMsg "OMG logged"
--                                return 42)
--   </pre>
--   
--   In order to also delegate to the previous predicate, use
--   <a>modifyLogPredicate</a>
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
setLogPredicate :: forall r b. (Member Logs r, HasCallStack) => LogPredicate -> Eff r b -> Eff r b

-- | Change the <a>LogPredicate</a>.
--   
--   Other than <a>setLogPredicate</a> this function allows to include the
--   previous predicate, too.
--   
--   For to discard all messages currently no satisfying the predicate and
--   also all messages that are to long:
--   
--   <pre>
--   modifyLogPredicate (previousPredicate msg -&gt; previousPredicate msg &amp;&amp; length (lmMessage msg) &lt; 29 )
--                      (do logMsg "this message will not be logged"
--                          logMsg "this message might be logged")
--   </pre>
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
modifyLogPredicate :: forall e b. (Member Logs e, HasCallStack) => (LogPredicate -> LogPredicate) -> Eff e b -> Eff e b

-- | Include <a>LogMessage</a>s that match a <a>LogPredicate</a>.
--   
--   <tt>excludeLogMessages p</tt> allows log message to be logged if <tt>p
--   m</tt>
--   
--   Although it is enough if the previous predicate holds. See
--   <a>excludeLogMessages</a> and <a>modifyLogPredicate</a>.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
includeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a

-- | Exclude <a>LogMessage</a>s that match a <a>LogPredicate</a>.
--   
--   <tt>excludeLogMessages p</tt> discards logs if <tt>p m</tt>
--   
--   Also the previous predicate must also hold for a message to be logged.
--   See <a>excludeLogMessages</a> and <a>modifyLogPredicate</a>.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
excludeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a

-- | Consume log messages.
--   
--   Exposed for custom extensions, if in doubt use <a>withLogging</a>.
--   
--   Respond to all <a>LogMessage</a>s logged from the given action, up to
--   any <a>MonadBaseControl</a> liftings.
--   
--   Note that all logging is done through <a>logMsg</a> and that means
--   only messages passing the <a>LogPredicate</a> are received.
--   
--   The <a>LogMessage</a>s are <b>consumed</b> once they are passed to the
--   given callback function, previous <a>respondToLogMessage</a>
--   invocations further up in the call stack will not get the messages
--   anymore.
--   
--   Use <a>interceptLogMessages</a> if the messages shall be passed any
--   previous handler.
--   
--   NOTE: The effects of this function are <b>lost</b> when using
--   <a>MonadBaseControl</a>, <a>MonadMask</a>, <a>MonadCatch</a> and
--   <a>MonadThrow</a>.
--   
--   In contrast the functions based on modifying the <a>LogWriter</a>,
--   such as <a>addLogWriter</a> or <a>censorLogs</a>, are save to use in
--   combination with the aforementioned liftings.
respondToLogMessage :: forall r b. Member Logs r => (LogMessage -> Eff r ()) -> Eff r b -> Eff r b

-- | Change the <a>LogMessage</a>s using an effectful function.
--   
--   Exposed for custom extensions, if in doubt use <a>withLogging</a>.
--   
--   This differs from <a>respondToLogMessage</a> in that the intercepted
--   messages will be written either way, albeit in altered form.
--   
--   NOTE: The effects of this function are <b>lost</b> when using
--   <a>MonadBaseControl</a>, <a>MonadMask</a>, <a>MonadCatch</a> and
--   <a>MonadThrow</a>.
--   
--   In contrast the functions based on modifying the <a>LogWriter</a>,
--   such as <a>addLogWriter</a> or <a>censorLogs</a>, are save to use in
--   combination with the aforementioned liftings.
interceptLogMessages :: forall r b. Member Logs r => (LogMessage -> Eff r LogMessage) -> Eff r b -> Eff r b

-- | Change the current <a>LogWriter</a>.
modifyLogWriter :: forall h e a. LogsTo h e => (LogWriter h -> LogWriter h) -> Eff e a -> Eff e a

-- | Replace the current <a>LogWriter</a>. To add an additional log message
--   consumer use <a>addLogWriter</a>
setLogWriter :: forall h e a. LogsTo h e => LogWriter h -> Eff e a -> Eff e a

-- | Modify the the <a>LogMessage</a>s written in the given sub-expression.
--   
--   Note: This is equivalent to <tt><a>modifyLogWriter</a> .
--   <a>mappingLogWriter</a></tt>
censorLogs :: LogsTo h e => (LogMessage -> LogMessage) -> Eff e a -> Eff e a

-- | Modify the the <a>LogMessage</a>s written in the given sub-expression,
--   as in <a>censorLogs</a> but with a effectful function.
--   
--   Note: This is equivalent to <tt><a>modifyLogWriter</a> .
--   <a>mappingLogWriterM</a></tt>
censorLogsM :: (LogsTo h e, Monad (LogWriterM h)) => (LogMessage -> LogWriterM h LogMessage) -> Eff e a -> Eff e a

-- | Combine the effects of a given <a>LogWriter</a> and the existing one.
--   
--   <pre>
--   import Data.Text    as T
--   import Data.Text.IO as T
--   
--   exampleAddLogWriter :: IO ()
--   exampleAddLogWriter = go &gt;&gt;= T.putStrLn
--    where go = fmap (unlines . map renderLogMessageConsoleLog . snd)
--                 $  runLift
--                 $  runCaptureLogWriter
--                 $  withLogging captureLogWriter
--                 $  addLogWriter (mappingLogWriter (lmMessage %~ ("CAPTURED "++)) captureLogWriter)
--                 $  addLogWriter (filteringLogWriter severeMessages (mappingLogWriter (lmMessage %~ ("TRACED "++)) debugTraceLogWriter))
--                 $  do
--                       logEmergency "test emergencySeverity 1"
--                       logCritical "test criticalSeverity 2"
--                       logAlert "test alertSeverity 3"
--                       logError "test errorSeverity 4"
--                       logWarning "test warningSeverity 5"
--                       logInfo "test informationalSeverity 6"
--                       logDebug "test debugSeverity 7"
--          severeMessages = view (lmSeverity . to (&lt;= errorSeverity))
--   </pre>
addLogWriter :: forall h e a. (HasCallStack, LogsTo h e, Monad (LogWriterM h)) => LogWriter h -> Eff e a -> Eff e a

-- | 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 died.
data ProcessDown
ProcessDown :: !MonitorReference -> !SomeExitReason -> !ProcessId -> ProcessDown
[downReference] :: ProcessDown -> !MonitorReference
[downReason] :: ProcessDown -> !SomeExitReason
[downProcess] :: ProcessDown -> !ProcessId

-- | 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>Interrupt</a>
data SomeExitReason
[SomeExitReason] :: Interrupt x -> SomeExitReason

-- | <a>Exc</a>eptions containing <a>Interrupt</a>s. See
--   <a>handleInterrupts</a>, <a>exitOnInterrupt</a> or
--   <a>provideInterrupts</a>
type Interrupts = Exc (Interrupt  'Recoverable)

-- | A constraint for an effect set that requires the presence of
--   <a>SafeProcesses</a>.
--   
--   This constrains the effect list to look like this: <tt>[e1 ... eN,
--   <a>Process</a> [e(N+1) .. e(N+k)], e(N+1) .. e(N+k)]</tt>
--   
--   It contrains <tt>e</tt> to support the (only) <a>Process</a> effect.
--   
--   This is more relaxed that <a>HasProcesses</a> since it does not
--   require <a>Interrupts</a>.
type HasSafeProcesses e inner = (SetMember Process (Process inner) e)

-- | <i>Cons</i> <a>Process</a> onto a list of effects. This is called
--   <tt>SafeProcesses</tt> because the the actions cannot be interrupted
--   in.
type SafeProcesses r = Process r : r

-- | A constraint for an effect set that requires the presence of
--   <a>Processes</a>.
--   
--   This constrains the effect list to look like this: <tt>[e1 ... eN,
--   <a>Interrupts</a>, <a>Process</a> [e(N+1) .. e(N+k)], e(N+1) ..
--   e(N+k)]</tt>
--   
--   It contrains <tt>e</tt> beyond <a>HasSafeProcesses</a> to encompass
--   <a>Interrupts</a>.
type HasProcesses e inner = (HasSafeProcesses e inner, Member Interrupts e)

-- | This adds a layer of the <a>Interrupts</a> effect on top of
--   <a>Processes</a>
type Processes e = Interrupts : SafeProcesses e

-- | <a>Interrupt</a>s which are <a>Recoverable</a>.
type RecoverableInterrupt = Interrupt  'Recoverable

-- | A sum-type with reasons for why a process operation, such as receiving
--   messages, is interrupted in the scheduling loop.
--   
--   This includes errors, that can occur when scheduling messages.
data Interrupt (t :: ExitRecovery)

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

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

-- | A <a>Recoverable</a> timeout has occurred.
[TimeoutInterrupt] :: String -> Interrupt  'Recoverable

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

-- | An exit reason that has an error message and is <a>Recoverable</a>.
[ErrorInterrupt] :: String -> Interrupt  'Recoverable

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

-- | An error causes the process to exit immediately. For example an
--   unexpected runtime exception was thrown, i.e. an exception derived
--   from <a>SomeException</a> Or a <a>Recoverable</a> Interrupt was not
--   recovered.
[ExitUnhandledError] :: Text -> Interrupt  'NoRecovery

-- | A process shall exit immediately, without any cleanup was cancelled
--   (e.g. killed, in <a>cancel</a>)
[ExitProcessCancelled] :: Interrupt  'NoRecovery

-- | This value indicates whether 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>Interrupt</a> can be treated
--   like a short interrupt which can be handled or ignored.
data ExitRecovery
Recoverable :: ExitRecovery
NoRecovery :: ExitRecovery

-- | A function that decided 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>Interrupt</a>. If <a>isRecoverable</a> holds for the given reason,
--   the process may choose to continue.
[Interrupted] :: Interrupt  'Recoverable -> ResumeProcess v

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

-- | Serialize a <tt>message</tt> into a <a>StrictDynamic</a> value to be
--   sent via <a>sendAnyMessage</a>.
--   
--   This indirection allows, among other things, the composition of
--   <a>Server</a>s.
newtype Serializer message
MkSerializer :: (message -> StrictDynamic) -> Serializer message
[runSerializer] :: Serializer message -> message -> StrictDynamic

-- | Data flows between <a>Process</a>es via these messages.
--   
--   This is just a newtype wrapper around <a>Dynamic</a>. The reason this
--   type exists is to force construction through the code in this module,
--   which always evaluates a message to <i>normal form</i> <b>before</b>
--   sending it to another process.
data StrictDynamic

-- | A multi-line text describing the <b>current</b> state of a process for
--   debugging purposes.
newtype ProcessDetails
MkProcessDetails :: Text -> ProcessDetails
[_fromProcessDetails] :: ProcessDetails -> Text

-- | A short title for a <a>Process</a> for logging purposes.
newtype ProcessTitle
MkProcessTitle :: Text -> ProcessTitle
[_fromProcessTitle] :: ProcessTitle -> Text

-- | 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 [StrictDynamic])

-- | 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] :: ProcessTitle -> Eff (Process r : r) () -> Process r (ResumeProcess ProcessId)

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

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

-- | Shutdown another process immediately, the other process has no way of
--   handling this!
[SendShutdown] :: ProcessId -> Interrupt  '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 -> Interrupt  'Recoverable -> Process r (ResumeProcess ())

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

-- | Receive a message that matches a criteria. This should block until an
--   a message was received. The message is returned as a
--   <a>ResumeProcess</a> 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, without 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 <a>Interrupt</a>
--   <a>LinkedProcessCrashed</a>.
[Link] :: ProcessId -> Process r (ResumeProcess ())

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

-- | Update the <a>ProcessDetails</a> of a process
[UpdateProcessDetails] :: ProcessDetails -> Process r (ResumeProcess ())

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

-- | An isomorphism lens for the <a>ProcessTitle</a>
fromProcessTitle :: Lens' ProcessTitle Text

-- | An isomorphism lens for the <a>ProcessDetails</a>
fromProcessDetails :: Lens' ProcessDetails Text

-- | Deeply evaluate the given value and wrap it into a
--   <a>StrictDynamic</a>.
toStrictDynamic :: (Typeable a, NFData a) => a -> StrictDynamic

-- | Convert a <a>StrictDynamic</a> back to a value.
fromStrictDynamic :: Typeable a => StrictDynamic -> Maybe a

-- | Convert a <a>StrictDynamic</a> back to an unwrapped <a>Dynamic</a>.
unwrapStrictDynamic :: StrictDynamic -> Dynamic

-- | Create a message selector for a value that can be obtained by
--   <a>fromStrictDynamic</a>.
selectMessage :: Typeable t => MessageSelector t

-- | Create a message selector from a predicate.
filterMessage :: 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>).
selectMessageWith :: Typeable a => (a -> Maybe b) -> MessageSelector b

-- | Create a message selector.
selectDynamicMessage :: (StrictDynamic -> 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.
selectAnyMessage :: MessageSelector StrictDynamic

-- | Get the <a>ExitRecovery</a>
toExitRecovery :: Interrupt r -> ExitRecovery

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

-- | Return either <a>ExitNormally</a> or <a>interruptToExit</a> from a
--   <a>Recoverable</a> <a>Interrupt</a>;
--   
--   If the <a>Interrupt</a> is <a>NormalExitRequested</a> then return
--   <a>ExitNormally</a>
interruptToExit :: Interrupt  'Recoverable -> Interrupt  'NoRecovery

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

-- | Handle all <a>Interrupt</a>s of an <a>Processes</a> by wrapping them
--   up in <a>interruptToExit</a> and then do a process <a>Shutdown</a>.
provideInterruptsShutdown :: forall e a. Eff (Processes e) a -> Eff (SafeProcesses e) a

-- | Handle <a>Interrupt</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) => (Interrupt  'Recoverable -> Eff r a) -> Eff r a -> Eff r a

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

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

-- | Handle <a>Interrupt</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, HasProcesses r q) => Eff r a -> Eff r a

-- | Handle <a>Interrupt</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 (Interrupt  'Recoverable) a)

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

-- | Throw an <a>Interrupt</a>, can be handled by <a>handleInterrupts</a>
--   or <a>exitOnInterrupt</a> or <a>provideInterrupts</a>.
interrupt :: (HasCallStack, Member Interrupts r) => Interrupt  'Recoverable -> Eff r a

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

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

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

-- | Print a <a>Interrupt</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 :: Interrupt -&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 :: Interrupt x -> Maybe Text

-- | Log the <a>Interrupt</a>s
logProcessExit :: forall e x. (Member Logs e, HasCallStack) => Interrupt 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. (HasSafeProcesses r q, HasCallStack) => Process q (ResumeProcess v) -> Eff r (Either (Interrupt  '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. (HasSafeProcesses r q, 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. (HasProcesses r q, HasCallStack) => 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. (HasProcesses r q, HasCallStack) => Eff r ()

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>.
--   
--   The message will be reduced to normal form (<a>rnf</a>) by/in the
--   caller process.
sendMessage :: forall r q o. (HasProcesses r q, HasCallStack, Typeable o, NFData o) => 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. (HasCallStack, HasProcesses r q) => ProcessId -> StrictDynamic -> 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. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt  '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. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt  'Recoverable -> 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>Interrupt</a> wrapped in <a>interruptToExit</a>. For specific use
--   cases it might be better to use <a>spawnRaw</a>.
spawn :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ProcessId

-- | Like <a>spawn</a> but return <tt>()</tt>.
spawn_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ()

-- | Start a new process, and immediately link to it.
spawnLink :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes 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>SafeProcesses</a> effects. For
--   non-library code <a>spawn</a> might be better suited.
spawnRaw :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff r ProcessId

-- | Like <a>spawnRaw</a> but return <tt>()</tt>.
spawnRaw_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff r ()

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

-- | Return the <a>ProcessTitle</a>, <a>ProcessDetails</a> and
--   <a>ProcessState</a>, for the given process, if the process is alive.
getProcessState :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r (Maybe (ProcessTitle, ProcessDetails, ProcessState))

-- | Replace the <a>ProcessDetails</a> of the process.
updateProcessDetails :: forall r q. (HasCallStack, HasProcesses r q) => ProcessDetails -> Eff r ()

-- | Block until a message was received. See <a>ReceiveSelectedMessage</a>
--   for more documentation.
receiveAnyMessage :: forall r q. (HasCallStack, HasProcesses r q) => Eff r StrictDynamic

-- | 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, HasProcesses r 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, NFData a, Show a, HasProcesses r q) => Eff r a

-- | Remove and return all messages currently enqueued in the process
--   message queue.
flushMessages :: forall r q. (HasCallStack, HasProcesses r q) => Eff r [StrictDynamic]

-- | 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> <a>Interrupt</a></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. (HasSafeProcesses r q, HasCallStack) => MessageSelector a -> (Either (Interrupt  'Recoverable) a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Like <a>receiveSelectedLoop</a> but <i>not selective</i>. See also
--   <a>selectAnyMessage</a>, <a>receiveSelectedLoop</a>.
receiveAnyLoop :: forall r q endOfLoopResult. (HasSafeProcesses r q, HasCallStack) => (Either (Interrupt  'Recoverable) StrictDynamic -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Like <a>receiveSelectedLoop</a> but refined to casting to a specific
--   <a>Typeable</a> using <a>selectMessage</a>.
receiveLoop :: forall r q a endOfLoopResult. (HasSafeProcesses r q, HasCallStack, NFData a, Typeable a) => (Either (Interrupt  'Recoverable) a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

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

-- | Generate a unique <a>Int</a> for the current process.
makeReference :: (HasCallStack, HasProcesses r 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, without exit reason
monitor :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r MonitorReference

-- | Remove a monitor created with <a>monitor</a>.
demonitor :: forall r q. (HasCallStack, HasProcesses r q) => MonitorReference -> Eff r ()

-- | <a>monitor</a> another process before while performing an action and
--   <a>demonitor</a> afterwards.
withMonitor :: (HasCallStack, HasProcesses r 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, HasProcesses r q, Typeable a, Show a) => ProcessId -> MessageSelector a -> Eff r (Either ProcessDown a)

-- | Make an <a>Interrupt</a> for a <a>ProcessDown</a> message.
--   
--   For example: <tt>doSomething &gt;&gt;= either (interrupt .
--   becauseProcessIsDown) return</tt>
becauseProcessIsDown :: ProcessDown -> Interrupt  'Recoverable

-- | A <a>MessageSelector</a> for the <a>ProcessDown</a> message of a
--   specific process.
--   
--   The parameter is the value obtained by <a>monitor</a>.
selectProcessDown :: MonitorReference -> MessageSelector ProcessDown

-- | A <a>MessageSelector</a> for the <a>ProcessDown</a> message. of a
--   specific process.
--   
--   In contrast to <a>selectProcessDown</a> this function matches the
--   <a>ProcessId</a>.
selectProcessDownByProcessId :: ProcessId -> 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 <a>Interrupt</a>
--   <a>LinkedProcessCrashed</a>.
linkProcess :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r ()

-- | Unlink the calling process from the other process.
unlinkProcess :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r ()

-- | Exit the process with a <a>Interrupt</a>.
exitBecause :: forall r q a. (HasCallStack, HasSafeProcesses r q) => Interrupt  'NoRecovery -> Eff r a

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

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

-- | A <a>ProcessId</a> and a <a>Serializer</a>. EXPERIMENTAL
--   
--   See <a>sendToReceiver</a>.
data Receiver a
Receiver :: ProcessId -> (a -> out) -> Receiver a
[_receiverPid] :: Receiver a -> ProcessId
[_receiverSerializer] :: Receiver a -> a -> out
fromProcessId :: Iso' ProcessId Int

-- | Serialize and send a message to the process in a <a>Receiver</a>.
--   
--   EXPERIMENTAL
sendToReceiver :: (NFData o, HasProcesses r q) => Receiver o -> o -> Eff r ()
receiverPid :: forall a_aHxu. Lens' (Receiver a_aHxu) ProcessId

-- | A class for <a>Pdu</a> instances that embed other <a>Pdu</a>.
--   
--   This is a part of <a>Embeds</a> provide instances for your <a>Pdu</a>s
--   but in client code use the <a>Embeds</a> constraint.
--   
--   Instances of this class serve as proof to <a>Embeds</a> that a
--   conversion into another <a>Pdu</a> actually exists.
--   
--   A <a>Prism</a> for the embedded <a>Pdu</a> is the center of this class
--   
--   Laws: <tt>embeddedPdu = prism' embedPdu fromPdu</tt>
class (Typeable protocol, Typeable embeddedProtocol) => HasPduPrism protocol embeddedProtocol

-- | A <a>Prism</a> for the embedded <a>Pdu</a>s.
embeddedPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Prism' (Pdu protocol result) (Pdu embeddedProtocol result)

-- | Embed the <a>Pdu</a> value of an embedded protocol into the
--   corresponding <a>Pdu</a> value.
embedPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Pdu embeddedProtocol result -> Pdu protocol result

-- | Examine a <a>Pdu</a> value from the outer protocol, and return it, if
--   it embeds a <a>Pdu</a> of embedded protocol, otherwise return
--   <a>Nothing</a>/
fromPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Pdu protocol result -> Maybe (Pdu embeddedProtocol result)

-- | This type function takes an <a>Pdu</a> and analysis the reply type,
--   i.e. the <a>Synchronicity</a> and evaluates to either <tt>t</tt> for
--   an <tt>Pdu x (<a>Synchronous</a> t)</tt> or to '()' for an <tt>Pdu x
--   <a>Asynchronous</a></tt>.
type family ProtocolReply (s :: Synchronicity)

-- | The (promoted) constructors of this type specify (at the type level)
--   the reply behavior of a specific constructor of an <tt>Pdu</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

-- | A <a>Constraint</a> that bundles the requirements for the <a>Pdu</a>
--   values of a protocol.
--   
--   This ensures that <a>Pdu</a>s can be strictly and deeply evaluated and
--   shown such that for example logging is possible.
type TangiblePdu p r = (Typeable p, Typeable r, Tangible (Pdu p r), HasPdu p)

-- | A set of constraints for types that can evaluated via <a>NFData</a>,
--   compared via <a>Ord</a> and presented dynamically via <a>Typeable</a>,
--   and represented both as values via <a>Show</a>.
type Tangible i = (NFData i, Typeable i, Show i)

-- | A constraint that requires that the <tt>outer</tt> <a>Pdu</a> has a
--   clause to embed values from the <tt>inner</tt> <a>Pdu</a>.
--   
--   Also, this constraint requires a <a>HasPduPrism</a> instance, as a
--   proof for a possible conversion of an embedded <a>Pdu</a> value into
--   to the enclosing <a>Pdu</a>.
--   
--   This generates better compiler error messages, when an embedding of a
--   <a>Pdu</a> into another.
--   
--   This is provided by <a>HasPdu</a> instances. The instances are
--   required to provide a list of embedded <a>Pdu</a> values in
--   <a>EmbeddedPduList</a>.
--   
--   Note that every type embeds itself, so <tt>Embeds x x</tt> always
--   holds.
type Embeds outer inner = (HasPduPrism outer inner, CheckEmbeds outer inner, HasPdu outer)

-- | This type class and the associated data family defines the <b>protocol
--   data units</b> (PDU) of a <i>protocol</i>.
--   
--   A Protocol in the sense of a communication interface description
--   between processes.
--   
--   The first parameter is usually a user defined type that identifies the
--   protocol that uses the <a>Pdu</a>s are. It maybe a <i>phantom</i>
--   type.
--   
--   The second parameter specifies if a specific constructor of an
--   (GADT-like) <tt>Pdu</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
--   
--   instance Typeable r =&gt; HasPdu BookShop r where
--     data instance Pdu BookShop r where
--       RentBook  :: BookId   -&gt; Pdu BookShop ('Synchronous (Either RentalError RentalId))
--       BringBack :: RentalId -&gt; Pdu BookShop 'Asynchronous
--       deriving Typeable
--   
--   type BookId = Int
--   type RentalId = Int
--   type RentalError = String
--   </pre>
class Typeable protocol => HasPdu (protocol :: Type) where {
    
    -- | A type level list Protocol phantom types included in the associated
    --   <a>Pdu</a> instance.
    --   
    --   This is just a helper for better compiler error messages. It relies on
    --   <a>Embeds</a> to add the constraint <a>HasPduPrism</a>.
    type family EmbeddedPduList protocol :: [Type];
    
    -- | The <b>protocol data unit</b> type for the given protocol.
    data family Pdu protocol (reply :: Synchronicity);
    type EmbeddedPduList protocol = '[];
}

-- | A server process for <i>protocol</i>.
--   
--   Protocols are represented by phantom types, which are used in
--   different places to index type families and type class instances.
--   
--   A <a>Process</a> can send and receive any messages. An <a>Endpoint</a>
--   wraps around a <a>ProcessId</a> and carries a phantom type to indicate
--   the kinds of messages accepted by the process.
--   
--   As a metaphor, communication between processes can be thought of
--   waiting for and sending <b>protocol data units</b> belonging to some
--   protocol.
newtype Endpoint protocol
Endpoint :: ProcessId -> Endpoint protocol
[_fromEndpoint] :: Endpoint protocol -> ProcessId

-- | Tag a <a>ProcessId</a> with an <a>Pdu</a> type index to mark it a
--   <a>Endpoint</a> process handling that API
proxyAsEndpoint :: proxy protocol -> ProcessId -> Endpoint protocol

-- | Tag a <a>ProcessId</a> with an <a>Pdu</a> type index to mark it a
--   <a>Endpoint</a> process handling that API
asEndpoint :: forall protocol. ProcessId -> Endpoint protocol

-- | Convert an <a>Endpoint</a> to an endpoint for an embedded protocol.
--   
--   See <a>Embeds</a>, <a>fromEmbeddedEndpoint</a>.
toEmbeddedEndpoint :: forall inner outer. Embeds outer inner => Endpoint outer -> Endpoint inner

-- | Convert an <a>Endpoint</a> to an endpoint for a server, that embeds
--   the protocol.
--   
--   See <a>Embeds</a>, <a>toEmbeddedEndpoint</a>.
fromEmbeddedEndpoint :: forall outer inner. HasPduPrism outer inner => Endpoint inner -> Endpoint outer
fromEndpoint :: forall protocol_aTMy protocol_aUUM. Iso (Endpoint protocol_aTMy) (Endpoint protocol_aUUM) ProcessId ProcessId

-- | Target of a <a>Call</a> reply.
--   
--   This combines a <a>RequestOrigin</a> with a <a>Serializer</a> for a
--   <a>Reply</a> using <a>Arg</a>. There are to smart constructors for
--   this type: <a>replyTarget</a> and <a>embeddedReplyTarget</a>.
--   
--   Because of <a>Arg</a> the <a>Eq</a> and <a>Ord</a> instances are
--   implemented via the <a>RequestOrigin</a> instances.
newtype ReplyTarget p r
MkReplyTarget :: Arg (RequestOrigin p r) (Serializer (Reply p r)) -> ReplyTarget p r

-- | Wraps the source <a>ProcessId</a> and a unique identifier for a
--   <a>Call</a>.
data RequestOrigin (proto :: Type) reply
RequestOrigin :: !ProcessId -> !Int -> RequestOrigin reply
[_requestOriginPid] :: RequestOrigin reply -> !ProcessId
[_requestOriginCallRef] :: RequestOrigin reply -> !Int

-- | The wrapper around replies to <a>Call</a>s.
data Reply protocol reply
[Reply] :: Tangible reply => {_replyTo :: RequestOrigin protocol reply, _replyValue :: reply} -> Reply protocol reply

-- | A wrapper sum type for calls and casts for the <a>Pdu</a>s of a
--   protocol
data Request protocol
[Call] :: forall protocol reply. (Tangible reply, TangiblePdu protocol ( 'Synchronous reply)) => RequestOrigin protocol reply -> Pdu protocol ( 'Synchronous reply) -> Request protocol
[Cast] :: forall protocol. (TangiblePdu protocol  'Asynchronous, NFData (Pdu protocol  'Asynchronous)) => Pdu protocol  'Asynchronous -> Request protocol

-- | Create a new, unique <a>RequestOrigin</a> value for the current
--   process.
makeRequestOrigin :: (Typeable r, NFData r, HasProcesses e q0) => Eff e (RequestOrigin p r)

-- | Turn an <a>RequestOrigin</a> to an origin for an embedded request (See
--   <a>Embeds</a>).
--   
--   This is useful of a server delegates the <tt>calls</tt> and
--   <tt>casts</tt> for an embedded protocol to functions, that require the
--   <a>Serializer</a> and <a>RequestOrigin</a> in order to call
--   <a>sendReply</a>.
--   
--   See also <a>embedReplySerializer</a>.
toEmbeddedOrigin :: forall outer inner reply. Embeds outer inner => RequestOrigin outer reply -> RequestOrigin inner reply

-- | Turn an <i>embedded</i> <a>RequestOrigin</a> to a <a>RequestOrigin</a>
--   for the <i>bigger</i> request.
--   
--   This is the inverse of <a>toEmbeddedOrigin</a>.
--   
--   This function is strict in all parameters.
embedRequestOrigin :: forall outer inner reply. Embeds outer inner => RequestOrigin inner reply -> RequestOrigin outer reply

-- | Turn a <a>Serializer</a> for a <a>Pdu</a> instance that contains
--   embedded <a>Pdu</a> values into a <a>Reply</a> <a>Serializer</a> for
--   the embedded <a>Pdu</a>.
--   
--   This is useful of a server delegates the <tt>calls</tt> and
--   <tt>casts</tt> for an embedded protocol to functions, that require the
--   <a>Serializer</a> and <a>RequestOrigin</a> in order to call
--   <a>sendReply</a>.
--   
--   See also <a>toEmbeddedOrigin</a>.
embedReplySerializer :: forall outer inner reply. Embeds outer inner => Serializer (Reply outer reply) -> Serializer (Reply inner reply)

-- | Answer a <a>Call</a> by sending the reply value to the client process.
--   
--   The <a>ProcessId</a>, the <a>RequestOrigin</a> and the <a>Reply</a>
--   <a>Serializer</a> are stored in the <a>ReplyTarget</a>.
sendReply :: (HasProcesses eff q, Tangible reply, Typeable protocol) => ReplyTarget protocol reply -> reply -> Eff eff ()

-- | Smart constructor for a <a>ReplyTarget</a>.
--   
--   To build a <tt>ReplyTarget</tt> for an <a>Embeds</a> instance use
--   <a>embeddedReplyTarget</a>.
replyTarget :: Serializer (Reply p reply) -> RequestOrigin p reply -> ReplyTarget p reply

-- | A simple <a>Lens</a> for the <a>RequestOrigin</a> of a
--   <a>ReplyTarget</a>.
replyTargetOrigin :: Lens' (ReplyTarget p reply) (RequestOrigin p reply)

-- | A simple <a>Lens</a> for the <a>Reply</a> <a>Serializer</a> of a
--   <a>ReplyTarget</a>.
replyTargetSerializer :: Lens' (ReplyTarget p reply) (Serializer (Reply p reply))

-- | Smart constructor for an <i>embedded</i> <a>ReplyTarget</a>.
--   
--   This combines <a>replyTarget</a> and <a>toEmbeddedReplyTarget</a>.
embeddedReplyTarget :: Embeds outer inner => Serializer (Reply outer reply) -> RequestOrigin outer reply -> ReplyTarget inner reply

-- | Convert a <a>ReplyTarget</a> to be usable for <i>embedded</i> replies.
--   
--   This combines a <a>toEmbeddedOrigin</a> with
--   <a>embedReplySerializer</a> to produce a <a>ReplyTarget</a> that can
--   be passed to functions defined soley on an embedded protocol.
toEmbeddedReplyTarget :: Embeds outer inner => ReplyTarget outer reply -> ReplyTarget inner reply

-- | 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, HasProcesses r q, Typeable a, NFData a, Show a) => 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, HasProcesses r q, Show a) => MessageSelector a -> Timeout -> Eff r (Either TimerElapsed a)

-- | Like <a>receiveWithMonitor</a> combined with
--   <a>receiveSelectedAfter</a>.
receiveSelectedWithMonitorAfter :: forall a r q. (Lifted IO q, HasCallStack, HasProcesses r q, Show a) => ProcessId -> MessageSelector a -> Timeout -> Eff r (Either (Either ProcessDown 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, HasProcesses r q, Typeable message, NFData message) => 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, HasProcesses r q) => Timeout -> Eff r TimerReference

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

-- | The reader effect for <a>ProcessId</a>s for <a>Pdu</a>s, see
--   <a>runEndpointReader</a>
type EndpointReader o = Reader (Endpoint o)

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

-- | Send a request <a>Pdu</a> that has no reply and return immediately.
--   
--   The type signature enforces that the corresponding <a>Pdu</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.
--   
--   The message will be reduced to normal form (<tt>rnf</tt>) in the
--   caller process.
cast :: forall destination protocol r q. (HasCallStack, HasProcesses r q, HasPdu destination, HasPdu protocol, Tangible (Pdu destination  'Asynchronous), Embeds destination protocol) => Endpoint destination -> Pdu protocol  'Asynchronous -> Eff r ()

-- | Send a request <a>Pdu</a> and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Pdu</a> clause
--   is <a>Synchronous</a>.
--   
--   <b>Always prefer <a>callWithTimeout</a> over <a>call</a></b>
call :: forall result destination protocol r q. (HasProcesses r q, TangiblePdu destination ( 'Synchronous result), TangiblePdu protocol ( 'Synchronous result), Tangible result, Embeds destination protocol, HasCallStack) => Endpoint destination -> Pdu protocol ( 'Synchronous result) -> Eff r result

-- | Send an request <a>Pdu</a> and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Pdu</a> clause
--   is <a>Synchronous</a>.
--   
--   If the server that was called dies, this function interrupts the
--   process with <a>ProcessDown</a>. If the server takes longer to reply
--   than the given timeout, this function interrupts the process with
--   <a>TimeoutInterrupt</a>.
--   
--   <b>Always prefer this function over <a>call</a></b>
callWithTimeout :: forall result destination protocol r q. (HasProcesses r q, TangiblePdu destination ( 'Synchronous result), TangiblePdu protocol ( 'Synchronous result), Tangible result, Member Logs r, Lifted IO q, Lifted IO r, HasCallStack, Embeds destination protocol) => Endpoint destination -> Pdu protocol ( 'Synchronous result) -> Timeout -> Eff r result

-- | Run a reader effect that contains <b>the one</b> server handling a
--   specific <a>Pdu</a> instance.
runEndpointReader :: HasCallStack => Endpoint o -> Eff (EndpointReader o : r) a -> Eff r a

-- | Get the <a>Endpoint</a> registered with <a>runEndpointReader</a>.
askEndpoint :: Member (EndpointReader o) e => Eff e (Endpoint o)

-- | Like <a>call</a> but take the <a>Endpoint</a> from the reader provided
--   by <a>runEndpointReader</a>.
--   
--   When working with an embedded <a>Pdu</a> use <a>callSingleton</a>.
callEndpointReader :: forall reply o r q. (HasEndpointReader o r, HasCallStack, Tangible reply, TangiblePdu o ( 'Synchronous reply), HasProcesses r q, Embeds o o) => Pdu o ( 'Synchronous reply) -> Eff r reply

-- | Like <a>cast</a> but take the <a>Endpoint</a> from the reader provided
--   by <a>runEndpointReader</a>.
--   
--   When working with an embedded <a>Pdu</a> use <a>castSingleton</a>.
castEndpointReader :: forall o r q. (HasEndpointReader o r, HasProcesses r q, Tangible (Pdu o  'Asynchronous), HasCallStack, HasPdu o, Embeds o o) => Pdu o  'Asynchronous -> Eff r ()

-- | Like <a>callEndpointReader</a>, uses <a>embedPdu</a> to embed the
--   value.
--   
--   This function makes use of AmbigousTypes and TypeApplications.
--   
--   When not working with an embedded <a>Pdu</a> use
--   <a>callEndpointReader</a>.
callSingleton :: forall outer inner reply q e. (HasCallStack, Member (EndpointReader outer) e, Embeds outer inner, Embeds outer outer, HasProcesses e q, TangiblePdu outer ( 'Synchronous reply), TangiblePdu inner ( 'Synchronous reply), Tangible reply) => Pdu inner ( 'Synchronous reply) -> Eff e reply

-- | Like <a>castEndpointReader</a>, but uses <a>embedPdu</a> to embed the
--   value.
--   
--   This function makes use of AmbigousTypes and TypeApplications.
--   
--   When not working with an embedded <a>Pdu</a> use
--   <a>castEndpointReader</a>.
castSingleton :: forall outer inner q e. (HasCallStack, Member (EndpointReader outer) e, Tangible (Pdu outer  'Asynchronous), HasProcesses e q, HasPdu outer, HasPdu inner, Embeds outer inner, Embeds outer outer) => Pdu inner  'Asynchronous -> Eff e ()

-- | Alias for the effect that contains the observers managed by
--   <a>evalObserverRegistryState</a>
type ObserverRegistryState event = State (ObserverRegistry event)

-- | A protocol for managing <a>Observer</a>s, encompassing registration
--   and de-registration of <a>Observer</a>s.
data ObserverRegistry (event :: Type)
MkObserverRegistry :: Map ProcessId (ObservationSink event) -> ObserverRegistry
[_observerRegistry] :: ObserverRegistry -> Map ProcessId (ObservationSink event)

-- | Convenience type alias.
type CanObserve eventSink event = (Tangible event, Embeds eventSink (Observer event), HasPdu eventSink)

-- | Convenience type alias.
type IsObservable eventSource event = (Tangible event, Embeds eventSource (ObserverRegistry event), HasPdu eventSource)

-- | The Information necessary to wrap an <a>Observed</a> event to a
--   process specific message, e.g. the embedded <a>Observer</a> <a>Pdu</a>
--   instance, and the <a>MonitorReference</a> of the destination process.
data ObservationSink event

-- | A <i>protocol</i> to communicate <a>Observed</a> events from a sources
--   to many sinks.
--   
--   A sink is any process that serves a protocol with a <a>Pdu</a>
--   instance that embeds the <a>Observer</a> Pdu via an <a>HasPduPrism</a>
--   instance.
--   
--   This type has <i>dual use</i>, for one it serves as type-index for
--   <a>Pdu</a>, i.e. <a>HasPdu</a> respectively, and secondly it contains
--   an <a>ObservationSink</a> and a <a>MonitorReference</a>.
--   
--   The <a>ObservationSink</a> is used to serialize and send the
--   <a>Observed</a> events, while the <a>ProcessId</a> serves as key for
--   internal maps.
newtype Observer event
MkObserver :: Arg ProcessId (ObservationSink event) -> Observer event

-- | And an <a>Observer</a> to the set of recipients for all observations
--   reported by <a>observerRegistryNotify</a>. Note that the
--   observerRegistry are keyed by the observing process, i.e. a previous
--   entry for the process contained in the <a>Observer</a> is overwritten.
--   If you want multiple entries for a single process, just combine
--   several filter functions.
registerObserver :: forall event eventSink eventSource r q. (HasCallStack, HasProcesses r q, IsObservable eventSource event, Tangible (Pdu eventSource  'Asynchronous), Tangible (Pdu eventSink  'Asynchronous), CanObserve eventSink event) => Endpoint eventSource -> Endpoint eventSink -> Eff r ()

-- | Send the <a>ForgetObserver</a> message
forgetObserver :: forall event eventSink eventSource r q. (HasProcesses r q, HasCallStack, Tangible (Pdu eventSource  'Asynchronous), Tangible (Pdu eventSink  'Asynchronous), IsObservable eventSource event, CanObserve eventSink event) => Endpoint eventSource -> Endpoint eventSink -> Eff r ()

-- | Send the <a>ForgetObserver</a> message, use a raw <a>ProcessId</a> as
--   parameter.
forgetObserverUnsafe :: forall event eventSource r q. (HasProcesses r q, HasCallStack, Tangible (Pdu eventSource  'Asynchronous), IsObservable eventSource event) => Endpoint eventSource -> ProcessId -> Eff r ()

-- | Provide the implementation for the <a>ObserverRegistry</a> Protocol,
--   this handled <a>RegisterObserver</a> and <a>ForgetObserver</a>
--   messages. It also adds the <a>ObserverRegistryState</a> constraint to
--   the effect list.
observerRegistryHandlePdu :: forall event q r. (HasCallStack, Typeable event, HasProcesses r q, Member (ObserverRegistryState event) r, Member Logs r) => Pdu (ObserverRegistry event)  'Asynchronous -> Eff r ()

-- | Remove the entry in the <a>ObserverRegistry</a> for the
--   <a>ProcessId</a> and return <a>True</a> if there was an entry,
--   <a>False</a> otherwise.
observerRegistryRemoveProcess :: forall event q r. (HasCallStack, Typeable event, HasProcesses r q, Member (ObserverRegistryState event) r, Member Logs r) => ProcessId -> Eff r Bool

-- | Keep track of registered <a>Observer</a>s.
--   
--   Handle the <a>ObserverRegistryState</a> effect, i.e. run
--   <a>evalState</a> on an <a>emptyObserverRegistry</a>.
evalObserverRegistryState :: HasCallStack => Eff (ObserverRegistryState event : r) a -> Eff r a

-- | The empty <a>ObserverRegistryState</a>
emptyObserverRegistry :: ObserverRegistry event

-- | Report an observation to all observers. The process needs to
--   <a>evalObserverRegistryState</a> and to
--   <a>observerRegistryHandlePdu</a>.
observerRegistryNotify :: forall event r q. (HasProcesses r q, Member (ObserverRegistryState event) r, Tangible event, HasCallStack) => event -> Eff r ()

-- | Alias for the <a>Writer</a> that contains the captured
--   <a>LogMessage</a>s from <a>CaptureLogs</a>.
type CaptureLogWriter = Writer LogMessage

-- | A <a>LogWriter</a> monad that provides pure logging by capturing via
--   the <a>Writer</a> effect.
type CaptureLogs a = LogWriterM CaptureLogWriter a

-- | A <a>LogWriter</a> monad that provides pure logging by capturing via
--   the <a>Writer</a> effect.
--   
--   See <a>exampleLogCapture</a>
captureLogWriter :: LogWriter CaptureLogWriter

-- | Run a <a>Writer</a> for <a>LogMessage</a>s.
--   
--   Such a <a>Writer</a> is needed to handle <a>CaptureLogWriter</a>
runCaptureLogWriter :: Eff (CaptureLogWriter : e) a -> Eff e (a, [LogMessage])

-- | The concrete list of <a>Eff</a>ects for logging with an IO based
--   <a>LogWriter</a>, and a <a>LogWriterReader</a>.
type LoggingAndIo = '[Logs, LogWriterReader (Lift IO), Lift IO]

-- | A <a>LogWriter</a> that uses an <a>IO</a> action to write the message.
--   
--   This is just an alias for <a>MkLogWriter</a> but with <tt>IO</tt> as
--   parameter. This reduces the need to apply something to the extra type
--   argument <tt>@IO</tt>.
--   
--   Example use cases for this function are the <tt>consoleLogWriter</tt>
--   and the <a>ioHandleLogWriter</a>.
mkLogWriterIO :: HasCallStack => (LogMessage -> IO ()) -> LogWriter (Lift IO)

-- | A <a>LogWriter</a> that renders <a>LogMessage</a>s to strings via
--   <a>renderLogMessageConsoleLog</a> and prints them to an <a>Handle</a>
--   using <tt>hPutStrLn</tt>.
ioHandleLogWriter :: HasCallStack => Handle -> LogWriter (Lift IO)

-- | Enable logging to IO using the <a>defaultIoLogWriter</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithIoLogging :: IO ()
--   exampleWithIoLogging =
--       runLift
--     $ withIoLogging debugTraceLogWriter
--                     "my-app"
--                     local7
--                     (lmSeverityIsAtLeast informationalSeverity)
--     $ logInfo "Oh, hi there"
--   </pre>
withIoLogging :: Lifted IO e => LogWriter (Lift IO) -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Decorate an IO based <a>LogWriter</a> to fill out these fields in
--   <a>LogMessage</a>s:
--   
--   <ul>
--   <li>The messages will carry the given application name in the
--   <a>lmAppName</a> field.</li>
--   <li>The <a>lmTimestamp</a> field contains the UTC time of the log
--   event</li>
--   <li>The <a>lmHostname</a> field contains the FQDN of the current
--   host</li>
--   <li>The <a>lmFacility</a> field contains the given
--   <a>Facility</a></li>
--   </ul>
--   
--   It works by using <a>mappingLogWriterM</a>.
defaultIoLogWriter :: Text -> Facility -> LogWriter (Lift IO) -> LogWriter (Lift IO)

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

-- | Enable logging to a file, with some <a>LogMessage</a> fields preset as
--   described in <a>withIoLogging</a>.
--   
--   If the file or its directory does not exist, it will be created.
--   
--   Example:
--   
--   <pre>
--   exampleWithFileLogging :: IO ()
--   exampleWithFileLogging =
--       runLift
--     $ withFileLogging "/var/log/my-app.log" "my-app" local7 allLogMessages
--     $ logInfo "Oh, hi there"
--   </pre>
--   
--   To vary the <a>LogWriter</a> use <a>withIoLogging</a>.
withFileLogging :: (Lifted IO e, MonadBaseControl IO (Eff e)) => FilePath -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Enable logging to a file.
--   
--   If the file or its directory does not exist, it will be created.
--   Example:
--   
--   <pre>
--   exampleWithFileLogWriter :: IO ()
--   exampleWithFileLogWriter =
--       runLift
--     $ withSomeLogging @IO
--     $ withFileLogWriter "test.log"
--     $ logInfo "Oh, hi there"
--   </pre>
withFileLogWriter :: (LogIo e, MonadBaseControl IO (Eff e)) => FilePath -> Eff e b -> Eff e b

-- | Enable logging via <a>traceM</a> using the <a>debugTraceLogWriter</a>,
--   with some <a>LogMessage</a> fields preset as in <a>withIoLogging</a>.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithTraceLogging :: IO ()
--   exampleWithTraceLogging =
--       runLift
--     $ withTraceLogging "my-app" local7 allLogMessages
--     $ logInfo "Oh, hi there"
--   </pre>
withTraceLogging :: Lifted IO e => Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Enable logging via <a>traceM</a> using the <a>debugTraceLogWriter</a>.
--   The logging monad type can be <i>any</i> type with a <a>Monad</a>
--   instance.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithTraceLogWriter :: IO ()
--   exampleWithTraceLogWriter =
--       runLift
--     $ withSomeLogging @IO
--     $ withTraceLogWriter
--     $ logInfo "Oh, hi there"
--   </pre>
withTraceLogWriter :: forall h e a. (Monad (LogWriterM h), LogsTo h e) => Eff e a -> Eff e a

-- | Write <a>LogMessage</a>s via <a>traceM</a>.
debugTraceLogWriter :: forall h. Monad (LogWriterM h) => LogMessageRenderer Text -> LogWriter h

-- | Enable logging to <tt>standard output</tt> using the
--   <a>consoleLogWriter</a>, with some <a>LogMessage</a> fields preset as
--   in <a>withIoLogging</a>.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithConsoleLogging :: IO ()
--   exampleWithConsoleLogging =
--       runLift
--     $ withConsoleLogging "my-app" local7 allLogMessages
--     $ logInfo "Oh, hi there"
--   </pre>
--   
--   To vary the <a>LogWriter</a> use <a>withIoLogging</a>.
withConsoleLogging :: Lifted IO e => Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Enable logging to <tt>standard output</tt> using the
--   <a>consoleLogWriter</a>.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithConsoleLogWriter :: IO ()
--   exampleWithConsoleLogWriter =
--       runLift
--     $ withSomeLogging @IO
--     $ withConsoleLogWriter
--     $ logInfo "Oh, hi there"
--   </pre>
withConsoleLogWriter :: LogIo e => Eff e a -> Eff e a

-- | Write <a>LogMessage</a>s to standard output, formatted with
--   <a>printLogMessage</a>.
--   
--   It uses <a>stdoutLogWriter</a> with <a>renderLogMessageConsoleLog</a>.
consoleLogWriter :: LogWriter (Lift IO)

-- | A <a>LogWriter</a> that uses a <a>LogMessageRenderer</a> to render,
--   and <a>putStrLn</a> to print it.
stdoutLogWriter :: LogMessageRenderer Text -> LogWriter (Lift IO)

-- | This is a wrapper around <a>withAsyncLogWriter</a> and
--   <a>withIoLogging</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithAsyncLogging :: IO ()
--   exampleWithAsyncLogging =
--       runLift
--     $ withAsyncLogWriter consoleLogWriter (1000::Int) "my-app" local0 allLogMessages
--     $ do logMsg "test 1"
--          logMsg "test 2"
--          logMsg "test 3"
--   </pre>
withAsyncLogging :: (Lifted IO e, MonadBaseControl IO (Eff e), Integral len) => LogWriter (Lift IO) -> len -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | <i>Move</i> the current <a>LogWriter</a> into its own thread.
--   
--   A bounded queue is used to forward logs to the process.
--   
--   If an exception is received, 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:
--   
--   <pre>
--   exampleAsyncLogWriter :: IO ()
--   exampleAsyncLogWriter =
--       runLift
--     $ withLogging consoleLogWriter
--     $ withAsyncLogWriter (1000::Int)
--     $ do logMsg "test 1"
--          logMsg "test 2"
--          logMsg "test 3"
--   </pre>
withAsyncLogWriter :: (LogIo e, MonadBaseControl IO (Eff e), Integral len) => len -> Eff e a -> Eff e a

-- | Enable logging to a remote host via <b>UDP</b>, with some
--   <a>LogMessage</a> fields preset as in <a>withIoLogging</a>.
--   
--   See <a>exampleUdpRFC3164Logging</a>
withUDPLogging :: (HasCallStack, MonadBaseControl IO (Eff e), Lifted IO e) => (LogMessage -> Text) -> String -> String -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Enable logging to a (remote-) host via UDP.
--   
--   See <a>exampleUdpRFC3164Logging</a>
withUDPLogWriter :: (LogIo e, MonadBaseControl IO (Eff e), HasCallStack) => (LogMessage -> Text) -> String -> String -> Eff e b -> Eff e b

-- | Enable logging to a <i>unix domain socket</i>, with some
--   <a>LogMessage</a> fields preset as in <a>withIoLogging</a>.
--   
--   See <a>exampleDevLogSyslogLogging</a>
withUnixSocketLogging :: (HasCallStack, MonadBaseControl IO (Eff e), Lifted IO e) => LogMessageRenderer Text -> FilePath -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Enable logging to a (remote-) host via UnixSocket.
--   
--   See <a>exampleDevLogSyslogLogging</a>
withUnixSocketLogWriter :: (LogIo e, MonadBaseControl IO (Eff e), HasCallStack) => LogMessageRenderer Text -> FilePath -> Eff e b -> Eff e b

-- | 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 ()

-- | Run the <a>Effects</a> using a single threaded, coroutine based,
--   scheduler from
--   <a>Control.Eff.Concurrent.Process.SingleThreadedScheduler</a>.
schedule :: HasCallStack => LogWriter (Lift IO) -> Eff Effects a -> IO (Either (Interrupt  'NoRecovery) a)

-- | Execute a <a>Process</a> using <a>scheduleM</a> on top of <a>Lift</a>
--   <tt>IO</tt>. All logging is written to the console using
--   <a>consoleLogWriter</a>.
--   
--   To use another <a>LogWriter</a> use <a>defaultMainWithLogWriter</a>
--   instead.
defaultMain :: HasCallStack => Eff EffectsIo () -> IO ()

-- | Execute a <a>Process</a> using <a>scheduleM</a> on top of <a>Lift</a>
--   <tt>IO</tt>. All logging is written using the given <a>LogWriter</a>.
defaultMainWithLogWriter :: HasCallStack => LogWriter (Lift IO) -> Eff EffectsIo () -> IO ()

-- | The effect list for <a>Process</a> effects in the single threaded
--   scheduler.
--   
--   See <a>EffectsIo</a>
type Effects = EffectsIo

-- | The effect list for <a>Process</a> effects in the single threaded
--   scheduler. This is like <a>SafeProcesses</a>, no <a>Interrupts</a> are
--   present.
--   
--   See <a>SafeEffectsIo</a>
type SafeEffects = SafeEffectsIo

-- | The effect list for the underlying scheduler.
--   
--   See <a>BaseEffectsIo</a>
type BaseEffects = BaseEffectsIo

-- | Constraint for the existence of the underlying scheduler effects.
--   
--   See <a>HasBaseEffectsIo</a>
type HasBaseEffects e = HasBaseEffectsIo e


-- | Concurrent, communicating processes, executed using a pure,
--   single-threaded scheduler.
--   
--   This module re-exports most of the library.
--   
--   There are several <i>scheduler</i> implementations to choose from.
--   
--   This module re-exports the pure parts of
--   <a>Control.Eff.Concurrent.Process.SingleThreadedScheduler</a>.
--   
--   To use another scheduler implementation, don't import this module, but
--   instead import one of:
--   
--   <ul>
--   <li><a>Control.Eff.Concurrent</a></li>
--   <li><a>Control.Eff.Concurrent.SingleThreaded</a></li>
--   </ul>
module Control.Eff.Concurrent.Pure

-- | An rfc 5424 facility
newtype Facility
Facility :: Int -> Facility
[fromFacility] :: Facility -> Int

-- | An rfc 5424 severity
data Severity

-- | Component of an RFC-5424 <a>StructuredDataElement</a>
data SdParameter
MkSdParameter :: !Text -> !Text -> SdParameter

-- | RFC-5424 defines how structured data can be included in a log message.
data StructuredDataElement
SdElement :: !Text -> ![SdParameter] -> StructuredDataElement
[_sdElementId] :: StructuredDataElement -> !Text
[_sdElementParameters] :: StructuredDataElement -> ![SdParameter]

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

-- | Smart constructor for the RFC-5424 <b>emergency</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>0</b>. See
--   <a>lmSeverity</a>.
emergencySeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>alert</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>1</b>. See
--   <a>lmSeverity</a>.
alertSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>critical</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>2</b>. See
--   <a>lmSeverity</a>.
criticalSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>error</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>3</b>. See
--   <a>lmSeverity</a>.
errorSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>warning</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>4</b>. See
--   <a>lmSeverity</a>.
warningSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>notice</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>5</b>. See
--   <a>lmSeverity</a>.
noticeSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>informational</b>
--   <a>LogMessage</a> <a>Severity</a>. This corresponds to the severity
--   value <b>6</b>. See <a>lmSeverity</a>.
informationalSeverity :: Severity

-- | Smart constructor for the RFC-5424 <b>debug</b> <a>LogMessage</a>
--   <a>Severity</a>. This corresponds to the severity value <b>7</b>. See
--   <a>lmSeverity</a>.
debugSeverity :: Severity

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>kernelMessages</tt>. See <a>lmFacility</a>.
kernelMessages :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>userLevelMessages</tt>. See <a>lmFacility</a>.
userLevelMessages :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>mailSystem</tt>. See <a>lmFacility</a>.
mailSystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>systemDaemons</tt>. See <a>lmFacility</a>.
systemDaemons :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>securityAuthorizationMessages4</tt>. See <a>lmFacility</a>.
securityAuthorizationMessages4 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>linePrinterSubsystem</tt>. See <a>lmFacility</a>.
linePrinterSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>networkNewsSubsystem</tt>. See <a>lmFacility</a>.
networkNewsSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>uucpSubsystem</tt>. See <a>lmFacility</a>.
uucpSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>clockDaemon</tt>. See <a>lmFacility</a>.
clockDaemon :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>securityAuthorizationMessages10</tt>. See <a>lmFacility</a>.
securityAuthorizationMessages10 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>ftpDaemon</tt>. See <a>lmFacility</a>.
ftpDaemon :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>ntpSubsystem</tt>. See <a>lmFacility</a>.
ntpSubsystem :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>logAuditFacility</tt>. See <a>lmFacility</a>.
logAuditFacility :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>logAlertFacility</tt>. See <a>lmFacility</a>.
logAlertFacility :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>clockDaemon2</tt>. See <a>lmFacility</a>.
clockDaemon2 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local0</tt>. See <a>lmFacility</a>.
local0 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local1</tt>. See <a>lmFacility</a>.
local1 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local2</tt>. See <a>lmFacility</a>.
local2 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local3</tt>. See <a>lmFacility</a>.
local3 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local4</tt>. See <a>lmFacility</a>.
local4 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local5</tt>. See <a>lmFacility</a>.
local5 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local6</tt>. See <a>lmFacility</a>.
local6 :: Facility

-- | Smart constructor for the RFC-5424 <a>LogMessage</a> facility
--   <tt>local7</tt>. See <a>lmFacility</a>.
local7 :: Facility

-- | A lens for the key or ID of a group of RFC 5424 key-value pairs.
sdElementId :: Functor f => (Text -> f Text) -> StructuredDataElement -> f StructuredDataElement

-- | A lens for <a>SdParameter</a>s
sdElementParameters :: Functor f => ([SdParameter] -> f [SdParameter]) -> StructuredDataElement -> f StructuredDataElement

-- | The filter predicate for message that shall be logged.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
type LogPredicate = LogMessage -> Bool

-- | Things that can become a <a>LogMessage</a>
class ToLogMessage a

-- | Convert the value to a <a>LogMessage</a>
toLogMessage :: ToLogMessage a => a -> LogMessage

-- | A lens for the RFC 5424 <i>application</i> name of a <a>LogMessage</a>
--   
--   One useful pattern for using this field, is to implement log filters
--   that allow info and debug message from the application itself while
--   only allowing warning and error messages from third party libraries:
--   
--   <pre>
--   debugLogsForAppName myAppName lm =
--     view lmAppName lm == Just myAppName || lmSeverityIsAtLeast warningSeverity lm
--   </pre>
--   
--   This concept is also implemented in <a>discriminateByAppName</a>.
lmAppName :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for the <a>Facility</a> of a <a>LogMessage</a>
lmFacility :: Functor f => (Facility -> f Facility) -> LogMessage -> f LogMessage

-- | A lens for the hostname of a <a>LogMessage</a> The function
--   <a>setLogMessageHostname</a> can be used to set the field.
lmHostname :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for the user defined textual message of a <a>LogMessage</a>
lmMessage :: Functor f => (Text -> f Text) -> LogMessage -> f LogMessage

-- | A lens for a user defined <i>message id</i> of a <a>LogMessage</a>
lmMessageId :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for a user defined of <i>process</i> id of a <a>LogMessage</a>
lmProcessId :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage

-- | A lens for the <a>Severity</a> of a <a>LogMessage</a>
lmSeverity :: Functor f => (Severity -> f Severity) -> LogMessage -> f LogMessage

-- | A lens for the <a>SrcLoc</a> of a <a>LogMessage</a>
lmSrcLoc :: Functor f => (Maybe SrcLoc -> f (Maybe SrcLoc)) -> LogMessage -> f LogMessage

-- | A lens for the <a>StructuredDataElement</a> of a <a>LogMessage</a>
lmStructuredData :: Functor f => ([StructuredDataElement] -> f [StructuredDataElement]) -> LogMessage -> f LogMessage

-- | A lens for the <a>ThreadId</a> of a <a>LogMessage</a> The function
--   <a>setLogMessageThreadId</a> can be used to set the field.
lmThreadId :: Functor f => (Maybe ThreadId -> f (Maybe ThreadId)) -> LogMessage -> f LogMessage

-- | A lens for the UTC time of a <a>LogMessage</a> The function
--   <a>setLogMessageTimestamp</a> can be used to set the field.
lmTimestamp :: Functor f => (Maybe UTCTime -> f (Maybe UTCTime)) -> LogMessage -> f LogMessage

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

-- | Prefix the <a>lmMessage</a>.
prefixLogMessagesWith :: Text -> LogMessage -> LogMessage

-- | An IO action that sets the current UTC time in <a>lmTimestamp</a>.
setLogMessageTimestamp :: LogMessage -> IO LogMessage

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

-- | An IO action that sets the current hosts fully qualified hostname in
--   <a>lmHostname</a>.
setLogMessageHostname :: LogMessage -> IO LogMessage

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

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

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

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

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

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

-- | All messages.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
allLogMessages :: LogPredicate

-- | No messages.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
noLogMessages :: LogPredicate

-- | Match <a>LogMessage</a>s that have exactly the given severity. See
--   <a>lmSeverityIsAtLeast</a>.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
lmSeverityIs :: Severity -> LogPredicate

-- | Match <a>LogMessage</a>s that have the given severity <b>or worse</b>.
--   See <a>lmSeverityIs</a>.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
lmSeverityIsAtLeast :: Severity -> LogPredicate

-- | Match <a>LogMessage</a>s whose <a>lmMessage</a> starts with the given
--   string.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
lmMessageStartsWith :: Text -> LogPredicate

-- | Apply a <a>LogPredicate</a> based on the <a>lmAppName</a> and delegate
--   to one of two <a>LogPredicate</a>s.
--   
--   One useful application for this is to allow info and debug message
--   from one application, e.g. the current application itself, while at
--   the same time allowing only warning and error messages from third
--   party libraries.
--   
--   See <a>Control.Eff.Log.Message#PredefinedPredicates</a> for more
--   predicates.
discriminateByAppName :: Text -> LogPredicate -> LogPredicate -> LogPredicate

-- | A rendering function for the <a>lmTimestamp</a> field.
data LogMessageTimeRenderer

-- | <a>LogMessage</a> rendering function
type LogMessageRenderer a = LogMessage -> a

-- | Make a <a>LogMessageTimeRenderer</a> using <a>formatTime</a> in the
--   <tt>defaultLocale</tt>.
mkLogMessageTimeRenderer :: String -> LogMessageTimeRenderer

-- | Don't render the time stamp
suppressTimestamp :: LogMessageTimeRenderer

-- | Render the time stamp using <tt>"%h %d %H:%M:%S"</tt>
rfc3164Timestamp :: LogMessageTimeRenderer

-- | Render the time stamp to <tt><a>iso8601DateFormat</a> (Just
--   "%H:%M:%S%6QZ")</tt>
rfc5424Timestamp :: LogMessageTimeRenderer

-- | Render the time stamp like <a>rfc5424Timestamp</a> does, but omit the
--   terminal <tt>Z</tt> character.
rfc5424NoZTimestamp :: LogMessageTimeRenderer

-- | Print the thread id, the message and the source file location,
--   seperated by simple white space.
renderLogMessageBody :: LogMessageRenderer Text

-- | Print the thread id, the message and the source file location,
--   seperated by simple white space.
renderLogMessageBodyNoLocation :: LogMessageRenderer Text

-- | Print the <i>body</i> of a <a>LogMessage</a> with fix size fields (60)
--   for the message itself and 30 characters for the location
renderLogMessageBodyFixWidth :: LogMessageRenderer Text

-- | Render a field of a <a>LogMessage</a> using the corresponsing lens.
renderMaybeLogMessageLens :: Text -> Getter LogMessage (Maybe Text) -> LogMessageRenderer Text

-- | Render the source location as: <tt>at filepath:linenumber</tt>.
renderLogMessageSrcLoc :: LogMessageRenderer (Maybe Text)

-- | Render the severity and facility as described in RFC-3164
--   
--   Render e.g. as <tt>&lt;192&gt;</tt>.
--   
--   Useful as header for syslog compatible log output.
renderSyslogSeverityAndFacility :: LogMessageRenderer Text

-- | Render the <a>LogMessage</a> to contain the severity, message,
--   message-id, pid.
--   
--   Omit hostname, PID and timestamp.
--   
--   Render the header using <tt>renderSyslogSeverity</tt>
--   
--   Useful for logging to <tt><i>dev</i>log</tt>
renderLogMessageSyslog :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> human readable, for console logging
renderLogMessageConsoleLog :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-3164.
renderRFC3164 :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-3164 but
--   use RFC5424 time stamps.
renderRFC3164WithRFC5424Timestamps :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-3164 but
--   use the custom <a>LogMessageTimeRenderer</a>.
renderRFC3164WithTimestamp :: LogMessageTimeRenderer -> LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-5424.
--   
--   Equivalent to <tt><a>renderRFC5424Header</a> &lt;&gt; const " "
--   &lt;&gt; <a>renderLogMessageBody</a></tt>.
renderRFC5424 :: LogMessageRenderer Text

-- | Render a <a>LogMessage</a> according to the rules in the RFC-5424,
--   like <a>renderRFC5424</a> but suppress the source location
--   information.
--   
--   Equivalent to <tt><a>renderRFC5424Header</a> &lt;&gt; const " "
--   &lt;&gt; <a>renderLogMessageBodyNoLocation</a></tt>.
renderRFC5424NoLocation :: LogMessageRenderer Text

-- | Render the header and strucuted data of a <a>LogMessage</a> according
--   to the rules in the RFC-5424, but do not render the <a>lmMessage</a>.
renderRFC5424Header :: LogMessageRenderer Text

-- | The instances of this class are the monads that define (side-)
--   effect(s) of writting logs.
class HandleLogWriter (writer :: Type -> Type) where {
    
    -- | The <a>Eff</a>ects required by the <a>handleLogWriterEffect</a>
    --   method.
    data family LogWriterM writer a;
}

-- | Run the side effect of a <a>LogWriter</a> in a compatible <a>Eff</a>.
handleLogWriterEffect :: (HandleLogWriter writer, Member writer e) => LogWriterM writer () -> Eff e ()

-- | Write a message using the <a>LogWriter</a> found in the environment.
--   
--   The semantics of this function are a combination of
--   <a>runLogWriter</a> and <a>handleLogWriterEffect</a>, with the
--   <a>LogWriter</a> read from a <a>LogWriterReader</a>.
liftWriteLogMessage :: (HandleLogWriter writer, SetMember LogWriterReader (LogWriterReader writer) e, Member writer e) => LogMessage -> Eff e ()

-- | A Reader specialized for <a>LogWriter</a>s
--   
--   The existing <tt>Reader</tt> couldn't be used together with
--   <a>SetMember</a>, so this lazy reader was written, specialized to
--   reading <a>LogWriter</a>.
data LogWriterReader h v

-- | A function that takes a log message and returns an effect that
--   <i>logs</i> the message.
newtype LogWriter writerM
MkLogWriter :: (LogMessage -> LogWriterM writerM ()) -> LogWriter writerM
[runLogWriter] :: LogWriter writerM -> LogMessage -> LogWriterM writerM ()

-- | Provide the <a>LogWriter</a>
--   
--   Exposed for custom extensions, if in doubt use <tt>withLogging</tt>.
runLogWriterReader :: LogWriter h -> Eff (LogWriterReader h : e) a -> Eff e a

-- | Get the current <a>LogWriter</a>.
askLogWriter :: SetMember LogWriterReader (LogWriterReader h) e => Eff e (LogWriter h)

-- | Modify the current <a>LogWriter</a>.
localLogWriterReader :: forall h e a. SetMember LogWriterReader (LogWriterReader h) e => (LogWriter h -> LogWriter h) -> Eff e a -> Eff e a

-- | This <a>LogWriter</a> will discard all messages.
--   
--   NOTE: This is just an alias for <a>def</a>
noOpLogWriter :: Applicative (LogWriterM m) => LogWriter m

-- | A <a>LogWriter</a> that applies a predicate to the <a>LogMessage</a>
--   and delegates to to the given writer of the predicate is satisfied.
filteringLogWriter :: Monad (LogWriterM e) => LogPredicate -> LogWriter e -> LogWriter e

-- | A <a>LogWriter</a> that applies a function to the <a>LogMessage</a>
--   and delegates the result to to the given writer.
mappingLogWriter :: (LogMessage -> LogMessage) -> LogWriter e -> LogWriter e

-- | Like <a>mappingLogWriter</a> allow the function that changes the
--   <a>LogMessage</a> to have effects.
mappingLogWriterM :: Monad (LogWriterM e) => (LogMessage -> LogWriterM e LogMessage) -> LogWriter e -> LogWriter e

-- | A constraint that required <tt><a>LogsTo</a> <a>IO</a> e</tt> and
--   <tt><a>Lifted</a> <a>IO</a> e</tt>.
type LogIo e = (LogsTo (Lift IO) e, Lifted IO e)

-- | A constraint alias for effects that requires a <a>LogWriterReader</a>,
--   as well as that the contained <a>LogWriterReader</a> has a
--   <a>HandleLogWriter</a> instance.
--   
--   The requirements of this constraint are provided by:
--   
--   <ul>
--   <li><tt>withIoLogging</tt></li>
--   <li><a>withLogging</a></li>
--   <li><a>withSomeLogging</a></li>
--   </ul>
type LogsTo h e = (Member Logs e, HandleLogWriter h, Member h e, SetMember LogWriterReader (LogWriterReader h) e)

-- | This effect sends <a>LogMessage</a>s and is a reader for a
--   <a>LogPredicate</a>.
--   
--   Logs are sent via <a>logMsg</a>; for more information about log
--   predicates, see <a>Control.Eff.Log#LogPredicate</a>
--   
--   This effect is handled via <a>withLogging</a>.
data Logs v

-- | Handle the <a>Logs</a> and <a>LogWriterReader</a> effects.
--   
--   It installs the given <a>LogWriter</a>, which determines the
--   underlying <a>LogWriter</a> type parameter.
--   
--   Example:
--   
--   <pre>
--   exampleWithLogging :: IO ()
--   exampleWithLogging =
--       runLift
--     $ withLogging consoleLogWriter
--     $ logDebug "Oh, hi there"
--   </pre>
withLogging :: forall h e a. (Applicative (LogWriterM h), LogsTo h (Logs : (LogWriterReader h : e))) => LogWriter h -> Eff (Logs : (LogWriterReader h : e)) a -> Eff e a

-- | Handles the <a>Logs</a> and <a>LogWriterReader</a> effects.
--   
--   By default it uses the <a>noOpLogWriter</a>, but using
--   <a>setLogWriter</a> the <a>LogWriter</a> can be replaced.
--   
--   This is like <a>withLogging</a> applied to <a>noOpLogWriter</a>
--   
--   Example:
--   
--   <pre>
--   exampleWithSomeLogging :: ()
--   exampleWithSomeLogging =
--       run
--     $ withSomeLogging @PureLogWriter
--     $ logDebug "Oh, hi there"
--   </pre>
withSomeLogging :: forall h e a. (Applicative (LogWriterM h), LogsTo h (Logs : (LogWriterReader h : e))) => Eff (Logs : (LogWriterReader h : e)) a -> Eff e a

-- | Raw handling of the <a>Logs</a> effect. Exposed for custom extensions,
--   if in doubt use <a>withLogging</a>.
runLogs :: forall h e b. LogsTo h (Logs : e) => LogPredicate -> Eff (Logs : e) b -> Eff e b

-- | Log a message.
--   
--   All logging goes through this function.
--   
--   This function is the only place where the <a>LogPredicate</a> is
--   applied.
--   
--   Also, <a>LogMessage</a>s are evaluated using <a>deepseq</a>,
--   <b>after</b> they pass the <a>LogPredicate</a>.
logMsg :: forall e. (HasCallStack, Member Logs e) => LogMessage -> Eff e ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Get the current <a>Logs</a> filter/transformer function.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
askLogPredicate :: forall e. Member Logs e => Eff e LogPredicate

-- | Keep only those messages, for which a predicate holds.
--   
--   E.g. to keep only messages which begin with <tt><a>OMG</a></tt>:
--   
--   <pre>
--   exampleLogPredicate :: IO Int
--   exampleLogPredicate =
--       runLift
--     $ withLogging consoleLogWriter
--     $ do logMsg "test"
--          setLogPredicate (\ msg -&gt; case view lmMessage msg of
--                                     'O':'M':'G':_ -&gt; True
--                                     _             -&gt; False)
--                            (do logMsg "this message will not be logged"
--                                logMsg "OMG logged"
--                                return 42)
--   </pre>
--   
--   In order to also delegate to the previous predicate, use
--   <a>modifyLogPredicate</a>
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
setLogPredicate :: forall r b. (Member Logs r, HasCallStack) => LogPredicate -> Eff r b -> Eff r b

-- | Change the <a>LogPredicate</a>.
--   
--   Other than <a>setLogPredicate</a> this function allows to include the
--   previous predicate, too.
--   
--   For to discard all messages currently no satisfying the predicate and
--   also all messages that are to long:
--   
--   <pre>
--   modifyLogPredicate (previousPredicate msg -&gt; previousPredicate msg &amp;&amp; length (lmMessage msg) &lt; 29 )
--                      (do logMsg "this message will not be logged"
--                          logMsg "this message might be logged")
--   </pre>
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
modifyLogPredicate :: forall e b. (Member Logs e, HasCallStack) => (LogPredicate -> LogPredicate) -> Eff e b -> Eff e b

-- | Include <a>LogMessage</a>s that match a <a>LogPredicate</a>.
--   
--   <tt>excludeLogMessages p</tt> allows log message to be logged if <tt>p
--   m</tt>
--   
--   Although it is enough if the previous predicate holds. See
--   <a>excludeLogMessages</a> and <a>modifyLogPredicate</a>.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
includeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a

-- | Exclude <a>LogMessage</a>s that match a <a>LogPredicate</a>.
--   
--   <tt>excludeLogMessages p</tt> discards logs if <tt>p m</tt>
--   
--   Also the previous predicate must also hold for a message to be logged.
--   See <a>excludeLogMessages</a> and <a>modifyLogPredicate</a>.
--   
--   See <a>Control.Eff.Log#LogPredicate</a>
excludeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a

-- | Consume log messages.
--   
--   Exposed for custom extensions, if in doubt use <a>withLogging</a>.
--   
--   Respond to all <a>LogMessage</a>s logged from the given action, up to
--   any <a>MonadBaseControl</a> liftings.
--   
--   Note that all logging is done through <a>logMsg</a> and that means
--   only messages passing the <a>LogPredicate</a> are received.
--   
--   The <a>LogMessage</a>s are <b>consumed</b> once they are passed to the
--   given callback function, previous <a>respondToLogMessage</a>
--   invocations further up in the call stack will not get the messages
--   anymore.
--   
--   Use <a>interceptLogMessages</a> if the messages shall be passed any
--   previous handler.
--   
--   NOTE: The effects of this function are <b>lost</b> when using
--   <a>MonadBaseControl</a>, <a>MonadMask</a>, <a>MonadCatch</a> and
--   <a>MonadThrow</a>.
--   
--   In contrast the functions based on modifying the <a>LogWriter</a>,
--   such as <a>addLogWriter</a> or <a>censorLogs</a>, are save to use in
--   combination with the aforementioned liftings.
respondToLogMessage :: forall r b. Member Logs r => (LogMessage -> Eff r ()) -> Eff r b -> Eff r b

-- | Change the <a>LogMessage</a>s using an effectful function.
--   
--   Exposed for custom extensions, if in doubt use <a>withLogging</a>.
--   
--   This differs from <a>respondToLogMessage</a> in that the intercepted
--   messages will be written either way, albeit in altered form.
--   
--   NOTE: The effects of this function are <b>lost</b> when using
--   <a>MonadBaseControl</a>, <a>MonadMask</a>, <a>MonadCatch</a> and
--   <a>MonadThrow</a>.
--   
--   In contrast the functions based on modifying the <a>LogWriter</a>,
--   such as <a>addLogWriter</a> or <a>censorLogs</a>, are save to use in
--   combination with the aforementioned liftings.
interceptLogMessages :: forall r b. Member Logs r => (LogMessage -> Eff r LogMessage) -> Eff r b -> Eff r b

-- | Change the current <a>LogWriter</a>.
modifyLogWriter :: forall h e a. LogsTo h e => (LogWriter h -> LogWriter h) -> Eff e a -> Eff e a

-- | Replace the current <a>LogWriter</a>. To add an additional log message
--   consumer use <a>addLogWriter</a>
setLogWriter :: forall h e a. LogsTo h e => LogWriter h -> Eff e a -> Eff e a

-- | Modify the the <a>LogMessage</a>s written in the given sub-expression.
--   
--   Note: This is equivalent to <tt><a>modifyLogWriter</a> .
--   <a>mappingLogWriter</a></tt>
censorLogs :: LogsTo h e => (LogMessage -> LogMessage) -> Eff e a -> Eff e a

-- | Modify the the <a>LogMessage</a>s written in the given sub-expression,
--   as in <a>censorLogs</a> but with a effectful function.
--   
--   Note: This is equivalent to <tt><a>modifyLogWriter</a> .
--   <a>mappingLogWriterM</a></tt>
censorLogsM :: (LogsTo h e, Monad (LogWriterM h)) => (LogMessage -> LogWriterM h LogMessage) -> Eff e a -> Eff e a

-- | Combine the effects of a given <a>LogWriter</a> and the existing one.
--   
--   <pre>
--   import Data.Text    as T
--   import Data.Text.IO as T
--   
--   exampleAddLogWriter :: IO ()
--   exampleAddLogWriter = go &gt;&gt;= T.putStrLn
--    where go = fmap (unlines . map renderLogMessageConsoleLog . snd)
--                 $  runLift
--                 $  runCaptureLogWriter
--                 $  withLogging captureLogWriter
--                 $  addLogWriter (mappingLogWriter (lmMessage %~ ("CAPTURED "++)) captureLogWriter)
--                 $  addLogWriter (filteringLogWriter severeMessages (mappingLogWriter (lmMessage %~ ("TRACED "++)) debugTraceLogWriter))
--                 $  do
--                       logEmergency "test emergencySeverity 1"
--                       logCritical "test criticalSeverity 2"
--                       logAlert "test alertSeverity 3"
--                       logError "test errorSeverity 4"
--                       logWarning "test warningSeverity 5"
--                       logInfo "test informationalSeverity 6"
--                       logDebug "test debugSeverity 7"
--          severeMessages = view (lmSeverity . to (&lt;= errorSeverity))
--   </pre>
addLogWriter :: forall h e a. (HasCallStack, LogsTo h e, Monad (LogWriterM h)) => LogWriter h -> Eff e a -> Eff e a

-- | 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 died.
data ProcessDown
ProcessDown :: !MonitorReference -> !SomeExitReason -> !ProcessId -> ProcessDown
[downReference] :: ProcessDown -> !MonitorReference
[downReason] :: ProcessDown -> !SomeExitReason
[downProcess] :: ProcessDown -> !ProcessId

-- | 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>Interrupt</a>
data SomeExitReason
[SomeExitReason] :: Interrupt x -> SomeExitReason

-- | <a>Exc</a>eptions containing <a>Interrupt</a>s. See
--   <a>handleInterrupts</a>, <a>exitOnInterrupt</a> or
--   <a>provideInterrupts</a>
type Interrupts = Exc (Interrupt  'Recoverable)

-- | A constraint for an effect set that requires the presence of
--   <a>SafeProcesses</a>.
--   
--   This constrains the effect list to look like this: <tt>[e1 ... eN,
--   <a>Process</a> [e(N+1) .. e(N+k)], e(N+1) .. e(N+k)]</tt>
--   
--   It contrains <tt>e</tt> to support the (only) <a>Process</a> effect.
--   
--   This is more relaxed that <a>HasProcesses</a> since it does not
--   require <a>Interrupts</a>.
type HasSafeProcesses e inner = (SetMember Process (Process inner) e)

-- | <i>Cons</i> <a>Process</a> onto a list of effects. This is called
--   <tt>SafeProcesses</tt> because the the actions cannot be interrupted
--   in.
type SafeProcesses r = Process r : r

-- | A constraint for an effect set that requires the presence of
--   <a>Processes</a>.
--   
--   This constrains the effect list to look like this: <tt>[e1 ... eN,
--   <a>Interrupts</a>, <a>Process</a> [e(N+1) .. e(N+k)], e(N+1) ..
--   e(N+k)]</tt>
--   
--   It contrains <tt>e</tt> beyond <a>HasSafeProcesses</a> to encompass
--   <a>Interrupts</a>.
type HasProcesses e inner = (HasSafeProcesses e inner, Member Interrupts e)

-- | This adds a layer of the <a>Interrupts</a> effect on top of
--   <a>Processes</a>
type Processes e = Interrupts : SafeProcesses e

-- | <a>Interrupt</a>s which are <a>Recoverable</a>.
type RecoverableInterrupt = Interrupt  'Recoverable

-- | A sum-type with reasons for why a process operation, such as receiving
--   messages, is interrupted in the scheduling loop.
--   
--   This includes errors, that can occur when scheduling messages.
data Interrupt (t :: ExitRecovery)

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

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

-- | A <a>Recoverable</a> timeout has occurred.
[TimeoutInterrupt] :: String -> Interrupt  'Recoverable

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

-- | An exit reason that has an error message and is <a>Recoverable</a>.
[ErrorInterrupt] :: String -> Interrupt  'Recoverable

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

-- | An error causes the process to exit immediately. For example an
--   unexpected runtime exception was thrown, i.e. an exception derived
--   from <a>SomeException</a> Or a <a>Recoverable</a> Interrupt was not
--   recovered.
[ExitUnhandledError] :: Text -> Interrupt  'NoRecovery

-- | A process shall exit immediately, without any cleanup was cancelled
--   (e.g. killed, in <a>cancel</a>)
[ExitProcessCancelled] :: Interrupt  'NoRecovery

-- | This value indicates whether 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>Interrupt</a> can be treated
--   like a short interrupt which can be handled or ignored.
data ExitRecovery
Recoverable :: ExitRecovery
NoRecovery :: ExitRecovery

-- | A function that decided 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>Interrupt</a>. If <a>isRecoverable</a> holds for the given reason,
--   the process may choose to continue.
[Interrupted] :: Interrupt  'Recoverable -> ResumeProcess v

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

-- | Serialize a <tt>message</tt> into a <a>StrictDynamic</a> value to be
--   sent via <a>sendAnyMessage</a>.
--   
--   This indirection allows, among other things, the composition of
--   <a>Server</a>s.
newtype Serializer message
MkSerializer :: (message -> StrictDynamic) -> Serializer message
[runSerializer] :: Serializer message -> message -> StrictDynamic

-- | Data flows between <a>Process</a>es via these messages.
--   
--   This is just a newtype wrapper around <a>Dynamic</a>. The reason this
--   type exists is to force construction through the code in this module,
--   which always evaluates a message to <i>normal form</i> <b>before</b>
--   sending it to another process.
data StrictDynamic

-- | A multi-line text describing the <b>current</b> state of a process for
--   debugging purposes.
newtype ProcessDetails
MkProcessDetails :: Text -> ProcessDetails
[_fromProcessDetails] :: ProcessDetails -> Text

-- | A short title for a <a>Process</a> for logging purposes.
newtype ProcessTitle
MkProcessTitle :: Text -> ProcessTitle
[_fromProcessTitle] :: ProcessTitle -> Text

-- | 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 [StrictDynamic])

-- | 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] :: ProcessTitle -> Eff (Process r : r) () -> Process r (ResumeProcess ProcessId)

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

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

-- | Shutdown another process immediately, the other process has no way of
--   handling this!
[SendShutdown] :: ProcessId -> Interrupt  '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 -> Interrupt  'Recoverable -> Process r (ResumeProcess ())

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

-- | Receive a message that matches a criteria. This should block until an
--   a message was received. The message is returned as a
--   <a>ResumeProcess</a> 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, without 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 <a>Interrupt</a>
--   <a>LinkedProcessCrashed</a>.
[Link] :: ProcessId -> Process r (ResumeProcess ())

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

-- | Update the <a>ProcessDetails</a> of a process
[UpdateProcessDetails] :: ProcessDetails -> Process r (ResumeProcess ())

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

-- | An isomorphism lens for the <a>ProcessTitle</a>
fromProcessTitle :: Lens' ProcessTitle Text

-- | An isomorphism lens for the <a>ProcessDetails</a>
fromProcessDetails :: Lens' ProcessDetails Text

-- | Deeply evaluate the given value and wrap it into a
--   <a>StrictDynamic</a>.
toStrictDynamic :: (Typeable a, NFData a) => a -> StrictDynamic

-- | Convert a <a>StrictDynamic</a> back to a value.
fromStrictDynamic :: Typeable a => StrictDynamic -> Maybe a

-- | Convert a <a>StrictDynamic</a> back to an unwrapped <a>Dynamic</a>.
unwrapStrictDynamic :: StrictDynamic -> Dynamic

-- | Create a message selector for a value that can be obtained by
--   <a>fromStrictDynamic</a>.
selectMessage :: Typeable t => MessageSelector t

-- | Create a message selector from a predicate.
filterMessage :: 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>).
selectMessageWith :: Typeable a => (a -> Maybe b) -> MessageSelector b

-- | Create a message selector.
selectDynamicMessage :: (StrictDynamic -> 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.
selectAnyMessage :: MessageSelector StrictDynamic

-- | Get the <a>ExitRecovery</a>
toExitRecovery :: Interrupt r -> ExitRecovery

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

-- | Return either <a>ExitNormally</a> or <a>interruptToExit</a> from a
--   <a>Recoverable</a> <a>Interrupt</a>;
--   
--   If the <a>Interrupt</a> is <a>NormalExitRequested</a> then return
--   <a>ExitNormally</a>
interruptToExit :: Interrupt  'Recoverable -> Interrupt  'NoRecovery

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

-- | Handle all <a>Interrupt</a>s of an <a>Processes</a> by wrapping them
--   up in <a>interruptToExit</a> and then do a process <a>Shutdown</a>.
provideInterruptsShutdown :: forall e a. Eff (Processes e) a -> Eff (SafeProcesses e) a

-- | Handle <a>Interrupt</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) => (Interrupt  'Recoverable -> Eff r a) -> Eff r a -> Eff r a

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

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

-- | Handle <a>Interrupt</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, HasProcesses r q) => Eff r a -> Eff r a

-- | Handle <a>Interrupt</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 (Interrupt  'Recoverable) a)

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

-- | Throw an <a>Interrupt</a>, can be handled by <a>handleInterrupts</a>
--   or <a>exitOnInterrupt</a> or <a>provideInterrupts</a>.
interrupt :: (HasCallStack, Member Interrupts r) => Interrupt  'Recoverable -> Eff r a

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

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

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

-- | Print a <a>Interrupt</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 :: Interrupt -&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 :: Interrupt x -> Maybe Text

-- | Log the <a>Interrupt</a>s
logProcessExit :: forall e x. (Member Logs e, HasCallStack) => Interrupt 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. (HasSafeProcesses r q, HasCallStack) => Process q (ResumeProcess v) -> Eff r (Either (Interrupt  '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. (HasSafeProcesses r q, 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. (HasProcesses r q, HasCallStack) => 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. (HasProcesses r q, HasCallStack) => Eff r ()

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>.
--   
--   The message will be reduced to normal form (<a>rnf</a>) by/in the
--   caller process.
sendMessage :: forall r q o. (HasProcesses r q, HasCallStack, Typeable o, NFData o) => 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. (HasCallStack, HasProcesses r q) => ProcessId -> StrictDynamic -> 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. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt  '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. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt  'Recoverable -> 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>Interrupt</a> wrapped in <a>interruptToExit</a>. For specific use
--   cases it might be better to use <a>spawnRaw</a>.
spawn :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ProcessId

-- | Like <a>spawn</a> but return <tt>()</tt>.
spawn_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ()

-- | Start a new process, and immediately link to it.
spawnLink :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes 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>SafeProcesses</a> effects. For
--   non-library code <a>spawn</a> might be better suited.
spawnRaw :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff r ProcessId

-- | Like <a>spawnRaw</a> but return <tt>()</tt>.
spawnRaw_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff r ()

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

-- | Return the <a>ProcessTitle</a>, <a>ProcessDetails</a> and
--   <a>ProcessState</a>, for the given process, if the process is alive.
getProcessState :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r (Maybe (ProcessTitle, ProcessDetails, ProcessState))

-- | Replace the <a>ProcessDetails</a> of the process.
updateProcessDetails :: forall r q. (HasCallStack, HasProcesses r q) => ProcessDetails -> Eff r ()

-- | Block until a message was received. See <a>ReceiveSelectedMessage</a>
--   for more documentation.
receiveAnyMessage :: forall r q. (HasCallStack, HasProcesses r q) => Eff r StrictDynamic

-- | 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, HasProcesses r 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, NFData a, Show a, HasProcesses r q) => Eff r a

-- | Remove and return all messages currently enqueued in the process
--   message queue.
flushMessages :: forall r q. (HasCallStack, HasProcesses r q) => Eff r [StrictDynamic]

-- | 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> <a>Interrupt</a></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. (HasSafeProcesses r q, HasCallStack) => MessageSelector a -> (Either (Interrupt  'Recoverable) a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Like <a>receiveSelectedLoop</a> but <i>not selective</i>. See also
--   <a>selectAnyMessage</a>, <a>receiveSelectedLoop</a>.
receiveAnyLoop :: forall r q endOfLoopResult. (HasSafeProcesses r q, HasCallStack) => (Either (Interrupt  'Recoverable) StrictDynamic -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

-- | Like <a>receiveSelectedLoop</a> but refined to casting to a specific
--   <a>Typeable</a> using <a>selectMessage</a>.
receiveLoop :: forall r q a endOfLoopResult. (HasSafeProcesses r q, HasCallStack, NFData a, Typeable a) => (Either (Interrupt  'Recoverable) a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult

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

-- | Generate a unique <a>Int</a> for the current process.
makeReference :: (HasCallStack, HasProcesses r 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, without exit reason
monitor :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r MonitorReference

-- | Remove a monitor created with <a>monitor</a>.
demonitor :: forall r q. (HasCallStack, HasProcesses r q) => MonitorReference -> Eff r ()

-- | <a>monitor</a> another process before while performing an action and
--   <a>demonitor</a> afterwards.
withMonitor :: (HasCallStack, HasProcesses r 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, HasProcesses r q, Typeable a, Show a) => ProcessId -> MessageSelector a -> Eff r (Either ProcessDown a)

-- | Make an <a>Interrupt</a> for a <a>ProcessDown</a> message.
--   
--   For example: <tt>doSomething &gt;&gt;= either (interrupt .
--   becauseProcessIsDown) return</tt>
becauseProcessIsDown :: ProcessDown -> Interrupt  'Recoverable

-- | A <a>MessageSelector</a> for the <a>ProcessDown</a> message of a
--   specific process.
--   
--   The parameter is the value obtained by <a>monitor</a>.
selectProcessDown :: MonitorReference -> MessageSelector ProcessDown

-- | A <a>MessageSelector</a> for the <a>ProcessDown</a> message. of a
--   specific process.
--   
--   In contrast to <a>selectProcessDown</a> this function matches the
--   <a>ProcessId</a>.
selectProcessDownByProcessId :: ProcessId -> 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 <a>Interrupt</a>
--   <a>LinkedProcessCrashed</a>.
linkProcess :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r ()

-- | Unlink the calling process from the other process.
unlinkProcess :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r ()

-- | Exit the process with a <a>Interrupt</a>.
exitBecause :: forall r q a. (HasCallStack, HasSafeProcesses r q) => Interrupt  'NoRecovery -> Eff r a

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

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

-- | A <a>ProcessId</a> and a <a>Serializer</a>. EXPERIMENTAL
--   
--   See <a>sendToReceiver</a>.
data Receiver a
Receiver :: ProcessId -> (a -> out) -> Receiver a
[_receiverPid] :: Receiver a -> ProcessId
[_receiverSerializer] :: Receiver a -> a -> out
fromProcessId :: Iso' ProcessId Int

-- | Serialize and send a message to the process in a <a>Receiver</a>.
--   
--   EXPERIMENTAL
sendToReceiver :: (NFData o, HasProcesses r q) => Receiver o -> o -> Eff r ()
receiverPid :: forall a_aHxu. Lens' (Receiver a_aHxu) ProcessId

-- | A class for <a>Pdu</a> instances that embed other <a>Pdu</a>.
--   
--   This is a part of <a>Embeds</a> provide instances for your <a>Pdu</a>s
--   but in client code use the <a>Embeds</a> constraint.
--   
--   Instances of this class serve as proof to <a>Embeds</a> that a
--   conversion into another <a>Pdu</a> actually exists.
--   
--   A <a>Prism</a> for the embedded <a>Pdu</a> is the center of this class
--   
--   Laws: <tt>embeddedPdu = prism' embedPdu fromPdu</tt>
class (Typeable protocol, Typeable embeddedProtocol) => HasPduPrism protocol embeddedProtocol

-- | A <a>Prism</a> for the embedded <a>Pdu</a>s.
embeddedPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Prism' (Pdu protocol result) (Pdu embeddedProtocol result)

-- | Embed the <a>Pdu</a> value of an embedded protocol into the
--   corresponding <a>Pdu</a> value.
embedPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Pdu embeddedProtocol result -> Pdu protocol result

-- | Examine a <a>Pdu</a> value from the outer protocol, and return it, if
--   it embeds a <a>Pdu</a> of embedded protocol, otherwise return
--   <a>Nothing</a>/
fromPdu :: forall (result :: Synchronicity). HasPduPrism protocol embeddedProtocol => Pdu protocol result -> Maybe (Pdu embeddedProtocol result)

-- | This type function takes an <a>Pdu</a> and analysis the reply type,
--   i.e. the <a>Synchronicity</a> and evaluates to either <tt>t</tt> for
--   an <tt>Pdu x (<a>Synchronous</a> t)</tt> or to '()' for an <tt>Pdu x
--   <a>Asynchronous</a></tt>.
type family ProtocolReply (s :: Synchronicity)

-- | The (promoted) constructors of this type specify (at the type level)
--   the reply behavior of a specific constructor of an <tt>Pdu</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

-- | A <a>Constraint</a> that bundles the requirements for the <a>Pdu</a>
--   values of a protocol.
--   
--   This ensures that <a>Pdu</a>s can be strictly and deeply evaluated and
--   shown such that for example logging is possible.
type TangiblePdu p r = (Typeable p, Typeable r, Tangible (Pdu p r), HasPdu p)

-- | A set of constraints for types that can evaluated via <a>NFData</a>,
--   compared via <a>Ord</a> and presented dynamically via <a>Typeable</a>,
--   and represented both as values via <a>Show</a>.
type Tangible i = (NFData i, Typeable i, Show i)

-- | A constraint that requires that the <tt>outer</tt> <a>Pdu</a> has a
--   clause to embed values from the <tt>inner</tt> <a>Pdu</a>.
--   
--   Also, this constraint requires a <a>HasPduPrism</a> instance, as a
--   proof for a possible conversion of an embedded <a>Pdu</a> value into
--   to the enclosing <a>Pdu</a>.
--   
--   This generates better compiler error messages, when an embedding of a
--   <a>Pdu</a> into another.
--   
--   This is provided by <a>HasPdu</a> instances. The instances are
--   required to provide a list of embedded <a>Pdu</a> values in
--   <a>EmbeddedPduList</a>.
--   
--   Note that every type embeds itself, so <tt>Embeds x x</tt> always
--   holds.
type Embeds outer inner = (HasPduPrism outer inner, CheckEmbeds outer inner, HasPdu outer)

-- | This type class and the associated data family defines the <b>protocol
--   data units</b> (PDU) of a <i>protocol</i>.
--   
--   A Protocol in the sense of a communication interface description
--   between processes.
--   
--   The first parameter is usually a user defined type that identifies the
--   protocol that uses the <a>Pdu</a>s are. It maybe a <i>phantom</i>
--   type.
--   
--   The second parameter specifies if a specific constructor of an
--   (GADT-like) <tt>Pdu</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
--   
--   instance Typeable r =&gt; HasPdu BookShop r where
--     data instance Pdu BookShop r where
--       RentBook  :: BookId   -&gt; Pdu BookShop ('Synchronous (Either RentalError RentalId))
--       BringBack :: RentalId -&gt; Pdu BookShop 'Asynchronous
--       deriving Typeable
--   
--   type BookId = Int
--   type RentalId = Int
--   type RentalError = String
--   </pre>
class Typeable protocol => HasPdu (protocol :: Type) where {
    
    -- | A type level list Protocol phantom types included in the associated
    --   <a>Pdu</a> instance.
    --   
    --   This is just a helper for better compiler error messages. It relies on
    --   <a>Embeds</a> to add the constraint <a>HasPduPrism</a>.
    type family EmbeddedPduList protocol :: [Type];
    
    -- | The <b>protocol data unit</b> type for the given protocol.
    data family Pdu protocol (reply :: Synchronicity);
    type EmbeddedPduList protocol = '[];
}

-- | A server process for <i>protocol</i>.
--   
--   Protocols are represented by phantom types, which are used in
--   different places to index type families and type class instances.
--   
--   A <a>Process</a> can send and receive any messages. An <a>Endpoint</a>
--   wraps around a <a>ProcessId</a> and carries a phantom type to indicate
--   the kinds of messages accepted by the process.
--   
--   As a metaphor, communication between processes can be thought of
--   waiting for and sending <b>protocol data units</b> belonging to some
--   protocol.
newtype Endpoint protocol
Endpoint :: ProcessId -> Endpoint protocol
[_fromEndpoint] :: Endpoint protocol -> ProcessId

-- | Tag a <a>ProcessId</a> with an <a>Pdu</a> type index to mark it a
--   <a>Endpoint</a> process handling that API
proxyAsEndpoint :: proxy protocol -> ProcessId -> Endpoint protocol

-- | Tag a <a>ProcessId</a> with an <a>Pdu</a> type index to mark it a
--   <a>Endpoint</a> process handling that API
asEndpoint :: forall protocol. ProcessId -> Endpoint protocol

-- | Convert an <a>Endpoint</a> to an endpoint for an embedded protocol.
--   
--   See <a>Embeds</a>, <a>fromEmbeddedEndpoint</a>.
toEmbeddedEndpoint :: forall inner outer. Embeds outer inner => Endpoint outer -> Endpoint inner

-- | Convert an <a>Endpoint</a> to an endpoint for a server, that embeds
--   the protocol.
--   
--   See <a>Embeds</a>, <a>toEmbeddedEndpoint</a>.
fromEmbeddedEndpoint :: forall outer inner. HasPduPrism outer inner => Endpoint inner -> Endpoint outer
fromEndpoint :: forall protocol_aTMy protocol_aUUM. Iso (Endpoint protocol_aTMy) (Endpoint protocol_aUUM) ProcessId ProcessId

-- | Target of a <a>Call</a> reply.
--   
--   This combines a <a>RequestOrigin</a> with a <a>Serializer</a> for a
--   <a>Reply</a> using <a>Arg</a>. There are to smart constructors for
--   this type: <a>replyTarget</a> and <a>embeddedReplyTarget</a>.
--   
--   Because of <a>Arg</a> the <a>Eq</a> and <a>Ord</a> instances are
--   implemented via the <a>RequestOrigin</a> instances.
newtype ReplyTarget p r
MkReplyTarget :: Arg (RequestOrigin p r) (Serializer (Reply p r)) -> ReplyTarget p r

-- | Wraps the source <a>ProcessId</a> and a unique identifier for a
--   <a>Call</a>.
data RequestOrigin (proto :: Type) reply
RequestOrigin :: !ProcessId -> !Int -> RequestOrigin reply
[_requestOriginPid] :: RequestOrigin reply -> !ProcessId
[_requestOriginCallRef] :: RequestOrigin reply -> !Int

-- | The wrapper around replies to <a>Call</a>s.
data Reply protocol reply
[Reply] :: Tangible reply => {_replyTo :: RequestOrigin protocol reply, _replyValue :: reply} -> Reply protocol reply

-- | A wrapper sum type for calls and casts for the <a>Pdu</a>s of a
--   protocol
data Request protocol
[Call] :: forall protocol reply. (Tangible reply, TangiblePdu protocol ( 'Synchronous reply)) => RequestOrigin protocol reply -> Pdu protocol ( 'Synchronous reply) -> Request protocol
[Cast] :: forall protocol. (TangiblePdu protocol  'Asynchronous, NFData (Pdu protocol  'Asynchronous)) => Pdu protocol  'Asynchronous -> Request protocol

-- | Create a new, unique <a>RequestOrigin</a> value for the current
--   process.
makeRequestOrigin :: (Typeable r, NFData r, HasProcesses e q0) => Eff e (RequestOrigin p r)

-- | Turn an <a>RequestOrigin</a> to an origin for an embedded request (See
--   <a>Embeds</a>).
--   
--   This is useful of a server delegates the <tt>calls</tt> and
--   <tt>casts</tt> for an embedded protocol to functions, that require the
--   <a>Serializer</a> and <a>RequestOrigin</a> in order to call
--   <a>sendReply</a>.
--   
--   See also <a>embedReplySerializer</a>.
toEmbeddedOrigin :: forall outer inner reply. Embeds outer inner => RequestOrigin outer reply -> RequestOrigin inner reply

-- | Turn an <i>embedded</i> <a>RequestOrigin</a> to a <a>RequestOrigin</a>
--   for the <i>bigger</i> request.
--   
--   This is the inverse of <a>toEmbeddedOrigin</a>.
--   
--   This function is strict in all parameters.
embedRequestOrigin :: forall outer inner reply. Embeds outer inner => RequestOrigin inner reply -> RequestOrigin outer reply

-- | Turn a <a>Serializer</a> for a <a>Pdu</a> instance that contains
--   embedded <a>Pdu</a> values into a <a>Reply</a> <a>Serializer</a> for
--   the embedded <a>Pdu</a>.
--   
--   This is useful of a server delegates the <tt>calls</tt> and
--   <tt>casts</tt> for an embedded protocol to functions, that require the
--   <a>Serializer</a> and <a>RequestOrigin</a> in order to call
--   <a>sendReply</a>.
--   
--   See also <a>toEmbeddedOrigin</a>.
embedReplySerializer :: forall outer inner reply. Embeds outer inner => Serializer (Reply outer reply) -> Serializer (Reply inner reply)

-- | Answer a <a>Call</a> by sending the reply value to the client process.
--   
--   The <a>ProcessId</a>, the <a>RequestOrigin</a> and the <a>Reply</a>
--   <a>Serializer</a> are stored in the <a>ReplyTarget</a>.
sendReply :: (HasProcesses eff q, Tangible reply, Typeable protocol) => ReplyTarget protocol reply -> reply -> Eff eff ()

-- | Smart constructor for a <a>ReplyTarget</a>.
--   
--   To build a <tt>ReplyTarget</tt> for an <a>Embeds</a> instance use
--   <a>embeddedReplyTarget</a>.
replyTarget :: Serializer (Reply p reply) -> RequestOrigin p reply -> ReplyTarget p reply

-- | A simple <a>Lens</a> for the <a>RequestOrigin</a> of a
--   <a>ReplyTarget</a>.
replyTargetOrigin :: Lens' (ReplyTarget p reply) (RequestOrigin p reply)

-- | A simple <a>Lens</a> for the <a>Reply</a> <a>Serializer</a> of a
--   <a>ReplyTarget</a>.
replyTargetSerializer :: Lens' (ReplyTarget p reply) (Serializer (Reply p reply))

-- | Smart constructor for an <i>embedded</i> <a>ReplyTarget</a>.
--   
--   This combines <a>replyTarget</a> and <a>toEmbeddedReplyTarget</a>.
embeddedReplyTarget :: Embeds outer inner => Serializer (Reply outer reply) -> RequestOrigin outer reply -> ReplyTarget inner reply

-- | Convert a <a>ReplyTarget</a> to be usable for <i>embedded</i> replies.
--   
--   This combines a <a>toEmbeddedOrigin</a> with
--   <a>embedReplySerializer</a> to produce a <a>ReplyTarget</a> that can
--   be passed to functions defined soley on an embedded protocol.
toEmbeddedReplyTarget :: Embeds outer inner => ReplyTarget outer reply -> ReplyTarget inner reply

-- | 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, HasProcesses r q, Typeable a, NFData a, Show a) => 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, HasProcesses r q, Show a) => MessageSelector a -> Timeout -> Eff r (Either TimerElapsed a)

-- | Like <a>receiveWithMonitor</a> combined with
--   <a>receiveSelectedAfter</a>.
receiveSelectedWithMonitorAfter :: forall a r q. (Lifted IO q, HasCallStack, HasProcesses r q, Show a) => ProcessId -> MessageSelector a -> Timeout -> Eff r (Either (Either ProcessDown 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, HasProcesses r q, Typeable message, NFData message) => 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, HasProcesses r q) => Timeout -> Eff r TimerReference

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

-- | The reader effect for <a>ProcessId</a>s for <a>Pdu</a>s, see
--   <a>runEndpointReader</a>
type EndpointReader o = Reader (Endpoint o)

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

-- | Send a request <a>Pdu</a> that has no reply and return immediately.
--   
--   The type signature enforces that the corresponding <a>Pdu</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.
--   
--   The message will be reduced to normal form (<tt>rnf</tt>) in the
--   caller process.
cast :: forall destination protocol r q. (HasCallStack, HasProcesses r q, HasPdu destination, HasPdu protocol, Tangible (Pdu destination  'Asynchronous), Embeds destination protocol) => Endpoint destination -> Pdu protocol  'Asynchronous -> Eff r ()

-- | Send a request <a>Pdu</a> and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Pdu</a> clause
--   is <a>Synchronous</a>.
--   
--   <b>Always prefer <a>callWithTimeout</a> over <a>call</a></b>
call :: forall result destination protocol r q. (HasProcesses r q, TangiblePdu destination ( 'Synchronous result), TangiblePdu protocol ( 'Synchronous result), Tangible result, Embeds destination protocol, HasCallStack) => Endpoint destination -> Pdu protocol ( 'Synchronous result) -> Eff r result

-- | Send an request <a>Pdu</a> and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Pdu</a> clause
--   is <a>Synchronous</a>.
--   
--   If the server that was called dies, this function interrupts the
--   process with <a>ProcessDown</a>. If the server takes longer to reply
--   than the given timeout, this function interrupts the process with
--   <a>TimeoutInterrupt</a>.
--   
--   <b>Always prefer this function over <a>call</a></b>
callWithTimeout :: forall result destination protocol r q. (HasProcesses r q, TangiblePdu destination ( 'Synchronous result), TangiblePdu protocol ( 'Synchronous result), Tangible result, Member Logs r, Lifted IO q, Lifted IO r, HasCallStack, Embeds destination protocol) => Endpoint destination -> Pdu protocol ( 'Synchronous result) -> Timeout -> Eff r result

-- | Run a reader effect that contains <b>the one</b> server handling a
--   specific <a>Pdu</a> instance.
runEndpointReader :: HasCallStack => Endpoint o -> Eff (EndpointReader o : r) a -> Eff r a

-- | Get the <a>Endpoint</a> registered with <a>runEndpointReader</a>.
askEndpoint :: Member (EndpointReader o) e => Eff e (Endpoint o)

-- | Like <a>call</a> but take the <a>Endpoint</a> from the reader provided
--   by <a>runEndpointReader</a>.
--   
--   When working with an embedded <a>Pdu</a> use <a>callSingleton</a>.
callEndpointReader :: forall reply o r q. (HasEndpointReader o r, HasCallStack, Tangible reply, TangiblePdu o ( 'Synchronous reply), HasProcesses r q, Embeds o o) => Pdu o ( 'Synchronous reply) -> Eff r reply

-- | Like <a>cast</a> but take the <a>Endpoint</a> from the reader provided
--   by <a>runEndpointReader</a>.
--   
--   When working with an embedded <a>Pdu</a> use <a>castSingleton</a>.
castEndpointReader :: forall o r q. (HasEndpointReader o r, HasProcesses r q, Tangible (Pdu o  'Asynchronous), HasCallStack, HasPdu o, Embeds o o) => Pdu o  'Asynchronous -> Eff r ()

-- | Like <a>callEndpointReader</a>, uses <a>embedPdu</a> to embed the
--   value.
--   
--   This function makes use of AmbigousTypes and TypeApplications.
--   
--   When not working with an embedded <a>Pdu</a> use
--   <a>callEndpointReader</a>.
callSingleton :: forall outer inner reply q e. (HasCallStack, Member (EndpointReader outer) e, Embeds outer inner, Embeds outer outer, HasProcesses e q, TangiblePdu outer ( 'Synchronous reply), TangiblePdu inner ( 'Synchronous reply), Tangible reply) => Pdu inner ( 'Synchronous reply) -> Eff e reply

-- | Like <a>castEndpointReader</a>, but uses <a>embedPdu</a> to embed the
--   value.
--   
--   This function makes use of AmbigousTypes and TypeApplications.
--   
--   When not working with an embedded <a>Pdu</a> use
--   <a>castEndpointReader</a>.
castSingleton :: forall outer inner q e. (HasCallStack, Member (EndpointReader outer) e, Tangible (Pdu outer  'Asynchronous), HasProcesses e q, HasPdu outer, HasPdu inner, Embeds outer inner, Embeds outer outer) => Pdu inner  'Asynchronous -> Eff e ()

-- | Alias for the effect that contains the observers managed by
--   <a>evalObserverRegistryState</a>
type ObserverRegistryState event = State (ObserverRegistry event)

-- | A protocol for managing <a>Observer</a>s, encompassing registration
--   and de-registration of <a>Observer</a>s.
data ObserverRegistry (event :: Type)
MkObserverRegistry :: Map ProcessId (ObservationSink event) -> ObserverRegistry
[_observerRegistry] :: ObserverRegistry -> Map ProcessId (ObservationSink event)

-- | Convenience type alias.
type CanObserve eventSink event = (Tangible event, Embeds eventSink (Observer event), HasPdu eventSink)

-- | Convenience type alias.
type IsObservable eventSource event = (Tangible event, Embeds eventSource (ObserverRegistry event), HasPdu eventSource)

-- | The Information necessary to wrap an <a>Observed</a> event to a
--   process specific message, e.g. the embedded <a>Observer</a> <a>Pdu</a>
--   instance, and the <a>MonitorReference</a> of the destination process.
data ObservationSink event

-- | A <i>protocol</i> to communicate <a>Observed</a> events from a sources
--   to many sinks.
--   
--   A sink is any process that serves a protocol with a <a>Pdu</a>
--   instance that embeds the <a>Observer</a> Pdu via an <a>HasPduPrism</a>
--   instance.
--   
--   This type has <i>dual use</i>, for one it serves as type-index for
--   <a>Pdu</a>, i.e. <a>HasPdu</a> respectively, and secondly it contains
--   an <a>ObservationSink</a> and a <a>MonitorReference</a>.
--   
--   The <a>ObservationSink</a> is used to serialize and send the
--   <a>Observed</a> events, while the <a>ProcessId</a> serves as key for
--   internal maps.
newtype Observer event
MkObserver :: Arg ProcessId (ObservationSink event) -> Observer event

-- | And an <a>Observer</a> to the set of recipients for all observations
--   reported by <a>observerRegistryNotify</a>. Note that the
--   observerRegistry are keyed by the observing process, i.e. a previous
--   entry for the process contained in the <a>Observer</a> is overwritten.
--   If you want multiple entries for a single process, just combine
--   several filter functions.
registerObserver :: forall event eventSink eventSource r q. (HasCallStack, HasProcesses r q, IsObservable eventSource event, Tangible (Pdu eventSource  'Asynchronous), Tangible (Pdu eventSink  'Asynchronous), CanObserve eventSink event) => Endpoint eventSource -> Endpoint eventSink -> Eff r ()

-- | Send the <a>ForgetObserver</a> message
forgetObserver :: forall event eventSink eventSource r q. (HasProcesses r q, HasCallStack, Tangible (Pdu eventSource  'Asynchronous), Tangible (Pdu eventSink  'Asynchronous), IsObservable eventSource event, CanObserve eventSink event) => Endpoint eventSource -> Endpoint eventSink -> Eff r ()

-- | Send the <a>ForgetObserver</a> message, use a raw <a>ProcessId</a> as
--   parameter.
forgetObserverUnsafe :: forall event eventSource r q. (HasProcesses r q, HasCallStack, Tangible (Pdu eventSource  'Asynchronous), IsObservable eventSource event) => Endpoint eventSource -> ProcessId -> Eff r ()

-- | Provide the implementation for the <a>ObserverRegistry</a> Protocol,
--   this handled <a>RegisterObserver</a> and <a>ForgetObserver</a>
--   messages. It also adds the <a>ObserverRegistryState</a> constraint to
--   the effect list.
observerRegistryHandlePdu :: forall event q r. (HasCallStack, Typeable event, HasProcesses r q, Member (ObserverRegistryState event) r, Member Logs r) => Pdu (ObserverRegistry event)  'Asynchronous -> Eff r ()

-- | Remove the entry in the <a>ObserverRegistry</a> for the
--   <a>ProcessId</a> and return <a>True</a> if there was an entry,
--   <a>False</a> otherwise.
observerRegistryRemoveProcess :: forall event q r. (HasCallStack, Typeable event, HasProcesses r q, Member (ObserverRegistryState event) r, Member Logs r) => ProcessId -> Eff r Bool

-- | Keep track of registered <a>Observer</a>s.
--   
--   Handle the <a>ObserverRegistryState</a> effect, i.e. run
--   <a>evalState</a> on an <a>emptyObserverRegistry</a>.
evalObserverRegistryState :: HasCallStack => Eff (ObserverRegistryState event : r) a -> Eff r a

-- | The empty <a>ObserverRegistryState</a>
emptyObserverRegistry :: ObserverRegistry event

-- | Report an observation to all observers. The process needs to
--   <a>evalObserverRegistryState</a> and to
--   <a>observerRegistryHandlePdu</a>.
observerRegistryNotify :: forall event r q. (HasProcesses r q, Member (ObserverRegistryState event) r, Tangible event, HasCallStack) => event -> Eff r ()

-- | Alias for the <a>Writer</a> that contains the captured
--   <a>LogMessage</a>s from <a>CaptureLogs</a>.
type CaptureLogWriter = Writer LogMessage

-- | A <a>LogWriter</a> monad that provides pure logging by capturing via
--   the <a>Writer</a> effect.
type CaptureLogs a = LogWriterM CaptureLogWriter a

-- | A <a>LogWriter</a> monad that provides pure logging by capturing via
--   the <a>Writer</a> effect.
--   
--   See <a>exampleLogCapture</a>
captureLogWriter :: LogWriter CaptureLogWriter

-- | Run a <a>Writer</a> for <a>LogMessage</a>s.
--   
--   Such a <a>Writer</a> is needed to handle <a>CaptureLogWriter</a>
runCaptureLogWriter :: Eff (CaptureLogWriter : e) a -> Eff e (a, [LogMessage])

-- | The concrete list of <a>Eff</a>ects for logging with an IO based
--   <a>LogWriter</a>, and a <a>LogWriterReader</a>.
type LoggingAndIo = '[Logs, LogWriterReader (Lift IO), Lift IO]

-- | A <a>LogWriter</a> that uses an <a>IO</a> action to write the message.
--   
--   This is just an alias for <a>MkLogWriter</a> but with <tt>IO</tt> as
--   parameter. This reduces the need to apply something to the extra type
--   argument <tt>@IO</tt>.
--   
--   Example use cases for this function are the <tt>consoleLogWriter</tt>
--   and the <a>ioHandleLogWriter</a>.
mkLogWriterIO :: HasCallStack => (LogMessage -> IO ()) -> LogWriter (Lift IO)

-- | A <a>LogWriter</a> that renders <a>LogMessage</a>s to strings via
--   <a>renderLogMessageConsoleLog</a> and prints them to an <a>Handle</a>
--   using <tt>hPutStrLn</tt>.
ioHandleLogWriter :: HasCallStack => Handle -> LogWriter (Lift IO)

-- | Enable logging to IO using the <a>defaultIoLogWriter</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithIoLogging :: IO ()
--   exampleWithIoLogging =
--       runLift
--     $ withIoLogging debugTraceLogWriter
--                     "my-app"
--                     local7
--                     (lmSeverityIsAtLeast informationalSeverity)
--     $ logInfo "Oh, hi there"
--   </pre>
withIoLogging :: Lifted IO e => LogWriter (Lift IO) -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Decorate an IO based <a>LogWriter</a> to fill out these fields in
--   <a>LogMessage</a>s:
--   
--   <ul>
--   <li>The messages will carry the given application name in the
--   <a>lmAppName</a> field.</li>
--   <li>The <a>lmTimestamp</a> field contains the UTC time of the log
--   event</li>
--   <li>The <a>lmHostname</a> field contains the FQDN of the current
--   host</li>
--   <li>The <a>lmFacility</a> field contains the given
--   <a>Facility</a></li>
--   </ul>
--   
--   It works by using <a>mappingLogWriterM</a>.
defaultIoLogWriter :: Text -> Facility -> LogWriter (Lift IO) -> LogWriter (Lift IO)

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

-- | Enable logging to a file, with some <a>LogMessage</a> fields preset as
--   described in <a>withIoLogging</a>.
--   
--   If the file or its directory does not exist, it will be created.
--   
--   Example:
--   
--   <pre>
--   exampleWithFileLogging :: IO ()
--   exampleWithFileLogging =
--       runLift
--     $ withFileLogging "/var/log/my-app.log" "my-app" local7 allLogMessages
--     $ logInfo "Oh, hi there"
--   </pre>
--   
--   To vary the <a>LogWriter</a> use <a>withIoLogging</a>.
withFileLogging :: (Lifted IO e, MonadBaseControl IO (Eff e)) => FilePath -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Enable logging to a file.
--   
--   If the file or its directory does not exist, it will be created.
--   Example:
--   
--   <pre>
--   exampleWithFileLogWriter :: IO ()
--   exampleWithFileLogWriter =
--       runLift
--     $ withSomeLogging @IO
--     $ withFileLogWriter "test.log"
--     $ logInfo "Oh, hi there"
--   </pre>
withFileLogWriter :: (LogIo e, MonadBaseControl IO (Eff e)) => FilePath -> Eff e b -> Eff e b

-- | Enable logging via <a>traceM</a> using the <a>debugTraceLogWriter</a>,
--   with some <a>LogMessage</a> fields preset as in <a>withIoLogging</a>.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithTraceLogging :: IO ()
--   exampleWithTraceLogging =
--       runLift
--     $ withTraceLogging "my-app" local7 allLogMessages
--     $ logInfo "Oh, hi there"
--   </pre>
withTraceLogging :: Lifted IO e => Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Enable logging via <a>traceM</a> using the <a>debugTraceLogWriter</a>.
--   The logging monad type can be <i>any</i> type with a <a>Monad</a>
--   instance.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithTraceLogWriter :: IO ()
--   exampleWithTraceLogWriter =
--       runLift
--     $ withSomeLogging @IO
--     $ withTraceLogWriter
--     $ logInfo "Oh, hi there"
--   </pre>
withTraceLogWriter :: forall h e a. (Monad (LogWriterM h), LogsTo h e) => Eff e a -> Eff e a

-- | Write <a>LogMessage</a>s via <a>traceM</a>.
debugTraceLogWriter :: forall h. Monad (LogWriterM h) => LogMessageRenderer Text -> LogWriter h

-- | Enable logging to <tt>standard output</tt> using the
--   <a>consoleLogWriter</a>, with some <a>LogMessage</a> fields preset as
--   in <a>withIoLogging</a>.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithConsoleLogging :: IO ()
--   exampleWithConsoleLogging =
--       runLift
--     $ withConsoleLogging "my-app" local7 allLogMessages
--     $ logInfo "Oh, hi there"
--   </pre>
--   
--   To vary the <a>LogWriter</a> use <a>withIoLogging</a>.
withConsoleLogging :: Lifted IO e => Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Enable logging to <tt>standard output</tt> using the
--   <a>consoleLogWriter</a>.
--   
--   Log messages are rendered using <a>renderLogMessageConsoleLog</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithConsoleLogWriter :: IO ()
--   exampleWithConsoleLogWriter =
--       runLift
--     $ withSomeLogging @IO
--     $ withConsoleLogWriter
--     $ logInfo "Oh, hi there"
--   </pre>
withConsoleLogWriter :: LogIo e => Eff e a -> Eff e a

-- | Write <a>LogMessage</a>s to standard output, formatted with
--   <a>printLogMessage</a>.
--   
--   It uses <a>stdoutLogWriter</a> with <a>renderLogMessageConsoleLog</a>.
consoleLogWriter :: LogWriter (Lift IO)

-- | A <a>LogWriter</a> that uses a <a>LogMessageRenderer</a> to render,
--   and <a>putStrLn</a> to print it.
stdoutLogWriter :: LogMessageRenderer Text -> LogWriter (Lift IO)

-- | This is a wrapper around <a>withAsyncLogWriter</a> and
--   <a>withIoLogging</a>.
--   
--   Example:
--   
--   <pre>
--   exampleWithAsyncLogging :: IO ()
--   exampleWithAsyncLogging =
--       runLift
--     $ withAsyncLogWriter consoleLogWriter (1000::Int) "my-app" local0 allLogMessages
--     $ do logMsg "test 1"
--          logMsg "test 2"
--          logMsg "test 3"
--   </pre>
withAsyncLogging :: (Lifted IO e, MonadBaseControl IO (Eff e), Integral len) => LogWriter (Lift IO) -> len -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | <i>Move</i> the current <a>LogWriter</a> into its own thread.
--   
--   A bounded queue is used to forward logs to the process.
--   
--   If an exception is received, 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:
--   
--   <pre>
--   exampleAsyncLogWriter :: IO ()
--   exampleAsyncLogWriter =
--       runLift
--     $ withLogging consoleLogWriter
--     $ withAsyncLogWriter (1000::Int)
--     $ do logMsg "test 1"
--          logMsg "test 2"
--          logMsg "test 3"
--   </pre>
withAsyncLogWriter :: (LogIo e, MonadBaseControl IO (Eff e), Integral len) => len -> Eff e a -> Eff e a

-- | Enable logging to a remote host via <b>UDP</b>, with some
--   <a>LogMessage</a> fields preset as in <a>withIoLogging</a>.
--   
--   See <a>exampleUdpRFC3164Logging</a>
withUDPLogging :: (HasCallStack, MonadBaseControl IO (Eff e), Lifted IO e) => (LogMessage -> Text) -> String -> String -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Enable logging to a (remote-) host via UDP.
--   
--   See <a>exampleUdpRFC3164Logging</a>
withUDPLogWriter :: (LogIo e, MonadBaseControl IO (Eff e), HasCallStack) => (LogMessage -> Text) -> String -> String -> Eff e b -> Eff e b

-- | Enable logging to a <i>unix domain socket</i>, with some
--   <a>LogMessage</a> fields preset as in <a>withIoLogging</a>.
--   
--   See <a>exampleDevLogSyslogLogging</a>
withUnixSocketLogging :: (HasCallStack, MonadBaseControl IO (Eff e), Lifted IO e) => LogMessageRenderer Text -> FilePath -> Text -> Facility -> LogPredicate -> Eff (Logs : (LogWriterReader (Lift IO) : e)) a -> Eff e a

-- | Enable logging to a (remote-) host via UnixSocket.
--   
--   See <a>exampleDevLogSyslogLogging</a>
withUnixSocketLogWriter :: (LogIo e, MonadBaseControl IO (Eff e), HasCallStack) => LogMessageRenderer Text -> FilePath -> Eff e b -> Eff e b

-- | 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 ()

-- | Run the <a>Effects</a> using a single threaded, coroutine based, pure
--   scheduler from
--   <a>Control.Eff.Concurrent.Process.SingleThreadedScheduler</a>.
schedule :: Eff Effects a -> Either (Interrupt  'NoRecovery) a

-- | The effect list for <a>Process</a> effects in the single threaded pure
--   scheduler.
--   
--   See <a>PureEffects</a>
type Effects = PureEffects

-- | The effect list for <a>Process</a> effects in the single threaded pure
--   scheduler. This is like <a>SafeProcesses</a>, no <a>Interrupts</a> are
--   present.
--   
--   See <a>PureSafeEffects</a>
type SafeEffects = PureSafeEffects

-- | The effect list for the underlying scheduler.
type BaseEffects = PureBaseEffects

-- | Constraint for the existence of the underlying scheduler effects.
type HasBaseEffects e = HasPureBaseEffects e