extensible-effects-concurrent 0.24.3 → 0.25.0

raw patch · 23 files changed

+453/−195 lines, 23 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• ChangeLog.md +3/−0
• README.md +6/−0
• examples/example-1/Main.hs +5/−5
• examples/example-2/Main.hs +5/−6
• examples/example-4/Main.hs +1/−1
• extensible-effects-concurrent.cabal +3/−1
• src/Control/Eff/Concurrent.hs +19/−14
• src/Control/Eff/Concurrent/Process.hs +16/−15
• src/Control/Eff/Concurrent/Process/ForkIOScheduler.hs +58/−50
• src/Control/Eff/Concurrent/Process/Interactive.hs +4/−4
• src/Control/Eff/Concurrent/Process/SingleThreadedScheduler.hs +93/−15
• src/Control/Eff/Concurrent/Protocol/EffectfulServer.hs +34/−34
• src/Control/Eff/Concurrent/Protocol/Observer/Queue.hs +2/−2
• src/Control/Eff/Concurrent/Protocol/StatefulServer.hs +12/−12
• src/Control/Eff/Concurrent/Protocol/Supervisor.hs +2/−2
• src/Control/Eff/Concurrent/Pure.hs +72/−0
• src/Control/Eff/Concurrent/SingleThreaded.hs +84/−0
• test/Common.hs +6/−6
• test/ForkIOScheduler.hs +6/−6
• test/Interactive.hs +3/−3
• test/ProcessBehaviourTestCases.hs +14/−14
• test/SingleThreadedScheduler.hs +2/−2
• test/SupervisorTests.hs +3/−3

@@ -1,5 +1,8 @@ # Changelog for extensible-effects-concurrent +## 0.25.0 +- Improve effect type aliases and module structure, [read the details here](./ChangeLog-Details-0.25.0.md).+         ## 0.24.3 - Add `EmbedProtocol` related function `toEmbeddedOrigin`     

@@ -37,6 +37,12 @@ - A *multi-threaded* scheduler, based on the `async` - A *pure* single-threaded scheduler, based on coroutines +For convenience, it is enough to import one of three modules:++- `Control.Eff.Concurrent` for a multi threaded scheduler and `LoggingAndIo`+- `Control.Eff.Concurrent.Pure`, for a single threaded scheduler and pure log capturing and otherwise no IO+- `Control.Eff.Concurrent.SingleThreaded`, for a single threaded scheduler and totally impure logging via IO+ ### Process Life-Cycles and Interprocess Links  All processes except the first process are **`spawned`** by existing 

@@ -6,7 +6,7 @@ import           Control.Monad import           Data.Dynamic import           Control.Eff.Concurrent-import           Control.Eff.Concurrent.Protocol.EffectfulServer+import           Control.Eff.Concurrent.Protocol.EffectfulServer as Server import qualified Control.Exception             as Exc import qualified Data.Text as T import           Control.DeepSeq@@ -41,10 +41,10 @@ main :: IO () main = defaultMain example -mainProcessSpawnsAChildAndReturns :: HasCallStack => Eff InterruptableProcEff ()+mainProcessSpawnsAChildAndReturns :: HasCallStack => Eff Effects () mainProcessSpawnsAChildAndReturns = void (spawn "some child" (void receiveAnyMessage)) -example:: HasCallStack => Eff InterruptableProcEff ()+example:: HasCallStack => Eff Effects () example = do   me <- self   logInfo (T.pack ("I am " ++ show me))@@ -73,10 +73,10 @@             go   go -testServerLoop :: Eff InterruptableProcEff (Endpoint TestProtocol)+testServerLoop :: Eff Effects (Endpoint TestProtocol) testServerLoop = start (genServer (const id) handleReq "test-server-1")  where-  handleReq :: GenServerId TestProtocol -> Event TestProtocol -> Eff InterruptableProcEff ()+  handleReq :: GenServerId TestProtocol -> Event TestProtocol -> Eff Effects ()   handleReq _myId (OnCall ser orig cm) =     case cm of       Terminate -> do

@@ -4,7 +4,7 @@  import           Data.Dynamic import           Control.Eff-import           Control.Eff.Concurrent+import           Control.Eff.Concurrent.SingleThreaded import           Control.Eff.Concurrent.Protocol.StatefulServer import           Control.Monad import           Data.Foldable@@ -33,8 +33,7 @@   rnf Cnt = ()  counterExample-  :: (Typeable q, LogsTo IO q, Lifted IO q)-  => Eff (InterruptableProcess q) ()+  :: Eff Effects () counterExample = do   c <- spawnCounter   let cp = _fromEndpoint c@@ -124,15 +123,15 @@      other -> logWarning (T.pack (show other)) -spawnCounter :: (LogsTo IO q, Lifted IO q) => Eff (InterruptableProcess q) ( Endpoint SupiCounter )+spawnCounter :: (LogIo q) => Eff (Processes q) ( Endpoint SupiCounter ) spawnCounter = start MkEmptySupiCounter   deriving instance Show (Pdu Counter x)  logCounterObservations-  :: (LogsTo IO q, Lifted IO q, Typeable q)-  => Eff (InterruptableProcess q) (Observer CounterChanged)+  :: (LogIo q, Typeable q)+  => Eff (Processes q) (Observer CounterChanged) logCounterObservations = do   svr <- start OCCStart   pure (toObserver svr)

@@ -14,7 +14,7 @@  newtype WhoAreYou = WhoAreYou ProcessId deriving (Typeable, NFData, Show) -firstExample :: (HasCallStack, Member Logs q) => Eff (InterruptableProcess q) ()+firstExample :: (HasCallStack, Member Logs q) => Eff (Processes q) () firstExample = do   person <- spawn "first-example"     (do

@@ -1,6 +1,6 @@ cabal-version:  2.0 name:           extensible-effects-concurrent-version:        0.24.3+version:        0.25.0 description:    Please see the README on GitHub at <https://github.com/sheyll/extensible-effects-concurrent#readme> synopsis:       Message passing concurrency as extensible-effect homepage:       https://github.com/sheyll/extensible-effects-concurrent#readme@@ -81,6 +81,8 @@                   Control.Eff.LogWriter.UDP,                   Control.Eff.LogWriter.UnixSocket,                   Control.Eff.Concurrent,+                  Control.Eff.Concurrent.Pure,+                  Control.Eff.Concurrent.SingleThreaded,                   Control.Eff.Concurrent.Protocol,                   Control.Eff.Concurrent.Protocol.Client,                   Control.Eff.Concurrent.Protocol.EffectfulServer,

@@ -1,5 +1,18 @@ -- | Erlang style processes with message passing concurrency based on -- (more) @extensible-effects@.+--+-- This module re-exports most of the library.+--+-- There are several /scheduler/ implementations to choose from.+--+-- This module re-exports "Control.Eff.Concurrent.Process.ForkIOScheduler".+--+-- To use another scheduler implementation, don't import this module, but instead+-- import one of:+--+-- * "Control.Eff.Concurrent.Pure"+-- * "Control.Eff.Concurrent.SingleThreaded"+-- module Control.Eff.Concurrent   (     -- * Concurrent Processes with Message Passing Concurrency@@ -9,9 +22,6 @@     -- ** Concurrent Scheduler     module Control.Eff.Concurrent.Process.ForkIOScheduler   ,-    -- ** Single Threaded Scheduler-    module Control.Eff.Concurrent.Process.SingleThreadedScheduler-  ,     -- * Timers and Timeouts     module Control.Eff.Concurrent.Process.Timer   ,@@ -69,7 +79,7 @@                                                 , Serializer(..)                                                 , ProcessId(..)                                                 , fromProcessId-                                                , ConsProcess+                                                , SafeProcesses                                                 , ResumeProcess(..)                                                 , ProcessState(..)                                                 , yieldProcess@@ -135,7 +145,7 @@                                                 , ExitRecovery(..)                                                 , RecoverableInterrupt                                                 , Interrupts-                                                , InterruptableProcess+                                                , Processes                                                 , ExitSeverity(..)                                                 , SomeExitReason(SomeExitReason)                                                 , toExitRecovery@@ -216,15 +226,10 @@                                                 ( schedule                                                 , defaultMain                                                 , defaultMainWithLogWriter-                                                , ProcEff-                                                , InterruptableProcEff-                                                , SchedulerIO-                                                , HasSchedulerIO-                                                )--import           Control.Eff.Concurrent.Process.SingleThreadedScheduler-                                                ( schedulePure-                                                , defaultMainSingleThreaded+                                                , SafeEffects+                                                , Effects+                                                , BaseEffects+                                                , HasBaseEffects                                                 ) import           Control.Eff.Log import           Control.Eff.LogWriter.Async

@@ -31,7 +31,7 @@     -- ** ProcessId Type   , ProcessId(..)   , fromProcessId-  , ConsProcess+  , SafeProcesses   , ResumeProcess(..)   -- ** Process State   , ProcessState(..)@@ -105,7 +105,7 @@   , ExitRecovery(..)   , RecoverableInterrupt   , Interrupts-  , InterruptableProcess+  , Processes   , ExitSeverity(..)   , SomeExitReason(SomeExitReason)   , toExitRecovery@@ -643,20 +643,21 @@ -- | 'Interrupt's which are 'Recoverable'. type RecoverableInterrupt = Interrupt 'Recoverable --- | /Cons/ 'Process' onto a list of effects.-type ConsProcess r = Process r ': r+-- | This adds a layer of the 'Interrupts' effect on top of 'Processes'+type Processes e = Interrupts ': SafeProcesses e +-- | /Cons/ 'Process' onto a list of effects. This is called @SafeProcesses@ because+-- the the actions cannot be interrupted in.+type SafeProcesses r = Process r ': r+ -- | 'Exc'eptions containing 'Interrupt's. -- See 'handleInterrupts', 'exitOnInterrupt' or 'provideInterrupts' type Interrupts = Exc (Interrupt 'Recoverable) --- | This adds a layer of the 'Interrupts' effect on top of 'Process'-type InterruptableProcess e = Interrupts ': Process e ': e---- | Handle all 'Interrupt's of an 'InterruptableProcess' by+-- | Handle all 'Interrupt's of an 'Processes' by -- wrapping them up in 'interruptToExit' and then do a process 'Shutdown'. provideInterruptsShutdown-  :: forall e a . Eff (InterruptableProcess e) a -> Eff (ConsProcess e) a+  :: forall e a . Eff (Processes e) a -> Eff (SafeProcesses e) a provideInterruptsShutdown e = do   res <- provideInterrupts e   case res of@@ -902,7 +903,7 @@   :: forall r q    . (HasCallStack, SetMember Process (Process q) r, Member Interrupts r)   => ProcessTitle-  -> Eff (InterruptableProcess q) ()+  -> Eff (Processes q) ()   -> Eff r ProcessId spawn t child =   executeAndResumeOrThrow (Spawn @q t (provideInterruptsShutdown child))@@ -912,7 +913,7 @@   :: forall r q    . (HasCallStack, SetMember Process (Process q) r, Member Interrupts r)   => ProcessTitle-  -> Eff (InterruptableProcess q) ()+  -> Eff (Processes q) ()   -> Eff r () spawn_ t child = void (spawn t child) @@ -923,20 +924,20 @@   :: forall r q    . (HasCallStack, SetMember Process (Process q) r, Member Interrupts r)   => ProcessTitle-  -> Eff (InterruptableProcess q) ()+  -> Eff (Processes q) ()   -> Eff r ProcessId spawnLink t child =   executeAndResumeOrThrow (SpawnLink @q t (provideInterruptsShutdown child))  -- | 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+-- /raw/ 'SafeProcesses' effects. For non-library code 'spawn' might be better -- suited. spawnRaw   :: forall r q    . (HasCallStack, SetMember Process (Process q) r, Member Interrupts r)   => ProcessTitle-  -> Eff (ConsProcess q) ()+  -> Eff (SafeProcesses q) ()   -> Eff r ProcessId spawnRaw t child = executeAndResumeOrThrow (Spawn @q t child) @@ -945,7 +946,7 @@   :: forall r q    . (HasCallStack, SetMember Process (Process q) r, Member Interrupts r)   => ProcessTitle-  -> Eff (ConsProcess q) ()+  -> Eff (SafeProcesses q) ()   -> Eff r () spawnRaw_ t = void . spawnRaw t 

@@ -14,10 +14,10 @@   ( schedule   , defaultMain   , defaultMainWithLogWriter-  , ProcEff-  , InterruptableProcEff-  , SchedulerIO-  , HasSchedulerIO+  , SafeEffects+  , Effects+  , BaseEffects+  , HasBaseEffects   ) where @@ -192,7 +192,7 @@ -- | Create a new 'SchedulerState' run an IO action, catching all exceptions, -- and when the actions returns, clean up and kill all processes. withNewSchedulerState-  :: (HasCallStack) => Eff SchedulerIO () -> Eff LoggingAndIo ()+  :: (HasCallStack) => Eff BaseEffects () -> Eff LoggingAndIo () withNewSchedulerState mainProcessAction = Safe.bracketWithError   (lift (atomically newSchedulerState))   (\exceptions schedulerState -> do@@ -213,7 +213,7 @@     return x   )  where-  tearDownScheduler :: Eff SchedulerIO ()+  tearDownScheduler :: Eff BaseEffects ()   tearDownScheduler = do     schedulerState <- getSchedulerState     let cancelTableVar = schedulerState ^. processCancellationTable@@ -243,28 +243,36 @@       )  -- | The concrete list of 'Eff'ects of processes compatible with this scheduler.--- This builds upon 'SchedulerIO'.-type ProcEff = ConsProcess SchedulerIO+-- This builds upon 'BaseEffects'.+--+-- @since 0.25.0+type SafeEffects = SafeProcesses BaseEffects --- | The concrete list of the effects, that the 'Process' uses-type InterruptableProcEff = InterruptableProcess SchedulerIO+-- | The 'Eff'ects for interruptable, concurrent processes, scheduled via 'forkIO'.+--+-- @since 0.25.0+type Effects = Processes BaseEffects  -- | Type class constraint to indicate that an effect union contains the -- effects required by every process and the scheduler implementation itself.-type HasSchedulerIO r = (HasCallStack, Lifted IO r, SchedulerIO <:: r)+--+-- @since 0.25.0+type HasBaseEffects r = (HasCallStack, Lifted IO r, BaseEffects <:: r)  -- | The concrete list of 'Eff'ects for this scheduler implementation.-type SchedulerIO = (Reader SchedulerState : LoggingAndIo)+--+-- @since 0.25.0+type BaseEffects = Reader SchedulerState : LoggingAndIo  -- | Start the message passing concurrency system then execute a 'Process' on--- top of 'SchedulerIO' effect. All logging is sent to standard output.-defaultMain :: HasCallStack => Eff InterruptableProcEff () -> IO ()+-- top of 'BaseEffects' effect. All logging is sent to standard output.+defaultMain :: HasCallStack => Eff Effects () -> IO () defaultMain = defaultMainWithLogWriter consoleLogWriter  -- | Start the message passing concurrency system then execute a 'Process' on--- top of 'SchedulerIO' effect. All logging is sent to standard output.+-- top of 'BaseEffects' effect. All logging is sent to standard output. defaultMainWithLogWriter-  :: HasCallStack => LogWriter IO -> Eff InterruptableProcEff () -> IO ()+  :: HasCallStack => LogWriter IO -> Eff Effects () -> IO () defaultMainWithLogWriter lw =   runLift . withLogging lw . withAsyncLogWriter (1024 :: Int) . schedule @@ -273,18 +281,18 @@ handleProcess   :: (HasCallStack)   => ProcessInfo-  -> Eff ProcEff (Interrupt 'NoRecovery)-  -> Eff SchedulerIO (Interrupt 'NoRecovery)+  -> Eff SafeEffects (Interrupt 'NoRecovery)+  -> Eff BaseEffects (Interrupt 'NoRecovery) handleProcess myProcessInfo actionToRun = fix   (handle_relay' singleStep (\er _nextRef -> return er))   actionToRun   0  where   singleStep-    :: (Eff ProcEff xx -> (Int -> Eff SchedulerIO (Interrupt 'NoRecovery)))-    -> Arrs ProcEff x xx-    -> Process SchedulerIO x-    -> (Int -> Eff SchedulerIO (Interrupt 'NoRecovery))+    :: (Eff SafeEffects xx -> (Int -> Eff BaseEffects (Interrupt 'NoRecovery)))+    -> Arrs SafeEffects x xx+    -> Process BaseEffects x+    -> (Int -> Eff BaseEffects (Interrupt 'NoRecovery))   singleStep k q p !nextRef = stepProcessInterpreter     nextRef     p@@ -303,8 +311,8 @@   kontinueWith     :: forall s v a      . HasCallStack-    => (s -> Arr SchedulerIO v a)-    -> (s -> Arr SchedulerIO v a)+    => (s -> Arr BaseEffects v a)+    -> (s -> Arr BaseEffects v a)   kontinueWith kontinue !nextRef !result = do     setMyProcessState ProcessIdle     lift yield@@ -312,8 +320,8 @@   diskontinueWith     :: forall a      . HasCallStack-    => Arr SchedulerIO (Interrupt 'NoRecovery) a-    -> Arr SchedulerIO (Interrupt 'NoRecovery) a+    => Arr BaseEffects (Interrupt 'NoRecovery) a+    -> Arr BaseEffects (Interrupt 'NoRecovery) a   diskontinueWith diskontinue !reason = do     setMyProcessState ProcessShuttingDown     diskontinue reason@@ -321,10 +329,10 @@     :: forall v a      . HasCallStack     => Int-    -> Process SchedulerIO v-    -> (Int -> Arr SchedulerIO v a)-    -> Arr SchedulerIO (Interrupt 'NoRecovery) a-    -> Eff SchedulerIO a+    -> Process BaseEffects v+    -> (Int -> Arr BaseEffects v a)+    -> Arr BaseEffects (Interrupt 'NoRecovery) a+    -> Eff BaseEffects a   stepProcessInterpreter !nextRef !request kontinue diskontinue =     tryTakeNextShutdownRequest >>= maybe       noShutdownRequested@@ -361,10 +369,10 @@   interpretRequestAfterShutdownRequest     :: forall v a      . HasCallStack-    => Arr SchedulerIO (Interrupt 'NoRecovery) a+    => Arr BaseEffects (Interrupt 'NoRecovery) a     -> Interrupt 'NoRecovery-    -> Process SchedulerIO v-    -> Eff SchedulerIO a+    -> Process BaseEffects v+    -> Eff BaseEffects a   interpretRequestAfterShutdownRequest diskontinue shutdownRequest = \case     SendMessage   _ _ -> diskontinue shutdownRequest     SendInterrupt _ _ -> diskontinue shutdownRequest@@ -387,11 +395,11 @@   interpretRequestAfterInterruptRequest     :: forall v a      . HasCallStack-    => Arr SchedulerIO v a-    -> Arr SchedulerIO (Interrupt 'NoRecovery) a+    => Arr BaseEffects v a+    -> Arr BaseEffects (Interrupt 'NoRecovery) a     -> Interrupt 'Recoverable-    -> Process SchedulerIO v-    -> Eff SchedulerIO a+    -> Process BaseEffects v+    -> Eff BaseEffects a   interpretRequestAfterInterruptRequest kontinue diskontinue interruptRequest =     \case       SendMessage   _     _ -> kontinue (Interrupted interruptRequest)@@ -416,11 +424,11 @@   interpretRequest     :: forall v a      . HasCallStack-    => (Int -> Arr SchedulerIO v a)-    -> Arr SchedulerIO (Interrupt 'NoRecovery) a+    => (Int -> Arr BaseEffects v a)+    -> Arr BaseEffects (Interrupt 'NoRecovery) a     -> Int-    -> Process SchedulerIO v-    -> Eff SchedulerIO a+    -> Process BaseEffects v+    -> Eff BaseEffects a   interpretRequest kontinue diskontinue nextRef = \case     SendMessage toPid msg ->       interpretSend toPid msg >>= kontinue nextRef . ResumeWith@@ -525,7 +533,7 @@         >>= lift         .   atomically         .   enqueueShutdownRequest toPid msg-    interpretFlush :: Eff SchedulerIO (ResumeProcess [StrictDynamic])+    interpretFlush :: Eff BaseEffects (ResumeProcess [StrictDynamic])     interpretFlush = do       setMyProcessState ProcessBusyReceiving       lift $ atomically $ do@@ -534,7 +542,7 @@         return (ResumeWith (toList (myMessageQ ^. incomingMessages)))     interpretReceive       :: MessageSelector b-      -> Eff SchedulerIO (Either (Interrupt 'NoRecovery) (ResumeProcess b))+      -> Eff BaseEffects (Either (Interrupt 'NoRecovery) (ResumeProcess b))     interpretReceive f = do       setMyProcessState ProcessBusyReceiving       lift $ atomically $ do@@ -561,9 +569,9 @@         (runMessageSelector f m)  -- | This is the main entry point to running a message passing concurrency--- application. This function takes a 'Process' on top of the 'SchedulerIO'+-- application. This function takes a 'Process' on top of the 'BaseEffects' -- effect for concurrent logging.-schedule :: (HasCallStack) => Eff InterruptableProcEff () -> Eff LoggingAndIo ()+schedule :: (HasCallStack) => Eff Effects () -> Eff LoggingAndIo () schedule procEff =   liftBaseWith       (\runS -> Async.withAsync@@ -585,8 +593,8 @@   :: (HasCallStack)   => Maybe ProcessInfo   -> ProcessTitle-  -> Eff ProcEff ()-  -> Eff SchedulerIO (ProcessId, Async (Interrupt 'NoRecovery))+  -> Eff SafeEffects ()+  -> Eff BaseEffects (ProcessId, Async (Interrupt 'NoRecovery)) spawnNewProcess mLinkedParent title mfa = do   schedulerState <- getSchedulerState   procInfo       <- allocateProcInfo schedulerState@@ -619,7 +627,7 @@           (maybe (Just (T.pack (printf "% 9s" (show pid)))) Just)     in  censorLogs @IO addProcessId   triggerProcessLinksAndMonitors-    :: ProcessId -> Interrupt e -> TVar (Set ProcessId) -> Eff SchedulerIO ()+    :: ProcessId -> Interrupt e -> TVar (Set ProcessId) -> Eff BaseEffects ()   triggerProcessLinksAndMonitors !pid !reason !linkSetVar = do     schedulerState <- getSchedulerState     lift $ atomically $ triggerAndRemoveMonitor pid@@ -670,7 +678,7 @@   doForkProc     :: ProcessInfo     -> SchedulerState-    -> Eff SchedulerIO (Async (Interrupt 'NoRecovery))+    -> Eff BaseEffects (Async (Interrupt 'NoRecovery))   doForkProc procInfo schedulerState = control     (\inScheduler -> do       let cancellationsVar = schedulerState ^. processCancellationTable@@ -723,7 +731,7 @@       return reason  -- * Scheduler Accessor-getSchedulerState :: HasSchedulerIO r => Eff r SchedulerState+getSchedulerState :: HasBaseEffects r => Eff r SchedulerState getSchedulerState = ask  enqueueMessageOtherProcess

@@ -50,14 +50,14 @@ newtype SchedulerSession r = SchedulerSession (TMVar (SchedulerQueue r))  newtype SchedulerQueue r =-  SchedulerQueue (TChan (Eff (InterruptableProcess r) (Maybe String)))+  SchedulerQueue (TChan (Eff (Processes r) (Maybe String)))  -- | Fork a scheduler with a process that communicates with it via 'MVar', -- which is also the reason for the @Lift IO@ constraint. forkInteractiveScheduler   :: forall r    . (SetMember Lift (Lift IO) r)-  => (Eff (InterruptableProcess r) () -> IO ())+  => (Eff (Processes r) () -> IO ())   -> IO (SchedulerSession r) forkInteractiveScheduler ioScheduler = do   inQueue  <- newTChanIO@@ -74,7 +74,7 @@   return (SchedulerSession queueVar)  where   readEvalPrintLoop-    :: TMVar (SchedulerQueue r) -> Eff (InterruptableProcess r) ()+    :: TMVar (SchedulerQueue r) -> Eff (Processes r) ()   readEvalPrintLoop queueVar = do     nextActionOrExit <- readAction     case nextActionOrExit of@@ -107,7 +107,7 @@   :: forall r a    . (SetMember Lift (Lift IO) r)   => SchedulerSession r-  -> Eff (InterruptableProcess r) a+  -> Eff (Processes r) a   -> IO a submit (SchedulerSession qVar) theAction = do   mResVar <- timeout 5000000 $ atomically

@@ -1,11 +1,20 @@ -- | A coroutine based, single threaded scheduler for 'Process'es. module Control.Eff.Concurrent.Process.SingleThreadedScheduler   ( scheduleM-  , schedulePure-  , scheduleIO   , scheduleMonadIOEff   , scheduleIOWithLogging-  , defaultMainSingleThreaded+  , schedulePure+  , PureEffects+  , PureSafeEffects+  , PureBaseEffects+  , HasPureBaseEffects+  , defaultMain+  , defaultMainWithLogWriter+  , scheduleIO+  , EffectsIo+  , SafeEffectsIo+  , BaseEffectsIo+  , HasBaseEffectsIo   ) where @@ -209,7 +218,7 @@ -- -- @since 0.3.0.2 schedulePure-  :: Eff (InterruptableProcess '[Logs, LogWriterReader PureLogWriter]) a+  :: Eff (Processes '[Logs, LogWriterReader PureLogWriter]) a   -> Either (Interrupt 'NoRecovery) a schedulePure e = run (scheduleM (withSomeLogging @PureLogWriter) (return ()) e) @@ -220,7 +229,7 @@ scheduleIO   :: MonadIO m   => (forall b . Eff r b -> Eff '[Lift m] b)-  -> Eff (InterruptableProcess r) a+  -> Eff (Processes r) a   -> m (Either (Interrupt 'NoRecovery) a) scheduleIO r = scheduleM (runLift . r) (liftIO yield) @@ -230,7 +239,7 @@ -- @since 0.3.0.2 scheduleMonadIOEff   :: MonadIO (Eff r)-  => Eff (InterruptableProcess r) a+  => Eff (Processes r) a   -> Eff r (Either (Interrupt 'NoRecovery) a) scheduleMonadIOEff = -- schedule (lift yield)   scheduleM id (liftIO yield)@@ -246,7 +255,7 @@ scheduleIOWithLogging   :: HasCallStack   => LogWriter IO-  -> Eff (InterruptableProcess LoggingAndIo) a+  -> Eff EffectsIo a   -> IO (Either (Interrupt 'NoRecovery) a) scheduleIOWithLogging h = scheduleIO (withLogging h) @@ -273,7 +282,7 @@   -> m () -- ^ An that performs a __yield__ w.r.t. the underlying effect   --  @r@. E.g. if @Lift IO@ is present, this might be:   --  @lift 'Control.Concurrent.yield'.-  -> Eff (InterruptableProcess r) a+  -> Eff (Processes r) a   -> m (Either (Interrupt 'NoRecovery) a) scheduleM r y e = do   c <- runAsCoroutinePure r (provideInterruptsShutdown e)@@ -359,12 +368,12 @@   :: forall v r m    . Monad m   => (forall a . Eff r a -> m a)-  -> Eff (ConsProcess r) v+  -> Eff (SafeProcesses r) v   -> m (OnYield r v) runAsCoroutinePure r = r . fix (handle_relay' cont (return . OnDone))  where-  cont :: (Eff (ConsProcess r) v -> Eff r (OnYield r v))-       -> Arrs (ConsProcess r) x v+  cont :: (Eff (SafeProcesses r) v -> Eff r (OnYield r v))+       -> Arrs (SafeProcesses r) x v        -> Process r x        -> Eff r (OnYield r v)   cont k q FlushMessages                = return (OnFlushMessages (k . qApp q))@@ -566,11 +575,80 @@       nextTargets <- _runEff sts $ traverse deliverTheGoodNews targets       return (nextTargets Seq.>< allButTarget) --- | Execute a 'Process' using 'scheduleM' on top of 'Lift' @IO@ and 'withLogging'--- @String@ effects.-defaultMainSingleThreaded :: HasCallStack => Eff (InterruptableProcess LoggingAndIo) () -> IO ()-defaultMainSingleThreaded =+-- | Execute a 'Process' using 'scheduleM' on top of 'Lift' @IO@.+-- All logging is written to the console using 'consoleLogWriter'.+--+-- To use another 'LogWriter' use 'defaultMainWithLogWriter' instead.+defaultMain :: HasCallStack => Eff EffectsIo () -> IO ()+defaultMain =   void     . runLift     . withLogging consoleLogWriter     . scheduleMonadIOEff++-- | Execute a 'Process' using 'scheduleM' on top of 'Lift' @IO@.+-- All logging is written using the given 'LogWriter'.+--+-- @since 0.25.0+defaultMainWithLogWriter :: HasCallStack => LogWriter IO -> Eff EffectsIo () -> IO ()+defaultMainWithLogWriter lw =+  void+    . runLift+    . withLogging lw+    . scheduleMonadIOEff+++-- | The effect list for 'Process' effects in the single threaded pure scheduler.+--+-- See 'PureBaseEffects' and 'Processes'+--+-- @since 0.25.0+type PureEffects = Processes PureBaseEffects++-- | The effect list for 'Process' effects in the single threaded pure scheduler.+--  This is like 'SafeProcesses', no 'Interrupts' are present.+--+-- See 'PureBaseEffects' and 'SafeProcesses'+--+-- @since 0.25.0+type PureSafeEffects = SafeProcesses PureBaseEffects++-- | The effect list for a pure, single threaded scheduler contains only+-- 'Logs' and the 'LogWriterReader' for 'PureLogWriter'.+--+-- @since 0.25.0+type PureBaseEffects = '[Logs, LogWriterReader PureLogWriter]++-- | Constraint for the existence of the underlying scheduler effects.+--+-- See 'PureBaseEffects'+--+-- @since 0.25.0+type HasPureBaseEffects e = (HasCallStack, PureBaseEffects <:: e)++-- | The effect list for 'Process' effects in the single threaded scheduler.+--+-- See 'BaseEffectsIo'+--+-- @since 0.25.0+type EffectsIo = Processes BaseEffectsIo++-- | The effect list for 'Process' effects in the single threaded scheduler.+--  This is like 'SafeProcesses', no 'Interrupts' are present.+--+-- See 'BaseEffectsIo'.+--+-- @since 0.25.0+type SafeEffectsIo = SafeProcesses BaseEffectsIo++-- | The effect list for the underlying scheduler.+--+-- See 'LoggingAndIo'+--+-- @since 0.25.0+type BaseEffectsIo = LoggingAndIo++-- | Constraint for the existence of the underlying scheduler effects.+--+-- @since 0.25.0+type HasBaseEffectsIo e = (HasCallStack, Lifted IO e, LoggingAndIo <:: e)

@@ -65,8 +65,8 @@   -- | Effects of the implementation   --   -- @since 0.24.1-  type Effects a e :: [Type -> Type]-  type Effects a e = e+  type ServerEffects a e :: [Type -> Type]+  type ServerEffects a e = e    -- | Return the 'ProcessTitle'.   --@@ -77,15 +77,15 @@   serverTitle _ = fromString $ prettyTypeableShows (typeRep (Proxy @(ServerPdu a))) "-server"    -- | Process the effects of the implementation-  runEffects :: Init a e -> Eff (Effects a e) x -> Eff e x+  runEffects :: Init a e -> Eff (ServerEffects a e) x -> Eff e x -  default runEffects :: Effects a e ~ e => Init a e -> Eff (Effects a e) x -> Eff e x+  default runEffects :: ServerEffects a e ~ e => Init a e -> Eff (ServerEffects a e) x -> Eff e x   runEffects = const id    -- | Update the 'Model' based on the 'Event'.-  onEvent :: Init a e -> Event (ServerPdu a) -> Eff (Effects a e) ()+  onEvent :: Init a e -> Event (ServerPdu a) -> Eff (ServerEffects a e) () -  default onEvent :: (Show (Init a e),  Member Logs (Effects a e)) => Init a e -> Event (ServerPdu a) -> Eff (Effects a e) ()+  default onEvent :: (Show (Init a e),  Member Logs (ServerEffects a e)) => Init a e -> Event (ServerPdu a) -> Eff (ServerEffects a e) ()   onEvent i e = logInfo ("unhandled: " <> T.pack (show i) <> " " <> T.pack (show e))  @@ -94,15 +94,15 @@ -- @since 0.24.0 start   :: forall a q h-  . ( Server a (InterruptableProcess q)+  . ( Server a (Processes q)     , Typeable a     , Typeable (ServerPdu a)-    , LogsTo h (InterruptableProcess q)-    , SetMember Process (Process q) (Effects a (InterruptableProcess q))-    , Member Interrupts             (Effects a (InterruptableProcess q))+    , LogsTo h (Processes q)+    , SetMember Process (Process q) (ServerEffects a (Processes q))+    , Member Interrupts             (ServerEffects a (Processes q))     , HasCallStack)-  => Init a (InterruptableProcess q)-  -> Eff (InterruptableProcess q) (Endpoint (ServerPdu a))+  => Init a (Processes q)+  -> Eff (Processes q) (Endpoint (ServerPdu a)) start a = asEndpoint <$> spawn (serverTitle a) (protocolServerLoop a)  -- | Execute the server loop.@@ -112,13 +112,13 @@   :: forall a q h   . ( Typeable a     , Typeable (ServerPdu a)-    , Server a (InterruptableProcess q)-    , LogsTo h (InterruptableProcess q)-    , SetMember Process (Process q) (Effects a (InterruptableProcess q))-    , Member Interrupts (Effects a (InterruptableProcess q))+    , Server a (Processes q)+    , LogsTo h (Processes q)+    , SetMember Process (Process q) (ServerEffects a (Processes q))+    , Member Interrupts (ServerEffects a (Processes q))     , HasCallStack)-  => Init a (InterruptableProcess q)-  -> Eff (InterruptableProcess q) (Endpoint (ServerPdu a))+  => Init a (Processes q)+  -> Eff (Processes q) (Endpoint (ServerPdu a)) startLink a = asEndpoint <$> spawnLink (serverTitle a) (protocolServerLoop a)  -- | Execute the server loop.@@ -126,14 +126,14 @@ -- @since 0.24.0 protocolServerLoop      :: forall q h a-     . ( Server a (InterruptableProcess q)-       , LogsTo h (InterruptableProcess q)-       , SetMember Process (Process q) (Effects a (InterruptableProcess q))-       , Member Interrupts (Effects a (InterruptableProcess q))+     . ( Server a (Processes q)+       , LogsTo h (Processes q)+       , SetMember Process (Process q) (ServerEffects a (Processes q))+       , Member Interrupts (ServerEffects a (Processes q))        , Typeable a        , Typeable (ServerPdu a)        )-  => Init a (InterruptableProcess q) -> Eff (InterruptableProcess q) ()+  => Init a (Processes q) -> Eff (Processes q) () protocolServerLoop a = do   myEp <- T.pack . show . asEndpoint @(ServerPdu a) <$> self   censorLogs (lmAddEp myEp) $ do@@ -154,7 +154,7 @@     handleInt i = onEvent a (OnInterrupt i) *> pure Nothing     mainLoop :: (Typeable a)       => Either (Interrupt 'Recoverable) (Event (ServerPdu a))-      -> Eff (Effects a (InterruptableProcess q)) (Maybe ())+      -> Eff (ServerEffects a (Processes q)) (Maybe ())     mainLoop (Left i) = handleInt i     mainLoop (Right i) = onEvent a i *> pure Nothing @@ -213,7 +213,7 @@ -- This is such a helper. The @GenServer@ is a record with to callbacks, -- and a 'Server' instance that simply invokes the given callbacks. ----- 'Server's that are directly based on 'LogIo' and 'InterruptableProcess' effects.+-- 'Server's that are directly based on 'LogIo' and 'Processes' effects. -- -- The name prefix @Gen@ indicates the inspiration from Erlang's @gen_server@ module. --@@ -221,7 +221,7 @@ data GenServer tag eLoop e where   MkGenServer     :: (TangibleGenServer tag eLoop e, HasCallStack) =>-    { genServerRunEffects :: forall x . (Eff eLoop x -> Eff (InterruptableProcess e) x)+    { genServerRunEffects :: forall x . (Eff eLoop x -> Eff (Processes e) x)     , genServerOnEvent :: Event tag -> Eff eLoop ()     } -> GenServer tag eLoop e   deriving Typeable@@ -254,10 +254,10 @@       . prettyTypeableShows (typeOf px)       ) -instance (TangibleGenServer tag eLoop e) => Server (GenServer (tag :: Type) eLoop e) (InterruptableProcess e) where+instance (TangibleGenServer tag eLoop e) => Server (GenServer (tag :: Type) eLoop e) (Processes e) where   type ServerPdu (GenServer tag eLoop e) = tag-  type Effects (GenServer tag eLoop e) (InterruptableProcess e) = eLoop-  data instance Init (GenServer tag eLoop e) (InterruptableProcess e) =+  type ServerEffects (GenServer tag eLoop e) (Processes e) = eLoop+  data instance Init (GenServer tag eLoop e) (Processes e) =         GenServerInit          { genServerCallbacks :: GenServer tag eLoop e          , genServerId :: GenServerId tag@@ -268,10 +268,10 @@       (genServerRunEffects cb m)   onEvent (GenServerInit cb _cId) req = genServerOnEvent cb req -instance NFData (Init (GenServer tag eLoop e) (InterruptableProcess e)) where+instance NFData (Init (GenServer tag eLoop e) (Processes e)) where   rnf (GenServerInit _ x) = rnf x -instance Typeable tag => Show (Init (GenServer tag eLoop e) (InterruptableProcess e)) where+instance Typeable tag => Show (Init (GenServer tag eLoop e) (Processes e)) where   showsPrec d (GenServerInit _ x) =     showParen (d>=10)       ( showsPrec 11 x@@ -294,12 +294,12 @@   :: forall tag eLoop e .      ( HasCallStack      , TangibleGenServer tag eLoop e-     , Server (GenServer tag eLoop e) (InterruptableProcess e)+     , Server (GenServer tag eLoop e) (Processes e)      )-  => (forall x . GenServerId tag -> Eff eLoop x -> Eff (InterruptableProcess e) x)+  => (forall x . GenServerId tag -> Eff eLoop x -> Eff (Processes e) x)   -> (GenServerId tag -> Event tag -> Eff eLoop ())   -> GenServerId tag-  -> Init (GenServer tag eLoop e) (InterruptableProcess e)+  -> Init (GenServer tag eLoop e) (Processes e) genServer initCb stepCb i =   GenServerInit     { genServerId = i

@@ -140,10 +140,10 @@      , TangiblePdu (Observer o) 'Asynchronous      , Member Logs q      , Lifted IO q-     , LogsTo h (InterruptableProcess q)+     , LogsTo h (Processes q)      , HasCallStack)   => ObservationQueue o-  -> Eff (InterruptableProcess q) (Observer o)+  -> Eff (Processes q) (Observer o) spawnLinkObservationQueueWriter q = do   cbo <- startLink (MkObservationQueue q)   pure (toObserver cbo)

@@ -81,19 +81,19 @@   -- | Return an initial 'Model' and 'Settings'   setup ::        StartArgument a q-    -> Eff (InterruptableProcess q) (Model a, Settings a)+    -> Eff (Processes q) (Model a, Settings a)    default setup ::        (Default (Model a), Default (Settings a))     => StartArgument a q-    -> Eff (InterruptableProcess q) (Model a, Settings a)+    -> Eff (Processes q) (Model a, Settings a)   setup _ = pure (def, def)    -- | Update the 'Model' based on the 'Event'.   update ::        StartArgument a q     -> Effectful.Event (Protocol a)-    -> Eff (ModelState a ': SettingsReader a ': InterruptableProcess q) ()+    -> Eff (ModelState a ': SettingsReader a ': Processes q) ()  -- | This type is used to build stateful 'EffectfulServer' instances. --@@ -102,10 +102,10 @@ -- @since 0.24.0 data Stateful a deriving Typeable -instance Server a q => Effectful.Server (Stateful a) (InterruptableProcess q) where-  data Init (Stateful a) (InterruptableProcess q) = Init (StartArgument a q)+instance Server a q => Effectful.Server (Stateful a) (Processes q) where+  data Init (Stateful a) (Processes q) = Init (StartArgument a q)   type ServerPdu (Stateful a) = Protocol a-  type Effects (Stateful a) (InterruptableProcess q) = ModelState a ': SettingsReader a ': InterruptableProcess q+  type ServerEffects (Stateful a) (Processes q) = ModelState a ': SettingsReader a ': Processes q    runEffects (Init sa) m = do     (st, env) <- setup sa@@ -121,11 +121,11 @@   :: forall a q h   . ( HasCallStack     , Typeable a-    , LogsTo h (InterruptableProcess q)-    , Effectful.Server (Stateful a) (InterruptableProcess q)+    , LogsTo h (Processes q)+    , Effectful.Server (Stateful a) (Processes q)     , Server a q     )-  => StartArgument a q -> Eff (InterruptableProcess q) (Endpoint (Protocol a))+  => StartArgument a q -> Eff (Processes q) (Endpoint (Protocol a)) start = Effectful.start . Init  -- | Execute the server loop.@@ -135,11 +135,11 @@   :: forall a q h   . ( HasCallStack     , Typeable a-    , LogsTo h (InterruptableProcess q)-    , Effectful.Server (Stateful a) (InterruptableProcess q)+    , LogsTo h (Processes q)+    , Effectful.Server (Stateful a) (Processes q)     , Server a q     )-  => StartArgument a q -> Eff (InterruptableProcess q) (Endpoint (Protocol a))+  => StartArgument a q -> Eff (Processes q) (Endpoint (Protocol a)) startLink = Effectful.startLink . Init  

@@ -252,13 +252,13 @@ startSupervisor   :: forall p e   . ( HasCallStack-    , LogsTo IO (InterruptableProcess e)+    , LogsTo IO (Processes e)     , Lifted IO e     , TangibleSup p     , Server (Sup p) e     )   => StartArgument (Sup p) e-  -> Eff (InterruptableProcess e) (Endpoint (Sup p))+  -> Eff (Processes e) (Endpoint (Sup p)) startSupervisor = Server.start  -- | Stop the supervisor and shutdown all processes.

@@ -0,0 +1,72 @@+-- | Concurrent, communicating processes, executed using a pure, single-threaded scheduler.+--+-- This module re-exports most of the library.+--+-- There are several /scheduler/ implementations to choose from.+--+-- This module re-exports the pure parts of "Control.Eff.Concurrent.Process.SingleThreadedScheduler".+--+-- To use another scheduler implementation, don't import this module, but instead+-- import one of:+--+-- * "Control.Eff.Concurrent"+-- * "Control.Eff.Concurrent.SingleThreaded"+--+-- @since 0.25.0+module Control.Eff.Concurrent.Pure+  ( -- * Generic functions and type for Processes and Messages+    module Control.Eff.Concurrent+    -- * Scheduler+  , schedule+  , Effects+  , SafeEffects+  , BaseEffects+  , HasBaseEffects+  -- * External Libraries+  ) where++import Control.Eff+import Control.Eff.Concurrent                  hiding+                                                ( schedule+                                                , defaultMain+                                                , defaultMainWithLogWriter+                                                , Effects+                                                , SafeEffects+                                                , BaseEffects+                                                , HasBaseEffects+                                                )++import Control.Eff.Concurrent.Process.SingleThreadedScheduler++-- | Run the 'Effects' using a single threaded, coroutine based, pure scheduler+-- from "Control.Eff.Concurrent.Process.SingleThreadedScheduler".+--+-- @since 0.25.0+schedule :: Eff Effects a -> Either (Interrupt 'NoRecovery) a+schedule = schedulePure++-- | The effect list for 'Process' effects in the single threaded pure scheduler.+--+-- See 'PureEffects'+--+-- @since 0.25.0+type Effects = PureEffects++-- | The effect list for 'Process' effects in the single threaded pure scheduler.+--  This is like 'SafeProcesses', no 'Interrupts' are present.+--+-- See 'PureSafeEffects'+--+-- @since 0.25.0+type SafeEffects = PureSafeEffects++-- | The effect list for the underlying scheduler.+--+-- @since 0.25.0+type BaseEffects = PureBaseEffects++-- | Constraint for the existence of the underlying scheduler effects.+--+-- @since 0.25.0+type HasBaseEffects e = HasPureBaseEffects e+

@@ -0,0 +1,84 @@+-- | Concurrent, communicating processes, executed using a single-threaded+-- scheduler, with support for 'IO' and 'Logs'.+--+-- This module re-exports most of the library.+--+-- There are several /scheduler/ implementations to choose from.+--+-- This module re-exports the impure parts of "Control.Eff.Concurrent.Process.SingleThreadedScheduler".+--+-- To use another scheduler implementation, don't import this module, but instead+-- import one of:+--+-- * "Control.Eff.Concurrent"+-- * "Control.Eff.Concurrent.Pure"+--+-- @since 0.25.0+module Control.Eff.Concurrent.SingleThreaded+  ( -- * Generic functions and type for Processes and Messages+    module Control.Eff.Concurrent+    -- * Scheduler+  , schedule+  , defaultMain+  , defaultMainWithLogWriter+  , Effects+  , SafeEffects+  , BaseEffects+  , HasBaseEffects+  -- * External Libraries+  ) where++import Control.Eff+import Control.Eff.Concurrent                  hiding+                                                ( schedule+                                                , defaultMain+                                                , defaultMainWithLogWriter+                                                , Effects+                                                , SafeEffects+                                                , BaseEffects+                                                , HasBaseEffects+                                                )++import Control.Eff.Concurrent.Process.SingleThreadedScheduler+import GHC.Stack (HasCallStack)++-- | Run the 'Effects' using a single threaded, coroutine based, scheduler+-- from "Control.Eff.Concurrent.Process.SingleThreadedScheduler".+--+-- @since 0.25.0+schedule+  :: HasCallStack+  => LogWriter IO+  -> Eff Effects a+  -> IO (Either (Interrupt 'NoRecovery) a)+schedule = scheduleIOWithLogging++-- | The effect list for 'Process' effects in the single threaded scheduler.+--+-- See 'EffectsIo'+--+-- @since 0.25.0+type Effects = EffectsIo++-- | The effect list for 'Process' effects in the single threaded scheduler.+--  This is like 'SafeProcesses', no 'Interrupts' are present.+--+-- See 'SafeEffectsIo'+--+-- @since 0.25.0+type SafeEffects = SafeEffectsIo++-- | The effect list for the underlying scheduler.+--+-- See 'BaseEffectsIo'+--+-- @since 0.25.0+type BaseEffects = BaseEffectsIo++-- | Constraint for the existence of the underlying scheduler effects.+--+-- See 'HasBaseEffectsIo'+--+-- @since 0.25.0+type HasBaseEffects e = HasBaseEffectsIo e+

@@ -18,7 +18,7 @@ timeoutSeconds :: Integer -> Timeout timeoutSeconds seconds = Timeout (seconds * 1000000) (show seconds ++ "s") -runTestCase :: TestName -> Eff InterruptableProcEff () -> TestTree+runTestCase :: TestName -> Eff Effects () -> TestTree runTestCase msg =   testCase msg .   runLift . withTraceLogging "unit-tests" local0 allLogMessages . Scheduler.schedule . handleInterrupts onInt@@ -36,9 +36,9 @@     _ -> untilInterrupted pa  scheduleAndAssert ::-     forall r. (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())-  -> ((String -> Bool -> Eff (InterruptableProcess r) ()) -> Eff (InterruptableProcess r) ())+     forall r. (LogIo r)+  => IO (Eff (Processes r) () -> IO ())+  -> ((String -> Bool -> Eff (Processes r) ()) -> Eff (Processes r) ())   -> IO () scheduleAndAssert schedulerFactory testCaseAction =   withFrozenCallStack $ do@@ -52,8 +52,8 @@  applySchedulerFactory ::      forall r. (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())-  -> Eff (InterruptableProcess r) ()+  => IO (Eff (Processes r) () -> IO ())+  -> Eff (Processes r) ()   -> IO () applySchedulerFactory factory procAction = do   scheduler <- factory

@@ -53,21 +53,21 @@           assertBool "the other process was still running" wasStillRunningP1   | (busyWith , busyEffect) <-     [ ( "receiving"-      , void (send (ReceiveSelectedMessage @SchedulerIO selectAnyMessage))+      , void (send (ReceiveSelectedMessage @BaseEffects selectAnyMessage))       )     , ( "sending"-      , void (send (SendMessage @SchedulerIO 44444 (toStrictDynamic ("test message" :: String))))+      , void (send (SendMessage @BaseEffects 44444 (toStrictDynamic ("test message" :: String))))       )     , ( "sending shutdown"-      , void (send (SendShutdown @SchedulerIO 44444 ExitNormally))+      , void (send (SendShutdown @BaseEffects 44444 ExitNormally))       )-    , ("selfpid-ing", void (send (SelfPid @SchedulerIO)))+    , ("selfpid-ing", void (send (SelfPid @BaseEffects)))     , ( "spawn-ing"       , void         (send-          (Spawn @SchedulerIO  "test"+          (Spawn @BaseEffects  "test"             (void-              (send (ReceiveSelectedMessage @SchedulerIO selectAnyMessage))+              (send (ReceiveSelectedMessage @BaseEffects selectAnyMessage))             )           )         )

@@ -15,19 +15,19 @@ test_interactive :: TestTree test_interactive = setTravisTestOptions $ testGroup   "Interactive"-  [ testGroup "SingleThreadedScheduler" $ allTests SingleThreaded.defaultMainSingleThreaded+  [ testGroup "SingleThreadedScheduler" $ allTests SingleThreaded.defaultMain   , testGroup "ForkIOScheduler" $ allTests ForkIOScheduler.defaultMain   ]  allTests   :: SetMember Lift (Lift IO) r-  => (Eff (InterruptableProcess r) () -> IO ())+  => (Eff (Processes r) () -> IO ())   -> [TestTree] allTests scheduler = [happyCaseTest scheduler]  happyCaseTest   :: SetMember Lift (Lift IO) r-  => (Eff (InterruptableProcess r) () -> IO ())+  => (Eff (Processes r) () -> IO ())   -> TestTree happyCaseTest scheduler =   testCase "start, wait and stop interactive scheduler" $ do

@@ -65,7 +65,7 @@ allTests   :: forall r    . (Lifted IO r, LogsTo IO r, Typeable r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree allTests schedulerFactory = localOption   (timeoutSeconds 300)@@ -124,7 +124,7 @@ returnToSenderServer   :: forall q    . (HasCallStack, Lifted IO q, LogsTo IO q, Member Logs q, Typeable q)-  => Eff (InterruptableProcess q) (Endpoint ReturnToSender)+  => Eff (Processes q) (Endpoint ReturnToSender) returnToSenderServer = start   (genServer @ReturnToSender     (const id)@@ -148,7 +148,7 @@ selectiveReceiveTests   :: forall r    . (Lifted IO r, LogsTo IO r, Typeable r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree selectiveReceiveTests schedulerFactory = setTravisTestOptions   (testGroup@@ -160,7 +160,7 @@           nMax = 10           receiverLoop donePid = go nMax            where-            go :: Int -> Eff (InterruptableProcess r) ()+            go :: Int -> Eff (Processes r) ()             go 0 = sendMessage donePid True             go n = do               void $ receiveSelectedMessage (filterMessage (== n))@@ -201,7 +201,7 @@ yieldLoopTests   :: forall r    . (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree yieldLoopTests schedulerFactory =   let maxN = 100000@@ -243,7 +243,7 @@ pingPongTests   :: forall r    . (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree pingPongTests schedulerFactory = testGroup   "Yield Tests"@@ -318,7 +318,7 @@ errorTests   :: forall r    . (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree errorTests schedulerFactory = testGroup   "causing and handling errors"@@ -363,7 +363,7 @@ concurrencyTests   :: forall r    . (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree concurrencyTests schedulerFactory =   let n = 100@@ -474,7 +474,7 @@ exitTests   :: forall r    . (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree exitTests schedulerFactory =   testGroup "process exit tests"@@ -624,7 +624,7 @@ sendShutdownTests   :: forall r    . (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree sendShutdownTests schedulerFactory = testGroup   "sendShutdown"@@ -717,7 +717,7 @@ linkingTests   :: forall r    . (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree linkingTests schedulerFactory = setTravisTestOptions   (testGroup@@ -931,7 +931,7 @@ monitoringTests   :: forall r    . (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree monitoringTests schedulerFactory = setTravisTestOptions   (testGroup@@ -1001,7 +1001,7 @@ timerTests   :: forall r    . (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree timerTests schedulerFactory = setTravisTestOptions   (testGroup@@ -1057,7 +1057,7 @@  processDetailsTests ::      forall r. (Lifted IO r, LogsTo IO r)-  => IO (Eff (InterruptableProcess r) () -> IO ())+  => IO (Eff (Processes r) () -> IO ())   -> TestTree processDetailsTests schedulerFactory =   setTravisTestOptions

@@ -38,7 +38,7 @@ test_mainProcessSpawnsAChildAndExitsNormally = setTravisTestOptions     (testCase         "spawn a child and exit normally"-        (Scheduler.defaultMainSingleThreaded+        (Scheduler.defaultMain             (do                 void (spawn "test" (void receiveAnyMessage))                 void exitNormally@@ -52,7 +52,7 @@ test_mainProcessSpawnsAChildBothExitNormally = setTravisTestOptions     (testCase         "spawn a child and let it exit and exit"-        (Scheduler.defaultMainSingleThreaded+        (Scheduler.defaultMain             (do                 child <- spawn "test"                     (do

@@ -37,7 +37,7 @@                  () <- receiveMessage                  Sup.stopSupervisor sup              unlinkProcess testWorker-             sup <- receiveMessage :: Eff InterruptableProcEff  (Endpoint (Sup.Sup TestProtocol))+             sup <- receiveMessage :: Eff Effects  (Endpoint (Sup.Sup TestProtocol))              supAliveAfter1 <- isSupervisorAlive sup              logInfo ("still alive 1: " <> pack (show supAliveAfter1))              lift (supAliveAfter1 @=? True)@@ -264,7 +264,7 @@   | ExitWhenRequested   deriving Eq -instance Server TestProtocol SchedulerIO where+instance Server TestProtocol BaseEffects where   update (TestServerArgs testMode tId) evt =     case evt of       OnCast (TestInterruptWith i) -> do@@ -283,6 +283,6 @@             exitBecause (interruptToExit x)       _ ->         logDebug (pack (show tId) <> ": got some info: " <> pack (show evt))-  data instance StartArgument TestProtocol SchedulerIO = TestServerArgs TestProtocolServerMode Int+  data instance StartArgument TestProtocol BaseEffects = TestServerArgs TestProtocolServerMode Int  type instance ChildId TestProtocol = Int