Safe Haskell	None
Language	Haskell2010

Control.Eff.Concurrent.Pure

Contents

Generic functions and type for Processes and Messages
Scheduler
External Libraries

Description

Concurrent, communicating processes, executed using a pure, single-threaded scheduler.

This module re-exports most of the library.

There are several scheduler implementations to choose from.

This module re-exports the pure parts of Control.Eff.Concurrent.Process.SingleThreadedScheduler.

To use another scheduler implementation, don't import this module, but instead import one of:

Since: 0.25.0

Synopsis

newtype Facility = Facility {
- fromFacility :: Int
}
data Severity
data SdParameter = MkSdParameter !Text !Text
data StructuredDataElement = SdElement {
- _sdElementId :: !Text
- _sdElementParameters :: ![SdParameter]
}
data LogMessage = MkLogMessage {
- _lmFacility :: !Facility
- _lmSeverity :: !Severity
- _lmTimestamp :: Maybe UTCTime
- _lmHostname :: Maybe Text
- _lmAppName :: Maybe Text
- _lmProcessId :: Maybe Text
- _lmMessageId :: Maybe Text
- _lmStructuredData :: [StructuredDataElement]
- _lmThreadId :: Maybe ThreadId
- _lmSrcLoc :: Maybe SrcLoc
- _lmMessage :: Text
}
emergencySeverity :: Severity
alertSeverity :: Severity
criticalSeverity :: Severity
errorSeverity :: Severity
warningSeverity :: Severity
noticeSeverity :: Severity
informationalSeverity :: Severity
debugSeverity :: Severity
kernelMessages :: Facility
userLevelMessages :: Facility
mailSystem :: Facility
systemDaemons :: Facility
securityAuthorizationMessages4 :: Facility
linePrinterSubsystem :: Facility
networkNewsSubsystem :: Facility
uucpSubsystem :: Facility
clockDaemon :: Facility
securityAuthorizationMessages10 :: Facility
ftpDaemon :: Facility
ntpSubsystem :: Facility
logAuditFacility :: Facility
logAlertFacility :: Facility
clockDaemon2 :: Facility
local0 :: Facility
local1 :: Facility
local2 :: Facility
local3 :: Facility
local4 :: Facility
local5 :: Facility
local6 :: Facility
local7 :: Facility
sdElementId :: Functor f => (Text -> f Text) -> StructuredDataElement -> f StructuredDataElement
sdElementParameters :: Functor f => ([SdParameter] -> f [SdParameter]) -> StructuredDataElement -> f StructuredDataElement
type LogPredicate = LogMessage -> Bool
class ToLogMessage a where
- toLogMessage :: a -> LogMessage
lmAppName :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage
lmFacility :: Functor f => (Facility -> f Facility) -> LogMessage -> f LogMessage
lmHostname :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage
lmMessage :: Functor f => (Text -> f Text) -> LogMessage -> f LogMessage
lmMessageId :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage
lmProcessId :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage
lmSeverity :: Functor f => (Severity -> f Severity) -> LogMessage -> f LogMessage
lmSrcLoc :: Functor f => (Maybe SrcLoc -> f (Maybe SrcLoc)) -> LogMessage -> f LogMessage
lmStructuredData :: Functor f => ([StructuredDataElement] -> f [StructuredDataElement]) -> LogMessage -> f LogMessage
lmThreadId :: Functor f => (Maybe ThreadId -> f (Maybe ThreadId)) -> LogMessage -> f LogMessage
lmTimestamp :: Functor f => (Maybe UTCTime -> f (Maybe UTCTime)) -> LogMessage -> f LogMessage
setCallStack :: CallStack -> LogMessage -> LogMessage
prefixLogMessagesWith :: Text -> LogMessage -> LogMessage
setLogMessageTimestamp :: LogMessage -> IO LogMessage
setLogMessageThreadId :: LogMessage -> IO LogMessage
setLogMessageHostname :: LogMessage -> IO LogMessage
errorMessage :: HasCallStack => Text -> LogMessage
infoMessage :: HasCallStack => Text -> LogMessage
debugMessage :: HasCallStack => Text -> LogMessage
errorMessageIO :: (HasCallStack, MonadIO m) => Text -> m LogMessage
infoMessageIO :: (HasCallStack, MonadIO m) => Text -> m LogMessage
debugMessageIO :: (HasCallStack, MonadIO m) => Text -> m LogMessage
allLogMessages :: LogPredicate
noLogMessages :: LogPredicate
lmSeverityIs :: Severity -> LogPredicate
lmSeverityIsAtLeast :: Severity -> LogPredicate
lmMessageStartsWith :: Text -> LogPredicate
discriminateByAppName :: Text -> LogPredicate -> LogPredicate -> LogPredicate
data LogMessageTimeRenderer
type LogMessageTextRenderer = LogMessageRenderer Text
type LogMessageRenderer a = LogMessage -> a
mkLogMessageTimeRenderer :: String -> LogMessageTimeRenderer
suppressTimestamp :: LogMessageTimeRenderer
rfc3164Timestamp :: LogMessageTimeRenderer
rfc5424Timestamp :: LogMessageTimeRenderer
rfc5424NoZTimestamp :: LogMessageTimeRenderer
renderLogMessageBody :: LogMessageTextRenderer
renderLogMessageBodyNoLocation :: LogMessageTextRenderer
renderLogMessageBodyFixWidth :: LogMessageTextRenderer
renderMaybeLogMessageLens :: Text -> Getter LogMessage (Maybe Text) -> LogMessageTextRenderer
renderLogMessageSrcLoc :: LogMessageRenderer (Maybe Text)
renderSyslogSeverityAndFacility :: LogMessageTextRenderer
renderLogMessageSyslog :: LogMessageTextRenderer
renderLogMessageConsoleLog :: LogMessageTextRenderer
renderConsoleMinimalisticWide :: LogMessageRenderer Text
renderRFC3164 :: LogMessageTextRenderer
renderRFC3164WithRFC5424Timestamps :: LogMessageTextRenderer
renderRFC3164WithTimestamp :: LogMessageTimeRenderer -> LogMessageTextRenderer
renderRFC5424 :: LogMessageTextRenderer
renderRFC5424NoLocation :: LogMessageTextRenderer
renderRFC5424Header :: LogMessageTextRenderer
type LogWriterReader = Reader LogWriter
newtype LogWriter = MkLogWriter {
- runLogWriter :: LogMessage -> IO ()
}
runLogWriterReader :: LogWriter -> Eff (Reader LogWriter ': e) a -> Eff e a
askLogWriter :: Member LogWriterReader e => Eff e LogWriter
localLogWriterReader :: forall e a. Member LogWriterReader e => (LogWriter -> LogWriter) -> Eff e a -> Eff e a
liftWriteLogMessage :: (Member LogWriterReader e, Lifted IO e) => LogMessage -> Eff e ()
noOpLogWriter :: LogWriter
filteringLogWriter :: LogPredicate -> LogWriter -> LogWriter
mappingLogWriter :: (LogMessage -> LogMessage) -> LogWriter -> LogWriter
mappingLogWriterIO :: (LogMessage -> IO LogMessage) -> LogWriter -> LogWriter
ioHandleLogWriter :: Handle -> LogMessageRenderer Text -> LogWriter
stdoutLogWriter :: LogMessageRenderer Text -> IO LogWriter
type LoggingAndIo = '[Logs, LogWriterReader, Lift IO]
type FilteredLogging e = (Member Logs e, Member LogWriterReader e)
type IoLogging e = (FilteredLogging e, Lifted IO e)
data Logs v
withLogging :: Lifted IO e => LogWriter -> Eff (Logs ': (LogWriterReader ': e)) a -> Eff e a
withoutLogging :: Eff (Logs ': (LogWriterReader ': e)) a -> Eff e a
runLogs :: forall e b. (Member LogWriterReader (Logs ': e), Lifted IO e) => LogPredicate -> Eff (Logs ': e) b -> Eff e b
logMsg :: forall e. (HasCallStack, Member Logs e) => LogMessage -> Eff e ()
logWithSeverity :: forall e. (HasCallStack, Member Logs e) => Severity -> Text -> Eff e ()
logWithSeverity' :: forall e. (HasCallStack, Member Logs e) => Severity -> String -> Eff e ()
logEmergency :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e ()
logAlert :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e ()
logCritical :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e ()
logError :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e ()
logWarning :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e ()
logNotice :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e ()
logInfo :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e ()
logDebug :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e ()
logEmergency' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e ()
logAlert' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e ()
logCritical' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e ()
logError' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e ()
logWarning' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e ()
logNotice' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e ()
logInfo' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e ()
logDebug' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e ()
logCallStack :: forall e. (HasCallStack, Member Logs e) => Severity -> Eff e ()
logMultiLine :: forall e. (HasCallStack, Member Logs e) => Severity -> [Text] -> Eff e ()
logMultiLine' :: forall e. (HasCallStack, Member Logs e) => Severity -> [String] -> Eff e ()
askLogPredicate :: forall e. Member Logs e => Eff e LogPredicate
setLogPredicate :: forall r b. (Member Logs r, HasCallStack) => LogPredicate -> Eff r b -> Eff r b
modifyLogPredicate :: forall e b. (Member Logs e, HasCallStack) => (LogPredicate -> LogPredicate) -> Eff e b -> Eff e b
includeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a
excludeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a
respondToLogMessage :: forall r b. Member Logs r => (LogMessage -> Eff r ()) -> Eff r b -> Eff r b
interceptLogMessages :: forall r b. Member Logs r => (LogMessage -> Eff r LogMessage) -> Eff r b -> Eff r b
modifyLogWriter :: IoLogging e => (LogWriter -> LogWriter) -> Eff e a -> Eff e a
setLogWriter :: IoLogging e => LogWriter -> Eff e a -> Eff e a
censorLogs :: IoLogging e => (LogMessage -> LogMessage) -> Eff e a -> Eff e a
censorLogsIo :: IoLogging e => (LogMessage -> IO LogMessage) -> Eff e a -> Eff e a
addLogWriter :: IoLogging e => LogWriter -> Eff e a -> Eff e a
newtype ProcessId = ProcessId {
- _fromProcessId :: Int
}
data ProcessDown = ProcessDown {
- downReference :: !MonitorReference
- downReason :: !(Interrupt NoRecovery)
- downProcess :: !ProcessId
}
data MonitorReference = MonitorReference {
- monitorIndex :: Int
- monitoredProcess :: ProcessId
}
data SomeExitReason where
- SomeExitReason :: Interrupt x -> SomeExitReason
type Interrupts = Exc (Interrupt Recoverable)
type HasSafeProcesses e inner = SetMember Process (Process inner) e
type SafeProcesses r = Process r ': r
type HasProcesses e inner = (HasSafeProcesses e inner, Member Interrupts e)
type Processes e = Interrupts ': SafeProcesses e
type RecoverableInterrupt = Interrupt Recoverable
data Interrupt (t :: ExitRecovery) where
- NormalExitRequested :: Interrupt Recoverable
- NormalExitRequestedWith :: forall a. (Typeable a, Show a, NFData a) => a -> Interrupt Recoverable
- OtherProcessNotRunning :: ProcessId -> Interrupt Recoverable
- TimeoutInterrupt :: String -> Interrupt Recoverable
- LinkedProcessCrashed :: ProcessId -> Interrupt Recoverable
- ErrorInterrupt :: String -> Interrupt Recoverable
- InterruptedBy :: forall a. (Typeable a, Show a, NFData a) => a -> Interrupt Recoverable
- ExitNormally :: Interrupt NoRecovery
- ExitNormallyWith :: forall a. (Typeable a, Show a, NFData a) => a -> Interrupt NoRecovery
- ExitUnhandledError :: Text -> Interrupt NoRecovery
- ExitProcessCancelled :: Maybe ProcessId -> Interrupt NoRecovery
- ExitOtherProcessNotRunning :: ProcessId -> Interrupt NoRecovery
data ExitSeverity
- = NormalExit
- | Crash
data ExitRecovery
- = Recoverable
- | NoRecovery
data MessageSelector a
data ResumeProcess v where
- Interrupted :: Interrupt Recoverable -> ResumeProcess v
- ResumeWith :: a -> ResumeProcess a
newtype Serializer message = MkSerializer {
- runSerializer :: message -> StrictDynamic
}
data StrictDynamic
newtype Timeout = TimeoutMicros {
- fromTimeoutMicros :: Int
}
newtype ProcessDetails = MkProcessDetails {
- _fromProcessDetails :: Text
}
newtype ProcessTitle = MkProcessTitle {
- _fromProcessTitle :: Text
}
data Process (r :: [Type -> Type]) b where
- FlushMessages :: Process r (ResumeProcess [StrictDynamic])
- YieldProcess :: Process r (ResumeProcess ())
- Delay :: Timeout -> Process r (ResumeProcess ())
- SelfPid :: Process r (ResumeProcess ProcessId)
- Spawn :: ProcessTitle -> Eff (Process r ': r) () -> Process r (ResumeProcess ProcessId)
- SpawnLink :: ProcessTitle -> Eff (Process r ': r) () -> Process r (ResumeProcess ProcessId)
- Shutdown :: Interrupt NoRecovery -> Process r a
- SendShutdown :: ProcessId -> Interrupt NoRecovery -> Process r (ResumeProcess ())
- SendInterrupt :: ProcessId -> Interrupt Recoverable -> Process r (ResumeProcess ())
- SendMessage :: ProcessId -> StrictDynamic -> Process r (ResumeProcess ())
- ReceiveSelectedMessage :: forall r a. MessageSelector a -> Process r (ResumeProcess a)
- MakeReference :: Process r (ResumeProcess Int)
- Monitor :: ProcessId -> Process r (ResumeProcess MonitorReference)
- Demonitor :: MonitorReference -> Process r (ResumeProcess ())
- Link :: ProcessId -> Process r (ResumeProcess ())
- Unlink :: ProcessId -> Process r (ResumeProcess ())
- UpdateProcessDetails :: ProcessDetails -> Process r (ResumeProcess ())
- GetProcessState :: ProcessId -> Process r (ResumeProcess (Maybe (ProcessTitle, ProcessDetails, ProcessState)))
fromProcessTitle :: Lens' ProcessTitle Text
fromProcessDetails :: Lens' ProcessDetails Text
toStrictDynamic :: (Typeable a, NFData a) => a -> StrictDynamic
fromStrictDynamic :: Typeable a => StrictDynamic -> Maybe a
unwrapStrictDynamic :: StrictDynamic -> Dynamic
selectMessage :: Typeable t => MessageSelector t
filterMessage :: Typeable a => (a -> Bool) -> MessageSelector a
selectMessageWith :: Typeable a => (a -> Maybe b) -> MessageSelector b
selectDynamicMessage :: (StrictDynamic -> Maybe a) -> MessageSelector a
selectAnyMessage :: MessageSelector StrictDynamic
toExitRecovery :: Interrupt r -> ExitRecovery
toExitSeverity :: Interrupt e -> ExitSeverity
interruptToExit :: Interrupt Recoverable -> Interrupt NoRecovery
isProcessDownInterrupt :: Maybe ProcessId -> Interrupt r -> Bool
provideInterruptsShutdown :: forall e a. Eff (Processes e) a -> Eff (SafeProcesses e) a
handleInterrupts :: (HasCallStack, Member Interrupts r) => (Interrupt Recoverable -> Eff r a) -> Eff r a -> Eff r a
tryUninterrupted :: (HasCallStack, Member Interrupts r) => Eff r a -> Eff r (Either (Interrupt Recoverable) a)
logInterrupts :: forall r. (Member Logs r, HasCallStack, Member Interrupts r) => Eff r () -> Eff r ()
exitOnInterrupt :: (HasCallStack, HasProcesses r q) => Eff r a -> Eff r a
provideInterrupts :: HasCallStack => Eff (Interrupts ': r) a -> Eff r (Either (Interrupt Recoverable) a)
mergeEitherInterruptAndExitReason :: Either (Interrupt Recoverable) (Interrupt NoRecovery) -> Interrupt NoRecovery
interrupt :: (HasCallStack, Member Interrupts r) => Interrupt Recoverable -> Eff r a
isCrash :: Interrupt x -> Bool
isRecoverable :: Interrupt x -> Bool
fromSomeExitReason :: SomeExitReason -> Either (Interrupt NoRecovery) (Interrupt Recoverable)
toCrashReason :: Interrupt x -> Maybe Text
logProcessExit :: forall e x. (Member Logs e, HasCallStack) => Interrupt x -> Eff e ()
executeAndResume :: forall q r v. (HasSafeProcesses r q, HasCallStack) => Process q (ResumeProcess v) -> Eff r (Either (Interrupt Recoverable) v)
executeAndResumeOrExit :: forall r q v. (HasSafeProcesses r q, HasCallStack) => Process q (ResumeProcess v) -> Eff r v
executeAndResumeOrThrow :: forall q r v. (HasProcesses r q, HasCallStack) => Process q (ResumeProcess v) -> Eff r v
yieldProcess :: forall r q. (HasProcesses r q, HasCallStack) => Eff r ()
delay :: forall r q. (HasProcesses r q, HasCallStack) => Timeout -> Eff r ()
sendMessage :: forall o r q. (HasProcesses r q, HasCallStack, Typeable o, NFData o) => ProcessId -> o -> Eff r ()
sendAnyMessage :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> StrictDynamic -> Eff r ()
sendShutdown :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt NoRecovery -> Eff r ()
sendInterrupt :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt Recoverable -> Eff r ()
spawn :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ProcessId
spawn_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ()
spawnLink :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ProcessId
spawnRaw :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff r ProcessId
spawnRaw_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff r ()
isProcessAlive :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r Bool
getProcessState :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r (Maybe (ProcessTitle, ProcessDetails, ProcessState))
updateProcessDetails :: forall r q. (HasCallStack, HasProcesses r q) => ProcessDetails -> Eff r ()
receiveAnyMessage :: forall r q. (HasCallStack, HasProcesses r q) => Eff r StrictDynamic
receiveSelectedMessage :: forall r q a. (HasCallStack, Show a, HasProcesses r q) => MessageSelector a -> Eff r a
receiveMessage :: forall a r q. (HasCallStack, Typeable a, NFData a, Show a, HasProcesses r q) => Eff r a
flushMessages :: forall r q. (HasCallStack, HasProcesses r q) => Eff r [StrictDynamic]
receiveSelectedLoop :: forall r q a endOfLoopResult. (HasSafeProcesses r q, HasCallStack) => MessageSelector a -> (Either (Interrupt Recoverable) a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult
receiveAnyLoop :: forall r q endOfLoopResult. (HasSafeProcesses r q, HasCallStack) => (Either (Interrupt Recoverable) StrictDynamic -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult
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
self :: (HasCallStack, HasSafeProcesses r q) => Eff r ProcessId
makeReference :: (HasCallStack, HasProcesses r q) => Eff r Int
monitor :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r MonitorReference
demonitor :: forall r q. (HasCallStack, HasProcesses r q) => MonitorReference -> Eff r ()
withMonitor :: (HasCallStack, HasProcesses r q) => ProcessId -> (MonitorReference -> Eff r a) -> Eff r a
receiveWithMonitor :: (HasCallStack, HasProcesses r q, Typeable a, Show a) => ProcessId -> MessageSelector a -> Eff r (Either ProcessDown a)
becauseProcessIsDown :: ProcessDown -> Interrupt Recoverable
selectProcessDown :: MonitorReference -> MessageSelector ProcessDown
selectProcessDownByProcessId :: ProcessId -> MessageSelector ProcessDown
linkProcess :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r ()
unlinkProcess :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r ()
exitBecause :: forall r q a. (HasCallStack, HasSafeProcesses r q) => Interrupt NoRecovery -> Eff r a
exitNormally :: forall r q a. (HasCallStack, HasSafeProcesses r q) => Eff r a
exitWithError :: forall r q a. (HasCallStack, HasSafeProcesses r q) => String -> Eff r a
data Receiver a = (NFData out, Typeable out, Show out) => Receiver {
- _receiverPid :: ProcessId
- _receiverSerializer :: a -> out
}
fromProcessId :: Iso' ProcessId Int
sendToReceiver :: (NFData o, HasProcesses r q) => Receiver o -> o -> Eff r ()
receiverPid :: forall a. Lens' (Receiver a) ProcessId
class (Typeable protocol, Typeable embeddedProtocol) => HasPduPrism protocol embeddedProtocol where
- embeddedPdu :: forall (result :: Synchronicity). Prism' (Pdu protocol result) (Pdu embeddedProtocol result)
- embedPdu :: forall (result :: Synchronicity). Pdu embeddedProtocol result -> Pdu protocol result
- fromPdu :: forall (result :: Synchronicity). Pdu protocol result -> Maybe (Pdu embeddedProtocol result)
type family ProtocolReply (s :: Synchronicity) where ...
data Synchronicity
- = Synchronous Type
- | Asynchronous
type TangiblePdu p r = (Typeable p, Typeable r, Tangible (Pdu p r), HasPdu p)
type Tangible i = (NFData i, Typeable i, Show i)
type Embeds outer inner = (HasPduPrism outer inner, CheckEmbeds outer inner, HasPdu outer)
class Typeable protocol => HasPdu (protocol :: Type) where
- type EmbeddedPduList protocol :: [Type]
- data Pdu protocol (reply :: Synchronicity)
newtype Endpoint protocol = Endpoint {
- _fromEndpoint :: ProcessId
}
proxyAsEndpoint :: proxy protocol -> ProcessId -> Endpoint protocol
asEndpoint :: forall protocol. ProcessId -> Endpoint protocol
toEmbeddedEndpoint :: forall inner outer. Embeds outer inner => Endpoint outer -> Endpoint inner
fromEmbeddedEndpoint :: forall outer inner. HasPduPrism outer inner => Endpoint inner -> Endpoint outer
fromEndpoint :: forall protocol protocol. Iso (Endpoint protocol) (Endpoint protocol) ProcessId ProcessId
newtype ReplyTarget p r = MkReplyTarget (Arg (RequestOrigin p r) (Serializer (Reply p r)))
data RequestOrigin (proto :: Type) reply = RequestOrigin {
- _requestOriginPid :: !ProcessId
- _requestOriginCallRef :: !Int
}
data Reply protocol reply where
- Reply :: Tangible reply => {..} -> Reply protocol reply
data Request protocol where
- 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
makeRequestOrigin :: (Typeable r, NFData r, HasProcesses e q0) => Eff e (RequestOrigin p r)
toEmbeddedOrigin :: forall outer inner reply. Embeds outer inner => RequestOrigin outer reply -> RequestOrigin inner reply
embedRequestOrigin :: forall outer inner reply. Embeds outer inner => RequestOrigin inner reply -> RequestOrigin outer reply
embedReplySerializer :: forall outer inner reply. Embeds outer inner => Serializer (Reply outer reply) -> Serializer (Reply inner reply)
sendReply :: (HasProcesses eff q, Tangible reply, Typeable protocol) => ReplyTarget protocol reply -> reply -> Eff eff ()
replyTarget :: Serializer (Reply p reply) -> RequestOrigin p reply -> ReplyTarget p reply
replyTargetOrigin :: Lens' (ReplyTarget p reply) (RequestOrigin p reply)
replyTargetSerializer :: Lens' (ReplyTarget p reply) (Serializer (Reply p reply))
embeddedReplyTarget :: Embeds outer inner => Serializer (Reply outer reply) -> RequestOrigin outer reply -> ReplyTarget inner reply
toEmbeddedReplyTarget :: Embeds outer inner => ReplyTarget outer reply -> ReplyTarget inner reply
data TimerElapsed
data TimerReference
receiveAfter :: forall a r q. (HasCallStack, HasProcesses r q, Typeable a, NFData a, Show a) => Timeout -> Eff r (Maybe a)
receiveSelectedAfter :: forall a r q. (HasCallStack, HasProcesses r q, Show a, Typeable a) => MessageSelector a -> Timeout -> Eff r (Either TimerElapsed a)
receiveSelectedWithMonitorAfter :: forall a r q. (HasCallStack, HasProcesses r q, Show a, Typeable a) => ProcessId -> MessageSelector a -> Timeout -> Eff r (Either (Either ProcessDown TimerElapsed) a)
receiveAfterWithTitle :: forall a r q. (HasCallStack, HasProcesses r q, Typeable a, NFData a, Show a) => Timeout -> ProcessTitle -> Eff r (Maybe a)
receiveSelectedAfterWithTitle :: forall a r q. (HasCallStack, HasProcesses r q, Show a, Typeable a) => MessageSelector a -> Timeout -> ProcessTitle -> Eff r (Either TimerElapsed a)
receiveSelectedWithMonitorAfterWithTitle :: forall a r q. (HasCallStack, HasProcesses r q, Show a, Typeable a) => ProcessId -> MessageSelector a -> Timeout -> ProcessTitle -> Eff r (Either (Either ProcessDown TimerElapsed) a)
selectTimerElapsed :: TimerReference -> MessageSelector TimerElapsed
sendAfter :: forall r q message. (HasCallStack, HasProcesses r q, Typeable message, NFData message) => ProcessId -> Timeout -> (TimerReference -> message) -> Eff r TimerReference
sendAfterWithTitle :: forall r q message. (HasCallStack, HasProcesses r q, Typeable message, NFData message) => ProcessTitle -> ProcessId -> Timeout -> (TimerReference -> message) -> Eff r TimerReference
startTimerWithTitle :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Timeout -> Eff r TimerReference
startTimer :: forall r q. (HasCallStack, HasProcesses r q) => Timeout -> Eff r TimerReference
cancelTimer :: forall r q. (HasCallStack, HasProcesses r q) => TimerReference -> Eff r ()
type EndpointReader o = Reader (Endpoint o)
type HasEndpointReader o r = (Typeable o, Member (EndpointReader o) r)
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 ()
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
callWithTimeout :: forall result destination protocol r q. (HasProcesses r q, TangiblePdu destination (Synchronous result), TangiblePdu protocol (Synchronous result), Tangible result, Member Logs r, HasCallStack, Embeds destination protocol) => Endpoint destination -> Pdu protocol (Synchronous result) -> Timeout -> Eff r result
runEndpointReader :: HasCallStack => Endpoint o -> Eff (EndpointReader o ': r) a -> Eff r a
askEndpoint :: Member (EndpointReader o) e => Eff e (Endpoint o)
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
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 ()
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
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 ()
type ObserverRegistryState event = State (ObserverRegistry event)
data ObserverRegistry (event :: Type) = MkObserverRegistry {
- _observerRegistry :: Map ProcessId (ObservationSink event)
}
type CanObserve eventSink event = (Tangible event, Embeds eventSink (Observer event), HasPdu eventSink)
type IsObservable eventSource event = (Tangible event, Embeds eventSource (ObserverRegistry event), HasPdu eventSource)
data ObservationSink event
newtype Observer event = MkObserver (Arg ProcessId (ObservationSink event))
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 ()
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 ()
forgetObserverUnsafe :: forall event eventSource r q. (HasProcesses r q, HasCallStack, Tangible (Pdu eventSource Asynchronous), IsObservable eventSource event) => Endpoint eventSource -> ProcessId -> Eff r ()
observerRegistryHandlePdu :: forall event q r. (HasCallStack, Typeable event, HasProcesses r q, Member (ObserverRegistryState event) r, Member Logs r) => Pdu (ObserverRegistry event) Asynchronous -> Eff r ()
observerRegistryRemoveProcess :: forall event q r. (HasCallStack, Typeable event, HasProcesses r q, Member (ObserverRegistryState event) r, Member Logs r) => ProcessId -> Eff r Bool
evalObserverRegistryState :: HasCallStack => Eff (ObserverRegistryState event ': r) a -> Eff r a
emptyObserverRegistry :: ObserverRegistry event
observerRegistryNotify :: forall event r q. (HasProcesses r q, Member (ObserverRegistryState event) r, Tangible event, HasCallStack) => event -> Eff r ()
withRichLogging :: Lifted IO e => LogWriter -> Text -> Facility -> LogPredicate -> Eff (Logs ': (LogWriterReader ': e)) a -> Eff e a
richLogWriter :: Text -> Facility -> LogWriter -> LogWriter
withFileLogging :: (Lifted IO e, MonadBaseControl IO (Eff e), HasCallStack) => FilePath -> Text -> Facility -> LogPredicate -> LogMessageTextRenderer -> Eff (Logs ': (LogWriterReader ': e)) a -> Eff e a
withFileLogWriter :: (IoLogging e, MonadBaseControl IO (Eff e), HasCallStack) => FilePath -> LogMessageTextRenderer -> Eff e b -> Eff e b
withTraceLogging :: Lifted IO e => Text -> Facility -> LogPredicate -> Eff (Logs ': (LogWriterReader ': e)) a -> Eff e a
withTraceLogWriter :: IoLogging e => Eff e a -> Eff e a
debugTraceLogWriter :: LogMessageTextRenderer -> LogWriter
withConsoleLogging :: Lifted IO e => Text -> Facility -> LogPredicate -> Eff (Logs ': (LogWriterReader ': e)) a -> Eff e a
withConsoleLogWriter :: IoLogging e => Eff e a -> Eff e a
consoleLogWriter :: IO LogWriter
withAsyncLogging :: (Lifted IO e, MonadBaseControl IO (Eff e), Integral len) => LogWriter -> len -> Text -> Facility -> LogPredicate -> Eff (Logs ': (LogWriterReader ': e)) a -> Eff e a
withAsyncLogWriter :: (IoLogging e, MonadBaseControl IO (Eff e), Integral len) => len -> Eff e a -> Eff e a
withUDPLogging :: (HasCallStack, MonadBaseControl IO (Eff e), Lifted IO e) => (LogMessage -> Text) -> String -> String -> Text -> Facility -> LogPredicate -> Eff (Logs ': (LogWriterReader ': e)) a -> Eff e a
withUDPLogWriter :: (IoLogging e, MonadBaseControl IO (Eff e), HasCallStack) => (LogMessage -> Text) -> String -> String -> Eff e b -> Eff e b
withUnixSocketLogging :: (HasCallStack, MonadBaseControl IO (Eff e), Lifted IO e) => LogMessageRenderer Text -> FilePath -> Text -> Facility -> LogPredicate -> Eff (Logs ': (LogWriterReader ': e)) a -> Eff e a
withUnixSocketLogWriter :: (IoLogging e, MonadBaseControl IO (Eff e), HasCallStack) => LogMessageRenderer Text -> FilePath -> Eff e b -> Eff e b
foreverCheap :: Monad m => m a -> m ()
replicateCheapM_ :: Monad m => Int -> m a -> m ()
schedule :: Eff Effects a -> Either (Interrupt NoRecovery) a
type Effects = PureEffects
type SafeEffects = PureSafeEffects
type BaseEffects = PureBaseEffects
type HasBaseEffects e = HasPureBaseEffects e

Generic functions and type for Processes and Messages

newtype Facility Source #

An rfc 5424 facility

Constructors

Facility
Fields fromFacility :: Int

Instances

Eq Facility Source #
Instance details Defined in Control.Eff.Log.Message Methods (==) :: Facility -> Facility -> Bool # (/=) :: Facility -> Facility -> Bool #
Ord Facility Source #
Instance details Defined in Control.Eff.Log.Message Methods compare :: Facility -> Facility -> Ordering # (<) :: Facility -> Facility -> Bool # (<=) :: Facility -> Facility -> Bool # (>) :: Facility -> Facility -> Bool # (>=) :: Facility -> Facility -> Bool # max :: Facility -> Facility -> Facility # min :: Facility -> Facility -> Facility #
Show Facility Source #
Instance details Defined in Control.Eff.Log.Message Methods showsPrec :: Int -> Facility -> ShowS # show :: Facility -> String # showList :: [Facility] -> ShowS #
Generic Facility Source #
Instance details Defined in Control.Eff.Log.Message Associated Types type Rep Facility :: Type -> Type # Methods from :: Facility -> Rep Facility x # to :: Rep Facility x -> Facility #
Default Facility Source #
Instance details Defined in Control.Eff.Log.Message Methods def :: Facility #
NFData Facility Source #
Instance details Defined in Control.Eff.Log.Message Methods rnf :: Facility -> () #
type Rep Facility Source #
Instance details Defined in Control.Eff.Log.Message type Rep Facility = D1 (MetaData "Facility" "Control.Eff.Log.Message" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" True) (C1 (MetaCons "Facility" PrefixI True) (S1 (MetaSel (Just "fromFacility") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

data Severity Source #

An rfc 5424 severity

Instances

Eq Severity Source #
Instance details Defined in Control.Eff.Log.Message Methods (==) :: Severity -> Severity -> Bool # (/=) :: Severity -> Severity -> Bool #
Ord Severity Source #
Instance details Defined in Control.Eff.Log.Message Methods compare :: Severity -> Severity -> Ordering # (<) :: Severity -> Severity -> Bool # (<=) :: Severity -> Severity -> Bool # (>) :: Severity -> Severity -> Bool # (>=) :: Severity -> Severity -> Bool # max :: Severity -> Severity -> Severity # min :: Severity -> Severity -> Severity #
Show Severity Source #
Instance details Defined in Control.Eff.Log.Message Methods showsPrec :: Int -> Severity -> ShowS # show :: Severity -> String # showList :: [Severity] -> ShowS #
Generic Severity Source #
Instance details Defined in Control.Eff.Log.Message Associated Types type Rep Severity :: Type -> Type # Methods from :: Severity -> Rep Severity x # to :: Rep Severity x -> Severity #
Default Severity Source #
Instance details Defined in Control.Eff.Log.Message Methods def :: Severity #
NFData Severity Source #
Instance details Defined in Control.Eff.Log.Message Methods rnf :: Severity -> () #
type Rep Severity Source #
Instance details Defined in Control.Eff.Log.Message type Rep Severity = D1 (MetaData "Severity" "Control.Eff.Log.Message" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" True) (C1 (MetaCons "Severity" PrefixI True) (S1 (MetaSel (Just "fromSeverity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

data SdParameter Source #

Component of an RFC-5424 StructuredDataElement

Constructors

MkSdParameter !Text !Text

Instances

Eq SdParameter Source #
Instance details Defined in Control.Eff.Log.Message Methods (==) :: SdParameter -> SdParameter -> Bool # (/=) :: SdParameter -> SdParameter -> Bool #
Ord SdParameter Source #
Instance details Defined in Control.Eff.Log.Message Methods compare :: SdParameter -> SdParameter -> Ordering # (<) :: SdParameter -> SdParameter -> Bool # (<=) :: SdParameter -> SdParameter -> Bool # (>) :: SdParameter -> SdParameter -> Bool # (>=) :: SdParameter -> SdParameter -> Bool # max :: SdParameter -> SdParameter -> SdParameter # min :: SdParameter -> SdParameter -> SdParameter #
Show SdParameter Source #
Instance details Defined in Control.Eff.Log.Message Methods showsPrec :: Int -> SdParameter -> ShowS # show :: SdParameter -> String # showList :: [SdParameter] -> ShowS #
Generic SdParameter Source #
Instance details Defined in Control.Eff.Log.Message Associated Types type Rep SdParameter :: Type -> Type # Methods from :: SdParameter -> Rep SdParameter x # to :: Rep SdParameter x -> SdParameter #
NFData SdParameter Source #
Instance details Defined in Control.Eff.Log.Message Methods rnf :: SdParameter -> () #
type Rep SdParameter Source #
Instance details Defined in Control.Eff.Log.Message type Rep SdParameter = D1 (MetaData "SdParameter" "Control.Eff.Log.Message" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" False) (C1 (MetaCons "MkSdParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text)))

data StructuredDataElement Source #

RFC-5424 defines how structured data can be included in a log message.

Constructors

SdElement
Fields _sdElementId :: !Text _sdElementParameters :: ![SdParameter]

Instances

Eq StructuredDataElement Source #
Instance details Defined in Control.Eff.Log.Message Methods (==) :: StructuredDataElement -> StructuredDataElement -> Bool # (/=) :: StructuredDataElement -> StructuredDataElement -> Bool #
Ord StructuredDataElement Source #
Instance details Defined in Control.Eff.Log.Message Methods compare :: StructuredDataElement -> StructuredDataElement -> Ordering # (<) :: StructuredDataElement -> StructuredDataElement -> Bool # (<=) :: StructuredDataElement -> StructuredDataElement -> Bool # (>) :: StructuredDataElement -> StructuredDataElement -> Bool # (>=) :: StructuredDataElement -> StructuredDataElement -> Bool # max :: StructuredDataElement -> StructuredDataElement -> StructuredDataElement # min :: StructuredDataElement -> StructuredDataElement -> StructuredDataElement #
Show StructuredDataElement Source #
Instance details Defined in Control.Eff.Log.Message Methods showsPrec :: Int -> StructuredDataElement -> ShowS # show :: StructuredDataElement -> String # showList :: [StructuredDataElement] -> ShowS #
Generic StructuredDataElement Source #
Instance details Defined in Control.Eff.Log.Message Associated Types type Rep StructuredDataElement :: Type -> Type # Methods from :: StructuredDataElement -> Rep StructuredDataElement x # to :: Rep StructuredDataElement x -> StructuredDataElement #
NFData StructuredDataElement Source #
Instance details Defined in Control.Eff.Log.Message Methods rnf :: StructuredDataElement -> () #
type Rep StructuredDataElement Source #
Instance details Defined in Control.Eff.Log.Message type Rep StructuredDataElement = D1 (MetaData "StructuredDataElement" "Control.Eff.Log.Message" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" False) (C1 (MetaCons "SdElement" PrefixI True) (S1 (MetaSel (Just "_sdElementId") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text) :*: S1 (MetaSel (Just "_sdElementParameters") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 [SdParameter])))

data LogMessage Source #

A message data type inspired by the RFC-5424 Syslog Protocol

Constructors

MkLogMessage
Fields _lmFacility :: !Facility _lmSeverity :: !Severity _lmTimestamp :: Maybe UTCTime _lmHostname :: Maybe Text _lmAppName :: Maybe Text _lmProcessId :: Maybe Text _lmMessageId :: Maybe Text _lmStructuredData :: [StructuredDataElement] _lmThreadId :: Maybe ThreadId _lmSrcLoc :: Maybe SrcLoc _lmMessage :: Text

Instances

Eq LogMessage Source #
Instance details Defined in Control.Eff.Log.Message Methods (==) :: LogMessage -> LogMessage -> Bool # (/=) :: LogMessage -> LogMessage -> Bool #
Show LogMessage Source #	This instance is only supposed to be used for unit tests and debugging.
Instance details Defined in Control.Eff.Log.Message Methods showsPrec :: Int -> LogMessage -> ShowS # show :: LogMessage -> String # showList :: [LogMessage] -> ShowS #
IsString LogMessage Source #
Instance details Defined in Control.Eff.Log.Message Methods fromString :: String -> LogMessage #
Generic LogMessage Source #
Instance details Defined in Control.Eff.Log.Message Associated Types type Rep LogMessage :: Type -> Type # Methods from :: LogMessage -> Rep LogMessage x # to :: Rep LogMessage x -> LogMessage #
Default LogMessage Source #
Instance details Defined in Control.Eff.Log.Message Methods def :: LogMessage #
NFData LogMessage Source #
Instance details Defined in Control.Eff.Log.Message Methods rnf :: LogMessage -> () #
ToLogMessage LogMessage Source #
Instance details Defined in Control.Eff.Log.Message Methods toLogMessage :: LogMessage -> LogMessage Source #
Handle Logs e a (LogPredicate -> k) Source #
Instance details Defined in Control.Eff.Log.Handler Methods handle :: (Eff e a -> LogPredicate -> k) -> Arrs e v a -> Logs v -> LogPredicate -> k # handle_relay :: (e ~ (Logs ': r'), Relay (LogPredicate -> k) r') => (a -> LogPredicate -> k) -> (Eff e a -> LogPredicate -> k) -> Eff e a -> LogPredicate -> k # respond_relay :: (a -> LogPredicate -> k) -> (Eff e a -> LogPredicate -> k) -> Eff e a -> LogPredicate -> k #
type Rep LogMessage Source #
Instance details Defined in Control.Eff.Log.Message type Rep LogMessage = D1 (MetaData "LogMessage" "Control.Eff.Log.Message" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" False) (C1 (MetaCons "MkLogMessage" PrefixI True) (((S1 (MetaSel (Just "_lmFacility") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Facility) :: S1 (MetaSel (Just "_lmSeverity") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Severity)) :: (S1 (MetaSel (Just "_lmTimestamp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe UTCTime)) :: (S1 (MetaSel (Just "_lmHostname") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Text)) :: S1 (MetaSel (Just "_lmAppName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Text))))) :: ((S1 (MetaSel (Just "_lmProcessId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Text)) :: (S1 (MetaSel (Just "_lmMessageId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Text)) :: S1 (MetaSel (Just "_lmStructuredData") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [StructuredDataElement]))) :: (S1 (MetaSel (Just "_lmThreadId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ThreadId)) :: (S1 (MetaSel (Just "_lmSrcLoc") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe SrcLoc)) :: S1 (MetaSel (Just "_lmMessage") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text))))))

emergencySeverity :: Severity Source #

Smart constructor for the RFC-5424 emergency LogMessage Severity. This corresponds to the severity value 0. See lmSeverity.

alertSeverity :: Severity Source #

Smart constructor for the RFC-5424 alert LogMessage Severity. This corresponds to the severity value 1. See lmSeverity.

criticalSeverity :: Severity Source #

Smart constructor for the RFC-5424 critical LogMessage Severity. This corresponds to the severity value 2. See lmSeverity.

errorSeverity :: Severity Source #

Smart constructor for the RFC-5424 error LogMessage Severity. This corresponds to the severity value 3. See lmSeverity.

warningSeverity :: Severity Source #

Smart constructor for the RFC-5424 warning LogMessage Severity. This corresponds to the severity value 4. See lmSeverity.

noticeSeverity :: Severity Source #

Smart constructor for the RFC-5424 notice LogMessage Severity. This corresponds to the severity value 5. See lmSeverity.

informationalSeverity :: Severity Source #

Smart constructor for the RFC-5424 informational LogMessage Severity. This corresponds to the severity value 6. See lmSeverity.

debugSeverity :: Severity Source #

Smart constructor for the RFC-5424 debug LogMessage Severity. This corresponds to the severity value 7. See lmSeverity.

kernelMessages :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility kernelMessages. See lmFacility.

userLevelMessages :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility userLevelMessages. See lmFacility.

mailSystem :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility mailSystem. See lmFacility.

systemDaemons :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility systemDaemons. See lmFacility.

securityAuthorizationMessages4 :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility securityAuthorizationMessages4. See lmFacility.

linePrinterSubsystem :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility linePrinterSubsystem. See lmFacility.

networkNewsSubsystem :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility networkNewsSubsystem. See lmFacility.

uucpSubsystem :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility uucpSubsystem. See lmFacility.

clockDaemon :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility clockDaemon. See lmFacility.

securityAuthorizationMessages10 :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility securityAuthorizationMessages10. See lmFacility.

ftpDaemon :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility ftpDaemon. See lmFacility.

ntpSubsystem :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility ntpSubsystem. See lmFacility.

logAuditFacility :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility logAuditFacility. See lmFacility.

logAlertFacility :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility logAlertFacility. See lmFacility.

clockDaemon2 :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility clockDaemon2. See lmFacility.

local0 :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility local0. See lmFacility.

local1 :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility local1. See lmFacility.

local2 :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility local2. See lmFacility.

local3 :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility local3. See lmFacility.

local4 :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility local4. See lmFacility.

local5 :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility local5. See lmFacility.

local6 :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility local6. See lmFacility.

local7 :: Facility Source #

Smart constructor for the RFC-5424 LogMessage facility local7. See lmFacility.

sdElementId :: Functor f => (Text -> f Text) -> StructuredDataElement -> f StructuredDataElement Source #

A lens for the key or ID of a group of RFC 5424 key-value pairs.

sdElementParameters :: Functor f => ([SdParameter] -> f [SdParameter]) -> StructuredDataElement -> f StructuredDataElement Source #

A lens for SdParameters

type LogPredicate = LogMessage -> Bool Source #

The filter predicate for message that shall be logged.

See Control.Eff.Log

class ToLogMessage a where Source #

Things that can become a LogMessage

Methods

toLogMessage :: a -> LogMessage Source #

Convert the value to a LogMessage

Instances

ToLogMessage Text Source #
Instance details Defined in Control.Eff.Log.Message Methods toLogMessage :: Text -> LogMessage Source #
ToLogMessage LogMessage Source #
Instance details Defined in Control.Eff.Log.Message Methods toLogMessage :: LogMessage -> LogMessage Source #

lmAppName :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage Source #

A lens for the RFC 5424 application name of a LogMessage

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:

debugLogsForAppName myAppName lm =
  view lmAppName lm == Just myAppName || lmSeverityIsAtLeast warningSeverity lm

This concept is also implemented in discriminateByAppName.

lmFacility :: Functor f => (Facility -> f Facility) -> LogMessage -> f LogMessage Source #

A lens for the Facility of a LogMessage

lmHostname :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage Source #

A lens for the hostname of a LogMessage The function setLogMessageHostname can be used to set the field.

lmMessage :: Functor f => (Text -> f Text) -> LogMessage -> f LogMessage Source #

A lens for the user defined textual message of a LogMessage

lmMessageId :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage Source #

A lens for a user defined message id of a LogMessage

lmProcessId :: Functor f => (Maybe Text -> f (Maybe Text)) -> LogMessage -> f LogMessage Source #

A lens for a user defined of process id of a LogMessage

lmSeverity :: Functor f => (Severity -> f Severity) -> LogMessage -> f LogMessage Source #

A lens for the Severity of a LogMessage

lmSrcLoc :: Functor f => (Maybe SrcLoc -> f (Maybe SrcLoc)) -> LogMessage -> f LogMessage Source #

A lens for the SrcLoc of a LogMessage

lmStructuredData :: Functor f => ([StructuredDataElement] -> f [StructuredDataElement]) -> LogMessage -> f LogMessage Source #

A lens for the StructuredDataElement of a LogMessage

lmThreadId :: Functor f => (Maybe ThreadId -> f (Maybe ThreadId)) -> LogMessage -> f LogMessage Source #

A lens for the ThreadId of a LogMessage The function setLogMessageThreadId can be used to set the field.

lmTimestamp :: Functor f => (Maybe UTCTime -> f (Maybe UTCTime)) -> LogMessage -> f LogMessage Source #

A lens for the UTC time of a LogMessage The function setLogMessageTimestamp can be used to set the field.

setCallStack :: CallStack -> LogMessage -> LogMessage Source #

Put the source location of the given callstack in lmSrcLoc

prefixLogMessagesWith :: Text -> LogMessage -> LogMessage Source #

Prefix the lmMessage.

setLogMessageTimestamp :: LogMessage -> IO LogMessage Source #

An IO action that sets the current UTC time in lmTimestamp.

setLogMessageThreadId :: LogMessage -> IO LogMessage Source #

An IO action appends the the ThreadId of the calling process (see myThreadId) to lmMessage.

setLogMessageHostname :: LogMessage -> IO LogMessage Source #

An IO action that sets the current hosts fully qualified hostname in lmHostname.

errorMessage :: HasCallStack => Text -> LogMessage Source #

Construct a LogMessage with errorSeverity

infoMessage :: HasCallStack => Text -> LogMessage Source #

Construct a LogMessage with informationalSeverity

debugMessage :: HasCallStack => Text -> LogMessage Source #

Construct a LogMessage with debugSeverity

errorMessageIO :: (HasCallStack, MonadIO m) => Text -> m LogMessage Source #

Construct a LogMessage with errorSeverity

infoMessageIO :: (HasCallStack, MonadIO m) => Text -> m LogMessage Source #

Construct a LogMessage with informationalSeverity

debugMessageIO :: (HasCallStack, MonadIO m) => Text -> m LogMessage Source #

Construct a LogMessage with debugSeverity

allLogMessages :: LogPredicate Source #

All messages.

See Control.Eff.Log.Message for more predicates.

noLogMessages :: LogPredicate Source #

No messages.

See Control.Eff.Log.Message for more predicates.

lmSeverityIs :: Severity -> LogPredicate Source #

Match LogMessages that have exactly the given severity. See lmSeverityIsAtLeast.

See Control.Eff.Log.Message for more predicates.

lmSeverityIsAtLeast :: Severity -> LogPredicate Source #

Match LogMessages that have the given severity or worse. See lmSeverityIs.

See Control.Eff.Log.Message for more predicates.

lmMessageStartsWith :: Text -> LogPredicate Source #

Match LogMessages whose lmMessage starts with the given string.

See Control.Eff.Log.Message for more predicates.

discriminateByAppName :: Text -> LogPredicate -> LogPredicate -> LogPredicate Source #

Apply a LogPredicate based on the lmAppName and delegate to one of two LogPredicates.

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 Control.Eff.Log.Message for more predicates.

data LogMessageTimeRenderer Source #

A rendering function for the lmTimestamp field.

type LogMessageTextRenderer = LogMessageRenderer Text Source #

LogMessage to Text rendering function.

Since: 0.31.0

type LogMessageRenderer a = LogMessage -> a Source #

LogMessage rendering function

mkLogMessageTimeRenderer Source #

Arguments

:: String	The format string that is passed to `formatTime`
-> LogMessageTimeRenderer

Make a LogMessageTimeRenderer using formatTime in the defaultLocale.

suppressTimestamp :: LogMessageTimeRenderer Source #

Don't render the time stamp

rfc3164Timestamp :: LogMessageTimeRenderer Source #

Render the time stamp using "%h %d %H:%M:%S"

rfc5424Timestamp :: LogMessageTimeRenderer Source #

Render the time stamp to iso8601DateFormat (Just "%H:%M:%S%6QZ")

rfc5424NoZTimestamp :: LogMessageTimeRenderer Source #

Render the time stamp like rfc5424Timestamp does, but omit the terminal Z character.

renderLogMessageBody :: LogMessageTextRenderer Source #

Print the thread id, the message and the source file location, seperated by simple white space.

renderLogMessageBodyNoLocation :: LogMessageTextRenderer Source #

Print the thread id, the message and the source file location, seperated by simple white space.

renderLogMessageBodyFixWidth :: LogMessageTextRenderer Source #

Print the body of a LogMessage with fix size fields (60) for the message itself and 30 characters for the location

renderMaybeLogMessageLens :: Text -> Getter LogMessage (Maybe Text) -> LogMessageTextRenderer Source #

Render a field of a LogMessage using the corresponsing lens.

renderLogMessageSrcLoc :: LogMessageRenderer (Maybe Text) Source #

Render the source location as: at filepath:linenumber.

renderSyslogSeverityAndFacility :: LogMessageTextRenderer Source #

Render the severity and facility as described in RFC-3164

Render e.g. as <192>.

Useful as header for syslog compatible log output.

renderLogMessageSyslog :: LogMessageTextRenderer Source #

Render the LogMessage to contain the severity, message, message-id, pid.

Omit hostname, PID and timestamp.

Render the header using renderSyslogSeverity

Useful for logging to devlog

renderLogMessageConsoleLog :: LogMessageTextRenderer Source #

Render a LogMessage human readable, for console logging

renderConsoleMinimalisticWide :: LogMessageRenderer Text Source #

Render a LogMessage human readable, for console logging

Since: 0.31.0

renderRFC3164 :: LogMessageTextRenderer Source #

Render a LogMessage according to the rules in the RFC-3164.

renderRFC3164WithRFC5424Timestamps :: LogMessageTextRenderer Source #

Render a LogMessage according to the rules in the RFC-3164 but use RFC5424 time stamps.

renderRFC3164WithTimestamp :: LogMessageTimeRenderer -> LogMessageTextRenderer Source #

Render a LogMessage according to the rules in the RFC-3164 but use the custom LogMessageTimeRenderer.

renderRFC5424 :: LogMessageTextRenderer Source #

Render a LogMessage according to the rules in the RFC-5424.

Equivalent to renderRFC5424Header <> const " " <> renderLogMessageBody.

Since: 0.21.0

renderRFC5424NoLocation :: LogMessageTextRenderer Source #

Render a LogMessage according to the rules in the RFC-5424, like renderRFC5424 but suppress the source location information.

Equivalent to renderRFC5424Header <> const " " <> renderLogMessageBodyNoLocation.

Since: 0.21.0

renderRFC5424Header :: LogMessageTextRenderer Source #

Render the header and strucuted data of a LogMessage according to the rules in the RFC-5424, but do not render the lmMessage.

Since: 0.22.0

type LogWriterReader = Reader LogWriter Source #

A Reader effect for LogWriters.

Since: 0.31.0

newtype LogWriter Source #

A function that takes a log message and returns an effect that logs the message.

Constructors

MkLogWriter
Fields runLogWriter :: LogMessage -> IO ()

Instances

Semigroup LogWriter Source #
Instance details Defined in Control.Eff.Log.Writer Methods (<>) :: LogWriter -> LogWriter -> LogWriter # sconcat :: NonEmpty LogWriter -> LogWriter # stimes :: Integral b => b -> LogWriter -> LogWriter #
Monoid LogWriter Source #
Instance details Defined in Control.Eff.Log.Writer Methods mempty :: LogWriter # mappend :: LogWriter -> LogWriter -> LogWriter # mconcat :: [LogWriter] -> LogWriter #

runLogWriterReader :: LogWriter -> Eff (Reader LogWriter ': e) a -> Eff e a Source #

Provide the LogWriter

Exposed for custom extensions, if in doubt use withLogging.

askLogWriter :: Member LogWriterReader e => Eff e LogWriter Source #

Get the current LogWriter.

localLogWriterReader :: forall e a. Member LogWriterReader e => (LogWriter -> LogWriter) -> Eff e a -> Eff e a Source #

Modify the current LogWriter.

liftWriteLogMessage :: (Member LogWriterReader e, Lifted IO e) => LogMessage -> Eff e () Source #

Write a message using the LogWriter found in the environment.

noOpLogWriter :: LogWriter Source #

This LogWriter will discard all messages.

NOTE: This is just an alias for mempty

filteringLogWriter :: LogPredicate -> LogWriter -> LogWriter Source #

A LogWriter that applies a predicate to the LogMessage and delegates to to the given writer of the predicate is satisfied.

mappingLogWriter :: (LogMessage -> LogMessage) -> LogWriter -> LogWriter Source #

A LogWriter that applies a function to the LogMessage and delegates the result to to the given writer.

mappingLogWriterIO :: (LogMessage -> IO LogMessage) -> LogWriter -> LogWriter Source #

Like mappingLogWriter allow the function that changes the LogMessage to have effects.

ioHandleLogWriter :: Handle -> LogMessageRenderer Text -> LogWriter Source #

Append the LogMessage to an Handle after rendering it.

Since: 0.31.0

stdoutLogWriter :: LogMessageRenderer Text -> IO LogWriter Source #

Render a LogMessage to stdout.

This function will also set the BufferMode of stdout to LineBuffering.

See ioHandleLogWriter.

Since: 0.31.0

type LoggingAndIo = '[Logs, LogWriterReader, Lift IO] Source #

The concrete list of Effects for logging with a LogWriter, and a LogWriterReader.

This also provides both IoLogging and FilteredLogging.

type FilteredLogging e = (Member Logs e, Member LogWriterReader e) Source #

A constraint that requires Logs and LogWriterReader, and hence supports the functions to filter and modify logs:

setLogWriter
addLogWriter
modifyLogWriter
censorLogs

Provided by withLogging, runLogs, and also withoutLogging and runLogsWithoutLogging.

Since: 0.31.0

type IoLogging e = (FilteredLogging e, Lifted IO e) Source #

A constraint that requires Logs e and Lifted IO e.

Provided by withLogging and runLogs.

It contains FilteredLogging and allows in addition:

censorLogsIo

Don't infect everything with IO, if you can fall back to FilteredLogging.

Since: 0.24.0

data Logs v Source #

This effect sends LogMessages and is a reader for a LogPredicate.

Logs are sent via logMsg; for more information about log predicates, see Control.Eff.Log

This effect is handled via withLogging.

Instances

Handle Logs e a (LogPredicate -> k) Source #
Instance details Defined in Control.Eff.Log.Handler Methods handle :: (Eff e a -> LogPredicate -> k) -> Arrs e v a -> Logs v -> LogPredicate -> k # handle_relay :: (e ~ (Logs ': r'), Relay (LogPredicate -> k) r') => (a -> LogPredicate -> k) -> (Eff e a -> LogPredicate -> k) -> Eff e a -> LogPredicate -> k # respond_relay :: (a -> LogPredicate -> k) -> (Eff e a -> LogPredicate -> k) -> Eff e a -> LogPredicate -> k #
(MonadBase m IO, MonadBaseControl IO (Eff e), LiftedBase m e, Lifted IO e, IoLogging (Logs ': e)) => MonadBaseControl m (Eff (Logs ': e)) Source #	This instance allows lifting the `Logs` effect into a base monad, e.g. `IO`. This instance needs a `LogWriterReader` in the base monad, that is capable to handle `logMsg` invocations.
Instance details Defined in Control.Eff.Log.Handler Associated Types type StM (Eff (Logs ': e)) a :: Type # Methods liftBaseWith :: (RunInBase (Eff (Logs ': e)) m -> m a) -> Eff (Logs ': e) a # restoreM :: StM (Eff (Logs ': e)) a -> Eff (Logs ': e) a #
(LiftedBase m e, MonadThrow (Eff e)) => MonadThrow (Eff (Logs ': e)) Source #
Instance details Defined in Control.Eff.Log.Handler Methods throwM :: Exception e0 => e0 -> Eff (Logs ': e) a #
(Applicative m, MonadBaseControl IO (Eff e), LiftedBase m e, MonadCatch (Eff e), IoLogging (Logs ': e), Lifted IO e) => MonadCatch (Eff (Logs ': e)) Source #
Instance details Defined in Control.Eff.Log.Handler Methods catch :: Exception e0 => Eff (Logs ': e) a -> (e0 -> Eff (Logs ': e) a) -> Eff (Logs ': e) a #
(Applicative m, MonadBaseControl IO (Eff e), LiftedBase m e, MonadMask (Eff e), IoLogging (Logs ': e), Lifted IO e) => MonadMask (Eff (Logs ': e)) Source #
Instance details Defined in Control.Eff.Log.Handler Methods mask :: ((forall a. Eff (Logs ': e) a -> Eff (Logs ': e) a) -> Eff (Logs ': e) b) -> Eff (Logs ': e) b # uninterruptibleMask :: ((forall a. Eff (Logs ': e) a -> Eff (Logs ': e) a) -> Eff (Logs ': e) b) -> Eff (Logs ': e) b # generalBracket :: Eff (Logs ': e) a -> (a -> ExitCase b -> Eff (Logs ': e) c) -> (a -> Eff (Logs ': e) b) -> Eff (Logs ': e) (b, c) #
type StM (Eff (Logs ': e)) a Source #
Instance details Defined in Control.Eff.Log.Handler type StM (Eff (Logs ': e)) a = StM (Eff e) a

withLogging :: Lifted IO e => LogWriter -> Eff (Logs ': (LogWriterReader ': e)) a -> Eff e a Source #

Handle the Logs and LogWriterReader effects.

It installs the given LogWriter, which determines the underlying LogWriter type parameter.

Example:

exampleWithLogging :: IO ()
exampleWithLogging =
    runLift
  $ withLogging consoleLogWriter
  $ logDebug "Oh, hi there"

This provides the IoLogging and FilteredLogging effects.

See also runLogsWithoutLogging.

runLogs :: forall e b. (Member LogWriterReader (Logs ': e), Lifted IO e) => LogPredicate -> Eff (Logs ': e) b -> Eff e b Source #

Raw handling of the Logs effect. Exposed for custom extensions, if in doubt use withLogging.

logMsg :: forall e. (HasCallStack, Member Logs e) => LogMessage -> Eff e () Source #

Log a message.

All logging goes through this function.

This function is the only place where the LogPredicate is applied.

Also, LogMessages are evaluated using deepseq, after they pass the LogPredicate.

logWithSeverity :: forall e. (HasCallStack, Member Logs e) => Severity -> Text -> Eff e () Source #

Log a Text as LogMessage with a given Severity.

logWithSeverity' :: forall e. (HasCallStack, Member Logs e) => Severity -> String -> Eff e () Source #

Log a Text as LogMessage with a given Severity.

logEmergency :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e () Source #

Log a String as emergencySeverity.

logAlert :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e () Source #

Log a message with alertSeverity.

logCritical :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e () Source #

Log a criticalSeverity message.

logError :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e () Source #

Log a errorSeverity message.

logWarning :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e () Source #

Log a warningSeverity message.

logNotice :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e () Source #

Log a noticeSeverity message.

logInfo :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e () Source #

Log a informationalSeverity message.

logDebug :: forall e. (HasCallStack, Member Logs e) => Text -> Eff e () Source #

Log a debugSeverity message.

logEmergency' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e () Source #

Log a String as emergencySeverity.

logAlert' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e () Source #

Log a message with alertSeverity.

logCritical' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e () Source #

Log a criticalSeverity message.

logError' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e () Source #

Log a errorSeverity message.

logWarning' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e () Source #

Log a warningSeverity message.

logNotice' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e () Source #

Log a noticeSeverity message.

logInfo' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e () Source #

Log a informationalSeverity message.

logDebug' :: forall e. (HasCallStack, Member Logs e) => String -> Eff e () Source #

Log a debugSeverity message.

logCallStack :: forall e. (HasCallStack, Member Logs e) => Severity -> Eff e () Source #

Log the current callStack using the given Severity.

Since: 0.30.0

logMultiLine :: forall e. (HasCallStack, Member Logs e) => Severity -> [Text] -> Eff e () Source #

Issue a log statement for each item in the list prefixed with a line number and a message hash.

When several concurrent processes issue log statements, multi line log statements are often interleaved.

In order to make the logs easier to read, this function will count the items and calculate a unique hash and prefix each message, so a user can grep to get all the lines of an interleaved, multi-line log message.

Since: 0.30.0

logMultiLine' :: forall e. (HasCallStack, Member Logs e) => Severity -> [String] -> Eff e () Source #

Issue a log statement for each item in the list prefixed with a line number and a message hash.

When several concurrent processes issue log statements, multiline log statements are often interleaved.

In order to make the logs easier to read, this function will count the items and calculate a unique hash and prefix each message, so a user can grep to get all the lines of an interleaved, multi-line log message.

This function takes a list of Strings as opposed to logMultiLine.

Since: 0.30.0

askLogPredicate :: forall e. Member Logs e => Eff e LogPredicate Source #

Get the current Logs filter/transformer function.

See Control.Eff.Log

setLogPredicate :: forall r b. (Member Logs r, HasCallStack) => LogPredicate -> Eff r b -> Eff r b Source #

Keep only those messages, for which a predicate holds.

E.g. to keep only messages which begin with OMG:

exampleSetLogWriter :: IO Int
exampleSetLogWriter =
    runLift
  $ withLogging consoleLogWriter
  $ do logMsg "test"
       setLogPredicate (\ msg -> case view lmMessage msg of
                                  'O':'M':'G':_ -> True
                                  _             -> False)
                         (do logMsg "this message will not be logged"
                             logMsg "OMG logged"
                             return 42)

In order to also delegate to the previous predicate, use modifyLogPredicate

See Control.Eff.Log

modifyLogPredicate :: forall e b. (Member Logs e, HasCallStack) => (LogPredicate -> LogPredicate) -> Eff e b -> Eff e b Source #

Change the LogPredicate.

Other than setLogPredicate 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:

modifyLogPredicate (previousPredicate msg -> previousPredicate msg && length (lmMessage msg) < 29 )
                   (do logMsg "this message will not be logged"
                       logMsg "this message might be logged")

See Control.Eff.Log

includeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a Source #

Include LogMessages that match a LogPredicate.

includeLogMessages p allows log message to be logged if p m

Although it is enough if the previous predicate holds. See excludeLogMessages and modifyLogPredicate.

See Control.Eff.Log

excludeLogMessages :: forall e a. Member Logs e => LogPredicate -> Eff e a -> Eff e a Source #

Exclude LogMessages that match a LogPredicate.

excludeLogMessages p discards logs if p m

Also the previous predicate must also hold for a message to be logged. See excludeLogMessages and modifyLogPredicate.

See Control.Eff.Log

respondToLogMessage :: forall r b. Member Logs r => (LogMessage -> Eff r ()) -> Eff r b -> Eff r b Source #

Consume log messages.

Exposed for custom extensions, if in doubt use withLogging.

Respond to all LogMessages logged from the given action, up to any MonadBaseControl liftings.

Note that all logging is done through logMsg and that means only messages passing the LogPredicate are received.

The LogMessages are consumed once they are passed to the given callback function, previous respondToLogMessage invocations further up in the call stack will not get the messages anymore.

Use interceptLogMessages if the messages shall be passed any previous handler.

NOTE: The effects of this function are lost when using MonadBaseControl, MonadMask, MonadCatch and MonadThrow.

In contrast the functions based on modifying the LogWriter, such as addLogWriter or censorLogs, 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 Source #

Change the LogMessages using an effectful function.

Exposed for custom extensions, if in doubt use withLogging.

This differs from respondToLogMessage in that the intercepted messages will be written either way, albeit in altered form.

NOTE: The effects of this function are lost when using MonadBaseControl, MonadMask, MonadCatch and MonadThrow.

In contrast the functions based on modifying the LogWriter, such as addLogWriter or censorLogs, are save to use in combination with the aforementioned liftings.

modifyLogWriter :: IoLogging e => (LogWriter -> LogWriter) -> Eff e a -> Eff e a Source #

Change the current LogWriter.

setLogWriter :: IoLogging e => LogWriter -> Eff e a -> Eff e a Source #

Replace the current LogWriter. To add an additional log message consumer use addLogWriter

censorLogs :: IoLogging e => (LogMessage -> LogMessage) -> Eff e a -> Eff e a Source #

Modify the the LogMessages written in the given sub-expression.

Note: This is equivalent to modifyLogWriter . mappingLogWriter

censorLogsIo :: IoLogging e => (LogMessage -> IO LogMessage) -> Eff e a -> Eff e a Source #

Modify the the LogMessages written in the given sub-expression, as in censorLogs but with a effectful function.

Note: This is equivalent to modifyLogWriter . mappingLogWriterIO

addLogWriter :: IoLogging e => LogWriter -> Eff e a -> Eff e a Source #

Combine the effects of a given LogWriter and the existing one.

import Data.Text    as T
import Data.Text.IO as T

exampleAddLogWriter :: IO ()
exampleAddLogWriter = go >>= 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 (<= errorSeverity))

newtype ProcessId Source #

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.

Constructors

ProcessId
Fields _fromProcessId :: Int

Instances

Bounded ProcessId Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods minBound :: ProcessId # maxBound :: ProcessId #
Enum ProcessId Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods succ :: ProcessId -> ProcessId # pred :: ProcessId -> ProcessId # toEnum :: Int -> ProcessId # fromEnum :: ProcessId -> Int # enumFrom :: ProcessId -> [ProcessId] # enumFromThen :: ProcessId -> ProcessId -> [ProcessId] # enumFromTo :: ProcessId -> ProcessId -> [ProcessId] # enumFromThenTo :: ProcessId -> ProcessId -> ProcessId -> [ProcessId] #
Eq ProcessId Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: ProcessId -> ProcessId -> Bool # (/=) :: ProcessId -> ProcessId -> Bool #
Integral ProcessId Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods quot :: ProcessId -> ProcessId -> ProcessId # rem :: ProcessId -> ProcessId -> ProcessId # div :: ProcessId -> ProcessId -> ProcessId # mod :: ProcessId -> ProcessId -> ProcessId # quotRem :: ProcessId -> ProcessId -> (ProcessId, ProcessId) # divMod :: ProcessId -> ProcessId -> (ProcessId, ProcessId) # toInteger :: ProcessId -> Integer #
Num ProcessId Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (+) :: ProcessId -> ProcessId -> ProcessId # (-) :: ProcessId -> ProcessId -> ProcessId # (*) :: ProcessId -> ProcessId -> ProcessId # negate :: ProcessId -> ProcessId # abs :: ProcessId -> ProcessId # signum :: ProcessId -> ProcessId # fromInteger :: Integer -> ProcessId #
Ord ProcessId Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: ProcessId -> ProcessId -> Ordering # (<) :: ProcessId -> ProcessId -> Bool # (<=) :: ProcessId -> ProcessId -> Bool # (>) :: ProcessId -> ProcessId -> Bool # (>=) :: ProcessId -> ProcessId -> Bool # max :: ProcessId -> ProcessId -> ProcessId # min :: ProcessId -> ProcessId -> ProcessId #
Read ProcessId Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods readsPrec :: Int -> ReadS ProcessId # readList :: ReadS [ProcessId] # readPrec :: ReadPrec ProcessId # readListPrec :: ReadPrec [ProcessId] #
Real ProcessId Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods toRational :: ProcessId -> Rational #
Show ProcessId Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> ProcessId -> ShowS # show :: ProcessId -> String # showList :: [ProcessId] -> ShowS #
NFData ProcessId Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: ProcessId -> () #

data ProcessDown Source #

A monitored process exited. This message is sent to a process by the scheduler, when a process that was monitored died.

Since: 0.12.0

Constructors

ProcessDown
Fields downReference :: !MonitorReference downReason :: !(Interrupt NoRecovery) downProcess :: !ProcessId

Instances

Eq ProcessDown Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: ProcessDown -> ProcessDown -> Bool # (/=) :: ProcessDown -> ProcessDown -> Bool #
Ord ProcessDown Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: ProcessDown -> ProcessDown -> Ordering # (<) :: ProcessDown -> ProcessDown -> Bool # (<=) :: ProcessDown -> ProcessDown -> Bool # (>) :: ProcessDown -> ProcessDown -> Bool # (>=) :: ProcessDown -> ProcessDown -> Bool # max :: ProcessDown -> ProcessDown -> ProcessDown # min :: ProcessDown -> ProcessDown -> ProcessDown #
Show ProcessDown Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> ProcessDown -> ShowS # show :: ProcessDown -> String # showList :: [ProcessDown] -> ShowS #
Generic ProcessDown Source #
Instance details Defined in Control.Eff.Concurrent.Process Associated Types type Rep ProcessDown :: Type -> Type # Methods from :: ProcessDown -> Rep ProcessDown x # to :: Rep ProcessDown x -> ProcessDown #
NFData ProcessDown Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: ProcessDown -> () #
type Rep ProcessDown Source #
Instance details Defined in Control.Eff.Concurrent.Process type Rep ProcessDown = D1 (MetaData "ProcessDown" "Control.Eff.Concurrent.Process" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" False) (C1 (MetaCons "ProcessDown" PrefixI True) (S1 (MetaSel (Just "downReference") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 MonitorReference) :: (S1 (MetaSel (Just "downReason") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Interrupt NoRecovery)) :: S1 (MetaSel (Just "downProcess") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 ProcessId))))

data MonitorReference Source #

A value that contains a unique reference of a process monitoring.

Since: 0.12.0

Constructors

MonitorReference
Fields monitorIndex :: Int monitoredProcess :: ProcessId

Instances

Eq MonitorReference Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: MonitorReference -> MonitorReference -> Bool # (/=) :: MonitorReference -> MonitorReference -> Bool #
Ord MonitorReference Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: MonitorReference -> MonitorReference -> Ordering # (<) :: MonitorReference -> MonitorReference -> Bool # (<=) :: MonitorReference -> MonitorReference -> Bool # (>) :: MonitorReference -> MonitorReference -> Bool # (>=) :: MonitorReference -> MonitorReference -> Bool # max :: MonitorReference -> MonitorReference -> MonitorReference # min :: MonitorReference -> MonitorReference -> MonitorReference #
Read MonitorReference Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods readsPrec :: Int -> ReadS MonitorReference # readList :: ReadS [MonitorReference] # readPrec :: ReadPrec MonitorReference # readListPrec :: ReadPrec [MonitorReference] #
Show MonitorReference Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> MonitorReference -> ShowS # show :: MonitorReference -> String # showList :: [MonitorReference] -> ShowS #
Generic MonitorReference Source #
Instance details Defined in Control.Eff.Concurrent.Process Associated Types type Rep MonitorReference :: Type -> Type # Methods from :: MonitorReference -> Rep MonitorReference x # to :: Rep MonitorReference x -> MonitorReference #
NFData MonitorReference Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: MonitorReference -> () #
type Rep MonitorReference Source #
Instance details Defined in Control.Eff.Concurrent.Process type Rep MonitorReference = D1 (MetaData "MonitorReference" "Control.Eff.Concurrent.Process" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" False) (C1 (MetaCons "MonitorReference" PrefixI True) (S1 (MetaSel (Just "monitorIndex") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Just "monitoredProcess") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ProcessId)))

data SomeExitReason where Source #

An existential wrapper around Interrupt

Constructors

SomeExitReason :: Interrupt x -> SomeExitReason

Instances

Eq SomeExitReason Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: SomeExitReason -> SomeExitReason -> Bool # (/=) :: SomeExitReason -> SomeExitReason -> Bool #
Ord SomeExitReason Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: SomeExitReason -> SomeExitReason -> Ordering # (<) :: SomeExitReason -> SomeExitReason -> Bool # (<=) :: SomeExitReason -> SomeExitReason -> Bool # (>) :: SomeExitReason -> SomeExitReason -> Bool # (>=) :: SomeExitReason -> SomeExitReason -> Bool # max :: SomeExitReason -> SomeExitReason -> SomeExitReason # min :: SomeExitReason -> SomeExitReason -> SomeExitReason #
Show SomeExitReason Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> SomeExitReason -> ShowS # show :: SomeExitReason -> String # showList :: [SomeExitReason] -> ShowS #
NFData SomeExitReason Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: SomeExitReason -> () #

type Interrupts = Exc (Interrupt Recoverable) Source #

Exceptions containing Interrupts. See handleInterrupts, exitOnInterrupt or provideInterrupts

type HasSafeProcesses e inner = SetMember Process (Process inner) e Source #

A constraint for an effect set that requires the presence of SafeProcesses.

This constrains the effect list to look like this: [e1 ... eN, Process [e(N+1) .. e(N+k)], e(N+1) .. e(N+k)]

It constrains e to support the (only) Process effect.

This is more relaxed that HasProcesses since it does not require Interrupts.

Since: 0.27.1

type SafeProcesses r = Process r ': r Source #

Cons Process onto a list of effects. This is called SafeProcesses because the the actions cannot be interrupted in.

type HasProcesses e inner = (HasSafeProcesses e inner, Member Interrupts e) Source #

A constraint for an effect set that requires the presence of Processes.

This constrains the effect list to look like this: [e1 ... eN, Interrupts, Process [e(N+1) .. e(N+k)], e(N+1) .. e(N+k)]

It constrains e beyond HasSafeProcesses to encompass Interrupts.

Since: 0.27.1

type Processes e = Interrupts ': SafeProcesses e Source #

This adds a layer of the Interrupts effect on top of Processes

type RecoverableInterrupt = Interrupt Recoverable Source #

Interrupts which are Recoverable.

data Interrupt (t :: ExitRecovery) where Source #

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.

Since: 0.23.0

Constructors

NormalExitRequested :: Interrupt Recoverable	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 `ExitNormally`) Since: 0.13.2
NormalExitRequestedWith :: forall a. (Typeable a, Show a, NFData a) => a -> Interrupt Recoverable	Extension of `ExitNormally` with a custom reason Since: 0.30.0
OtherProcessNotRunning :: ProcessId -> Interrupt Recoverable	A process that should be running was not running.
TimeoutInterrupt :: String -> Interrupt Recoverable	A `Recoverable` timeout has occurred.
LinkedProcessCrashed :: ProcessId -> Interrupt Recoverable	A linked process is down, see `Link` for a discussion on linking.
ErrorInterrupt :: String -> Interrupt Recoverable	An exit reason that has an error message and is `Recoverable`.
InterruptedBy :: forall a. (Typeable a, Show a, NFData a) => a -> Interrupt Recoverable	An interrupt with a custom message. Since: 0.30.0
ExitNormally :: Interrupt NoRecovery	A process function returned or exited without any error.
ExitNormallyWith :: forall a. (Typeable a, Show a, NFData a) => a -> Interrupt NoRecovery	A process function returned or exited without any error, and with a custom message Since: 0.30.0
ExitUnhandledError :: Text -> Interrupt NoRecovery	An error causes the process to exit immediately. For example an unexpected runtime exception was thrown, i.e. an exception derived from `SomeException` Or a `Recoverable` Interrupt was not recovered.
ExitProcessCancelled :: Maybe ProcessId -> Interrupt NoRecovery	A process shall exit immediately, without any cleanup was cancelled (e.g. killed, in `cancel`)
ExitOtherProcessNotRunning :: ProcessId -> Interrupt NoRecovery	A process that is vital to the crashed process was not running

Instances

Eq (Interrupt x) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: Interrupt x -> Interrupt x -> Bool # (/=) :: Interrupt x -> Interrupt x -> Bool #
Ord (Interrupt x) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: Interrupt x -> Interrupt x -> Ordering # (<) :: Interrupt x -> Interrupt x -> Bool # (<=) :: Interrupt x -> Interrupt x -> Bool # (>) :: Interrupt x -> Interrupt x -> Bool # (>=) :: Interrupt x -> Interrupt x -> Bool # max :: Interrupt x -> Interrupt x -> Interrupt x # min :: Interrupt x -> Interrupt x -> Interrupt x #
Show (Interrupt x) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> Interrupt x -> ShowS # show :: Interrupt x -> String # showList :: [Interrupt x] -> ShowS #
Exception (Interrupt Recoverable) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods toException :: Interrupt Recoverable -> SomeException # fromException :: SomeException -> Maybe (Interrupt Recoverable) # displayException :: Interrupt Recoverable -> String #
Exception (Interrupt NoRecovery) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods toException :: Interrupt NoRecovery -> SomeException # fromException :: SomeException -> Maybe (Interrupt NoRecovery) # displayException :: Interrupt NoRecovery -> String #
NFData (Interrupt x) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: Interrupt x -> () #
(Typeable event, Lifted IO q, Member Logs q) => Server (ObservationQueue event) (Processes q) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer.Queue Associated Types data StartArgument (ObservationQueue event) :: Type Source # type Protocol (ObservationQueue event) :: Type Source # data Model (ObservationQueue event) :: Type Source # type Settings (ObservationQueue event) :: Type Source # Methods title :: StartArgument (ObservationQueue event) -> ProcessTitle Source # setup :: Endpoint (Protocol (ObservationQueue event)) -> StartArgument (ObservationQueue event) -> Eff (Processes q) (Model (ObservationQueue event), Settings (ObservationQueue event)) Source # update :: Endpoint (Protocol (ObservationQueue event)) -> StartArgument (ObservationQueue event) -> Event (Protocol (ObservationQueue event)) -> Eff (ModelState (ObservationQueue event) ': (SettingsReader (ObservationQueue event) ': Processes q)) () Source #
(IoLogging q, TangibleBroker p, Tangible (ChildId p), Typeable (ServerPdu p), Server p (Processes q), HasProcesses (ServerEffects p (Processes q)) q) => Server (Broker p) (Processes q) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Broker Associated Types data StartArgument (Broker p) :: Type Source # type Protocol (Broker p) :: Type Source # data Model (Broker p) :: Type Source # type Settings (Broker p) :: Type Source # Methods title :: StartArgument (Broker p) -> ProcessTitle Source # setup :: Endpoint (Protocol (Broker p)) -> StartArgument (Broker p) -> Eff (Processes q) (Model (Broker p), Settings (Broker p)) Source # update :: Endpoint (Protocol (Broker p)) -> StartArgument (Broker p) -> Event (Protocol (Broker p)) -> Eff (ModelState (Broker p) ': (SettingsReader (Broker p) ': Processes q)) () Source #
(Typeable child, HasPdu (ServerPdu child), Tangible (ChildId child), Ord (ChildId child), Eq (ChildId child), Lifted IO e, Member Logs e) => Server (Watchdog child) (Processes e) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Watchdog Associated Types data StartArgument (Watchdog child) :: Type Source # type Protocol (Watchdog child) :: Type Source # data Model (Watchdog child) :: Type Source # type Settings (Watchdog child) :: Type Source # Methods title :: StartArgument (Watchdog child) -> ProcessTitle Source # setup :: Endpoint (Protocol (Watchdog child)) -> StartArgument (Watchdog child) -> Eff (Processes e) (Model (Watchdog child), Settings (Watchdog child)) Source # update :: Endpoint (Protocol (Watchdog child)) -> StartArgument (Watchdog child) -> Event (Protocol (Watchdog child)) -> Eff (ModelState (Watchdog child) ': (SettingsReader (Watchdog child) ': Processes e)) () Source #
TangibleCallbacks tag eLoop e => Server (Server tag eLoop e) (Processes e) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.CallbackServer Associated Types data Init (Server tag eLoop e) :: Type Source # type ServerPdu (Server tag eLoop e) :: Type Source # type ServerEffects (Server tag eLoop e) (Processes e) :: [Type -> Type] Source # Methods serverTitle :: Init (Server tag eLoop e) -> ProcessTitle Source # runEffects :: Endpoint (ServerPdu (Server tag eLoop e)) -> Init (Server tag eLoop e) -> Eff (ServerEffects (Server tag eLoop e) (Processes e)) x -> Eff (Processes e) x Source # onEvent :: Endpoint (ServerPdu (Server tag eLoop e)) -> Init (Server tag eLoop e) -> Event (ServerPdu (Server tag eLoop e)) -> Eff (ServerEffects (Server tag eLoop e) (Processes e)) () Source #
type ServerEffects (Server tag eLoop e) (Processes e) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.CallbackServer type ServerEffects (Server tag eLoop e) (Processes e) = eLoop

data ExitSeverity Source #

This value indicates whether a process exited in way consistent with the planned behaviour or not.

Constructors

NormalExit
Crash

Instances

Eq ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: ExitSeverity -> ExitSeverity -> Bool # (/=) :: ExitSeverity -> ExitSeverity -> Bool #
Ord ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: ExitSeverity -> ExitSeverity -> Ordering # (<) :: ExitSeverity -> ExitSeverity -> Bool # (<=) :: ExitSeverity -> ExitSeverity -> Bool # (>) :: ExitSeverity -> ExitSeverity -> Bool # (>=) :: ExitSeverity -> ExitSeverity -> Bool # max :: ExitSeverity -> ExitSeverity -> ExitSeverity # min :: ExitSeverity -> ExitSeverity -> ExitSeverity #
Show ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> ExitSeverity -> ShowS # show :: ExitSeverity -> String # showList :: [ExitSeverity] -> ShowS #
Generic ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process Associated Types type Rep ExitSeverity :: Type -> Type # Methods from :: ExitSeverity -> Rep ExitSeverity x # to :: Rep ExitSeverity x -> ExitSeverity #
NFData ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: ExitSeverity -> () #
type Rep ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process type Rep ExitSeverity = D1 (MetaData "ExitSeverity" "Control.Eff.Concurrent.Process" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" False) (C1 (MetaCons "NormalExit" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Crash" PrefixI False) (U1 :: Type -> Type))

data ExitRecovery Source #

This kind is used to indicate if a Interrupt can be treated like a short interrupt which can be handled or ignored.

Constructors

Recoverable
NoRecovery

Instances

Eq ExitRecovery Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: ExitRecovery -> ExitRecovery -> Bool # (/=) :: ExitRecovery -> ExitRecovery -> Bool #
Ord ExitRecovery Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: ExitRecovery -> ExitRecovery -> Ordering # (<) :: ExitRecovery -> ExitRecovery -> Bool # (<=) :: ExitRecovery -> ExitRecovery -> Bool # (>) :: ExitRecovery -> ExitRecovery -> Bool # (>=) :: ExitRecovery -> ExitRecovery -> Bool # max :: ExitRecovery -> ExitRecovery -> ExitRecovery # min :: ExitRecovery -> ExitRecovery -> ExitRecovery #
Show ExitRecovery Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> ExitRecovery -> ShowS # show :: ExitRecovery -> String # showList :: [ExitRecovery] -> ShowS #
Generic ExitRecovery Source #
Instance details Defined in Control.Eff.Concurrent.Process Associated Types type Rep ExitRecovery :: Type -> Type # Methods from :: ExitRecovery -> Rep ExitRecovery x # to :: Rep ExitRecovery x -> ExitRecovery #
NFData ExitRecovery Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: ExitRecovery -> () #
type Rep ExitRecovery Source #
Instance details Defined in Control.Eff.Concurrent.Process type Rep ExitRecovery = D1 (MetaData "ExitRecovery" "Control.Eff.Concurrent.Process" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" False) (C1 (MetaCons "Recoverable" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "NoRecovery" PrefixI False) (U1 :: Type -> Type))

data MessageSelector a Source #

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

Instances

Functor MessageSelector Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods fmap :: (a -> b) -> MessageSelector a -> MessageSelector b # (<$) :: a -> MessageSelector b -> MessageSelector a #
Applicative MessageSelector Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods pure :: a -> MessageSelector a # (<>) :: MessageSelector (a -> b) -> MessageSelector a -> MessageSelector b # liftA2 :: (a -> b -> c) -> MessageSelector a -> MessageSelector b -> MessageSelector c # (>) :: MessageSelector a -> MessageSelector b -> MessageSelector b # (<*) :: MessageSelector a -> MessageSelector b -> MessageSelector a #
Alternative MessageSelector Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods empty :: MessageSelector a # (<\|>) :: MessageSelector a -> MessageSelector a -> MessageSelector a # some :: MessageSelector a -> MessageSelector [a] # many :: MessageSelector a -> MessageSelector [a] #
Semigroup a => Semigroup (MessageSelector a) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (<>) :: MessageSelector a -> MessageSelector a -> MessageSelector a # sconcat :: NonEmpty (MessageSelector a) -> MessageSelector a # stimes :: Integral b => b -> MessageSelector a -> MessageSelector a #
Semigroup a => Monoid (MessageSelector a) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods mempty :: MessageSelector a # mappend :: MessageSelector a -> MessageSelector a -> MessageSelector a # mconcat :: [MessageSelector a] -> MessageSelector a #

data ResumeProcess v where Source #

Every Process 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.

Constructors

Interrupted :: Interrupt Recoverable -> ResumeProcess v	The current operation of the process was interrupted with a `Interrupt`. If `isRecoverable` holds for the given reason, the process may choose to continue.
ResumeWith :: a -> ResumeProcess a	The process may resume to do work, using the given result.

Instances

NFData1 ResumeProcess Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods liftRnf :: (a -> ()) -> ResumeProcess a -> () #
Show v => Show (ResumeProcess v) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> ResumeProcess v -> ShowS # show :: ResumeProcess v -> String # showList :: [ResumeProcess v] -> ShowS #
Generic (ResumeProcess v) Source #
Instance details Defined in Control.Eff.Concurrent.Process Associated Types type Rep (ResumeProcess v) :: Type -> Type # Methods from :: ResumeProcess v -> Rep (ResumeProcess v) x # to :: Rep (ResumeProcess v) x -> ResumeProcess v #
NFData a => NFData (ResumeProcess a) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: ResumeProcess a -> () #
Generic1 ResumeProcess Source #
Instance details Defined in Control.Eff.Concurrent.Process Associated Types type Rep1 ResumeProcess :: k -> Type # Methods from1 :: ResumeProcess a -> Rep1 ResumeProcess a # to1 :: Rep1 ResumeProcess a -> ResumeProcess a #
type Rep (ResumeProcess v) Source #
Instance details Defined in Control.Eff.Concurrent.Process type Rep (ResumeProcess v) = D1 (MetaData "ResumeProcess" "Control.Eff.Concurrent.Process" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" False) (C1 (MetaCons "Interrupted" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Interrupt Recoverable))) :+: C1 (MetaCons "ResumeWith" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 v)))
type Rep1 ResumeProcess Source #
Instance details Defined in Control.Eff.Concurrent.Process type Rep1 ResumeProcess = D1 (MetaData "ResumeProcess" "Control.Eff.Concurrent.Process" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" False) (C1 (MetaCons "Interrupted" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Interrupt Recoverable))) :+: C1 (MetaCons "ResumeWith" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype Serializer message Source #

Serialize a message into a StrictDynamic value to be sent via sendAnyMessage.

This indirection allows, among other things, the composition of Servers.

Since: 0.24.1

Constructors

MkSerializer
Fields runSerializer :: message -> StrictDynamic

Instances

Contravariant Serializer Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods contramap :: (a -> b) -> Serializer b -> Serializer a # (>$) :: b -> Serializer b -> Serializer a #
Typeable message => Show (Serializer message) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> Serializer message -> ShowS # show :: Serializer message -> String # showList :: [Serializer message] -> ShowS #
NFData (Serializer message) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: Serializer message -> () #

data StrictDynamic Source #

Data flows between Processes via these messages.

This is just a newtype wrapper around Dynamic. The reason this type exists is to force construction through the code in this module, which always evaluates a message to normal form before sending it to another process.

Since: 0.22.0

Instances

Show StrictDynamic Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> StrictDynamic -> ShowS # show :: StrictDynamic -> String # showList :: [StrictDynamic] -> ShowS #
NFData StrictDynamic Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: StrictDynamic -> () #

newtype Timeout Source #

A number of micro seconds.

Since: 0.12.0

Constructors

TimeoutMicros
Fields fromTimeoutMicros :: Int

Instances

Enum Timeout Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods succ :: Timeout -> Timeout # pred :: Timeout -> Timeout # toEnum :: Int -> Timeout # fromEnum :: Timeout -> Int # enumFrom :: Timeout -> [Timeout] # enumFromThen :: Timeout -> Timeout -> [Timeout] # enumFromTo :: Timeout -> Timeout -> [Timeout] # enumFromThenTo :: Timeout -> Timeout -> Timeout -> [Timeout] #
Eq Timeout Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: Timeout -> Timeout -> Bool # (/=) :: Timeout -> Timeout -> Bool #
Integral Timeout Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods quot :: Timeout -> Timeout -> Timeout # rem :: Timeout -> Timeout -> Timeout # div :: Timeout -> Timeout -> Timeout # mod :: Timeout -> Timeout -> Timeout # quotRem :: Timeout -> Timeout -> (Timeout, Timeout) # divMod :: Timeout -> Timeout -> (Timeout, Timeout) # toInteger :: Timeout -> Integer #
Num Timeout Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (+) :: Timeout -> Timeout -> Timeout # (-) :: Timeout -> Timeout -> Timeout # (*) :: Timeout -> Timeout -> Timeout # negate :: Timeout -> Timeout # abs :: Timeout -> Timeout # signum :: Timeout -> Timeout # fromInteger :: Integer -> Timeout #
Ord Timeout Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: Timeout -> Timeout -> Ordering # (<) :: Timeout -> Timeout -> Bool # (<=) :: Timeout -> Timeout -> Bool # (>) :: Timeout -> Timeout -> Bool # (>=) :: Timeout -> Timeout -> Bool # max :: Timeout -> Timeout -> Timeout # min :: Timeout -> Timeout -> Timeout #
Real Timeout Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods toRational :: Timeout -> Rational #
Show Timeout Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> Timeout -> ShowS # show :: Timeout -> String # showList :: [Timeout] -> ShowS #
NFData Timeout Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: Timeout -> () #

newtype ProcessDetails Source #

A multi-line text describing the current state of a process for debugging purposes.

Since: 0.24.1

Constructors

MkProcessDetails
Fields _fromProcessDetails :: Text

Instances

Eq ProcessDetails Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: ProcessDetails -> ProcessDetails -> Bool # (/=) :: ProcessDetails -> ProcessDetails -> Bool #
Ord ProcessDetails Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: ProcessDetails -> ProcessDetails -> Ordering # (<) :: ProcessDetails -> ProcessDetails -> Bool # (<=) :: ProcessDetails -> ProcessDetails -> Bool # (>) :: ProcessDetails -> ProcessDetails -> Bool # (>=) :: ProcessDetails -> ProcessDetails -> Bool # max :: ProcessDetails -> ProcessDetails -> ProcessDetails # min :: ProcessDetails -> ProcessDetails -> ProcessDetails #
Show ProcessDetails Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> ProcessDetails -> ShowS # show :: ProcessDetails -> String # showList :: [ProcessDetails] -> ShowS #
IsString ProcessDetails Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods fromString :: String -> ProcessDetails #
Generic ProcessDetails Source #
Instance details Defined in Control.Eff.Concurrent.Process Associated Types type Rep ProcessDetails :: Type -> Type # Methods from :: ProcessDetails -> Rep ProcessDetails x # to :: Rep ProcessDetails x -> ProcessDetails #
Semigroup ProcessDetails Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (<>) :: ProcessDetails -> ProcessDetails -> ProcessDetails # sconcat :: NonEmpty ProcessDetails -> ProcessDetails # stimes :: Integral b => b -> ProcessDetails -> ProcessDetails #
Monoid ProcessDetails Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods mempty :: ProcessDetails # mappend :: ProcessDetails -> ProcessDetails -> ProcessDetails # mconcat :: [ProcessDetails] -> ProcessDetails #
NFData ProcessDetails Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: ProcessDetails -> () #
type Rep ProcessDetails Source #
Instance details Defined in Control.Eff.Concurrent.Process type Rep ProcessDetails = D1 (MetaData "ProcessDetails" "Control.Eff.Concurrent.Process" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" True) (C1 (MetaCons "MkProcessDetails" PrefixI True) (S1 (MetaSel (Just "_fromProcessDetails") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

newtype ProcessTitle Source #

A short title for a Process for logging purposes.

Since: 0.24.1

Constructors

MkProcessTitle
Fields _fromProcessTitle :: Text

Instances

Eq ProcessTitle Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: ProcessTitle -> ProcessTitle -> Bool # (/=) :: ProcessTitle -> ProcessTitle -> Bool #
Ord ProcessTitle Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: ProcessTitle -> ProcessTitle -> Ordering # (<) :: ProcessTitle -> ProcessTitle -> Bool # (<=) :: ProcessTitle -> ProcessTitle -> Bool # (>) :: ProcessTitle -> ProcessTitle -> Bool # (>=) :: ProcessTitle -> ProcessTitle -> Bool # max :: ProcessTitle -> ProcessTitle -> ProcessTitle # min :: ProcessTitle -> ProcessTitle -> ProcessTitle #
Show ProcessTitle Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> ProcessTitle -> ShowS # show :: ProcessTitle -> String # showList :: [ProcessTitle] -> ShowS #
IsString ProcessTitle Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods fromString :: String -> ProcessTitle #
Generic ProcessTitle Source #
Instance details Defined in Control.Eff.Concurrent.Process Associated Types type Rep ProcessTitle :: Type -> Type # Methods from :: ProcessTitle -> Rep ProcessTitle x # to :: Rep ProcessTitle x -> ProcessTitle #
Semigroup ProcessTitle Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (<>) :: ProcessTitle -> ProcessTitle -> ProcessTitle # sconcat :: NonEmpty ProcessTitle -> ProcessTitle # stimes :: Integral b => b -> ProcessTitle -> ProcessTitle #
Monoid ProcessTitle Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods mempty :: ProcessTitle # mappend :: ProcessTitle -> ProcessTitle -> ProcessTitle # mconcat :: [ProcessTitle] -> ProcessTitle #
NFData ProcessTitle Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: ProcessTitle -> () #
type Rep ProcessTitle Source #
Instance details Defined in Control.Eff.Concurrent.Process type Rep ProcessTitle = D1 (MetaData "ProcessTitle" "Control.Eff.Concurrent.Process" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" True) (C1 (MetaCons "MkProcessTitle" PrefixI True) (S1 (MetaSel (Just "_fromProcessTitle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data Process (r :: [Type -> Type]) b where Source #

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:

fair scheduling
sending a message does not block
receiving a message does block
spawning a child blocks only a very moment
a newly spawned process shall be scheduled before the parent process after
the spawnRaw
when the first process exists, all process should be killed immediately

Constructors

FlushMessages :: Process r (ResumeProcess [StrictDynamic])	Remove all messages from the process' message queue
YieldProcess :: Process r (ResumeProcess ())	In cooperative schedulers, this will give processing time to the scheduler. Every other operation implicitly serves the same purpose. Since: 0.12.0
Delay :: Timeout -> Process r (ResumeProcess ())	Simply wait until the time in the given `Timeout` has elapsed and return. Since: 0.30.0
SelfPid :: Process r (ResumeProcess ProcessId)	Return the current `ProcessId`
Spawn :: ProcessTitle -> Eff (Process r ': r) () -> Process r (ResumeProcess ProcessId)	Start a new process, the new process will execute an effect, the function will return immediately with a `ProcessId`.
SpawnLink :: ProcessTitle -> Eff (Process r ': r) () -> Process r (ResumeProcess ProcessId)	Start a new process, and `Link` to it . Since: 0.12.0
Shutdown :: Interrupt NoRecovery -> Process r a	Shutdown the process; irregardless of the exit reason, this function never returns,
SendShutdown :: ProcessId -> Interrupt NoRecovery -> Process r (ResumeProcess ())	Shutdown another process immediately, the other process has no way of handling this!
SendInterrupt :: ProcessId -> Interrupt Recoverable -> Process r (ResumeProcess ())	Request that another a process interrupts. The targeted process is interrupted and gets an `Interrupted`, the target process may decide to ignore the interrupt and continue as if nothing happened.
SendMessage :: ProcessId -> StrictDynamic -> Process r (ResumeProcess ())	Send a message to a process addressed by the `ProcessId`. Sending a message should always succeed and return immediately, even if the destination process does not exist, or does not accept messages of the given type.
ReceiveSelectedMessage :: forall r a. MessageSelector a -> Process r (ResumeProcess a)	Receive a message that matches a criteria. This should block until an a message was received. The message is returned as a `ResumeProcess` value. The function should also return if an exception was caught or a shutdown was requested.
MakeReference :: Process r (ResumeProcess Int)	Generate a unique `Int` for the current process.
Monitor :: ProcessId -> Process r (ResumeProcess MonitorReference)	Monitor another process. When the monitored process exits a `ProcessDown` 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 `ProcessDown` message will be sent immediately, without exit reason Since: 0.12.0
Demonitor :: MonitorReference -> Process r (ResumeProcess ())	Remove a monitor. Since: 0.12.0
Link :: ProcessId -> Process r (ResumeProcess ())	Connect the calling process to another process, such that if one of the processes crashes (i.e. `isCrash` returns `True`), the other is shutdown with the `Interrupt` `LinkedProcessCrashed`. You might wonder: Why not tearing down the linked process when exiting normally? I thought about this. If a process exits normally, it should have the opportunity to shutdown stuff explicitly. And if you want to make sure that there are no dangling child processes after e.g. a broker crash, you can always use `monitor`. Since: 0.12.0
Unlink :: ProcessId -> Process r (ResumeProcess ())	Unlink the calling process from the other process. See `Link` for a discussion on linking. Since: 0.12.0
UpdateProcessDetails :: ProcessDetails -> Process r (ResumeProcess ())	Update the `ProcessDetails` of a process
GetProcessState :: ProcessId -> Process r (ResumeProcess (Maybe (ProcessTitle, ProcessDetails, ProcessState)))	Get the `ProcessState` (or `Nothing` if the process is dead)

Instances

(Typeable event, Lifted IO q, Member Logs q) => Server (ObservationQueue event) (Processes q) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer.Queue Associated Types data StartArgument (ObservationQueue event) :: Type Source # type Protocol (ObservationQueue event) :: Type Source # data Model (ObservationQueue event) :: Type Source # type Settings (ObservationQueue event) :: Type Source # Methods title :: StartArgument (ObservationQueue event) -> ProcessTitle Source # setup :: Endpoint (Protocol (ObservationQueue event)) -> StartArgument (ObservationQueue event) -> Eff (Processes q) (Model (ObservationQueue event), Settings (ObservationQueue event)) Source # update :: Endpoint (Protocol (ObservationQueue event)) -> StartArgument (ObservationQueue event) -> Event (Protocol (ObservationQueue event)) -> Eff (ModelState (ObservationQueue event) ': (SettingsReader (ObservationQueue event) ': Processes q)) () Source #
(IoLogging q, TangibleBroker p, Tangible (ChildId p), Typeable (ServerPdu p), Server p (Processes q), HasProcesses (ServerEffects p (Processes q)) q) => Server (Broker p) (Processes q) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Broker Associated Types data StartArgument (Broker p) :: Type Source # type Protocol (Broker p) :: Type Source # data Model (Broker p) :: Type Source # type Settings (Broker p) :: Type Source # Methods title :: StartArgument (Broker p) -> ProcessTitle Source # setup :: Endpoint (Protocol (Broker p)) -> StartArgument (Broker p) -> Eff (Processes q) (Model (Broker p), Settings (Broker p)) Source # update :: Endpoint (Protocol (Broker p)) -> StartArgument (Broker p) -> Event (Protocol (Broker p)) -> Eff (ModelState (Broker p) ': (SettingsReader (Broker p) ': Processes q)) () Source #
(Typeable child, HasPdu (ServerPdu child), Tangible (ChildId child), Ord (ChildId child), Eq (ChildId child), Lifted IO e, Member Logs e) => Server (Watchdog child) (Processes e) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Watchdog Associated Types data StartArgument (Watchdog child) :: Type Source # type Protocol (Watchdog child) :: Type Source # data Model (Watchdog child) :: Type Source # type Settings (Watchdog child) :: Type Source # Methods title :: StartArgument (Watchdog child) -> ProcessTitle Source # setup :: Endpoint (Protocol (Watchdog child)) -> StartArgument (Watchdog child) -> Eff (Processes e) (Model (Watchdog child), Settings (Watchdog child)) Source # update :: Endpoint (Protocol (Watchdog child)) -> StartArgument (Watchdog child) -> Event (Protocol (Watchdog child)) -> Eff (ModelState (Watchdog child) ': (SettingsReader (Watchdog child) ': Processes e)) () Source #
Show (Process r b) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> Process r b -> ShowS # show :: Process r b -> String # showList :: [Process r b] -> ShowS #
TangibleCallbacks tag eLoop e => Server (Server tag eLoop e) (Processes e) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.CallbackServer Associated Types data Init (Server tag eLoop e) :: Type Source # type ServerPdu (Server tag eLoop e) :: Type Source # type ServerEffects (Server tag eLoop e) (Processes e) :: [Type -> Type] Source # Methods serverTitle :: Init (Server tag eLoop e) -> ProcessTitle Source # runEffects :: Endpoint (ServerPdu (Server tag eLoop e)) -> Init (Server tag eLoop e) -> Eff (ServerEffects (Server tag eLoop e) (Processes e)) x -> Eff (Processes e) x Source # onEvent :: Endpoint (ServerPdu (Server tag eLoop e)) -> Init (Server tag eLoop e) -> Event (ServerPdu (Server tag eLoop e)) -> Eff (ServerEffects (Server tag eLoop e) (Processes e)) () Source #
type ServerEffects (Server tag eLoop e) (Processes e) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.CallbackServer type ServerEffects (Server tag eLoop e) (Processes e) = eLoop

fromProcessTitle :: Lens' ProcessTitle Text Source #

An isomorphism lens for the ProcessTitle

Since: 0.24.1

fromProcessDetails :: Lens' ProcessDetails Text Source #

An isomorphism lens for the ProcessDetails

Since: 0.24.1

toStrictDynamic :: (Typeable a, NFData a) => a -> StrictDynamic Source #

Deeply evaluate the given value and wrap it into a StrictDynamic.

Since: 0.22.0

fromStrictDynamic :: Typeable a => StrictDynamic -> Maybe a Source #

Convert a StrictDynamic back to a value.

Since: 0.22.0

unwrapStrictDynamic :: StrictDynamic -> Dynamic Source #

Convert a StrictDynamic back to an unwrapped Dynamic.

Since: 0.22.0

selectMessage :: Typeable t => MessageSelector t Source #

Create a message selector for a value that can be obtained by fromStrictDynamic.

Since: 0.9.1

filterMessage :: Typeable a => (a -> Bool) -> MessageSelector a Source #

Create a message selector from a predicate.

Since: 0.9.1

selectMessageWith :: Typeable a => (a -> Maybe b) -> MessageSelector b Source #

Select a message of type a and apply the given function to it. If the function returns Just The ReceiveSelectedMessage function will return the result (sans Maybe).

Since: 0.9.1

selectDynamicMessage :: (StrictDynamic -> Maybe a) -> MessageSelector a Source #

Create a message selector.

Since: 0.9.1

selectAnyMessage :: MessageSelector StrictDynamic Source #

Create a message selector that will match every message. This is lazy because the result is not forceed.

Since: 0.9.1

toExitRecovery :: Interrupt r -> ExitRecovery Source #

Get the ExitRecovery

toExitSeverity :: Interrupt e -> ExitSeverity Source #

Get the ExitSeverity of a Interrupt.

interruptToExit :: Interrupt Recoverable -> Interrupt NoRecovery Source #

Return either ExitNormally or interruptToExit from a Recoverable Interrupt;

If the Interrupt is NormalExitRequested then return ExitNormally

isProcessDownInterrupt :: Maybe ProcessId -> Interrupt r -> Bool Source #

A predicate for linked process crashes.

provideInterruptsShutdown :: forall e a. Eff (Processes e) a -> Eff (SafeProcesses e) a Source #

Handle all Interrupts of an Processes by wrapping them up in interruptToExit and then do a process Shutdown.

handleInterrupts :: (HasCallStack, Member Interrupts r) => (Interrupt Recoverable -> Eff r a) -> Eff r a -> Eff r a Source #

Handle Interrupts arising during process operations, e.g. when a linked process crashes while we wait in a receiveSelectedMessage via a call to interrupt.

tryUninterrupted :: (HasCallStack, Member Interrupts r) => Eff r a -> Eff r (Either (Interrupt Recoverable) a) Source #

Like handleInterrupts, but instead of passing the Interrupt to a handler function, Either is returned.

Since: 0.13.2

logInterrupts :: forall r. (Member Logs r, HasCallStack, Member Interrupts r) => Eff r () -> Eff r () Source #

Handle interrupts by logging them with logProcessExit and otherwise ignoring them.

exitOnInterrupt :: (HasCallStack, HasProcesses r q) => Eff r a -> Eff r a Source #

Handle Interrupts arising during process operations, e.g. when a linked process crashes while we wait in a receiveSelectedMessage via a call to interrupt.

provideInterrupts :: HasCallStack => Eff (Interrupts ': r) a -> Eff r (Either (Interrupt Recoverable) a) Source #

Handle Interrupts arising during process operations, e.g. when a linked process crashes while we wait in a receiveSelectedMessage via a call to interrupt.

mergeEitherInterruptAndExitReason :: Either (Interrupt Recoverable) (Interrupt NoRecovery) -> Interrupt NoRecovery Source #

Wrap all (left) Interrupts into interruptToExit and return the (right) NoRecovery Interrupts as is.

interrupt :: (HasCallStack, Member Interrupts r) => Interrupt Recoverable -> Eff r a Source #

Throw an Interrupt, can be handled by handleInterrupts or exitOnInterrupt or provideInterrupts.

isCrash :: Interrupt x -> Bool Source #

A predicate for crashes. A crash happens when a process exits with an Interrupt other than ExitNormally

isRecoverable :: Interrupt x -> Bool Source #

A predicate for recoverable exit reasons. This predicate defines the exit reasons which functions such as executeAndResume

fromSomeExitReason :: SomeExitReason -> Either (Interrupt NoRecovery) (Interrupt Recoverable) Source #

Partition a SomeExitReason back into either a NoRecovery or a Recoverable Interrupt

toCrashReason :: Interrupt x -> Maybe Text Source #

Print a Interrupt to Just a formatted String when isCrash is True. This can be useful in combination with view patterns, e.g.:

logCrash :: Interrupt -> Eff e ()
logCrash (toCrashReason -> Just reason) = logError reason
logCrash _ = return ()

Though this can be improved to:

logCrash = traverse_ logError . toCrashReason

logProcessExit :: forall e x. (Member Logs e, HasCallStack) => Interrupt x -> Eff e () Source #

Log the Interrupts

executeAndResume :: forall q r v. (HasSafeProcesses r q, HasCallStack) => Process q (ResumeProcess v) -> Eff r (Either (Interrupt Recoverable) v) Source #

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 isRecoverable, return the exit reason.

executeAndResumeOrExit :: forall r q v. (HasSafeProcesses r q, HasCallStack) => Process q (ResumeProcess v) -> Eff r v Source #

Execute a Process action and resume the process, exit the process when an Interrupts was raised. Use executeAndResume to catch interrupts.

executeAndResumeOrThrow :: forall q r v. (HasProcesses r q, HasCallStack) => Process q (ResumeProcess v) -> Eff r v Source #

Execute a Process action and resume the process, exit the process when an Interrupts was raised. Use executeAndResume to catch interrupts.

yieldProcess :: forall r q. (HasProcesses r q, HasCallStack) => Eff r () Source #

Use executeAndResumeOrExit to execute YieldProcess. Refer to YieldProcess for more information.

delay :: forall r q. (HasProcesses r q, HasCallStack) => Timeout -> Eff r () Source #

Simply block until the time in the Timeout has passed.

Since: 0.30.0

sendMessage :: forall o r q. (HasProcesses r q, HasCallStack, Typeable o, NFData o) => ProcessId -> o -> Eff r () Source #

Send a message to a process addressed by the ProcessId. See SendMessage.

The message will be reduced to normal form (rnf) by/in the caller process.

sendAnyMessage :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> StrictDynamic -> Eff r () Source #

Send a Dynamic value to a process addressed by the ProcessId. See SendMessage.

sendShutdown :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt NoRecovery -> Eff r () Source #

Exit a process addressed by the ProcessId. The process will exit, it might do some cleanup, but is ultimately unrecoverable. See SendShutdown.

sendInterrupt :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Interrupt Recoverable -> Eff r () Source #

Interrupts a process addressed by the ProcessId. The process might exit, or it may continue. | Like sendInterrupt, but also return True iff the process to exit exists.

spawn :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ProcessId Source #

Start a new process, the new process will execute an effect, the function will return immediately with a ProcessId. If the new process is interrupted, the process will Shutdown with the Interrupt wrapped in interruptToExit. For specific use cases it might be better to use spawnRaw.

spawn_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r () Source #

Like spawn but return ().

spawnLink :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (Processes q) () -> Eff r ProcessId Source #

Start a new process, and immediately link to it.

See Link for a discussion on linking.

Since: 0.12.0

spawnRaw :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff r ProcessId Source #

Start a new process, the new process will execute an effect, the function will return immediately with a ProcessId. The spawned process has only the raw SafeProcesses effects. For non-library code spawn might be better suited.

spawnRaw_ :: forall r q. (HasCallStack, HasProcesses r q) => ProcessTitle -> Eff (SafeProcesses q) () -> Eff r () Source #

Like spawnRaw but return ().

isProcessAlive :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r Bool Source #

Return True if the process is alive.

Since: 0.12.0

getProcessState :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r (Maybe (ProcessTitle, ProcessDetails, ProcessState)) Source #

Return the ProcessTitle, ProcessDetails and ProcessState, for the given process, if the process is alive.

Since: 0.24.1

updateProcessDetails :: forall r q. (HasCallStack, HasProcesses r q) => ProcessDetails -> Eff r () Source #

Replace the ProcessDetails of the process.

Since: 0.24.1

receiveAnyMessage :: forall r q. (HasCallStack, HasProcesses r q) => Eff r StrictDynamic Source #

Block until a message was received. See ReceiveSelectedMessage for more documentation.

receiveSelectedMessage :: forall r q a. (HasCallStack, Show a, HasProcesses r q) => MessageSelector a -> Eff r a Source #

Block until a message was received, that is not Nothing after applying a callback to it. See ReceiveSelectedMessage for more documentation.

receiveMessage :: forall a r q. (HasCallStack, Typeable a, NFData a, Show a, HasProcesses r q) => Eff r a Source #

Receive and cast the message to some Typeable instance. See ReceiveSelectedMessage for more documentation. This will wait for a message of the return type using receiveSelectedMessage

flushMessages :: forall r q. (HasCallStack, HasProcesses r q) => Eff r [StrictDynamic] Source #

Remove and return all messages currently enqueued in the process message queue.

Since: 0.12.0

receiveSelectedLoop :: forall r q a endOfLoopResult. (HasSafeProcesses r q, HasCallStack) => MessageSelector a -> (Either (Interrupt Recoverable) a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult Source #

Enter a loop to receive messages and pass them to a callback, until the function returns Just a result. Only the messages of the given type will be received. If the process is interrupted by an exception of by a SendShutdown from another process, with an exit reason that satisfies isRecoverable, then the callback will be invoked with Left Interrupt, otherwise the process will be exited with the same reason using exitBecause. See also ReceiveSelectedMessage for more documentation.

receiveAnyLoop :: forall r q endOfLoopResult. (HasSafeProcesses r q, HasCallStack) => (Either (Interrupt Recoverable) StrictDynamic -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult Source #

Like receiveSelectedLoop but not selective. See also selectAnyMessage, receiveSelectedLoop.

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

Like receiveSelectedLoop but refined to casting to a specific Typeable using selectMessage.

self :: (HasCallStack, HasSafeProcesses r q) => Eff r ProcessId Source #

Returns the ProcessId of the current process.

makeReference :: (HasCallStack, HasProcesses r q) => Eff r Int Source #

Generate a unique Int for the current process.

monitor :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r MonitorReference Source #

Monitor another process. When the monitored process exits a ProcessDown 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 ProcessDown message will be sent immediately, without exit reason

Since: 0.12.0

demonitor :: forall r q. (HasCallStack, HasProcesses r q) => MonitorReference -> Eff r () Source #

Remove a monitor created with monitor.

Since: 0.12.0

withMonitor :: (HasCallStack, HasProcesses r q) => ProcessId -> (MonitorReference -> Eff r a) -> Eff r a Source #

monitor another process before while performing an action and demonitor afterwards.

Since: 0.12.0

receiveWithMonitor :: (HasCallStack, HasProcesses r q, Typeable a, Show a) => ProcessId -> MessageSelector a -> Eff r (Either ProcessDown a) Source #

A MessageSelector for receiving either a monitor of the given process or another message.

Since: 0.12.0

becauseProcessIsDown :: ProcessDown -> Interrupt Recoverable Source #

Make an Interrupt for a ProcessDown message.

For example: doSomething >>= either (interrupt . becauseProcessIsDown) return

Since: 0.12.0

selectProcessDown :: MonitorReference -> MessageSelector ProcessDown Source #

A MessageSelector for the ProcessDown message of a specific process.

The parameter is the value obtained by monitor.

Since: 0.12.0

selectProcessDownByProcessId :: ProcessId -> MessageSelector ProcessDown Source #

A MessageSelector for the ProcessDown message. of a specific process.

In contrast to selectProcessDown this function matches the ProcessId.

Since: 0.28.0

linkProcess :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r () Source #

Connect the calling process to another process, such that if one of the processes crashes (i.e. isCrash returns True), the other is shutdown with the Interrupt LinkedProcessCrashed.

See Link for a discussion on linking.

Since: 0.12.0

unlinkProcess :: forall r q. (HasCallStack, HasProcesses r q) => ProcessId -> Eff r () Source #

Unlink the calling process from the other process.

See Link for a discussion on linking.

Since: 0.12.0

exitBecause :: forall r q a. (HasCallStack, HasSafeProcesses r q) => Interrupt NoRecovery -> Eff r a Source #

Exit the process with a Interrupt.

exitNormally :: forall r q a. (HasCallStack, HasSafeProcesses r q) => Eff r a Source #

Exit the process.

exitWithError :: forall r q a. (HasCallStack, HasSafeProcesses r q) => String -> Eff r a Source #

Exit the process with an error.

data Receiver a Source #

A ProcessId and a Serializer. EXPERIMENTAL

See sendToReceiver.

Since: 0.29.0

Constructors

(NFData out, Typeable out, Show out) => Receiver
Fields _receiverPid :: ProcessId _receiverSerializer :: a -> out

Instances

Contravariant Receiver Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods contramap :: (a -> b) -> Receiver b -> Receiver a # (>$) :: b -> Receiver b -> Receiver a #
Eq (Receiver o) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: Receiver o -> Receiver o -> Bool # (/=) :: Receiver o -> Receiver o -> Bool #
Ord (Receiver o) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: Receiver o -> Receiver o -> Ordering # (<) :: Receiver o -> Receiver o -> Bool # (<=) :: Receiver o -> Receiver o -> Bool # (>) :: Receiver o -> Receiver o -> Bool # (>=) :: Receiver o -> Receiver o -> Bool # max :: Receiver o -> Receiver o -> Receiver o # min :: Receiver o -> Receiver o -> Receiver o #
Typeable protocol => Show (Receiver protocol) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> Receiver protocol -> ShowS # show :: Receiver protocol -> String # showList :: [Receiver protocol] -> ShowS #
NFData (Receiver o) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: Receiver o -> () #

fromProcessId :: Iso' ProcessId Int Source #

sendToReceiver :: (NFData o, HasProcesses r q) => Receiver o -> o -> Eff r () Source #

Serialize and send a message to the process in a Receiver.

EXPERIMENTAL

Since: 0.29.0

receiverPid :: forall a. Lens' (Receiver a) ProcessId Source #

class (Typeable protocol, Typeable embeddedProtocol) => HasPduPrism protocol embeddedProtocol where Source #

A class for Pdu instances that embed other Pdu.

This is a part of Embeds provide instances for your Pdus but in client code use the Embeds constraint.

Instances of this class serve as proof to Embeds that a conversion into another Pdu actually exists.

A Prism for the embedded Pdu is the center of this class

Laws: embeddedPdu = prism' embedPdu fromPdu

Since: 0.29.0

Minimal complete definition

Nothing

Methods

embeddedPdu :: forall (result :: Synchronicity). Prism' (Pdu protocol result) (Pdu embeddedProtocol result) Source #

A Prism for the embedded Pdus.

embedPdu :: forall (result :: Synchronicity). Pdu embeddedProtocol result -> Pdu protocol result Source #

Embed the Pdu value of an embedded protocol into the corresponding Pdu value.

fromPdu :: forall (result :: Synchronicity). Pdu protocol result -> Maybe (Pdu embeddedProtocol result) Source #

Examine a Pdu value from the outer protocol, and return it, if it embeds a Pdu of embedded protocol, otherwise return Nothing/

Instances

Typeable a => HasPduPrism a a Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu a result) (Pdu a result) Source # embedPdu :: Pdu a result -> Pdu a result Source # fromPdu :: Pdu a result -> Maybe (Pdu a result) Source #
Typeable p => HasPduPrism (Broker p) (ObserverRegistry (ChildEvent p)) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Broker Methods embeddedPdu :: Prism' (Pdu (Broker p) result) (Pdu (ObserverRegistry (ChildEvent p)) result) Source # embedPdu :: Pdu (ObserverRegistry (ChildEvent p)) result -> Pdu (Broker p) result Source # fromPdu :: Pdu (Broker p) result -> Maybe (Pdu (ObserverRegistry (ChildEvent p)) result) Source #
Typeable child => HasPduPrism (Watchdog child) (Observer (ChildEvent child)) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Watchdog Methods embeddedPdu :: Prism' (Pdu (Watchdog child) result) (Pdu (Observer (ChildEvent child)) result) Source # embedPdu :: Pdu (Observer (ChildEvent child)) result -> Pdu (Watchdog child) result Source # fromPdu :: Pdu (Watchdog child) result -> Maybe (Pdu (Observer (ChildEvent child)) result) Source #
(Typeable a1, Typeable a2) => HasPduPrism (a1, a2) a2 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2) result) (Pdu a2 result) Source # embedPdu :: Pdu a2 result -> Pdu (a1, a2) result Source # fromPdu :: Pdu (a1, a2) result -> Maybe (Pdu a2 result) Source #
(Typeable a1, Typeable a2) => HasPduPrism (a1, a2) a1 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2) result) (Pdu a1 result) Source # embedPdu :: Pdu a1 result -> Pdu (a1, a2) result Source # fromPdu :: Pdu (a1, a2) result -> Maybe (Pdu a1 result) Source #
(Typeable a1, Typeable a2, Typeable a3) => HasPduPrism (a1, a2, a3) a3 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3) result) (Pdu a3 result) Source # embedPdu :: Pdu a3 result -> Pdu (a1, a2, a3) result Source # fromPdu :: Pdu (a1, a2, a3) result -> Maybe (Pdu a3 result) Source #
(Typeable a1, Typeable a2, Typeable a3) => HasPduPrism (a1, a2, a3) a2 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3) result) (Pdu a2 result) Source # embedPdu :: Pdu a2 result -> Pdu (a1, a2, a3) result Source # fromPdu :: Pdu (a1, a2, a3) result -> Maybe (Pdu a2 result) Source #
(Typeable a1, Typeable a2, Typeable a3) => HasPduPrism (a1, a2, a3) a1 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3) result) (Pdu a1 result) Source # embedPdu :: Pdu a1 result -> Pdu (a1, a2, a3) result Source # fromPdu :: Pdu (a1, a2, a3) result -> Maybe (Pdu a1 result) Source #
(HasPdu a1, HasPdu a2, HasPdu a3, HasPdu a4) => HasPduPrism (a1, a2, a3, a4) a4 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3, a4) result) (Pdu a4 result) Source # embedPdu :: Pdu a4 result -> Pdu (a1, a2, a3, a4) result Source # fromPdu :: Pdu (a1, a2, a3, a4) result -> Maybe (Pdu a4 result) Source #
(HasPdu a1, HasPdu a2, HasPdu a3, HasPdu a4) => HasPduPrism (a1, a2, a3, a4) a3 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3, a4) result) (Pdu a3 result) Source # embedPdu :: Pdu a3 result -> Pdu (a1, a2, a3, a4) result Source # fromPdu :: Pdu (a1, a2, a3, a4) result -> Maybe (Pdu a3 result) Source #
(HasPdu a1, HasPdu a2, HasPdu a3, HasPdu a4) => HasPduPrism (a1, a2, a3, a4) a2 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3, a4) result) (Pdu a2 result) Source # embedPdu :: Pdu a2 result -> Pdu (a1, a2, a3, a4) result Source # fromPdu :: Pdu (a1, a2, a3, a4) result -> Maybe (Pdu a2 result) Source #
(HasPdu a1, HasPdu a2, HasPdu a3, HasPdu a4) => HasPduPrism (a1, a2, a3, a4) a1 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3, a4) result) (Pdu a1 result) Source # embedPdu :: Pdu a1 result -> Pdu (a1, a2, a3, a4) result Source # fromPdu :: Pdu (a1, a2, a3, a4) result -> Maybe (Pdu a1 result) Source #
(HasPdu a1, HasPdu a2, HasPdu a3, HasPdu a4, HasPdu a5) => HasPduPrism (a1, a2, a3, a4, a5) a5 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3, a4, a5) result) (Pdu a5 result) Source # embedPdu :: Pdu a5 result -> Pdu (a1, a2, a3, a4, a5) result Source # fromPdu :: Pdu (a1, a2, a3, a4, a5) result -> Maybe (Pdu a5 result) Source #
(HasPdu a1, HasPdu a2, HasPdu a3, HasPdu a4, HasPdu a5) => HasPduPrism (a1, a2, a3, a4, a5) a4 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3, a4, a5) result) (Pdu a4 result) Source # embedPdu :: Pdu a4 result -> Pdu (a1, a2, a3, a4, a5) result Source # fromPdu :: Pdu (a1, a2, a3, a4, a5) result -> Maybe (Pdu a4 result) Source #
(HasPdu a1, HasPdu a2, HasPdu a3, HasPdu a4, HasPdu a5) => HasPduPrism (a1, a2, a3, a4, a5) a3 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3, a4, a5) result) (Pdu a3 result) Source # embedPdu :: Pdu a3 result -> Pdu (a1, a2, a3, a4, a5) result Source # fromPdu :: Pdu (a1, a2, a3, a4, a5) result -> Maybe (Pdu a3 result) Source #
(HasPdu a1, HasPdu a2, HasPdu a3, HasPdu a4, HasPdu a5) => HasPduPrism (a1, a2, a3, a4, a5) a2 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3, a4, a5) result) (Pdu a2 result) Source # embedPdu :: Pdu a2 result -> Pdu (a1, a2, a3, a4, a5) result Source # fromPdu :: Pdu (a1, a2, a3, a4, a5) result -> Maybe (Pdu a2 result) Source #
(HasPdu a1, HasPdu a2, HasPdu a3, HasPdu a4, HasPdu a5) => HasPduPrism (a1, a2, a3, a4, a5) a1 Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods embeddedPdu :: Prism' (Pdu (a1, a2, a3, a4, a5) result) (Pdu a1 result) Source # embedPdu :: Pdu a1 result -> Pdu (a1, a2, a3, a4, a5) result Source # fromPdu :: Pdu (a1, a2, a3, a4, a5) result -> Maybe (Pdu a1 result) Source #

type family ProtocolReply (s :: Synchronicity) where ... Source #

This type function takes an Pdu and analysis the reply type, i.e. the Synchronicity and evaluates to either t for an Pdu x (Synchronous t) or to '()' for an Pdu x Asynchronous.

Since: 0.24.0

Equations

ProtocolReply (Synchronous t) = t
ProtocolReply Asynchronous = ()

data Synchronicity Source #

The (promoted) constructors of this type specify (at the type level) the reply behavior of a specific constructor of an Pdu instance.

Constructors

Synchronous Type	Specify that handling a request is a blocking operation with a specific return type, e.g. `('Synchronous (Either RentalError RentalId))`
Asynchronous	Non-blocking, asynchronous, request handling

type TangiblePdu p r = (Typeable p, Typeable r, Tangible (Pdu p r), HasPdu p) Source #

A Constraint that bundles the requirements for the Pdu values of a protocol.

This ensures that Pdus can be strictly and deeply evaluated and shown such that for example logging is possible.

Since: 0.24.0

type Tangible i = (NFData i, Typeable i, Show i) Source #

A set of constraints for types that can evaluated via NFData, compared via Ord and presented dynamically via Typeable, and represented both as values via Show.

Since: 0.23.0

type Embeds outer inner = (HasPduPrism outer inner, CheckEmbeds outer inner, HasPdu outer) Source #

A constraint that requires that the outer Pdu has a clause to embed values from the inner Pdu.

Also, this constraint requires a HasPduPrism instance, as a proof for a possible conversion of an embedded Pdu value into to the enclosing Pdu.

This generates better compiler error messages, when an embedding of a Pdu into another.

This is provided by HasPdu instances. The instances are required to provide a list of embedded Pdu values in EmbeddedPduList.

Note that every type embeds itself, so Embeds x x always holds.

Since: 0.29.1

class Typeable protocol => HasPdu (protocol :: Type) Source #

This type class and the associated data family defines the protocol data units (PDU) of a protocol.

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 Pdus are. It maybe a phantom type.

The second parameter specifies if a specific constructor of an (GADT-like) Pdu instance is Synchronous, i.e. returns a result and blocks the caller or if it is Asynchronous

Example:

data BookShop deriving Typeable

instance Typeable r => HasPdu BookShop r where
  data instance Pdu BookShop r where
    RentBook  :: BookId   -> Pdu BookShop ('Synchronous (Either RentalError RentalId))
    BringBack :: RentalId -> Pdu BookShop 'Asynchronous
    deriving Typeable

type BookId = Int
type RentalId = Int
type RentalError = String

Since: 0.25.1

Associated Types

type EmbeddedPduList protocol :: [Type] Source #

A type level list Protocol phantom types included in the associated Pdu instance.

This is just a helper for better compiler error messages. It relies on Embeds to add the constraint HasPduPrism.

Since: 0.29.0

data Pdu protocol (reply :: Synchronicity) Source #

The protocol data unit type for the given protocol.

Instances

Tangible event => HasPdu (ObserverRegistry event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Associated Types type EmbeddedPduList (ObserverRegistry event) :: [Type] Source # data Pdu (ObserverRegistry event) reply :: Type Source #
Typeable p => HasPdu (Broker p) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Broker Associated Types type EmbeddedPduList (Broker p) :: [Type] Source # data Pdu (Broker p) reply :: Type Source #
Typeable child => HasPdu (Watchdog child) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Watchdog Associated Types type EmbeddedPduList (Watchdog child) :: [Type] Source # data Pdu (Watchdog child) reply :: Type Source #
(HasPdu a1, HasPdu a2) => HasPdu (a1, a2) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Associated Types type EmbeddedPduList (a1, a2) :: [Type] Source # data Pdu (a1, a2) reply :: Type Source #
Tangible event => HasPdu (Observer event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Associated Types type EmbeddedPduList (Observer event) :: [Type] Source # data Pdu (Observer event) reply :: Type Source #
(HasPdu a1, HasPdu a2, HasPdu a3) => HasPdu (a1, a2, a3) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Associated Types type EmbeddedPduList (a1, a2, a3) :: [Type] Source # data Pdu (a1, a2, a3) reply :: Type Source #
(HasPdu a1, HasPdu a2, HasPdu a3, HasPdu a4) => HasPdu (a1, a2, a3, a4) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Associated Types type EmbeddedPduList (a1, a2, a3, a4) :: [Type] Source # data Pdu (a1, a2, a3, a4) reply :: Type Source #
(HasPdu a1, HasPdu a2, HasPdu a3, HasPdu a4, HasPdu a5) => HasPdu (a1, a2, a3, a4, a5) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Associated Types type EmbeddedPduList (a1, a2, a3, a4, a5) :: [Type] Source # data Pdu (a1, a2, a3, a4, a5) reply :: Type Source #

newtype Endpoint protocol Source #

A server process for protocol.

Protocols are represented by phantom types, which are used in different places to index type families and type class instances.

A Process can send and receive any messages. An Endpoint wraps around a ProcessId 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 protocol data units belonging to some protocol.

Constructors

Endpoint
Fields _fromEndpoint :: ProcessId

Instances

Eq (Endpoint protocol) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods (==) :: Endpoint protocol -> Endpoint protocol -> Bool # (/=) :: Endpoint protocol -> Endpoint protocol -> Bool #
Ord (Endpoint protocol) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods compare :: Endpoint protocol -> Endpoint protocol -> Ordering # (<) :: Endpoint protocol -> Endpoint protocol -> Bool # (<=) :: Endpoint protocol -> Endpoint protocol -> Bool # (>) :: Endpoint protocol -> Endpoint protocol -> Bool # (>=) :: Endpoint protocol -> Endpoint protocol -> Bool # max :: Endpoint protocol -> Endpoint protocol -> Endpoint protocol # min :: Endpoint protocol -> Endpoint protocol -> Endpoint protocol #
Typeable protocol => Show (Endpoint protocol) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods showsPrec :: Int -> Endpoint protocol -> ShowS # show :: Endpoint protocol -> String # showList :: [Endpoint protocol] -> ShowS #
NFData (Endpoint protocol) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol Methods rnf :: Endpoint protocol -> () #
type ToPretty (Endpoint a :: Type) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol type ToPretty (Endpoint a :: Type) = ToPretty a <+> PutStr "endpoint"

proxyAsEndpoint :: proxy protocol -> ProcessId -> Endpoint protocol Source #

Tag a ProcessId with an Pdu type index to mark it a Endpoint process handling that API

asEndpoint :: forall protocol. ProcessId -> Endpoint protocol Source #

Tag a ProcessId with an Pdu type index to mark it a Endpoint process handling that API

toEmbeddedEndpoint :: forall inner outer. Embeds outer inner => Endpoint outer -> Endpoint inner Source #

Convert an Endpoint to an endpoint for an embedded protocol.

See Embeds, fromEmbeddedEndpoint.

Since: 0.25.1

fromEmbeddedEndpoint :: forall outer inner. HasPduPrism outer inner => Endpoint inner -> Endpoint outer Source #

Convert an Endpoint to an endpoint for a server, that embeds the protocol.

See Embeds, toEmbeddedEndpoint.

Since: 0.25.1

fromEndpoint :: forall protocol protocol. Iso (Endpoint protocol) (Endpoint protocol) ProcessId ProcessId Source #

newtype ReplyTarget p r Source #

Target of a Call reply.

This combines a RequestOrigin with a Serializer for a Reply using Arg. There are to smart constructors for this type: replyTarget and embeddedReplyTarget.

Because of Arg the Eq and Ord instances are implemented via the RequestOrigin instances.

Since: 0.26.0

Constructors

MkReplyTarget (Arg (RequestOrigin p r) (Serializer (Reply p r)))

Instances

Eq (ReplyTarget p r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods (==) :: ReplyTarget p r -> ReplyTarget p r -> Bool # (/=) :: ReplyTarget p r -> ReplyTarget p r -> Bool #
Ord (ReplyTarget p r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods compare :: ReplyTarget p r -> ReplyTarget p r -> Ordering # (<) :: ReplyTarget p r -> ReplyTarget p r -> Bool # (<=) :: ReplyTarget p r -> ReplyTarget p r -> Bool # (>) :: ReplyTarget p r -> ReplyTarget p r -> Bool # (>=) :: ReplyTarget p r -> ReplyTarget p r -> Bool # max :: ReplyTarget p r -> ReplyTarget p r -> ReplyTarget p r # min :: ReplyTarget p r -> ReplyTarget p r -> ReplyTarget p r #
Show (ReplyTarget p r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods showsPrec :: Int -> ReplyTarget p r -> ShowS # show :: ReplyTarget p r -> String # showList :: [ReplyTarget p r] -> ShowS #
NFData (ReplyTarget p r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods rnf :: ReplyTarget p r -> () #

data RequestOrigin (proto :: Type) reply Source #

Wraps the source ProcessId and a unique identifier for a Call.

Since: 0.15.0

Constructors

RequestOrigin
Fields _requestOriginPid :: !ProcessId _requestOriginCallRef :: !Int

Instances

Eq (RequestOrigin proto reply) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods (==) :: RequestOrigin proto reply -> RequestOrigin proto reply -> Bool # (/=) :: RequestOrigin proto reply -> RequestOrigin proto reply -> Bool #
Ord (RequestOrigin proto reply) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods compare :: RequestOrigin proto reply -> RequestOrigin proto reply -> Ordering # (<) :: RequestOrigin proto reply -> RequestOrigin proto reply -> Bool # (<=) :: RequestOrigin proto reply -> RequestOrigin proto reply -> Bool # (>) :: RequestOrigin proto reply -> RequestOrigin proto reply -> Bool # (>=) :: RequestOrigin proto reply -> RequestOrigin proto reply -> Bool # max :: RequestOrigin proto reply -> RequestOrigin proto reply -> RequestOrigin proto reply # min :: RequestOrigin proto reply -> RequestOrigin proto reply -> RequestOrigin proto reply #
Show (RequestOrigin p r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods showsPrec :: Int -> RequestOrigin p r -> ShowS # show :: RequestOrigin p r -> String # showList :: [RequestOrigin p r] -> ShowS #
Generic (RequestOrigin proto reply) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Associated Types type Rep (RequestOrigin proto reply) :: Type -> Type # Methods from :: RequestOrigin proto reply -> Rep (RequestOrigin proto reply) x # to :: Rep (RequestOrigin proto reply) x -> RequestOrigin proto reply #
NFData (RequestOrigin p r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods rnf :: RequestOrigin p r -> () #
type Rep (RequestOrigin proto reply) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper type Rep (RequestOrigin proto reply) = D1 (MetaData "RequestOrigin" "Control.Eff.Concurrent.Protocol.Wrapper" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" False) (C1 (MetaCons "RequestOrigin" PrefixI True) (S1 (MetaSel (Just "_requestOriginPid") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 ProcessId) :*: S1 (MetaSel (Just "_requestOriginCallRef") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Int)))

data Reply protocol reply where Source #

The wrapper around replies to Calls.

Since: 0.15.0

Constructors

Reply
Fields :: Tangible reply => { _replyTo :: RequestOrigin protocol reply , _replyValue :: reply } -> Reply protocol reply

Instances

Show r => Show (Reply p r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods showsPrec :: Int -> Reply p r -> ShowS # show :: Reply p r -> String # showList :: [Reply p r] -> ShowS #
NFData (Reply p r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods rnf :: Reply p r -> () #

data Request protocol where Source #

A wrapper sum type for calls and casts for the Pdus of a protocol

Since: 0.15.0

Constructors

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

Instances

Show (Request protocol) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods showsPrec :: Int -> Request protocol -> ShowS # show :: Request protocol -> String # showList :: [Request protocol] -> ShowS #
NFData (Request protocol) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Wrapper Methods rnf :: Request protocol -> () #

makeRequestOrigin :: (Typeable r, NFData r, HasProcesses e q0) => Eff e (RequestOrigin p r) Source #

Create a new, unique RequestOrigin value for the current process.

Since: 0.24.0

toEmbeddedOrigin :: forall outer inner reply. Embeds outer inner => RequestOrigin outer reply -> RequestOrigin inner reply Source #

Turn an RequestOrigin to an origin for an embedded request (See Embeds).

This is useful of a server delegates the calls and casts for an embedded protocol to functions, that require the Serializer and RequestOrigin in order to call sendReply.

Scheduler

schedule :: Eff Effects a -> Either (Interrupt NoRecovery) a Source #

Run the Effects using a single threaded, coroutine based, pure scheduler from Control.Eff.Concurrent.Process.SingleThreadedScheduler.

Since: 0.25.0

type Effects = PureEffects Source #

The effect list for Process effects in the single threaded pure scheduler.

See PureEffects

Since: 0.25.0

type SafeEffects = PureSafeEffects Source #

The effect list for Process effects in the single threaded pure scheduler. This is like SafeProcesses, no Interrupts are present.

See PureSafeEffects

Since: 0.25.0

type BaseEffects = PureBaseEffects Source #

The effect list for the underlying scheduler.

Since: 0.25.0

type HasBaseEffects e = HasPureBaseEffects e Source #

Constraint for the existence of the underlying scheduler effects.

Since: 0.25.0

Eq TimerElapsed Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods (==) :: TimerElapsed -> TimerElapsed -> Bool # (/=) :: TimerElapsed -> TimerElapsed -> Bool #
Ord TimerElapsed Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods compare :: TimerElapsed -> TimerElapsed -> Ordering # (<) :: TimerElapsed -> TimerElapsed -> Bool # (<=) :: TimerElapsed -> TimerElapsed -> Bool # (>) :: TimerElapsed -> TimerElapsed -> Bool # (>=) :: TimerElapsed -> TimerElapsed -> Bool # max :: TimerElapsed -> TimerElapsed -> TimerElapsed # min :: TimerElapsed -> TimerElapsed -> TimerElapsed #
Show TimerElapsed Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods showsPrec :: Int -> TimerElapsed -> ShowS # show :: TimerElapsed -> String # showList :: [TimerElapsed] -> ShowS #
NFData TimerElapsed Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods rnf :: TimerElapsed -> () #

Enum TimerReference Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods succ :: TimerReference -> TimerReference # pred :: TimerReference -> TimerReference # toEnum :: Int -> TimerReference # fromEnum :: TimerReference -> Int # enumFrom :: TimerReference -> [TimerReference] # enumFromThen :: TimerReference -> TimerReference -> [TimerReference] # enumFromTo :: TimerReference -> TimerReference -> [TimerReference] # enumFromThenTo :: TimerReference -> TimerReference -> TimerReference -> [TimerReference] #
Eq TimerReference Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods (==) :: TimerReference -> TimerReference -> Bool # (/=) :: TimerReference -> TimerReference -> Bool #
Integral TimerReference Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods quot :: TimerReference -> TimerReference -> TimerReference # rem :: TimerReference -> TimerReference -> TimerReference # div :: TimerReference -> TimerReference -> TimerReference # mod :: TimerReference -> TimerReference -> TimerReference # quotRem :: TimerReference -> TimerReference -> (TimerReference, TimerReference) # divMod :: TimerReference -> TimerReference -> (TimerReference, TimerReference) # toInteger :: TimerReference -> Integer #
Num TimerReference Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods (+) :: TimerReference -> TimerReference -> TimerReference # (-) :: TimerReference -> TimerReference -> TimerReference # (*) :: TimerReference -> TimerReference -> TimerReference # negate :: TimerReference -> TimerReference # abs :: TimerReference -> TimerReference # signum :: TimerReference -> TimerReference # fromInteger :: Integer -> TimerReference #
Ord TimerReference Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods compare :: TimerReference -> TimerReference -> Ordering # (<) :: TimerReference -> TimerReference -> Bool # (<=) :: TimerReference -> TimerReference -> Bool # (>) :: TimerReference -> TimerReference -> Bool # (>=) :: TimerReference -> TimerReference -> Bool # max :: TimerReference -> TimerReference -> TimerReference # min :: TimerReference -> TimerReference -> TimerReference #
Real TimerReference Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods toRational :: TimerReference -> Rational #
Show TimerReference Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods showsPrec :: Int -> TimerReference -> ShowS # show :: TimerReference -> String # showList :: [TimerReference] -> ShowS #
NFData TimerReference Source #
Instance details Defined in Control.Eff.Concurrent.Process.Timer Methods rnf :: TimerReference -> () #

Tangible event => HasPdu (ObserverRegistry event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Associated Types type EmbeddedPduList (ObserverRegistry event) :: [Type] Source # data Pdu (ObserverRegistry event) reply :: Type Source #
Typeable p => HasPduPrism (Broker p) (ObserverRegistry (ChildEvent p)) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Broker Methods embeddedPdu :: Prism' (Pdu (Broker p) result) (Pdu (ObserverRegistry (ChildEvent p)) result) Source # embedPdu :: Pdu (ObserverRegistry (ChildEvent p)) result -> Pdu (Broker p) result Source # fromPdu :: Pdu (Broker p) result -> Maybe (Pdu (ObserverRegistry (ChildEvent p)) result) Source #
Typeable event => Show (Pdu (ObserverRegistry event) r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Methods showsPrec :: Int -> Pdu (ObserverRegistry event) r -> ShowS # show :: Pdu (ObserverRegistry event) r -> String # showList :: [Pdu (ObserverRegistry event) r] -> ShowS #
NFData (Pdu (ObserverRegistry event) r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Methods rnf :: Pdu (ObserverRegistry event) r -> () #
type EmbeddedPduList (ObserverRegistry event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer type EmbeddedPduList (ObserverRegistry event) = ([] :: [Type])
data Pdu (ObserverRegistry event) r Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer data Pdu (ObserverRegistry event) r where RegisterObserver :: forall event (r :: Synchronicity). Serializer (Pdu (Observer event) Asynchronous) -> ProcessId -> Pdu (ObserverRegistry event) Asynchronous ForgetObserver :: forall event (r :: Synchronicity). ProcessId -> Pdu (ObserverRegistry event) Asynchronous
type ToPretty (ObserverRegistry event :: Type) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer type ToPretty (ObserverRegistry event :: Type) = PrettyParens ("observer registry" <:> ToPretty event)

Generic (ObservationSink event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Associated Types type Rep (ObservationSink event) :: Type -> Type # Methods from :: ObservationSink event -> Rep (ObservationSink event) x # to :: Rep (ObservationSink event) x -> ObservationSink event #
NFData (ObservationSink event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Methods rnf :: ObservationSink event -> () #
type Rep (ObservationSink event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer type Rep (ObservationSink event) = D1 (MetaData "ObservationSink" "Control.Eff.Concurrent.Protocol.Observer" "extensible-effects-concurrent-0.32.0-GimAdtHOovq4dulPgeQPe9" False) (C1 (MetaCons "MkObservationSink" PrefixI True) (S1 (MetaSel (Just "_observerSerializer") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Serializer (Pdu (Observer event) Asynchronous))) :*: S1 (MetaSel (Just "_observerMonitorReference") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 MonitorReference)))

Typeable child => HasPduPrism (Watchdog child) (Observer (ChildEvent child)) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Watchdog Methods embeddedPdu :: Prism' (Pdu (Watchdog child) result) (Pdu (Observer (ChildEvent child)) result) Source # embedPdu :: Pdu (Observer (ChildEvent child)) result -> Pdu (Watchdog child) result Source # fromPdu :: Pdu (Watchdog child) result -> Maybe (Pdu (Observer (ChildEvent child)) result) Source #
Eq (Observer event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Methods (==) :: Observer event -> Observer event -> Bool # (/=) :: Observer event -> Observer event -> Bool #
Ord (Observer event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Methods compare :: Observer event -> Observer event -> Ordering # (<) :: Observer event -> Observer event -> Bool # (<=) :: Observer event -> Observer event -> Bool # (>) :: Observer event -> Observer event -> Bool # (>=) :: Observer event -> Observer event -> Bool # max :: Observer event -> Observer event -> Observer event # min :: Observer event -> Observer event -> Observer event #
Show event => Show (Pdu (Observer event) r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Methods showsPrec :: Int -> Pdu (Observer event) r -> ShowS # show :: Pdu (Observer event) r -> String # showList :: [Pdu (Observer event) r] -> ShowS #
Typeable event => Show (Observer event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Methods showsPrec :: Int -> Observer event -> ShowS # show :: Observer event -> String # showList :: [Observer event] -> ShowS #
NFData event => NFData (Pdu (Observer event) r) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Methods rnf :: Pdu (Observer event) r -> () #
NFData (Observer event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Methods rnf :: Observer event -> () #
Tangible event => HasPdu (Observer event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer Associated Types type EmbeddedPduList (Observer event) :: [Type] Source # data Pdu (Observer event) reply :: Type Source #
type ToPretty (Observer event :: Type) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer type ToPretty (Observer event :: Type) = PrettyParens ("observing" <:> ToPretty event)
type EmbeddedPduList (Observer event) Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer type EmbeddedPduList (Observer event) = ([] :: [Type])
data Pdu (Observer event) r Source #
Instance details Defined in Control.Eff.Concurrent.Protocol.Observer data Pdu (Observer event) r where Observed :: forall event (r :: Synchronicity). event -> Pdu (Observer event) Asynchronous

MkObserverRegistry
Fields _observerRegistry :: Map ProcessId (ObservationSink event)

:: Lifted IO e
=> LogWriter	The `LogWriter` that will be used to write log messages.
-> Text	The default application name to put into the `lmAppName` field.
-> Facility	The default RFC-5424 facility to put into the `lmFacility` field.
-> LogPredicate	The inital predicate for log messages, there are some pre-defined in Control.Eff.Log.Message
-> Eff (Logs ': (LogWriterReader ': e)) a
-> Eff e a

:: Text	The default application name to put into the `lmAppName` field.
-> Facility	The default RFC-5424 facility to put into the `lmFacility` field.
-> LogWriter	The IO based writer to decorate
-> LogWriter

:: (Lifted IO e, MonadBaseControl IO (Eff e), HasCallStack)
=> FilePath	Path to the log-file.
-> Text	The default application name to put into the `lmAppName` field.
-> Facility	The default RFC-5424 facility to put into the `lmFacility` field.
-> LogPredicate	The inital predicate for log messages, there are some pre-defined in Control.Eff.Log.Message
-> LogMessageTextRenderer	The `LogMessage` render function
-> Eff (Logs ': (LogWriterReader ': e)) a
-> Eff e a

:: (IoLogging e, MonadBaseControl IO (Eff e), HasCallStack)
=> FilePath	Path to the log-file.
-> LogMessageTextRenderer
-> Eff e b
-> Eff e b

:: Lifted IO e
=> Text	The default application name to put into the `lmAppName` field.
-> Facility	The default RFC-5424 facility to put into the `lmFacility` field.
-> LogPredicate	The inital predicate for log messages, there are some pre-defined in Control.Eff.Log.Message
-> Eff (Logs ': (LogWriterReader ': e)) a
-> Eff e a

:: (Lifted IO e, MonadBaseControl IO (Eff e), Integral len)
=> LogWriter
-> len	Size of the log message input queue. If the queue is full, message are dropped silently.
-> Text	The default application name to put into the `lmAppName` field.
-> Facility	The default RFC-5424 facility to put into the `lmFacility` field.
-> LogPredicate	The inital predicate for log messages, there are some pre-defined in Control.Eff.Log.Message
-> Eff (Logs ': (LogWriterReader ': e)) a
-> Eff e a

:: (IoLogging e, MonadBaseControl IO (Eff e), Integral len)
=> len	Size of the log message input queue. If the queue is full, message are dropped silently.
-> Eff e a
-> Eff e a

:: (HasCallStack, MonadBaseControl IO (Eff e), Lifted IO e)
=> (LogMessage -> Text)	`LogMessage` rendering function
-> String	Hostname or IP
-> String	Port e.g. `"514"`
-> Text	The default application name to put into the `lmAppName` field.
-> Facility	The default RFC-5424 facility to put into the `lmFacility` field.
-> LogPredicate	The inital predicate for log messages, there are some pre-defined in Control.Eff.Log.Message
-> Eff (Logs ': (LogWriterReader ': e)) a
-> Eff e a

:: (HasCallStack, MonadBaseControl IO (Eff e), Lifted IO e)
=> LogMessageRenderer Text	`LogMessage` rendering function
-> FilePath	Path to the socket file
-> Text	The default application name to put into the `lmAppName` field.
-> Facility	The default RFC-5424 facility to put into the `lmFacility` field.
-> LogPredicate	The inital predicate for log messages, there are some pre-defined in Control.Eff.Log.Message
-> Eff (Logs ': (LogWriterReader ': e)) a
-> Eff e a

Generic functions and type for Processes and Messages

Scheduler

External Libraries