extensible-effects-concurrent-0.32.0: Message passing concurrency as extensible-effect

Safe HaskellNone
LanguageHaskell2010

Control.Eff.Concurrent.Pure

Contents

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

Generic functions and type for Processes and Messages

newtype Facility Source #

An rfc 5424 facility

Constructors

Facility 

Fields

Instances
Eq Facility Source # 
Instance details

Defined in Control.Eff.Log.Message

Ord Facility Source # 
Instance details

Defined in Control.Eff.Log.Message

Show Facility Source # 
Instance details

Defined in Control.Eff.Log.Message

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

Ord Severity Source # 
Instance details

Defined in Control.Eff.Log.Message

Show Severity Source # 
Instance details

Defined in Control.Eff.Log.Message

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

Ord SdParameter Source # 
Instance details

Defined in Control.Eff.Log.Message

Show SdParameter Source # 
Instance details

Defined in Control.Eff.Log.Message

Generic SdParameter Source # 
Instance details

Defined in Control.Eff.Log.Message

Associated Types

type Rep SdParameter :: Type -> Type #

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.

Instances
Eq StructuredDataElement Source # 
Instance details

Defined in Control.Eff.Log.Message

Ord StructuredDataElement Source # 
Instance details

Defined in Control.Eff.Log.Message

Show StructuredDataElement Source # 
Instance details

Defined in Control.Eff.Log.Message

Generic StructuredDataElement Source # 
Instance details

Defined in Control.Eff.Log.Message

Associated Types

type Rep StructuredDataElement :: Type -> Type #

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

Instances
Eq LogMessage Source # 
Instance details

Defined in Control.Eff.Log.Message

Show LogMessage Source #

This instance is only supposed to be used for unit tests and debugging.

Instance details

Defined in Control.Eff.Log.Message

IsString LogMessage Source # 
Instance details

Defined in Control.Eff.Log.Message

Generic LogMessage Source # 
Instance details

Defined in Control.Eff.Log.Message

Associated Types

type Rep LogMessage :: Type -> Type #

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

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

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.

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

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.

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

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

A lens for the SrcLoc 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

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.

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

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

Provide the LogWriter

Exposed for custom extensions, if in doubt use withLogging.

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

withoutLogging :: Eff (Logs ': (LogWriterReader ': e)) a -> Eff e a Source #

Handles the Logs and LogWriterReader effects, while not invoking the LogWriter at all.

There is no way to get log output when this logger is used.

Example:

exampleWithSomeLogging :: ()
exampleWithSomeLogging =
    run
  $ withoutLogging
  $ logDebug "Oh, hi there" -- Nothing written

This provides the FilteredLogging effect.

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.

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.

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

Instances
Bounded ProcessId Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Enum ProcessId Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Eq ProcessId Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Integral ProcessId Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Num ProcessId Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Ord ProcessId Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Read ProcessId Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Real ProcessId Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Show ProcessId Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

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

Instances
Eq ProcessDown Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Ord ProcessDown Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Show ProcessDown Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Generic ProcessDown Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Associated Types

type Rep ProcessDown :: Type -> Type #

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

Instances
Eq MonitorReference Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Ord MonitorReference Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Read MonitorReference Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Show MonitorReference Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Generic MonitorReference Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Associated Types

type Rep MonitorReference :: Type -> Type #

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

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

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

Show (Interrupt x) Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Exception (Interrupt Recoverable) Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Exception (Interrupt NoRecovery) Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

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 #

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

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

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

Ord ExitSeverity Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Show ExitSeverity Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Generic ExitSeverity Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Associated Types

type Rep ExitSeverity :: Type -> Type #

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

Ord ExitRecovery Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Show ExitRecovery Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Generic ExitRecovery Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Associated Types

type Rep ExitRecovery :: Type -> Type #

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

Alternative MessageSelector Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Semigroup a => Semigroup (MessageSelector a) Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Semigroup a => Monoid (MessageSelector a) Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

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

Generic (ResumeProcess v) Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Associated Types

type Rep (ResumeProcess v) :: Type -> Type #

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 #

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

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

newtype Timeout Source #

A number of micro seconds.

Since: 0.12.0

Constructors

TimeoutMicros 
Instances
Enum Timeout Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

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

Num Timeout Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Ord Timeout Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Real Timeout Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Show Timeout Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

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 
Instances
Eq ProcessDetails Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Ord ProcessDetails Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Show ProcessDetails Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

IsString ProcessDetails Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Generic ProcessDetails Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Associated Types

type Rep ProcessDetails :: Type -> Type #

Semigroup ProcessDetails Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Monoid ProcessDetails Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

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 
Instances
Eq ProcessTitle Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Ord ProcessTitle Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Show ProcessTitle Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

IsString ProcessTitle Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Generic ProcessTitle Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Associated Types

type Rep ProcessTitle :: Type -> Type #

Semigroup ProcessTitle Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

Monoid ProcessTitle Source # 
Instance details

Defined in Control.Eff.Concurrent.Process

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 #

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

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

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

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.

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

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 
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 -> () #

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

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

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

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

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

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.

See also embedReplySerializer.

Since: 0.24.3

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

Turn an embedded RequestOrigin to a RequestOrigin for the bigger request.

This is the inverse of toEmbeddedOrigin.

This function is strict in all parameters.

Since: 0.24.2

embedReplySerializer :: forall outer inner reply. Embeds outer inner => Serializer (Reply outer reply) -> Serializer (Reply inner reply) Source #

Turn a Serializer for a Pdu instance that contains embedded Pdu values into a Reply Serializer for the embedded Pdu.

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.

See also toEmbeddedOrigin.

Since: 0.24.2

sendReply :: (HasProcesses eff q, Tangible reply, Typeable protocol) => ReplyTarget protocol reply -> reply -> Eff eff () Source #

Answer a Call by sending the reply value to the client process.

The ProcessId, the RequestOrigin and the Reply Serializer are stored in the ReplyTarget.

Since: 0.25.1

replyTarget :: Serializer (Reply p reply) -> RequestOrigin p reply -> ReplyTarget p reply Source #

Smart constructor for a ReplyTarget.

To build a ReplyTarget for an Embeds instance use embeddedReplyTarget.

Since: 0.26.0

replyTargetOrigin :: Lens' (ReplyTarget p reply) (RequestOrigin p reply) Source #

A simple Lens for the RequestOrigin of a ReplyTarget.

Since: 0.26.0

replyTargetSerializer :: Lens' (ReplyTarget p reply) (Serializer (Reply p reply)) Source #

A simple Lens for the Reply Serializer of a ReplyTarget.

Since: 0.26.0

embeddedReplyTarget :: Embeds outer inner => Serializer (Reply outer reply) -> RequestOrigin outer reply -> ReplyTarget inner reply Source #

Smart constructor for an embedded ReplyTarget.

This combines replyTarget and toEmbeddedReplyTarget.

Since: 0.26.0

toEmbeddedReplyTarget :: Embeds outer inner => ReplyTarget outer reply -> ReplyTarget inner reply Source #

Convert a ReplyTarget to be usable for embedded replies.

This combines a toEmbeddedOrigin with embedReplySerializer to produce a ReplyTarget that can be passed to functions defined soley on an embedded protocol.

Since: 0.26.0

data TimerReference Source #

The reference to a timer started by startTimer, required to stop a timer via cancelTimer.

Since: 0.12.0

Instances
Enum TimerReference Source # 
Instance details

Defined in Control.Eff.Concurrent.Process.Timer

Eq TimerReference Source # 
Instance details

Defined in Control.Eff.Concurrent.Process.Timer

Integral TimerReference Source # 
Instance details

Defined in Control.Eff.Concurrent.Process.Timer

Num TimerReference Source # 
Instance details

Defined in Control.Eff.Concurrent.Process.Timer

Ord TimerReference Source # 
Instance details

Defined in Control.Eff.Concurrent.Process.Timer

Methods

compare :: TimerReference ->