Safe Haskell	None
Language	Haskell2010

Control.Eff.Concurrent

Contents

Concurrent Processes with Message Passing Concurrency
Timers and Timeouts
Data Types and Functions for APIs (aka Protocols)
Scheduler Process Effect Handler
- Concurrent Scheduler
- Single Threaded Scheduler
Utilities
- Logging Effect
- Preventing Space Leaks

Description

Erlang style processes with message passing concurrency based on (more) extensible-effects.

Synopsis

newtype ProcessId = ProcessId {
- _fromProcessId :: Int
}
data ProcessDown = ProcessDown {
- downReference :: !MonitorReference
- downReason :: !SomeExitReason
}
data MonitorReference = MonitorReference {
- monitorIndex :: Int
- monitoredProcess :: ProcessId
}
data SomeExitReason where
- SomeExitReason :: ExitReason x -> SomeExitReason
type InterruptableProcess e = Interrupts ': ConsProcess e
type Interrupts = Exc InterruptReason
type InterruptReason = ExitReason Recoverable
data ExitReason (t :: ExitRecovery) where
- ProcessNotRunning :: ProcessId -> ExitReason Recoverable
- LinkedProcessCrashed :: ProcessId -> ExitReason Recoverable
- ProcessError :: String -> ExitReason Recoverable
- ExitNormally :: ExitReason NoRecovery
- NotRecovered :: ExitReason Recoverable -> ExitReason NoRecovery
- UnexpectedException :: String -> String -> ExitReason NoRecovery
- Killed :: ExitReason NoRecovery
data ExitSeverity
- = NormalExit
- | Crash
data ExitRecovery
- = Recoverable
- | NoRecovery
data ProcessState
- = ProcessBooting
- | ProcessIdle
- | ProcessBusy
- | ProcessBusySending
- | ProcessBusySendingShutdown
- | ProcessBusySendingInterrupt
- | ProcessBusyReceiving
- | ProcessBusyLinking
- | ProcessBusyUnlinking
- | ProcessBusyMonitoring
- | ProcessBusyDemonitoring
- | ProcessInterrupted
- | ProcessShuttingDown
type ConsProcess r = Process r ': r
type HasScheduler q = ?_schedulerProxy :: SchedulerProxy q
data SchedulerProxy :: [Type -> Type] -> Type where
- SchedulerProxy :: SchedulerProxy q
- SP :: SchedulerProxy q
- Scheduler :: SchedulerProxy q
data MessageSelector a
data ResumeProcess v where
- Interrupted :: InterruptReason -> ResumeProcess v
- ResumeWith :: a -> ResumeProcess a
data Process (r :: [Type -> Type]) b where
- FlushMessages :: Process r (ResumeProcess [Dynamic])
- YieldProcess :: Process r (ResumeProcess ())
- SelfPid :: Process r (ResumeProcess ProcessId)
- Spawn :: Eff (Process r ': r) () -> Process r (ResumeProcess ProcessId)
- SpawnLink :: Eff (Process r ': r) () -> Process r (ResumeProcess ProcessId)
- GetProcessState :: ProcessId -> Process r (ResumeProcess (Maybe ProcessState))
- Shutdown :: ExitReason NoRecovery -> Process r a
- SendShutdown :: ProcessId -> ExitReason NoRecovery -> Process r (ResumeProcess ())
- SendInterrupt :: ProcessId -> InterruptReason -> Process r (ResumeProcess ())
- SendMessage :: ProcessId -> Dynamic -> Process r (ResumeProcess ())
- ReceiveSelectedMessage :: forall r a. MessageSelector a -> Process r (ResumeProcess a)
- MakeReference :: Process r (ResumeProcess Int)
- Monitor :: ProcessId -> Process r (ResumeProcess MonitorReference)
- Demonitor :: MonitorReference -> Process r (ResumeProcess ())
- Link :: ProcessId -> Process r (ResumeProcess ())
- Unlink :: ProcessId -> Process r (ResumeProcess ())
selectMessage :: (NFData t, Typeable t) => MessageSelector t
selectMessageLazy :: Typeable t => MessageSelector t
filterMessage :: (Typeable a, NFData a) => (a -> Bool) -> MessageSelector a
filterMessageLazy :: Typeable a => (a -> Bool) -> MessageSelector a
selectMessageWith :: (Typeable a, NFData b) => (a -> Maybe b) -> MessageSelector b
selectMessageWithLazy :: Typeable a => (a -> Maybe b) -> MessageSelector b
selectDynamicMessage :: NFData a => (Dynamic -> Maybe a) -> MessageSelector a
selectDynamicMessageLazy :: (Dynamic -> Maybe a) -> MessageSelector a
selectAnyMessageLazy :: MessageSelector Dynamic
selectMessageProxy :: forall proxy t. (NFData t, Typeable t) => proxy t -> MessageSelector t
selectMessageProxyLazy :: forall proxy t. Typeable t => proxy t -> MessageSelector t
getSchedulerProxy :: HasScheduler q => SchedulerProxy q
withSchedulerProxy :: SchedulerProxy q -> (HasScheduler q => a) -> a
thisSchedulerProxy :: Eff (Process r ': r) (SchedulerProxy r)
toExitRecovery :: ExitReason r -> ExitRecovery
toExitSeverity :: ExitReason e -> ExitSeverity
isBecauseDown :: Maybe ProcessId -> ExitReason r -> Bool
provideInterruptsShutdown :: forall e a. Eff (InterruptableProcess e) a -> Eff (ConsProcess e) a
handleInterrupts :: (HasCallStack, Member Interrupts r) => (InterruptReason -> Eff r a) -> Eff r a -> Eff r a
logInterrupts :: (HasCallStack, '[Interrupts, Logs LogMessage] <:: r) => Eff r () -> Eff r ()
exitOnInterrupt :: (HasCallStack, Member Interrupts r, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a -> Eff r a
provideInterrupts :: HasCallStack => Eff (Interrupts ': r) a -> Eff r (Either InterruptReason a)
mergeEitherInterruptAndExitReason :: Either InterruptReason (ExitReason NoRecovery) -> ExitReason NoRecovery
interrupt :: (HasCallStack, Member Interrupts r) => InterruptReason -> Eff r a
isCrash :: ExitReason x -> Bool
isRecoverable :: ExitReason x -> Bool
fromSomeExitReason :: SomeExitReason -> Either (ExitReason NoRecovery) InterruptReason
toCrashReason :: ExitReason x -> Maybe String
logProcessExit :: (HasCallStack, Member (Logs LogMessage) e) => ExitReason x -> Eff e ()
executeAndResume :: forall q r v. (SetMember Process (Process q) r, HasCallStack) => Process q (ResumeProcess v) -> Eff r (Either (ExitReason Recoverable) v)
executeAndResumeOrExit :: forall r q v. (SetMember Process (Process q) r, HasCallStack) => Process q (ResumeProcess v) -> Eff r v
executeAndResumeOrThrow :: forall q r v. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => Process q (ResumeProcess v) -> Eff r v
yieldProcess :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Eff r ()
sendMessage :: forall r q o. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r, Typeable o) => SchedulerProxy q -> ProcessId -> o -> Eff r ()
sendAnyMessage :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Dynamic -> Eff r ()
sendShutdown :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> ExitReason NoRecovery -> Eff r ()
sendInterrupt :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> InterruptReason -> Eff r ()
spawn :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess q) () -> Eff r ProcessId
spawn_ :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess q) () -> Eff r ()
spawnLink :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess q) () -> Eff r ProcessId
spawnRaw :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (ConsProcess q) () -> Eff r ProcessId
spawnRaw_ :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (ConsProcess q) () -> Eff r ()
isProcessAlive :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r Bool
receiveAnyMessage :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Eff r Dynamic
receiveSelectedMessage :: forall r q a. (HasCallStack, Show a, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> MessageSelector a -> Eff r a
receiveMessage :: forall a r q. (HasCallStack, Typeable a, Show a, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Eff r a
flushMessages :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r, HasScheduler q) => Eff r [Dynamic]
receiveSelectedLoop :: forall r q a endOfLoopResult. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> MessageSelector a -> (Either InterruptReason a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult
receiveAnyLoop :: forall r q endOfLoopResult. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> (Either InterruptReason Dynamic -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult
receiveLoop :: forall r q a endOfLoopResult. (SetMember Process (Process q) r, HasCallStack, Typeable a) => SchedulerProxy q -> (Either InterruptReason a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult
self :: (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r ProcessId
makeReference :: (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Eff r Int
monitor :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r MonitorReference
demonitor :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> MonitorReference -> Eff r ()
withMonitor :: (HasCallStack, Member Interrupts r, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> (MonitorReference -> Eff r a) -> Eff r a
receiveWithMonitor :: (HasCallStack, Member Interrupts r, SetMember Process (Process q) r, Member Interrupts r, Typeable a, Show a) => SchedulerProxy q -> ProcessId -> MessageSelector a -> Eff r (Either ProcessDown a)
becauseProcessIsDown :: ProcessDown -> InterruptReason
selectProcessDown :: MonitorReference -> MessageSelector ProcessDown
linkProcess :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r ()
unlinkProcess :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r ()
exitBecause :: forall r q a. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ExitReason NoRecovery -> Eff r a
exitNormally :: forall r q a. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a
exitWithError :: forall r q a. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> String -> Eff r a
fromProcessId :: Iso' ProcessId Int
data TimerElapsed
data TimerReference
data Timeout
receiveAfter :: forall a r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable a, NFData a, Show a) => SchedulerProxy q -> Timeout -> Eff r (Maybe a)
receiveSelectedAfter :: forall a r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Show a) => SchedulerProxy q -> MessageSelector a -> Timeout -> Eff r (Either TimerElapsed a)
selectTimerElapsed :: TimerReference -> MessageSelector TimerElapsed
sendAfter :: forall r q message. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable message, NFData message) => SchedulerProxy q -> ProcessId -> Timeout -> (TimerReference -> message) -> Eff r TimerReference
startTimer :: forall r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Timeout -> Eff r TimerReference
newtype Server api = Server {
- _fromServer :: ProcessId
}
data Synchronicity
- = Synchronous Type
- | Asynchronous
data family Api (api :: Type) (reply :: Synchronicity)
fromServer :: forall api api. Iso (Server api) (Server api) ProcessId ProcessId
proxyAsServer :: proxy api -> ProcessId -> Server api
asServer :: forall api. ProcessId -> Server api
type ServerReader o = Reader (Server o)
type ServesApi o r q = (Typeable o, SetMember Process (Process q) r, Member (ServerReader o) r)
cast :: forall r q o. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable o, Typeable (Api o Asynchronous)) => SchedulerProxy q -> Server o -> Api o Asynchronous -> Eff r ()
call :: forall result api r q. (SetMember Process (Process q) r, Member Interrupts r, Typeable api, Typeable (Api api (Synchronous result)), Typeable result, HasCallStack, NFData result, Show result) => SchedulerProxy q -> Server api -> Api api (Synchronous result) -> Eff r result
registerServer :: HasCallStack => Server o -> Eff (ServerReader o ': r) a -> Eff r a
whereIsServer :: Member (ServerReader o) e => Eff e (Server o)
callRegistered :: (Typeable reply, ServesApi o r q, HasCallStack, NFData reply, Show reply, Member Interrupts r) => SchedulerProxy q -> Api o (Synchronous reply) -> Eff r reply
castRegistered :: (Typeable o, ServesApi o r q, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Api o Asynchronous -> Eff r ()
data ApiServerCmd where
- HandleNextRequest :: ApiServerCmd
- StopApiServer :: ExitReason Recoverable -> ApiServerCmd
data ApiHandler api eff where
- ApiHandler :: {..} -> ApiHandler api eff
apiHandler :: (Api api Asynchronous -> Eff e ApiServerCmd) -> (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> (ExitReason Recoverable -> Eff e ()) -> ApiHandler api e
apiHandlerForever :: (Api api Asynchronous -> Eff e ()) -> (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> (ExitReason Recoverable -> Eff e ()) -> ApiHandler api e
castHandler :: (Api api Asynchronous -> Eff eff ApiServerCmd) -> ApiHandler api eff
castHandlerForever :: (Api api Asynchronous -> Eff eff ()) -> ApiHandler api eff
callHandler :: (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> ApiHandler api e
callHandlerForever :: (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> ApiHandler api e
castAndCallHandler :: (Api api Asynchronous -> Eff e ApiServerCmd) -> (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> ApiHandler api e
castAndCallHandlerForever :: (Api api Asynchronous -> Eff e ()) -> (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> ApiHandler api e
data ServerCallback eff = ServerCallback {
- _requestHandlerSelector :: MessageSelector (Eff eff ApiServerCmd)
- _terminationHandler :: ExitReason Recoverable -> Eff eff ()
}
callCallback :: forall api eff reply. Getter (ApiHandler api eff) (Maybe (Api api (Synchronous reply) -> (reply -> Eff eff ()) -> Eff eff ApiServerCmd))
castCallback :: forall api eff. Lens' (ApiHandler api eff) (Maybe (Api api Asynchronous -> Eff eff ApiServerCmd))
terminateCallback :: forall api eff. Lens' (ApiHandler api eff) (Maybe (ExitReason Recoverable -> Eff eff ()))
class Servable a where
- type ServerEff a :: [Type -> Type]
- type ServerPids a
- toServerPids :: proxy a -> ProcessId -> ServerPids a
- toServerCallback :: (Member Interrupts (ServerEff a), SetMember Process (Process effScheduler) (ServerEff a)) => SchedulerProxy effScheduler -> a -> ServerCallback (ServerEff a)
requestHandlerSelector :: forall eff. Lens' (ServerCallback eff) (MessageSelector (Eff eff ApiServerCmd))
terminationHandler :: forall eff. Lens' (ServerCallback eff) (ExitReason Recoverable -> Eff eff ())
serve :: forall a effScheduler. (Servable a, SetMember Process (Process effScheduler) (ServerEff a), Member Interrupts (ServerEff a), HasCallStack) => SchedulerProxy effScheduler -> a -> Eff (ServerEff a) ()
spawnServer :: forall a effScheduler eff. (Servable a, ServerEff a ~ InterruptableProcess effScheduler, SetMember Process (Process effScheduler) eff, Member Interrupts eff, HasCallStack) => SchedulerProxy effScheduler -> a -> Eff eff (ServerPids a)
spawnServerWithEffects :: forall a effScheduler eff. (Servable a, SetMember Process (Process effScheduler) (ServerEff a), SetMember Process (Process effScheduler) eff, Member Interrupts eff, Member Interrupts (ServerEff a), HasCallStack) => SchedulerProxy effScheduler -> a -> (Eff (ServerEff a) () -> Eff (InterruptableProcess effScheduler) ()) -> Eff eff (ServerPids a)
unhandledCallError :: forall p x r q. (Typeable p, HasCallStack, SetMember Process (Process q) r, Member (Exc (ExitReason Recoverable)) r) => SchedulerProxy q -> Api p (Synchronous x) -> (x -> Eff r ()) -> Eff r ApiServerCmd
unhandledCastError :: forall p r q. (Typeable p, HasCallStack, SetMember Process (Process q) r, Member (Exc (ExitReason Recoverable)) r) => SchedulerProxy q -> Api p Asynchronous -> Eff r ApiServerCmd
defaultTermination :: forall q r. (HasCallStack, SetMember Process (Process q) r, Member (Logs LogMessage) r) => SchedulerProxy q -> ExitReason Recoverable -> Eff r ()
data CallbackObserver o
type ObserverState o = State (Observers o)
data Observers o
data SomeObserver o where
- SomeObserver :: (Show (Server p), Typeable p, Observer p o) => Server p -> SomeObserver o
class (Typeable o, Typeable (Observation o)) => Observable o where
- data Observation o
- registerObserverMessage :: SomeObserver o -> Api o Asynchronous
- forgetObserverMessage :: SomeObserver o -> Api o Asynchronous
class (Typeable p, Observable o) => Observer p o where
- observationMessage :: Server o -> Observation o -> Api p Asynchronous
notifyObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Observation o -> Eff r ()
registerObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Eff r ()
forgetObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Eff r ()
notifySomeObserver :: (SetMember Process (Process q) r, Observable o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server o -> Observation o -> SomeObserver o -> Eff r ()
manageObservers :: Eff (ObserverState o ': r) a -> Eff r a
addObserver :: (SetMember Process (Process q) r, Member (ObserverState o) r, Observable o) => SomeObserver o -> Eff r ()
removeObserver :: (SetMember Process (Process q) r, Member (ObserverState o) r, Observable o, Member Interrupts r) => SomeObserver o -> Eff r ()
notifyObservers :: forall o r q. (Observable o, SetMember Process (Process q) r, Member (ObserverState o) r, Member Interrupts r) => SchedulerProxy q -> Observation o -> Eff r ()
spawnCallbackObserver :: forall o r q. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, Member (Logs LogMessage) q, Member Interrupts r, HasCallStack) => SchedulerProxy q -> (Server o -> Observation o -> Eff (InterruptableProcess q) ApiServerCmd) -> Eff r (Server (CallbackObserver o))
spawnLoggingObserver :: forall o r q. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, Member (Logs LogMessage) q, Member (Logs LogMessage) r, Member Interrupts r, HasCallStack) => SchedulerProxy q -> Eff r (Server (CallbackObserver o))
type ObservationQueueReader a = Reader (ObservationQueue a)
data ObservationQueue a
readObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r (Observation o)
tryReadObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r (Maybe (Observation o))
flushObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r [Observation o]
enqueueObservationsRegistered :: forall o r q a. (ServesApi o r q, SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, HasLogging IO q, HasLogging IO r, Member Interrupts q, Member Interrupts r, Lifted IO r, HasCallStack, MonadCatch (Eff r)) => SchedulerProxy q -> Int -> Eff (ObservationQueueReader o ': r) a -> Eff r a
enqueueObservations :: forall o r q a. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, HasLogging IO r, HasLogging IO q, Member Interrupts r, Member Interrupts q, Lifted IO q, HasCallStack, MonadCatch (Eff r)) => SchedulerProxy q -> Server o -> Int -> Eff (ObservationQueueReader o ': r) a -> Eff r a
type SchedulerIO = Reader SchedulerState ': LoggingAndIO
type HasSchedulerIO r = (HasCallStack, Lifted IO r, SchedulerIO <:: r)
type InterruptableProcEff = InterruptableProcess SchedulerIO
type ProcEff = ConsProcess SchedulerIO
defaultMain :: HasCallStack => Eff InterruptableProcEff () -> IO ()
defaultMainWithLogChannel :: HasCallStack => Eff InterruptableProcEff () -> LogChannel LogMessage -> IO ()
forkIoScheduler :: SchedulerProxy SchedulerIO
schedule :: (HasLogging IO SchedulerIO, HasCallStack) => Eff InterruptableProcEff () -> Eff LoggingAndIO ()
schedulePure :: Eff (InterruptableProcess '[Logs LogMessage]) a -> Either (ExitReason NoRecovery) a
singleThreadedIoScheduler :: SchedulerProxy LoggingAndIo
defaultMainSingleThreaded :: HasCallStack => Eff (InterruptableProcess '[Logs LogMessage, LogWriterReader LogMessage IO, Lift IO]) () -> IO ()
module Control.Eff.Log
module Control.Eff.Loop

Concurrent Processes with Message Passing Concurrency

newtype ProcessId Source #

Each process is identified by a single process id, that stays constant throughout the life cycle of a process. Also, message sending relies on these values to address messages to processes.

Constructors

ProcessId
Fields _fromProcessId :: Int

Instances

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

data ProcessDown Source #

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

Since: 0.12.0

Constructors

ProcessDown
Fields downReference :: !MonitorReference downReason :: !SomeExitReason

Instances

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

data MonitorReference Source #

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

Since: 0.12.0

Constructors

MonitorReference
Fields monitorIndex :: Int monitoredProcess :: ProcessId

Instances

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

data SomeExitReason where Source #

An existential wrapper around ExitReason

Constructors

SomeExitReason :: ExitReason x -> SomeExitReason

Instances

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

type InterruptableProcess e = Interrupts ': ConsProcess e Source #

This adds a layer of the Interrupts effect ontop of ConsProcess

type Interrupts = Exc InterruptReason Source #

Exceptions containing InterruptReasons. See handleInterrupts, exitOnInterrupt or provideInterrupts

type InterruptReason = ExitReason Recoverable Source #

ExitReasons which are recoverable are interrupts.

data ExitReason (t :: ExitRecovery) where Source #

A sum-type with reasons for why a process exists the scheduling loop, this includes errors, that can occur when scheduleing messages.

Constructors

ProcessNotRunning :: ProcessId -> ExitReason Recoverable	A process that should be running was not running.
LinkedProcessCrashed :: ProcessId -> ExitReason Recoverable	A linked process is down
ProcessError :: String -> ExitReason Recoverable	An exit reason that has an error message but isn't `Recoverable`.
ExitNormally :: ExitReason NoRecovery	A process function returned or exited without any error.
NotRecovered :: ExitReason Recoverable -> ExitReason NoRecovery	An unhandled `Recoverable` allows `NoRecovery`.
UnexpectedException :: String -> String -> ExitReason NoRecovery	An unexpected runtime exception was thrown, i.e. an exception derived from `SomeException`
Killed :: ExitReason NoRecovery	A process was cancelled (e.g. killed, in `cancel`)

Instances

Eq (ExitReason x) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: ExitReason x -> ExitReason x -> Bool # (/=) :: ExitReason x -> ExitReason x -> Bool #
Ord (ExitReason x) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: ExitReason x -> ExitReason x -> Ordering # (<) :: ExitReason x -> ExitReason x -> Bool # (<=) :: ExitReason x -> ExitReason x -> Bool # (>) :: ExitReason x -> ExitReason x -> Bool # (>=) :: ExitReason x -> ExitReason x -> Bool # max :: ExitReason x -> ExitReason x -> ExitReason x # min :: ExitReason x -> ExitReason x -> ExitReason x #
Show (ExitReason x) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> ExitReason x -> ShowS # show :: ExitReason x -> String # showList :: [ExitReason x] -> ShowS #
Exception (ExitReason Recoverable) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods toException :: ExitReason Recoverable -> SomeException # fromException :: SomeException -> Maybe (ExitReason Recoverable) # displayException :: ExitReason Recoverable -> String #
Exception (ExitReason NoRecovery) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods toException :: ExitReason NoRecovery -> SomeException # fromException :: SomeException -> Maybe (ExitReason NoRecovery) # displayException :: ExitReason NoRecovery -> String #
NFData (ExitReason x) Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: ExitReason x -> () #

data ExitSeverity Source #

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

Constructors

NormalExit
Crash

Instances

Eq ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: ExitSeverity -> ExitSeverity -> Bool # (/=) :: ExitSeverity -> ExitSeverity -> Bool #
Ord ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: ExitSeverity -> ExitSeverity -> Ordering # (<) :: ExitSeverity -> ExitSeverity -> Bool # (<=) :: ExitSeverity -> ExitSeverity -> Bool # (>) :: ExitSeverity -> ExitSeverity -> Bool # (>=) :: ExitSeverity -> ExitSeverity -> Bool # max :: ExitSeverity -> ExitSeverity -> ExitSeverity # min :: ExitSeverity -> ExitSeverity -> ExitSeverity #
Show ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> ExitSeverity -> ShowS # show :: ExitSeverity -> String # showList :: [ExitSeverity] -> ShowS #
Generic ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process Associated Types type Rep ExitSeverity :: Type -> Type # Methods from :: ExitSeverity -> Rep ExitSeverity x # to :: Rep ExitSeverity x -> ExitSeverity #
NFData ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: ExitSeverity -> () #
type Rep ExitSeverity Source #
Instance details Defined in Control.Eff.Concurrent.Process type Rep ExitSeverity = D1 (MetaData "ExitSeverity" "Control.Eff.Concurrent.Process" "extensible-effects-concurrent-0.12.1-LO3m0Cool5YKUevlLHsdu" 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 ExitReason can be treated like a short interrupt which can be handled or ignored.

Constructors

Recoverable
NoRecovery

Instances

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

data ProcessState Source #

The state that a Process is currently in.

Constructors

ProcessBooting	The process has just been started but not called `handleProcess` yet.
ProcessIdle	The process yielded it's timeslice
ProcessBusy	The process is busy with non-blocking
ProcessBusySending	The process is busy with sending a message
ProcessBusySendingShutdown	The process is busy with killing
ProcessBusySendingInterrupt	The process is busy with killing
ProcessBusyReceiving	The process blocked by a `receiveAnyMessage`
ProcessBusyLinking	The process blocked by a `linkProcess`
ProcessBusyUnlinking	The process blocked by a `unlinkProcess`
ProcessBusyMonitoring	The process blocked by a `monitor`
ProcessBusyDemonitoring	The process blocked by a `demonitor`
ProcessInterrupted	The process was interrupted
ProcessShuttingDown	The process was shutdown or crashed

Instances

Enum ProcessState Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods succ :: ProcessState -> ProcessState # pred :: ProcessState -> ProcessState # toEnum :: Int -> ProcessState # fromEnum :: ProcessState -> Int # enumFrom :: ProcessState -> [ProcessState] # enumFromThen :: ProcessState -> ProcessState -> [ProcessState] # enumFromTo :: ProcessState -> ProcessState -> [ProcessState] # enumFromThenTo :: ProcessState -> ProcessState -> ProcessState -> [ProcessState] #
Eq ProcessState Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods (==) :: ProcessState -> ProcessState -> Bool # (/=) :: ProcessState -> ProcessState -> Bool #
Ord ProcessState Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods compare :: ProcessState -> ProcessState -> Ordering # (<) :: ProcessState -> ProcessState -> Bool # (<=) :: ProcessState -> ProcessState -> Bool # (>) :: ProcessState -> ProcessState -> Bool # (>=) :: ProcessState -> ProcessState -> Bool # max :: ProcessState -> ProcessState -> ProcessState # min :: ProcessState -> ProcessState -> ProcessState #
Read ProcessState Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods readsPrec :: Int -> ReadS ProcessState # readList :: ReadS [ProcessState] # readPrec :: ReadPrec ProcessState # readListPrec :: ReadPrec [ProcessState] #
Show ProcessState Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods showsPrec :: Int -> ProcessState -> ShowS # show :: ProcessState -> String # showList :: [ProcessState] -> ShowS #
Generic ProcessState Source #
Instance details Defined in Control.Eff.Concurrent.Process Associated Types type Rep ProcessState :: Type -> Type # Methods from :: ProcessState -> Rep ProcessState x # to :: Rep ProcessState x -> ProcessState #
Default ProcessState Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods def :: ProcessState #
NFData ProcessState Source #
Instance details Defined in Control.Eff.Concurrent.Process Methods rnf :: ProcessState -> () #
type Rep ProcessState Source #
Instance details Defined in Control.Eff.Concurrent.Process type Rep ProcessState = D1 (MetaData "ProcessState" "Control.Eff.Concurrent.Process" "extensible-effects-concurrent-0.12.1-LO3m0Cool5YKUevlLHsdu" False) (((C1 (MetaCons "ProcessBooting" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "ProcessIdle" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ProcessBusy" PrefixI False) (U1 :: Type -> Type))) :+: (C1 (MetaCons "ProcessBusySending" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "ProcessBusySendingShutdown" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ProcessBusySendingInterrupt" PrefixI False) (U1 :: Type -> Type)))) :+: ((C1 (MetaCons "ProcessBusyReceiving" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "ProcessBusyLinking" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ProcessBusyUnlinking" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "ProcessBusyMonitoring" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ProcessBusyDemonitoring" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "ProcessInterrupted" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ProcessShuttingDown" PrefixI False) (U1 :: Type -> Type)))))

type ConsProcess r = Process r ': r Source #

Cons Process onto a list of effects.

type HasScheduler q = ?_schedulerProxy :: SchedulerProxy q Source #

A constraint for the implicit SchedulerProxy parameter. Use getSchedulerProxy to query it. _EXPERIMENTAL_

Since: 0.12.0

data SchedulerProxy :: [Type -> Type] -> Type where Source #

Every function for Process things needs such a proxy value for the low-level effect list, i.e. the effects identified by r in Process r : r, this might be dependent on the scheduler implementation.

Constructors

SchedulerProxy :: SchedulerProxy q	Tell the typechecker what effects we have below `Process`
SP :: SchedulerProxy q	Like `SchedulerProxy` but shorter
Scheduler :: SchedulerProxy q	Like `SP` but different

data MessageSelector a Source #

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

Instances

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

data ResumeProcess v where Source #

Every Process action returns it's actual result wrapped in this type. It will allow to signal errors as well as pass on normal results such as incoming messages.

Constructors

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

Instances

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

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 [Dynamic])	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
SelfPid :: Process r (ResumeProcess ProcessId)	Return the current `ProcessId`
Spawn :: 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 :: Eff (Process r ': r) () -> Process r (ResumeProcess ProcessId)	Start a new process, and `Link` to it . Since: 0.12.0
GetProcessState :: ProcessId -> Process r (ResumeProcess (Maybe ProcessState))	Get the process state (or `Nothing` if the process is dead)
Shutdown :: ExitReason NoRecovery -> Process r a	Shutdown the process; irregardles of the exit reason, this function never returns,
SendShutdown :: ProcessId -> ExitReason NoRecovery -> Process r (ResumeProcess ())	Raise an error, that can be handled.
SendInterrupt :: ProcessId -> InterruptReason -> 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 -> Dynamic -> 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 criterium. This should block until an a message was received. The message is returned as a `ProcessMessage` 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, w.thout 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 `ProcessExitReaon` `LinkedProcessCrashed`. Since: 0.12.0
Unlink :: ProcessId -> Process r (ResumeProcess ())	Unlink the calling proccess from the other process. Since: 0.12.0

Instances

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 #

selectMessage :: (NFData t, Typeable t) => MessageSelector t Source #

Create a message selector for a value that can be obtained by fromDynamic. It will also force the result.

Since: 0.9.1

selectMessageLazy :: Typeable t => MessageSelector t Source #

Create a message selector for a value that can be obtained by fromDynamic. It will also force the result.

Since: 0.9.1

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

Create a message selector from a predicate. It will force the result.

Since: 0.9.1

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

Create a message selector from a predicate. It will force the result.

Since: 0.9.1

selectMessageWith :: (Typeable a, NFData b) => (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). It will force the result.

Since: 0.9.1

selectMessageWithLazy :: 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). It will force the result.

Since: 0.9.1

selectDynamicMessage :: NFData a => (Dynamic -> Maybe a) -> MessageSelector a Source #

Create a message selector. It will force the result.

Since: 0.9.1

selectDynamicMessageLazy :: (Dynamic -> Maybe a) -> MessageSelector a Source #

Create a message selector.

Since: 0.9.1

selectAnyMessageLazy :: MessageSelector Dynamic Source #

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

Since: 0.9.1

selectMessageProxy :: forall proxy t. (NFData t, Typeable t) => proxy t -> MessageSelector t Source #

Create a message selector for a value that can be obtained by fromDynamic with a proxy argument. It will also force the result.

Since: 0.9.1

selectMessageProxyLazy :: forall proxy t. Typeable t => proxy t -> MessageSelector t Source #

Create a message selector for a value that can be obtained by fromDynamic with a proxy argument. It will also force the result.

Since: 0.9.1

getSchedulerProxy :: HasScheduler q => SchedulerProxy q Source #

Get access to the SchedulerProxy for the current scheduler effects. _EXPERIMENTAL_

Since: 0.12.0

withSchedulerProxy :: SchedulerProxy q -> (HasScheduler q => a) -> a Source #

Set the SchedulerProxy to use, this satisfies HasScheduler . _EXPERIMENTAL_

Since: 0.12.0

thisSchedulerProxy :: Eff (Process r ': r) (SchedulerProxy r) Source #

Return a SchedulerProxy for a Process effect.

toExitRecovery :: ExitReason r -> ExitRecovery Source #

Get the ExitRecovery

toExitSeverity :: ExitReason e -> ExitSeverity Source #

Get the ExitSeverity of a ExitReason.

isBecauseDown :: Maybe ProcessId -> ExitReason r -> Bool Source #

A predicate for linked process crashes.

provideInterruptsShutdown :: forall e a. Eff (InterruptableProcess e) a -> Eff (ConsProcess e) a Source #

Handle all InterruptReasons of an InterruptableProcess by wrapping them up in NotRecovered and then do a process Shutdown.

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

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

logInterrupts :: (HasCallStack, '[Interrupts, Logs LogMessage] <:: r) => Eff r () -> Eff r () Source #

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

exitOnInterrupt :: (HasCallStack, Member Interrupts r, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a -> Eff r a Source #

Handle InterruptReasons 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 InterruptReason a) Source #

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

mergeEitherInterruptAndExitReason :: Either InterruptReason (ExitReason NoRecovery) -> ExitReason NoRecovery Source #

Wrap all (left) InterruptReasons into NotRecovered and return the (right) NoRecovery ExitReasons as is.

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

Throw an InterruptReason, can be handled by recoverFromInterrupt or exitOnInterrupt or provideInterrupts.

isCrash :: ExitReason x -> Bool Source #

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

isRecoverable :: ExitReason x -> Bool Source #

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

fromSomeExitReason :: SomeExitReason -> Either (ExitReason NoRecovery) InterruptReason Source #

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

toCrashReason :: ExitReason x -> Maybe String Source #

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

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

Though this can be improved to:

logCrash = traverse_ logError . toCrashReason

logProcessExit :: (HasCallStack, Member (Logs LogMessage) e) => ExitReason x -> Eff e () Source #

Log the ProcessExitReaons

executeAndResume :: forall q r v. (SetMember Process (Process q) r, HasCallStack) => Process q (ResumeProcess v) -> Eff r (Either (ExitReason 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. (SetMember Process (Process q) r, 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. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => 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. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Eff r () Source #

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

sendMessage :: forall r q o. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r, Typeable o) => SchedulerProxy q -> ProcessId -> o -> Eff r () Source #

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

sendAnyMessage :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Dynamic -> Eff r () Source #

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

sendShutdown :: forall r q. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> ExitReason 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. (SetMember Process (Process q) r, HasCallStack, Member Interrupts r) => SchedulerProxy q -> ProcessId -> InterruptReason -> 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, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess 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 InterruptReason wrapped in NotCovered. For specific use cases it might be better to use spawnRaw.

spawn_ :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess q) () -> Eff r () Source #

Like spawn but return ().

spawnLink :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (InterruptableProcess q) () -> Eff r ProcessId Source #

Start a new process, and immediately link to it.

Since: 0.12.0

spawnRaw :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (ConsProcess 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 ConsProcess effects. For non-library code spawn might be better suited.

spawnRaw_ :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => Eff (ConsProcess q) () -> Eff r () Source #

Like spawnRaw but return ().

isProcessAlive :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r Bool Source #

Return True if the process is alive.

Since: 0.12.0

receiveAnyMessage :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Eff r Dynamic Source #

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

receiveSelectedMessage :: forall r q a. (HasCallStack, Show a, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> MessageSelector a -> Eff r a 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, Show a, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy 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, SetMember Process (Process q) r, Member Interrupts r, HasScheduler q) => Eff r [Dynamic] Source #

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

Since: 0.12.0

receiveSelectedLoop :: forall r q a endOfLoopResult. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> MessageSelector a -> (Either InterruptReason a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult 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 ProcessExitReaon, otherwise the process will be exited with the same reason using exitBecause. See also ReceiveSelectedMessage for more documentation.

receiveAnyLoop :: forall r q endOfLoopResult. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> (Either InterruptReason Dynamic -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult Source #

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

receiveLoop :: forall r q a endOfLoopResult. (SetMember Process (Process q) r, HasCallStack, Typeable a) => SchedulerProxy q -> (Either InterruptReason a -> Eff r (Maybe endOfLoopResult)) -> Eff r endOfLoopResult Source #

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

self :: (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r ProcessId Source #

Returns the ProcessId of the current process.

makeReference :: (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Eff r Int Source #

Generate a unique Int for the current process.

monitor :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy 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, w.thout exit reason

Since: 0.12.0

demonitor :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> MonitorReference -> Eff r () Source #

Remove a monitor created with monitor.

Since: 0.12.0

withMonitor :: (HasCallStack, Member Interrupts r, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy 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, Member Interrupts r, SetMember Process (Process q) r, Member Interrupts r, Typeable a, Show a) => SchedulerProxy q -> ProcessId -> MessageSelector a -> Eff r (Either ProcessDown a) Source #

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

Since: 0.12.0

becauseProcessIsDown :: ProcessDown -> InterruptReason Source #

Trigger an Interrupt for a ProcessDown message. The reason will be ProcessNotRunning

Since: 0.12.0

selectProcessDown :: MonitorReference -> MessageSelector ProcessDown Source #

A MesssageSelector for the ProcessDown message of a specific process.

Since: 0.12.0

linkProcess :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy 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 ProcessExitReaon LinkedProcessCrashed.

Since: 0.12.0

unlinkProcess :: forall r q. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> ProcessId -> Eff r () Source #

Unlink the calling proccess from the other process.

Since: 0.12.0

exitBecause :: forall r q a. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ExitReason NoRecovery -> Eff r a Source #

Exit the process with a ProcessExitReaon.

exitNormally :: forall r q a. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a Source #

Exit the process.

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

Exit the process with an error.

fromProcessId :: Iso' ProcessId Int Source #

Timers and Timeouts

data TimerElapsed Source #

A value to be sent when timer started with startTimer has elapsed.

Since: 0.12.0

Instances

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

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

data Timeout Source #

A number of micro seconds.

Since: 0.12.0

Instances

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

receiveAfter :: forall a r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable a, NFData a, Show a) => SchedulerProxy q -> Timeout -> Eff r (Maybe a) Source #

Wait for a message of the given type for the given time. When no message arrives in time, return Nothing. This is based on receiveSelectedAfter.

Since: 0.12.0

receiveSelectedAfter :: forall a r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Show a) => SchedulerProxy q -> MessageSelector a -> Timeout -> Eff r (Either TimerElapsed a) Source #

Wait for a message of the given type for the given time. When no message arrives in time, return Left TimerElapsed. This is based on selectTimerElapsed and startTimer.

Since: 0.12.0

selectTimerElapsed :: TimerReference -> MessageSelector TimerElapsed Source #

A MessageSelector matching TimerElapsed messages created by startTimer.

Since: 0.12.0

sendAfter :: forall r q message. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable message, NFData message) => SchedulerProxy q -> ProcessId -> Timeout -> (TimerReference -> message) -> Eff r TimerReference Source #

Send a message to a given process after waiting. The message is created by applying the function parameter to the TimerReference, such that the message can directly refer to the timer.

Since: 0.12.0

startTimer :: forall r q. (Lifted IO q, HasCallStack, SetMember Process (Process q) r, Member Interrupts r) => SchedulerProxy q -> Timeout -> Eff r TimerReference Source #

Start a new timer, after the time has elapsed, TimerElapsed is sent to calling process. The message also contains the TimerReference returned by this function. Use cancelTimer to cancel the timer. Use selectTimerElapsed to receive the message using receiveSelectedMessage. To receive messages with guarded with a timeout see receiveAfter.

Since: 0.12.0

Data Types and Functions for APIs (aka Protocols)

newtype Server api Source #

This is a tag-type that wraps around a ProcessId and holds an Api index type.

Constructors

Server
Fields _fromServer :: ProcessId

Instances

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

data Synchronicity Source #

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

data family Api (api :: Type) (reply :: Synchronicity) Source #

This data family defines an API, a communication interface description between at least two processes. The processes act as servers or client(s) regarding a specific instance of this type.

The first parameter is usually a user defined phantom type that identifies the Api instance.

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

Example:

data BookShop deriving Typeable

data instance Api BookShop r where
  RentBook  :: BookId   -> Api BookShop ('Synchronous (Either RentalError RentalId))
  BringBack :: RentalId -> Api BookShop 'Asynchronous

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

Instances

Show (Observation o) => Show (Api (CallbackObserver o) r) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Observer Methods showsPrec :: Int -> Api (CallbackObserver o) r -> ShowS # show :: Api (CallbackObserver o) r -> String # showList :: [Api (CallbackObserver o) r] -> ShowS #
data Api (CallbackObserver o) r Source #
Instance details Defined in Control.Eff.Concurrent.Api.Observer data Api (CallbackObserver o) r where CbObserved :: forall k (o :: k) (r :: Synchronicity) o. (Typeable o, Typeable (Observation o)) => Server o -> Observation o -> Api (CallbackObserver o) Asynchronous

fromServer :: forall api api. Iso (Server api) (Server api) ProcessId ProcessId Source #

proxyAsServer :: proxy api -> ProcessId -> Server api Source #

Tag a ProcessId with an Api type index to mark it a Server process handling that API

asServer :: forall api. ProcessId -> Server api Source #

Tag a ProcessId with an Api type index to mark it a Server process handling that API

Client Functions for Consuming APIs

type ServerReader o = Reader (Server o) Source #

The reader effect for ProcessIds for Apis, see registerServer

type ServesApi o r q = (Typeable o, SetMember Process (Process q) r, Member (ServerReader o) r) Source #

Instead of passing around a Server value and passing to functions like cast or call, a Server can provided by a Reader effect, if there is only a single server for a given Api instance. This type alias is convenience to express that an effect has Process and a reader for a Server.

cast :: forall r q o. (HasCallStack, SetMember Process (Process q) r, Member Interrupts r, Typeable o, Typeable (Api o Asynchronous)) => SchedulerProxy q -> Server o -> Api o Asynchronous -> Eff r () Source #

Send an Api request that has no return value and return as fast as possible. The type signature enforces that the corresponding Api clause is Asynchronous. The operation never fails, if it is important to know if the message was delivered, use call instead.

call :: forall result api r q. (SetMember Process (Process q) r, Member Interrupts r, Typeable api, Typeable (Api api (Synchronous result)), Typeable result, HasCallStack, NFData result, Show result) => SchedulerProxy q -> Server api -> Api api (Synchronous result) -> Eff r result Source #

Send an Api request and wait for the server to return a result value.

The type signature enforces that the corresponding Api clause is Synchronous.

registerServer :: HasCallStack => Server o -> Eff (ServerReader o ': r) a -> Eff r a Source #

Run a reader effect that contains the one server handling a specific Api instance.

whereIsServer :: Member (ServerReader o) e => Eff e (Server o) Source #

Get the Server registered with registerServer.

callRegistered :: (Typeable reply, ServesApi o r q, HasCallStack, NFData reply, Show reply, Member Interrupts r) => SchedulerProxy q -> Api o (Synchronous reply) -> Eff r reply Source #

Like call but take the Server from the reader provided by registerServer.

castRegistered :: (Typeable o, ServesApi o r q, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Api o Asynchronous -> Eff r () Source #

Like cast but take the Server from the reader provided by registerServer.

Server Functions for Providing APIs

data ApiServerCmd where Source #

A command to the server loop started e.g. by server or spawnServerWithEffects. Typically returned by an ApiHandler member to indicate if the server should continue or stop.

Constructors

HandleNextRequest :: ApiServerCmd	Tell the server to keep the server loop running
StopApiServer :: ExitReason Recoverable -> ApiServerCmd	Tell the server to exit, this will make `serve` stop handling requests without exitting the process. `_terminateCallback` will be invoked with the given optional reason.

Instances

Show ApiServerCmd Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server Methods showsPrec :: Int -> ApiServerCmd -> ShowS # show :: ApiServerCmd -> String # showList :: [ApiServerCmd] -> ShowS #
Generic ApiServerCmd Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server Associated Types type Rep ApiServerCmd :: Type -> Type # Methods from :: ApiServerCmd -> Rep ApiServerCmd x # to :: Rep ApiServerCmd x -> ApiServerCmd #
NFData ApiServerCmd Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server Methods rnf :: ApiServerCmd -> () #
type Rep ApiServerCmd Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server type Rep ApiServerCmd = D1 (MetaData "ApiServerCmd" "Control.Eff.Concurrent.Api.Server" "extensible-effects-concurrent-0.12.1-LO3m0Cool5YKUevlLHsdu" False) (C1 (MetaCons "HandleNextRequest" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "StopApiServer" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ExitReason Recoverable))))

data ApiHandler api eff where Source #

A record of callbacks, handling requests sent to a server Process, all belonging to a specific Api family instance. The values of this type can be serveed or combined via Servable or ServerCallbacks.

Constructors

ApiHandler

Fields

:: { _castCallback :: Maybe (Api api Asynchronous -> Eff eff ApiServerCmd)
A cast will not return a result directly. This is used for async methods. This returns an ApiServerCmd to the server loop.
, _callCallback :: forall reply. Maybe (Api api (Synchronous reply) -> (reply -> Eff eff ()) -> Eff eff ApiServerCmd)
A call is a blocking operation, the caller is blocked until this handler calls the reply continuation. This returns an ApiServerCmd to the server loop.
, _terminateCallback :: Maybe (ExitReason Recoverable -> Eff eff ())
This callback is called with Nothing if one of these things happen:
- the process exits
- _callCallback or _castCallback return StopApiServer
If the process exist peacefully the parameter is Nothing, otherwise Just "error message..." if the process exits with an error.
The default behavior is defined in defaultTermination.
} -> ApiHandler api eff

Instances

Default (ApiHandler api eff) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server Methods def :: ApiHandler api eff #
Typeable a => Servable (ApiHandler a eff) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server Associated Types type ServerEff (ApiHandler a eff) :: [Type -> Type] Source # type ServerPids (ApiHandler a eff) :: Type Source # Methods toServerPids :: proxy (ApiHandler a eff) -> ProcessId -> ServerPids (ApiHandler a eff) Source # toServerCallback :: (Member Interrupts (ServerEff (ApiHandler a eff)), SetMember Process (Process effScheduler) (ServerEff (ApiHandler a eff))) => SchedulerProxy effScheduler -> ApiHandler a eff -> ServerCallback (ServerEff (ApiHandler a eff)) Source #
type ServerEff (ApiHandler a eff) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server type ServerEff (ApiHandler a eff) = eff
type ServerPids (ApiHandler a eff) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server type ServerPids (ApiHandler a eff) = Server a

apiHandler :: (Api api Asynchronous -> Eff e ApiServerCmd) -> (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> (ExitReason Recoverable -> Eff e ()) -> ApiHandler api e Source #

Create an ApiHandler with a _castCallback, a _callCallback and a _terminateCallback implementation.

apiHandlerForever :: (Api api Asynchronous -> Eff e ()) -> (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> (ExitReason Recoverable -> Eff e ()) -> ApiHandler api e Source #

Like apiHandler but the server will loop until an error is raised or the process exits. The callback actions won't decide wether to stop the server or not, instead the ApiServerCmd HandleNextRequest is used.

castHandler :: (Api api Asynchronous -> Eff eff ApiServerCmd) -> ApiHandler api eff Source #

Create an ApiHandler with only a _castCallback implementation.

castHandlerForever :: (Api api Asynchronous -> Eff eff ()) -> ApiHandler api eff Source #

Like castHandler but the server will loop until an error is raised or the process exits. See apiHandlerForver.

callHandler :: (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> ApiHandler api e Source #

Create an ApiHandler with only a _callCallback implementation.

callHandlerForever :: (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> ApiHandler api e Source #

Like callHandler but the server will loop until an error is raised or the process exits. See apiHandlerForver.

castAndCallHandler :: (Api api Asynchronous -> Eff e ApiServerCmd) -> (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ApiServerCmd) -> ApiHandler api e Source #

Create an ApiHandler with only a _castCallback and _callCallback implementation.

castAndCallHandlerForever :: (Api api Asynchronous -> Eff e ()) -> (forall r. Api api (Synchronous r) -> (r -> Eff e ()) -> Eff e ()) -> ApiHandler api e Source #

Like castAndCallHandler but the server will loop until an error is raised or the process exits. See apiHandlerForver.

data ServerCallback eff Source #

Building block for composition of ApiHandler. A wrapper for ApiHandler. Use this to combine ApiHandler, allowing a process to implement several Api instances. The termination will be evenly propagated. Create this via e.g. Servable instances To serve multiple apis use <> to combine server callbacks, e.g.

@@let f = apiHandlerServerCallback px $ ApiHandler ... g = apiHandlerServerCallback px $ ApiHandler ... h = f <> g in serve px h@@

Constructors

ServerCallback
Fields _requestHandlerSelector :: MessageSelector (Eff eff ApiServerCmd) _terminationHandler :: ExitReason Recoverable -> Eff eff ()

Instances

Semigroup (ServerCallback eff) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server Methods (<>) :: ServerCallback eff -> ServerCallback eff -> ServerCallback eff # sconcat :: NonEmpty (ServerCallback eff) -> ServerCallback eff # stimes :: Integral b => b -> ServerCallback eff -> ServerCallback eff #
Monoid (ServerCallback eff) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server Methods mempty :: ServerCallback eff # mappend :: ServerCallback eff -> ServerCallback eff -> ServerCallback eff # mconcat :: [ServerCallback eff] -> ServerCallback eff #
Servable (ServerCallback eff) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server Associated Types type ServerEff (ServerCallback eff) :: [Type -> Type] Source # type ServerPids (ServerCallback eff) :: Type Source # Methods toServerPids :: proxy (ServerCallback eff) -> ProcessId -> ServerPids (ServerCallback eff) Source # toServerCallback :: (Member Interrupts (ServerEff (ServerCallback eff)), SetMember Process (Process effScheduler) (ServerEff (ServerCallback eff))) => SchedulerProxy effScheduler -> ServerCallback eff -> ServerCallback (ServerEff (ServerCallback eff)) Source #
type ServerEff (ServerCallback eff) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server type ServerEff (ServerCallback eff) = eff
type ServerPids (ServerCallback eff) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server type ServerPids (ServerCallback eff) = ProcessId

callCallback :: forall api eff reply. Getter (ApiHandler api eff) (Maybe (Api api (Synchronous reply) -> (reply -> Eff eff ()) -> Eff eff ApiServerCmd)) Source #

castCallback :: forall api eff. Lens' (ApiHandler api eff) (Maybe (Api api Asynchronous -> Eff eff ApiServerCmd)) Source #

terminateCallback :: forall api eff. Lens' (ApiHandler api eff) (Maybe (ExitReason Recoverable -> Eff eff ())) Source #

class Servable a where Source #

Helper type class to allow composition of ApiHandler.

Associated Types

type ServerEff a :: [Type -> Type] Source #

The effect of the callbacks

type ServerPids a Source #

The is used to let the spawn function return multiple Server ProcessIds in a type safe way, e.g. for a tuple instance of this class (Server a, Server b)

Methods

toServerPids :: proxy a -> ProcessId -> ServerPids a Source #

The is used to let the spawn function return multiple Server ProcessIds in a type safe way.

toServerCallback :: (Member Interrupts (ServerEff a), SetMember Process (Process effScheduler) (ServerEff a)) => SchedulerProxy effScheduler -> a -> ServerCallback (ServerEff a) Source #

Convert the value to a ServerCallback

Instances

Servable (ServerCallback eff) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server Associated Types type ServerEff (ServerCallback eff) :: [Type -> Type] Source # type ServerPids (ServerCallback eff) :: Type Source # Methods toServerPids :: proxy (ServerCallback eff) -> ProcessId -> ServerPids (ServerCallback eff) Source # toServerCallback :: (Member Interrupts (ServerEff (ServerCallback eff)), SetMember Process (Process effScheduler) (ServerEff (ServerCallback eff))) => SchedulerProxy effScheduler -> ServerCallback eff -> ServerCallback (ServerEff (ServerCallback eff)) Source #
(ServerEff a ~ ServerEff b, Servable a, Servable b) => Servable (a, b) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server Associated Types type ServerEff (a, b) :: [Type -> Type] Source # type ServerPids (a, b) :: Type Source # Methods toServerPids :: proxy (a, b) -> ProcessId -> ServerPids (a, b) Source # toServerCallback :: (Member Interrupts (ServerEff (a, b)), SetMember Process (Process effScheduler) (ServerEff (a, b))) => SchedulerProxy effScheduler -> (a, b) -> ServerCallback (ServerEff (a, b)) Source #
Typeable a => Servable (ApiHandler a eff) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Server Associated Types type ServerEff (ApiHandler a eff) :: [Type -> Type] Source # type ServerPids (ApiHandler a eff) :: Type Source # Methods toServerPids :: proxy (ApiHandler a eff) -> ProcessId -> ServerPids (ApiHandler a eff) Source # toServerCallback :: (Member Interrupts (ServerEff (ApiHandler a eff)), SetMember Process (Process effScheduler) (ServerEff (ApiHandler a eff))) => SchedulerProxy effScheduler -> ApiHandler a eff -> ServerCallback (ServerEff (ApiHandler a eff)) Source #

requestHandlerSelector :: forall eff. Lens' (ServerCallback eff) (MessageSelector (Eff eff ApiServerCmd)) Source #

terminationHandler :: forall eff. Lens' (ServerCallback eff) (ExitReason Recoverable -> Eff eff ()) Source #

serve :: forall a effScheduler. (Servable a, SetMember Process (Process effScheduler) (ServerEff a), Member Interrupts (ServerEff a), HasCallStack) => SchedulerProxy effScheduler -> a -> Eff (ServerEff a) () Source #

Receive and process incoming requests until the process exits.

spawnServer :: forall a effScheduler eff. (Servable a, ServerEff a ~ InterruptableProcess effScheduler, SetMember Process (Process effScheduler) eff, Member Interrupts eff, HasCallStack) => SchedulerProxy effScheduler -> a -> Eff eff (ServerPids a) Source #

Spawn a new process, that will receive and process incoming requests until the process exits.

spawnServerWithEffects :: forall a effScheduler eff. (Servable a, SetMember Process (Process effScheduler) (ServerEff a), SetMember Process (Process effScheduler) eff, Member Interrupts eff, Member Interrupts (ServerEff a), HasCallStack) => SchedulerProxy effScheduler -> a -> (Eff (ServerEff a) () -> Eff (InterruptableProcess effScheduler) ()) -> Eff eff (ServerPids a) Source #

Spawn a new process, that will receive and process incoming requests until the process exits. Also handle all internal effects.

unhandledCallError :: forall p x r q. (Typeable p, HasCallStack, SetMember Process (Process q) r, Member (Exc (ExitReason Recoverable)) r) => SchedulerProxy q -> Api p (Synchronous x) -> (x -> Eff r ()) -> Eff r ApiServerCmd Source #

A default handler to use in _callCallback in ApiHandler. It will call raiseError with a nice error message.

unhandledCastError :: forall p r q. (Typeable p, HasCallStack, SetMember Process (Process q) r, Member (Exc (ExitReason Recoverable)) r) => SchedulerProxy q -> Api p Asynchronous -> Eff r ApiServerCmd Source #

A default handler to use in _castCallback in ApiHandler. It will call raiseError with a nice error message.

defaultTermination :: forall q r. (HasCallStack, SetMember Process (Process q) r, Member (Logs LogMessage) r) => SchedulerProxy q -> ExitReason Recoverable -> Eff r () Source #

Either do nothing, if the error message is Nothing, or call exitWithError with the error message.

Observer Functions for Events and Event Listener

data CallbackObserver o Source #

An Observer that schedules the observations to an effectful callback.

Instances

Show (Observation o) => Show (Api (CallbackObserver o) r) Source #
Instance details Defined in Control.Eff.Concurrent.Api.Observer Methods showsPrec :: Int -> Api (CallbackObserver o) r -> ShowS # show :: Api (CallbackObserver o) r -> String # showList :: [Api (CallbackObserver o) r] -> ShowS #
Observable o => Observer (CallbackObserver o) o Source #
Instance details Defined in Control.Eff.Concurrent.Api.Observer Methods observationMessage :: Server o -> Observation o -> Api (CallbackObserver o) Asynchronous Source #
data Api (CallbackObserver o) r Source #
Instance details Defined in Control.Eff.Concurrent.Api.Observer data Api (CallbackObserver o) r where CbObserved :: forall k (o :: k) (r :: Synchronicity) o. (Typeable o, Typeable (Observation o)) => Server o -> Observation o -> Api (CallbackObserver o) Asynchronous

type ObserverState o = State (Observers o) Source #

Alias for the effect that contains the observers managed by manageObservers

data Observers o Source #

Internal state for manageObservers

data SomeObserver o where Source #

An existential wrapper around a Server of an Observer. Needed to support different types of observers to observe the same Observable in a general fashion.

Constructors

SomeObserver :: (Show (Server p), Typeable p, Observer p o) => Server p -> SomeObserver o

Instances

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

class (Typeable o, Typeable (Observation o)) => Observable o where Source #

An Api index that supports registration and de-registration of Observers.

Associated Types

data Observation o Source #

Type of observations visible on this observable

Methods

registerObserverMessage :: SomeObserver o -> Api o Asynchronous Source #

Return the Api value for the cast_ that registeres an observer

forgetObserverMessage :: SomeObserver o -> Api o Asynchronous Source #

Return the Api value for the cast_ that de-registeres an observer

class (Typeable p, Observable o) => Observer p o where Source #

An Api index that support observation of the another Api that is Observable.

Methods

observationMessage :: Server o -> Observation o -> Api p Asynchronous Source #

Wrap the Observation and the ProcessId (i.e. the Server) that caused the observation into an Api value that the Observable understands.

Instances

Observable o => Observer (CallbackObserver o) o Source #
Instance details Defined in Control.Eff.Concurrent.Api.Observer Methods observationMessage :: Server o -> Observation o -> Api (CallbackObserver o) Asynchronous Source #

notifyObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Observation o -> Eff r () Source #

Send an Observation to an Observer

registerObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Eff r () Source #

Send the registerObserverMessage

forgetObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, Member Interrupts r) => SchedulerProxy q -> Server p -> Server o -> Eff r () Source #

Send the forgetObserverMessage

notifySomeObserver :: (SetMember Process (Process q) r, Observable o, HasCallStack, Member Interrupts r) => SchedulerProxy q -> Server o -> Observation o -> SomeObserver o -> Eff r () Source #

Send an Observation to SomeObserver.

manageObservers :: Eff (ObserverState o ': r) a -> Eff r a Source #

Keep track of registered Observers Observers can be added and removed, and an Observation can be sent to all registerd observers at once.

addObserver :: (SetMember Process (Process q) r, Member (ObserverState o) r, Observable o) => SomeObserver o -> Eff r () Source #

Add an Observer to the Observers managed by manageObservers.

removeObserver :: (SetMember Process (Process q) r, Member (ObserverState o) r, Observable o, Member Interrupts r) => SomeObserver o -> Eff r () Source #

Delete an Observer from the Observers managed by manageObservers.

notifyObservers :: forall o r q. (Observable o, SetMember Process (Process q) r, Member (ObserverState o) r, Member Interrupts r) => SchedulerProxy q -> Observation o -> Eff r () Source #

Send an Observation to all SomeObservers in the Observers state.

spawnCallbackObserver :: forall o r q. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, Member (Logs LogMessage) q, Member Interrupts r, HasCallStack) => SchedulerProxy q -> (Server o -> Observation o -> Eff (InterruptableProcess q) ApiServerCmd) -> Eff r (Server (CallbackObserver o)) Source #

Start a new process for an Observer that schedules all observations to an effectful callback.

spawnLoggingObserver :: forall o r q. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, Member (Logs LogMessage) q, Member (Logs LogMessage) r, Member Interrupts r, HasCallStack) => SchedulerProxy q -> Eff r (Server (CallbackObserver o)) Source #

Start a new process for an Observer that schedules all observations to an effectful callback.

Since: 0.3.0.0

Capture Observation in a FIFO Queue

type ObservationQueueReader a = Reader (ObservationQueue a) Source #

A Reader for an ObservationQueue.

data ObservationQueue a Source #

Contains a TBQueue capturing observations received by enqueueObservationsRegistered or enqueueObservations.

readObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r (Observation o) Source #

Read queued observations captured by observing a Server that implements an Observable Api using enqueueObservationsRegistered or enqueueObservations. This blocks until the next Observation received. For a non-blocking variant use tryReadObservationQueue or flushObservationQueue.

tryReadObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r (Maybe (Observation o)) Source #

Read queued observations captured by observing a Server that implements an Observable Api using enqueueObservationsRegistered or enqueueObservations. Return the next Observation immediately or Nothing if the queue is empty. Use readObservationQueue to block until an observation is observed.

flushObservationQueue :: forall o r. (Member (ObservationQueueReader o) r, HasCallStack, MonadIO (Eff r), Typeable o, HasLogging IO r) => Eff r [Observation o] Source #

Read all currently queued Observations captured by enqueueObservations. This returns immediately all currently enqueued Observations. For a blocking variant use readObservationQueue.

enqueueObservationsRegistered :: forall o r q a. (ServesApi o r q, SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, HasLogging IO q, HasLogging IO r, Member Interrupts q, Member Interrupts r, Lifted IO r, HasCallStack, MonadCatch (Eff r)) => SchedulerProxy q -> Int -> Eff (ObservationQueueReader o ': r) a -> Eff r a Source #

Observe a(the) registered Server that implements an Observable Api. Based on enqueueObservations.

enqueueObservations :: forall o r q a. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, HasLogging IO r, HasLogging IO q, Member Interrupts r, Member Interrupts q, Lifted IO q, HasCallStack, MonadCatch (Eff r)) => SchedulerProxy q -> Server o -> Int -> Eff (ObservationQueueReader o ': r) a -> Eff r a Source #

Observe a Server that implements an Observable Api, the Observations can be obtained by readObservationQueue. All observations are captured up to the queue size limit, such that the first message received will be first message returned by readObservationQueue.

This function captures runtime exceptions and cleans up accordingly.

Scheduler Process Effect Handler

Concurrent Scheduler

type SchedulerIO = Reader SchedulerState ': LoggingAndIO Source #

The concrete list of Effects for this scheduler implementation.

type HasSchedulerIO r = (HasCallStack, Lifted IO r, SchedulerIO <:: r) Source #

Type class constraint to indicate that an effect union contains the effects required by every process and the scheduler implementation itself.

type InterruptableProcEff = InterruptableProcess SchedulerIO Source #

The concrete list of the effects, that the Process uses

type ProcEff = ConsProcess SchedulerIO Source #

The concrete list of Effects of processes compatible with this scheduler. This builds upon SchedulerIO.

defaultMain :: HasCallStack => Eff InterruptableProcEff () -> IO () Source #

Start the message passing concurrency system then execute a Process on top of SchedulerIO effect. All logging is sent to standard output.

defaultMainWithLogChannel :: HasCallStack => Eff InterruptableProcEff () -> LogChannel LogMessage -> IO () Source #

Start the message passing concurrency system then execute a Process on top of SchedulerIO effect. All logging is sent to standard output.

forkIoScheduler :: SchedulerProxy SchedulerIO Source #

A SchedulerProxy for SchedulerIO

schedule :: (HasLogging IO SchedulerIO, HasCallStack) => Eff InterruptableProcEff () -> Eff LoggingAndIO () Source #

This is the main entry point to running a message passing concurrency application. This function takes a Process on top of the SchedulerIO effect and a LogChannel for concurrent logging.