-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Message passing concurrency as extensible-effect
--   
--   Please see the README on GitHub at
--   <a>https://github.com/sheyll/extensible-effects-concurrent#readme</a>
@package extensible-effects-concurrent
@version 0.6.0


-- | The message passing effect.
--   
--   This module describes an abstract message passing effect, and a
--   process effect, mimicking Erlang's process and message semantics.
--   
--   Two <b>scheduler</b> implementations for the <a>Process</a> effect are
--   provided:
--   
--   <ul>
--   <li>A scheduler using <tt>forkIO</tt>, i.e. relying on the multi
--   threaded GHC runtime:
--   <a>Control.Eff.Concurrent.Process.ForkIOScheduler</a></li>
--   <li>And a <i>pure</i>(rer) coroutine based scheduler in:
--   <a>Control.Eff.Concurrent.Process.SingleThreadedScheduler</a></li>
--   </ul>
module Control.Eff.Concurrent.Process

-- | Each process is identified by a single process id, that stays constant
--   throughout the life cycle of a process. Also, message sending relies
--   on these values to address messages to processes.
newtype ProcessId
ProcessId :: Int -> ProcessId
[_fromProcessId] :: ProcessId -> Int
fromProcessId :: Iso' ProcessId Int

-- | The process effect is the basis for message passing concurrency. This
--   effect describes an interface for concurrent, communicating isolated
--   processes identified uniquely by a process-id.
--   
--   Processes can raise exceptions that can be caught, exit gracefully or
--   with an error, or be killed by other processes, with the option of
--   ignoring the shutdown request.
--   
--   Process Scheduling is implemented in different modules. All scheduler
--   implementations should follow some basic rules:
--   
--   <ul>
--   <li>fair scheduling</li>
--   <li>sending a message does not block</li>
--   <li>receiving a message does block</li>
--   <li>spawning a child blocks only a very moment</li>
--   <li>a newly spawned process shall be scheduled before the parent
--   process after</li>
--   <li>the spawn</li>
--   <li>when the first process exists, all process should be killed
--   immediately</li>
--   </ul>
data Process (r :: [Type -> Type]) b

-- | In cooperative schedulers, this will give processing time to the
--   scheduler. Every other operation implicitly serves the same purpose.
[YieldProcess] :: Process r (ResumeProcess ())

-- | Return the current <a>ProcessId</a>
[SelfPid] :: Process r (ResumeProcess ProcessId)

-- | Start a new process, the new process will execute an effect, the
--   function will return immediately with a <a>ProcessId</a>.
[Spawn] :: Eff (Process r : r) () -> Process r (ResumeProcess ProcessId)

-- | Process exit, this is the same as if the function that was applied to
--   a spawn function returned.
[Shutdown] :: Process r a

-- | Exit the process due to an error, this cannot be caught.
[ExitWithError] :: String -> Process r b

-- | Raise an error, that can be handled.
[RaiseError] :: String -> Process r b

-- | Request that another a process exits. The targeted process is
--   interrupted and gets a <a>ShutdownRequested</a>, the target process
--   may decide to ignore the shutdown requests.
[SendShutdown] :: ProcessId -> Process r (ResumeProcess Bool)

-- | Send a message to a process addressed by the <a>ProcessId</a>. 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.
[SendMessage] :: ProcessId -> Dynamic -> Process r (ResumeProcess Bool)

-- | Receive a message. This should block until an a message was received.
--   The pure function may convert the incoming message into something, and
--   the result is returned as <tt>ProcessMessage</tt> value. Another
--   reason why this function returns, is if a process control message was
--   sent to the process. This can only occur from inside the runtime
--   system, aka the effect handler implementation. (Currently there is one
--   in <a>ForkIOScheduler</a>.)
[ReceiveMessage] :: Process r (ResumeProcess Dynamic)

-- | <i>Cons</i> <a>Process</a> onto a list of effects.
type ConsProcess r = Process r : r

-- | Every <a>Process</a> action returns it's actual result wrapped in this
--   type. It will allow to signal errors as well as pass on normal results
--   such as incoming messages.
data ResumeProcess v

-- | The process is required to exit.
[ShutdownRequested] :: ResumeProcess v

-- | The process is required to exit from an error condition, that cannot
--   be recovered from.
[OnError] :: String -> ResumeProcess v

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

-- | This indicates that the action did not complete, and maybe retried
[RetryLastAction] :: ResumeProcess v

-- | Every function for <a>Process</a> things needs such a proxy value for
--   the low-level effect list, i.e. the effects identified by
--   <tt><b>r</b></tt> in <tt><a>Process</a> r : r</tt>, this might be
--   dependent on the scheduler implementation.
data SchedulerProxy :: [Type -> Type] -> Type

-- | Tell the typechecker what effects we have below <a>Process</a>
[SchedulerProxy] :: SchedulerProxy q

-- | Like <a>SchedulerProxy</a> but shorter
[SP] :: SchedulerProxy q

-- | Return a <a>SchedulerProxy</a> for a <a>Process</a> effect.
thisSchedulerProxy :: Eff (Process r : r) (SchedulerProxy r)

-- | Execute a and action and resume the process, retry the action,
--   shutdown the process or return an error.
executeAndCatch :: forall q r v. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> Eff r (ResumeProcess v) -> Eff r (Either String v)

-- | Execute a <a>Process</a> action and resume the process, retry the
--   action or exit the process when a shutdown was requested.
executeAndResume :: forall r q v. (SetMember Process (Process q) r, HasCallStack) => Process q (ResumeProcess v) -> Eff r v

-- | Use <a>executeAndResume</a> to execute <a>YieldProcess</a>. Refer to
--   <a>YieldProcess</a> for more information.
yieldProcess :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r ()

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>.
sendMessage :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ProcessId -> Dynamic -> Eff r ()

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>.
sendMessageAs :: forall o r q. (HasCallStack, SetMember Process (Process q) r, Typeable o) => SchedulerProxy q -> ProcessId -> o -> Eff r ()

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>. Return <tt>True</tt> if the process existed. I you
--   don't care, just <a>sendMessage</a> instead.
sendMessageChecked :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ProcessId -> Dynamic -> Eff r Bool

-- | Start a new process, the new process will execute an effect, the
--   function will return immediately with a <a>ProcessId</a>.
spawn :: forall r q. (HasCallStack, SetMember Process (Process q) r) => Eff (Process q : q) () -> Eff r ProcessId

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

-- | Block until a message was received.
receiveMessage :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r Dynamic

-- | Receive and cast the message to some <a>Typeable</a> instance.
receiveMessageAs :: forall a r q. (HasCallStack, Typeable a, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a

-- | Enter a loop to receive messages and pass them to a callback, until
--   the function returns <a>False</a>.
receiveLoop :: forall r q. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> (Either (Maybe String) Dynamic -> Eff r ()) -> Eff r ()

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

-- | Exit a process addressed by the <a>ProcessId</a>. See
--   <a>SendShutdown</a>.
sendShutdown :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ProcessId -> Eff r ()

-- | Like <a>sendShutdown</a>, but also return <tt>True</tt> iff the
--   process to exit exists.
sendShutdownChecked :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ProcessId -> Eff r Bool

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

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

-- | Thrown an error, can be caught by <a>catchRaisedError</a>.
raiseError :: forall r q b. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> String -> Eff r b

-- | Catch and handle an error raised by <a>raiseError</a>. Works
--   independent of the handler implementation.
catchRaisedError :: forall r q w. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> (String -> Eff r w) -> Eff r w -> Eff r w

-- | Like <a>catchRaisedError</a> it catches <a>raiseError</a>, but instead
--   of invoking a user provided handler, the result is wrapped into an
--   <a>Either</a>.
ignoreProcessError :: (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a -> Eff r (Either String a)
instance GHC.Real.Real Control.Eff.Concurrent.Process.ProcessId
instance GHC.Real.Integral Control.Eff.Concurrent.Process.ProcessId
instance GHC.Enum.Enum Control.Eff.Concurrent.Process.ProcessId
instance GHC.Num.Num Control.Eff.Concurrent.Process.ProcessId
instance GHC.Enum.Bounded Control.Eff.Concurrent.Process.ProcessId
instance GHC.Classes.Ord Control.Eff.Concurrent.Process.ProcessId
instance GHC.Classes.Eq Control.Eff.Concurrent.Process.ProcessId
instance GHC.Generics.Generic1 Control.Eff.Concurrent.Process.ResumeProcess
instance GHC.Generics.Generic (Control.Eff.Concurrent.Process.ResumeProcess v)
instance Data.Traversable.Traversable Control.Eff.Concurrent.Process.ResumeProcess
instance GHC.Classes.Ord v => GHC.Classes.Ord (Control.Eff.Concurrent.Process.ResumeProcess v)
instance GHC.Classes.Eq v => GHC.Classes.Eq (Control.Eff.Concurrent.Process.ResumeProcess v)
instance GHC.Show.Show v => GHC.Show.Show (Control.Eff.Concurrent.Process.ResumeProcess v)
instance GHC.Base.Functor Control.Eff.Concurrent.Process.ResumeProcess
instance Data.Foldable.Foldable Control.Eff.Concurrent.Process.ResumeProcess
instance GHC.Read.Read Control.Eff.Concurrent.Process.ProcessId
instance GHC.Show.Show Control.Eff.Concurrent.Process.ProcessId
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Control.Eff.Concurrent.Process.ResumeProcess a)
instance Control.DeepSeq.NFData1 Control.Eff.Concurrent.Process.ResumeProcess


-- | This module contains a mechanism to specify what kind of messages (aka
--   <i>requests</i>) a <a>Server</a> (<a>Process</a>) can handle, and if
--   the caller blocks and waits for an answer, which the server process
--   provides.
--   
--   The type magic in the <a>Api</a> type familiy allows to define a
--   related set of <i>requests</i> along with the corresponding responses.
--   
--   Request handling can be either blocking, if a response is requred, or
--   non-blocking.
--   
--   A process can <i>serve</i> a specific <a>Api</a> instance by using the
--   functions provided by the <a>Control.Eff.Concurrent.Api.Server</a>
--   module.
--   
--   To enable a process to use such a <i>service</i>, the functions
--   provided by the <a>Control.Eff.Concurrent.Api.Client</a> should be
--   used.
module Control.Eff.Concurrent.Api

-- | This data family defines an API, a communication interface description
--   between at least two processes. The processes act as <b>servers</b> or
--   <b>client(s)</b> regarding a specific instance of this type.
--   
--   The first parameter is usually a user defined phantom type that
--   identifies the <a>Api</a> instance.
--   
--   The second parameter specifies if a specific constructor of an
--   (GADT-like) <tt>Api</tt> instance is <a>Synchronous</a>, i.e. returns
--   a result and blocks the caller or if it is <a>Asynchronous</a>
--   
--   Example:
--   
--   <pre>
--   data BookShop deriving Typeable
--   
--   data instance Api BookShop r where
--     RentBook  :: BookId   -&gt; Api BookShop ('Synchronous (Either RentalError RentalId))
--     BringBack :: RentalId -&gt; Api BookShop 'Asynchronous
--   
--   type BookId = Int
--   type RentalId = Int
--   type RentalError = String
--   </pre>

-- | The (promoted) constructors of this type specify (at the type level)
--   the reply behavior of a specific constructor of an <tt>Api</tt>
--   instance.
data Synchronicity

-- | Specify that handling a request is a blocking operation with a
--   specific return type, e.g. <tt>('Synchronous (Either RentalError
--   RentalId))</tt>
Synchronous :: Type -> Synchronicity

-- | Non-blocking, asynchronous, request handling
Asynchronous :: Synchronicity

-- | This is a tag-type that wraps around a <a>ProcessId</a> and holds an
--   <a>Api</a> index type.
newtype Server api
Server :: ProcessId -> Server api
[_fromServer] :: Server api -> ProcessId
fromServer :: forall api_aoVK api_ap5G. Iso (Server api_aoVK) (Server api_ap5G) ProcessId ProcessId

-- | Tag a <a>ProcessId</a> with an <a>Api</a> type index to mark it a
--   <a>Server</a> process handling that API
proxyAsServer :: proxy api -> ProcessId -> Server api

-- | Tag a <a>ProcessId</a> with an <a>Api</a> type index to mark it a
--   <a>Server</a> process handling that API
asServer :: forall api. ProcessId -> Server api
instance forall k (api :: k). GHC.Classes.Ord (Control.Eff.Concurrent.Api.Server api)
instance forall k (api :: k). GHC.Classes.Eq (Control.Eff.Concurrent.Api.Server api)
instance forall k (api :: k). GHC.Read.Read (Control.Eff.Concurrent.Api.Server api)
instance forall k (api :: k). Data.Typeable.Internal.Typeable api => GHC.Show.Show (Control.Eff.Concurrent.Api.Server api)


-- | Functions to implement <a>Api</a> <b>servers</b>.
module Control.Eff.Concurrent.Api.Server

-- | Receive and process incoming requests until the process exits, using
--   an <a>ApiHandler</a>.
serve :: forall r q p. (Typeable p, SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> ApiHandler p r -> Eff r ()

-- | A record of callbacks, handling requests sent to a <i>server</i>
--   <a>Process</a>, all belonging to a specific <a>Api</a> family
--   instance.
data ApiHandler p r
[ApiHandler] :: {_handleCast :: HasCallStack => Api p  'Asynchronous -> Eff r ()  A cast will not return a result directly. This is used for async methods., _handleCall :: forall x. HasCallStack => Api p ( 'Synchronous x) -> (x -> Eff r ()) -> Eff r ()  A call is a blocking operation, the caller is blocked until this handler calls the reply continuation., _handleTerminate :: HasCallStack => Maybe String -> Eff r ()  This callback is called with @Nothing@ if the process exits peacefully, or @Just "error message..."@ if the process exits with an error. This function is responsible to exit the process if necessary. The default behavior is defined in 'defaultTermination'.} -> ApiHandler p r

-- | A default handler to use in <a>_handleCall</a> in <a>ApiHandler</a>.
--   It will call <a>raiseError</a> with a nice error message.
unhandledCallError :: forall p x r q. (Show (Api p ( 'Synchronous x)), Typeable p, HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Api p ( 'Synchronous x) -> (x -> Eff r ()) -> Eff r ()

-- | A default handler to use in <a>_handleCast</a> in <a>ApiHandler</a>.
--   It will call <a>raiseError</a> with a nice error message.
unhandledCastError :: forall p r q. (Show (Api p  'Asynchronous), Typeable p, HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Api p  'Asynchronous -> Eff r ()

-- | Exit the process either normally of the error message is
--   <tt>Nothing</tt> or with <a>exitWithError</a> otherwise.
defaultTermination :: forall q r. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Maybe String -> Eff r ()

-- | <a>serve</a> two <a>ApiHandler</a>s at once. The first handler is used
--   for termination handling.
serveBoth :: forall r q p1 p2. (Typeable p1, Typeable p2, SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> ApiHandler p1 r -> ApiHandler p2 r -> Eff r ()

-- | <a>serve</a> three <a>ApiHandler</a>s at once. The first handler is
--   used for termination handling.
serve3 :: forall r q p1 p2 p3. (Typeable p1, Typeable p2, Typeable p3, SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> ApiHandler p1 r -> ApiHandler p2 r -> ApiHandler p3 r -> Eff r ()

-- | The basic building block of the combination of <a>ApiHandler</a>s is
--   this function, which can not only be passed to <a>receiveLoop</a>, but
--   also throws an <a>UnhandledRequest</a> exception if
--   <a>requestFromDynamic</a> failed, such that multiple invokation of
--   this function for different <a>ApiHandler</a>s can be tried, by using
--   <a>catchUnhandled</a>.
--   
--   <pre>
--   tryApiHandler px handlers1 message
--     `catchUnhandled`
--   tryApiHandler px handlers2
--     `catchUnhandled`
--   tryApiHandler px handlers3
--   </pre>
tryApiHandler :: forall r q p. (Typeable p, SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> ApiHandler p r -> Dynamic -> Eff (Exc UnhandledRequest : r) ()

-- | An exception that is used by the mechanism that chains together
--   multiple different <a>ApiHandler</a> allowing a single process to
--   implement multiple <a>Api</a>s. This exception is thrown by
--   <a>requestFromDynamic</a>. This exception can be caught with
--   <a>catchUnhandled</a>, this way, several distinct <a>ApiHandler</a>
--   can be tried until one <i>fits</i> or until the <a>exitUnhandled</a>
--   is invoked.
data UnhandledRequest

-- | If <a>requestFromDynamic</a> failes to cast the message to a
--   <a>Request</a> for a certain <a>ApiHandler</a> it throws an
--   <a>UnhandledRequest</a> exception. That exception is caught by this
--   function and the raw message is given to the handler function. This is
--   the basis for chaining <a>ApiHandler</a>s.
catchUnhandled :: forall r a. (Member (Exc UnhandledRequest) r, HasCallStack) => Eff r a -> (Dynamic -> Eff r a) -> Eff r a

-- | Catch <a>UnhandledRequest</a>s and terminate the process with an
--   error, if necessary.
ensureAllHandled :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff (Exc UnhandledRequest : r) () -> Eff r ()

-- | Cast a <a>Dynamic</a> value, and if that fails, throw an
--   <a>UnhandledRequest</a> error.
requestFromDynamic :: forall r a. (HasCallStack, Typeable a, Member (Exc UnhandledRequest) r) => Dynamic -> Eff r a

-- | If an incoming message could not be casted to a <a>Request</a>
--   corresponding to an <a>ApiHandler</a> (e.g. with
--   <a>requestFromDynamic</a>) one should use this function to exit the
--   process with a corresponding error.
exitUnhandled :: forall r q. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> Dynamic -> Eff r ()


-- | Functions for <a>Api</a> clients.
--   
--   This modules is required to write clients that consume an <a>Api</a>.
module Control.Eff.Concurrent.Api.Client

-- | Send an <a>Api</a> request that has no return value and return as fast
--   as possible. The type signature enforces that the corresponding
--   <a>Api</a> clause is <a>Asynchronous</a>.
cast :: forall r q o. (HasCallStack, SetMember Process (Process q) r, Typeable o, Typeable (Api o  'Asynchronous)) => SchedulerProxy q -> Server o -> Api o  'Asynchronous -> Eff r ()

-- | Send an <a>Api</a> request that has no return value and return as fast
--   as possible. The type signature enforces that the corresponding
--   <a>Api</a> clause is <a>Asynchronous</a>. Return <tt>True</tt> if the
--   message was sent to the process. Note that this is totally not the
--   same as that the request was successfully handled. If that is
--   important, use <a>call</a> instead.
castChecked :: forall r q o. (HasCallStack, SetMember Process (Process q) r, Typeable o, Typeable (Api o  'Asynchronous)) => SchedulerProxy q -> Server o -> Api o  'Asynchronous -> Eff r Bool

-- | Send an <a>Api</a> request and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Api</a> clause
--   is <a>Synchronous</a>.
call :: forall result api r q. (SetMember Process (Process q) r, Typeable api, Typeable (Api api ( 'Synchronous result)), Typeable result, HasCallStack) => SchedulerProxy q -> Server api -> Api api ( 'Synchronous result) -> Eff r result

-- | Like <a>cast</a> but take the <a>Server</a> from the reader provided
--   by <a>registerServer</a>.
castRegistered :: (Typeable o, ServesApi o r q) => SchedulerProxy q -> Api o  'Asynchronous -> Eff r ()

-- | Like <a>call</a> but take the <a>Server</a> from the reader provided
--   by <a>registerServer</a>.
callRegistered :: (Typeable reply, ServesApi o r q) => SchedulerProxy q -> Api o ( 'Synchronous reply) -> Eff r reply

-- | Like <a>callRegistered</a> but also catch errors raised if e.g. the
--   server crashed. By allowing <a>Alternative</a> instances to contain
--   the reply, application level errors can be combined with errors rising
--   from inter process communication.
callRegisteredA :: forall r q o f reply. (Alternative f, Typeable f, Typeable reply, ServesApi o r q) => SchedulerProxy q -> Api o ( 'Synchronous (f reply)) -> Eff r (f reply)

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

-- | Run a reader effect that contains <b>the one</b> server handling a
--   specific <a>Api</a> instance.
registerServer :: Server o -> Eff (Reader (Server o) : r) a -> Eff r a


-- | This module provides support for executing <a>Process</a> actions from
--   <a>IO</a>.
--   
--   One use case is interacting with processes from the REPL, e.g.:
--   
--   <pre>
--   &gt;&gt;&gt; import Control.Eff.Concurrent.Process.SingleThreadedScheduler (defaultMain)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; import Control.Eff.Loop
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Dynamic
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Maybe
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; s &lt;- forkInteractiveScheduler Control.Eff.Concurrent.Process.SingleThreadedScheduler.defaultMain
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; fooPid &lt;- submit s (spawn (foreverCheap (receiveMessage SP &gt;&gt;= (logMsg . fromMaybe "Huh!??" . fromDynamic))))
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; fooPid
--   &lt;0.1.0&gt;
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; submit s (sendMessageAs SP fooPid "test")
--   test
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; submit s (sendShutdown SP fooPid)
--   </pre>
module Control.Eff.Concurrent.Process.Interactive

-- | Contains the communication channels to interact with a scheduler
--   running in its' own thread.
data SchedulerSession r

-- | Fork a scheduler with a process that communicates with it via
--   <a>MVar</a>, which is also the reason for the <tt>Lift IO</tt>
--   constraint.
forkInteractiveScheduler :: forall r. (SetMember Lift (Lift IO) r) => (Eff (Process r : r) () -> IO ()) -> IO (SchedulerSession r)

-- | Exit the schedulder immediately using an asynchronous exception.
killInteractiveScheduler :: SchedulerSession r -> IO ()

-- | Send a <a>Process</a> effect to the main process of a scheduler, this
--   blocks until the effect is executed.
submit :: forall r a. (SetMember Lift (Lift IO) r) => SchedulerSession r -> Eff (Process r : r) a -> IO a

-- | Combination of <a>submit</a> and <a>cast</a>.
submitCast :: forall o r. (SetMember Lift (Lift IO) r, Typeable o) => SchedulerSession r -> Server o -> Api o  'Asynchronous -> IO ()

-- | Combination of <a>submit</a> and <a>cast</a>.
submitCall :: forall o q r. (SetMember Lift (Lift IO) r, Typeable o, Typeable q) => SchedulerSession r -> Server o -> Api o ( 'Synchronous q) -> IO q


-- | Add-ons to <a>Exception</a>
module Control.Eff.ExceptionExtra

-- | Catch <a>Exception</a> thrown by an effect.
liftTry :: forall e r a. (HasCallStack, Exception e, SetMember Lift (Lift IO) r) => Eff r a -> Eff r (Either e a)


-- | A logging effect based on <a>MonadLog</a>.
module Control.Eff.Log.Handler

-- | Logging effect type, parameterized by a log message type.
data Logs message a
[LogMsg] :: message -> Logs message ()

-- | Log a message.
logMsg :: Member (Logs m) r => m -> Eff r ()

-- | Change, add or remove log messages and perform arbitrary actions upon
--   intercepting a log message.
--   
--   Requirements:
--   
--   <ul>
--   <li>All log meta data for typical prod code can be added without
--   changing much of the code</li>
--   <li>Add timestamp to a log messages of a sub-computation.</li>
--   <li>Write some messages to a file.</li>
--   <li>Log something extra, e.g. runtime memory usage in load tests</li>
--   </ul>
--   
--   Approach: Install a callback that sneaks into to log message
--   sending/receiving, to intercept the messages and execute some code and
--   then return a new message.
interceptLogging :: forall r m a. Member (Logs m) r => (m -> Eff r ()) -> Eff r a -> Eff r a

-- | Intercept logging to change, add or remove log messages.
--   
--   This is without side effects, hence faster than
--   <a>interceptLogging</a>.
foldLogMessages :: forall r m a f. (Foldable f, Member (Logs m) r) => (m -> f m) -> Eff r a -> Eff r a

-- | Handle a <a>Logs</a> effect with a message that has a <a>Show</a>
--   instance by **re-logging** each message applied to <a>show</a>.
relogAsString :: forall m e a. (Show m, Member (Logs String) e) => Eff (Logs m : e) a -> Eff e a

-- | Capture all log messages in a <a>Seq</a> (strict).
captureLogs :: NFData message => Eff (Logs message : r) a -> Eff r (a, Seq message)

-- | Throw away all log messages.
ignoreLogs :: forall message r a. Eff (Logs message : r) a -> Eff r a

-- | Apply a function that returns an effect to each log message.
handleLogsWith :: forall message e a. (message -> Eff e ()) -> Eff (Logs message : e) a -> Eff e a

-- | Handle the <a>Logs</a> effect with a monadic call back function
--   (strict).
handleLogsLifted :: forall m r message a. (NFData message, Monad m, SetMember Lift (Lift m) r) => (message -> m ()) -> Eff (Logs message : r) a -> Eff r a

-- | Handle the <a>Logs</a> effect using <a>LoggingT</a> <a>Handler</a>s.
handleLogsWithLoggingTHandler :: forall m r message a. (Monad m, SetMember Lift (Lift m) r) => (forall b. (Handler m message -> m b) -> m b) -> Eff (Logs message : r) a -> Eff r a


-- | Concurrent Logging
module Control.Eff.Log.Channel

-- | A log channel processes logs from the <a>Logs</a> effect by en-queuing
--   them in a shared queue read from a seperate processes. A channel can
--   contain log message filters.
data LogChannel message

-- | Send the log messages to a <a>LogChannel</a>.
logToChannel :: forall r message a. (SetMember Lift (Lift IO) r) => LogChannel message -> Eff (Logs message : r) a -> Eff r a

-- | Create a <a>LogChannel</a> that will discard all messages sent via
--   <tt>forwardLogstochannel</tt> or <a>logChannelPutIO</a>.
noLogger :: LogChannel message

-- | Fork a new process, that applies a monadic action to all log messages
--   sent via <a>logToChannel</a> or <a>logChannelPutIO</a>.
forkLogger :: forall message. (Typeable message) => Int -> (message -> IO ()) -> Maybe message -> IO (LogChannel message)

-- | Filter logs sent to a <a>LogChannel</a> using a predicate.
filterLogChannel :: (message -> Bool) -> LogChannel message -> LogChannel message

-- | Close a log channel created by e.g. <a>forkLogger</a>. Message already
--   enqueue are handled. Subsequent log message will not be handled
--   anymore. If the log channel must be closed immediately, use
--   <a>killLogChannel</a> instead.
joinLogChannel :: (Typeable message) => LogChannel message -> IO ()

-- | Close a log channel quickly, without logging messages already in the
--   queue. Subsequent logging requests will not be handled anymore. If the
--   log channel must be closed without loosing any messages, use
--   <a>joinLogChannel</a> instead.
killLogChannel :: (Typeable message) => LogChannel message -> IO ()

-- | Run an action and close a <a>LogChannel</a> created by
--   <a>noLogger</a>, <a>forkLogger</a> or <a>filterLogChannel</a>
--   afterwards using <a>joinLogChannel</a>. If a <a>SomeException</a> was
--   thrown, the log channel is killed with <a>killLogChannel</a>, and the
--   exception is re-thrown.
closeLogChannelAfter :: (Typeable message, IsString message) => Maybe message -> LogChannel message -> IO a -> IO a

-- | Wrap <a>LogChannel</a> creation and destruction around a monad action
--   in <a>bracket</a>y manner. This function uses <a>joinLogChannel</a>,
--   so en-queued messages are flushed on exit. The resulting action is a
--   <a>LoggingT</a> action, which is essentially a reader for a log
--   handler function in <a>IO</a>.
logChannelBracket :: (Typeable message) => Int -> Maybe message -> (LogChannel message -> IO a) -> LoggingT message IO a

-- | Enqueue a log message into a log channel
logChannelPutIO :: LogChannel message -> message -> IO ()

-- | Internal exception to shutdown a <a>LogChannel</a> process created by
--   <a>forkLogger</a>. This exception is handled such that all message
--   already en-queued are handled and then an optional final message is
--   written.
data JoinLogChannelException

-- | Internal exception to **immediately** shutdown a <a>LogChannel</a>
--   process created by <a>forkLogger</a>, other than
--   <a>JoinLogChannelException</a> the message queue will not be flushed,
--   not further messages will be logged, except for the optional final
--   message.
data KillLogChannelException
instance GHC.Show.Show Control.Eff.Log.Channel.KillLogChannelException
instance GHC.Show.Show Control.Eff.Log.Channel.JoinLogChannelException
instance GHC.Exception.Exception Control.Eff.Log.Channel.KillLogChannelException
instance GHC.Exception.Exception Control.Eff.Log.Channel.JoinLogChannelException


-- | An RFC 5434 inspired log message and convenience functions for logging
--   them.
module Control.Eff.Log.Message

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

-- | Render a <a>LogMessage</a> according to the rules in the given RFC,
--   except for the rules concerning unicode and ascii
renderRFC5424 :: LogMessage -> String

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

-- | Handle a <a>Logs</a> effect for <a>String</a> messages by re-logging
--   the messages as <a>LogMessage</a>s with <a>debugSeverity</a>.
relogAsDebugMessages :: Member (Logs LogMessage) e => Eff (Logs String : e) a -> Eff e a

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

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

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

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

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

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

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

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

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

-- | Construct a <a>LogMessage</a> with <a>errorSeverity</a>
errorMessage :: String -> LogMessage

-- | Construct a <a>LogMessage</a> with <a>informationalSeverity</a>
infoMessage :: String -> LogMessage

-- | Construct a <a>LogMessage</a> with <a>debugSeverity</a>
debugMessage :: String -> LogMessage

-- | Construct a <a>LogMessage</a> with <a>errorSeverity</a>
errorMessageIO :: MonadIO m => String -> m LogMessage

-- | Construct a <a>LogMessage</a> with <a>informationalSeverity</a>
infoMessageIO :: MonadIO m => String -> m LogMessage

-- | Construct a <a>LogMessage</a> with <a>debugSeverity</a>
debugMessageIO :: MonadIO m => String -> m LogMessage

-- | An rfc 5424 severity
data Severity
emergencySeverity :: Severity
alertSeverity :: Severity
criticalSeverity :: Severity
errorSeverity :: Severity
warningSeverity :: Severity
noticeSeverity :: Severity
informationalSeverity :: Severity
debugSeverity :: Severity

-- | An rfc 5424 facility
data Facility
kernelMessages :: Facility
userLevelMessages :: Facility
mailSystem :: Facility
systemDaemons :: Facility
securityAuthorizationMessages4 :: Facility
linePrinterSubsystem :: Facility
networkNewsSubsystem :: Facility
uucpSubsystem :: Facility
clockDaemon :: Facility
securityAuthorizationMessages10 :: Facility
ftpDaemon :: Facility
ntpSubsystem :: Facility
logAuditFacility :: Facility
logAlertFacility :: Facility
clockDaemon2 :: Facility
local0 :: Facility
local1 :: Facility
local2 :: Facility
local3 :: Facility
local4 :: Facility
local5 :: Facility
local6 :: Facility
local7 :: Facility
lmFacility :: Lens' LogMessage Facility
lmSeverity :: Lens' LogMessage Severity
lmTimestamp :: Lens' LogMessage (Maybe UTCTime)
lmHostname :: Lens' LogMessage (Maybe String)
lmAppname :: Lens' LogMessage (Maybe String)
lmProcessId :: Lens' LogMessage (Maybe String)
lmMessageId :: Lens' LogMessage (Maybe String)
lmStructuredData :: Lens' LogMessage [StructuredDataElement]
lmSrcLoc :: Lens' LogMessage (Maybe SrcLoc)
lmThreadId :: Lens' LogMessage (Maybe ThreadId)
lmMessage :: Lens' LogMessage String

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

-- | RFC-5424 defines how structured data can be included in a log message.
data StructuredDataElement
SdElement :: String -> [SdParameter] -> StructuredDataElement
[_sdElementId] :: StructuredDataElement -> String
[_sdElementParameters] :: StructuredDataElement -> [SdParameter]
sdElementId :: Lens' StructuredDataElement String
sdElementParameters :: Lens' StructuredDataElement [SdParameter]
instance Data.Default.Class.Default Control.Eff.Log.Message.LogMessage
instance Data.String.IsString Control.Eff.Log.Message.LogMessage
instance Data.Default.Class.Default Control.Eff.Log.Message.Severity
instance Data.Default.Class.Default Control.Eff.Log.Message.Facility
instance GHC.Generics.Generic Control.Eff.Log.Message.LogMessage
instance GHC.Classes.Eq Control.Eff.Log.Message.LogMessage
instance Control.DeepSeq.NFData Control.Eff.Log.Message.Facility
instance GHC.Generics.Generic Control.Eff.Log.Message.Facility
instance GHC.Show.Show Control.Eff.Log.Message.Facility
instance GHC.Classes.Ord Control.Eff.Log.Message.Facility
instance GHC.Classes.Eq Control.Eff.Log.Message.Facility
instance Control.DeepSeq.NFData Control.Eff.Log.Message.Severity
instance GHC.Generics.Generic Control.Eff.Log.Message.Severity
instance GHC.Classes.Ord Control.Eff.Log.Message.Severity
instance GHC.Classes.Eq Control.Eff.Log.Message.Severity
instance GHC.Generics.Generic Control.Eff.Log.Message.StructuredDataElement
instance GHC.Classes.Ord Control.Eff.Log.Message.StructuredDataElement
instance GHC.Classes.Eq Control.Eff.Log.Message.StructuredDataElement
instance GHC.Generics.Generic Control.Eff.Log.Message.SdParameter
instance GHC.Classes.Ord Control.Eff.Log.Message.SdParameter
instance GHC.Classes.Eq Control.Eff.Log.Message.SdParameter
instance Control.DeepSeq.NFData Control.Eff.Log.Message.LogMessage
instance GHC.Show.Show Control.Eff.Log.Message.Severity
instance GHC.Show.Show Control.Eff.Log.Message.StructuredDataElement
instance Control.DeepSeq.NFData Control.Eff.Log.Message.StructuredDataElement
instance GHC.Show.Show Control.Eff.Log.Message.SdParameter
instance Control.DeepSeq.NFData Control.Eff.Log.Message.SdParameter


-- | A logging effect based on <a>MonadLog</a>.
module Control.Eff.Log


-- | A coroutine based, single threaded scheduler for <a>Process</a>es.
module Control.Eff.Concurrent.Process.SingleThreadedScheduler

-- | Handle the <a>Process</a> effect, as well as all lower effects using
--   an effect handler function.
--   
--   Execute the <b>main</b> <a>Process</a> and all the other processes
--   <a>spawn</a>ed by it in the current thread concurrently, using a
--   co-routine based, round-robin scheduler. If a process exits with
--   <a>exitNormally</a>, <a>exitWithError</a>, <a>raiseError</a> or is
--   killed by another process <tt>Left ...</tt> is returned. Otherwise,
--   the result will be wrapped in a <tt>Right</tt>.
--   
--   Every time a process _yields_ the effects are evaluated down to the a
--   value of type <tt>m (Either String a)</tt>.
--   
--   If the evaluator function runs the action down e.g. <tt>IO</tt> this
--   might improve memory consumption, for long running services, with
--   processes that loop endlessly.
scheduleM :: Monad m => (forall b. Eff r b -> m b) -> m () -> Eff (ConsProcess r) a -> m (Either String a)

-- | Like <tt>schedule</tt> but <i>pure</i>. The <tt>yield</tt> effect is
--   just <tt>return ()</tt>. <tt>schedulePure == runIdentity .
--   <a>scheduleM</a> (Identity . run) (return ())</tt>
schedulePure :: Eff (ConsProcess '[]) a -> Either String a

-- | Invoke <tt>schedule</tt> with <tt>lift <a>yield</a></tt> as yield
--   effect. <tt>scheduleIO runEff == <a>scheduleM</a> (runLift . runEff)
--   (liftIO <a>yield</a>)</tt>
scheduleIO :: MonadIO m => (forall b. Eff r b -> Eff '[Lift m] b) -> Eff (ConsProcess r) a -> m (Either String a)

-- | Invoke <tt>schedule</tt> with <tt>lift <a>yield</a></tt> as yield
--   effect. <tt>scheduleMonadIOEff == <a>scheduleM</a> id (liftIO
--   <a>yield</a>)</tt>
scheduleMonadIOEff :: MonadIO (Eff r) => Eff (ConsProcess r) a -> Eff r (Either String a)

-- | Run processes that have the <a>Logs</a> and the <a>Lift</a> effects.
--   The user must provide a log handler function.
--   
--   Log messages are evaluated strict.
--   
--   <pre>
--   scheduleIOWithLogging == <a>run</a> . <a>captureLogs</a> . <tt>schedule</tt> (return ())
--   </pre>
scheduleIOWithLogging :: (NFData l, MonadIO m) => (l -> m ()) -> Eff (ConsProcess '[Logs l, Lift m]) a -> m (Either String a)

-- | Execute a <a>Process</a> using <tt>schedule</tt> on top of <a>Lift</a>
--   <tt>IO</tt> and <a>Logs</a> <tt>String</tt> effects.
defaultMain :: HasCallStack => Eff '[Process '[Logs LogMessage, Lift IO], Logs LogMessage, Lift IO] () -> IO ()

-- | A <a>SchedulerProxy</a> for <a>LoggingAndIo</a>.
singleThreadedIoScheduler :: SchedulerProxy LoggingAndIo

-- | The concrete list of <a>Eff</a>ects for running this pure scheduler on
--   <tt>IO</tt> and with string logging.
type LoggingAndIo = '[Logs LogMessage, Lift IO]


-- | Implement Erlang style message passing concurrency.
--   
--   This handles the <tt>MessagePassing</tt> and <a>Process</a> effects,
--   using <a>TQueue</a>s and <a>forkIO</a>.
--   
--   This aims to be a pragmatic implementation, so even logging is
--   supported.
--   
--   At the core is a <i>main process</i> that enters <a>schedule</a> and
--   creates all of the internal state stored in <a>TVar</a>s to manage
--   processes with message queues.
--   
--   The <a>Eff</a> handler for <a>Process</a> and <tt>MessagePassing</tt>
--   use are implemented and available through <a>spawn</a>.
--   
--   <a>spawn</a> uses <a>forkFinally</a> and <a>TQueue</a>s and tries to
--   catch most exceptions.
module Control.Eff.Concurrent.Process.ForkIOScheduler

-- | This is the main entry point to running a message passing concurrency
--   application. This function takes a <a>Process</a> on top of the
--   <a>SchedulerIO</a> effect and a <a>LogChannel</a> for concurrent
--   logging.
schedule :: Eff (ConsProcess SchedulerIO) () -> LogChannel LogMessage -> IO ()

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

-- | Start the message passing concurrency system then execute a
--   <a>Process</a> on top of <a>SchedulerIO</a> effect. All logging is
--   sent to standard output.
defaultMainWithLogChannel :: LogChannel LogMessage -> Eff (ConsProcess SchedulerIO) () -> IO ()

-- | A sum-type with errors that can occur when scheduleing messages.
data SchedulerError

-- | No process info was found for a <a>ProcessId</a> during internal
--   processing. NOTE: This is **ONLY** caused by internal errors, probably
--   by an incorrect <tt>MessagePassing</tt> handler in this module.
--   **Sending a message to a process ALWAYS succeeds!** Even if the
--   process does not exist.
ProcessNotFound :: ProcessId -> SchedulerError

-- | A process called <a>raiseError</a>.
ProcessRaisedError :: String -> SchedulerError

-- | A process called <a>exitWithError</a>.
ProcessExitError :: String -> SchedulerError

-- | A process exits.
ProcessShuttingDown :: SchedulerError

-- | An action was not performed while the scheduler was exiting.
SchedulerShuttingDown :: SchedulerError

-- | The concrete list of <a>Eff</a>ects for this scheduler implementation.
--   See HasSchedulerIO
type SchedulerIO = '[Reader SchedulerVar, Logs LogMessage, Lift IO]

-- | A <a>SchedulerProxy</a> for <a>SchedulerIO</a>
forkIoScheduler :: SchedulerProxy SchedulerIO

-- | An alias for the constraints for the effects essential to this
--   scheduler implementation, i.e. these effects allow <a>spawn</a>ing new
--   <a>Process</a>es. See SchedulerIO
type HasSchedulerIO r = (HasCallStack, SetMember Lift (Lift IO) r, Member (Logs LogMessage) r, Member (Reader SchedulerVar) r)
instance GHC.Show.Show Control.Eff.Concurrent.Process.ForkIOScheduler.SchedulerError
instance GHC.Exception.Exception Control.Eff.Concurrent.Process.ForkIOScheduler.SchedulerError
instance GHC.Show.Show Control.Eff.Concurrent.Process.ForkIOScheduler.ProcessInfo


-- | Observer Effects
--   
--   This module supports the implementation of observers and observables.
--   One use case is event propagation. The tools in this module are
--   tailored towards <a>Api</a> servers/clients.
module Control.Eff.Concurrent.Api.Observer

-- | An <a>Api</a> index that support observation of the another <a>Api</a>
--   that is <a>Observable</a>.
class (Typeable p, Observable o) => Observer p o

-- | Wrap the <a>Observation</a> and the <a>ProcessId</a> (i.e. the
--   <a>Server</a>) that caused the observation into a <a>Api</a> value
--   that the <a>Observable</a> understands.
observationMessage :: Observer p o => Server o -> Observation o -> Api p  'Asynchronous

-- | An <a>Api</a> index that supports registration and de-registration of
--   <a>Observer</a>s.
class (Typeable o, Typeable (Observation o)) => Observable o where {
    data family Observation o;
}

-- | Return the <a>Api</a> value for the <tt>cast_</tt> that registeres an
--   observer
registerObserverMessage :: Observable o => SomeObserver o -> Api o  'Asynchronous

-- | Return the <a>Api</a> value for the <tt>cast_</tt> that de-registeres
--   an observer
forgetObserverMessage :: Observable o => SomeObserver o -> Api o  'Asynchronous

-- | Send an <a>Observation</a> to an <a>Observer</a>
notifyObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack) => SchedulerProxy q -> Server p -> Server o -> Observation o -> Eff r ()

-- | Send the <a>registerObserverMessage</a>
registerObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack) => SchedulerProxy q -> Server p -> Server o -> Eff r ()

-- | Send the <a>forgetObserverMessage</a>
forgetObserver :: (SetMember Process (Process q) r, Observable o, Observer p o) => SchedulerProxy q -> Server p -> Server o -> Eff r ()

-- | An existential wrapper around a <a>Server</a> of an <a>Observer</a>.
--   Needed to support different types of observers to observe the same
--   <a>Observable</a> in a general fashion.
data SomeObserver o
[SomeObserver] :: (Show (Server p), Typeable p, Observer p o) => Server p -> SomeObserver o

-- | Send an <a>Observation</a> to <a>SomeObserver</a>.
notifySomeObserver :: (SetMember Process (Process q) r, Observable o, HasCallStack) => SchedulerProxy q -> Server o -> Observation o -> SomeObserver o -> Eff r ()

-- | Internal state for <tt>manageobservers</tt>
data Observers o

-- | Keep track of registered <a>Observer</a>s Observers can be added and
--   removed, and an <a>Observation</a> can be sent to all registerd
--   observers at once.
manageObservers :: Eff (State (Observers o) : r) a -> Eff r a

-- | Add an <a>Observer</a> to the <a>Observers</a> managed by
--   <a>manageObservers</a>.
addObserver :: (SetMember Process (Process q) r, Member (State (Observers o)) r, Observable o) => SomeObserver o -> Eff r ()

-- | Delete an <a>Observer</a> from the <a>Observers</a> managed by
--   <a>manageObservers</a>.
removeObserver :: (SetMember Process (Process q) r, Member (State (Observers o)) r, Observable o) => SomeObserver o -> Eff r ()

-- | Send an <a>Observation</a> to all <a>SomeObserver</a>s in the
--   <a>Observers</a> state.
notifyObservers :: forall o r q. (Observable o, SetMember Process (Process q) r, Member (State (Observers o)) r) => SchedulerProxy q -> Observation o -> Eff r ()

-- | An <a>Observer</a> that schedules the observations to an effectful
--   callback.
data CallbackObserver o

-- | Start a new process for an <a>Observer</a> that schedules all
--   observations to an effectful callback.
spawnCallbackObserver :: forall o r q. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, Member (Logs LogMessage) q) => SchedulerProxy q -> (Server o -> Observation o -> Eff (Process q : q) Bool) -> Eff r (Server (CallbackObserver o))

-- | Use <a>spawnCallbackObserver</a> to create a universal logging
--   observer, using the <a>Show</a> instance of the <a>Observation</a>. |
--   Start a new process for an <a>Observer</a> 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) => SchedulerProxy q -> Eff r (Server (CallbackObserver o))
instance GHC.Show.Show (Control.Eff.Concurrent.Api.Observer.SomeObserver o)
instance GHC.Show.Show (Control.Eff.Concurrent.Api.Observer.Observation o) => GHC.Show.Show (Control.Eff.Concurrent.Api.Api (Control.Eff.Concurrent.Api.Observer.CallbackObserver o) r)
instance Control.Eff.Concurrent.Api.Observer.Observable o => Control.Eff.Concurrent.Api.Observer.Observer (Control.Eff.Concurrent.Api.Observer.CallbackObserver o) o
instance GHC.Classes.Ord (Control.Eff.Concurrent.Api.Observer.SomeObserver o)
instance GHC.Classes.Eq (Control.Eff.Concurrent.Api.Observer.SomeObserver o)


-- | In rare occasions GHC optimizes innocent looking loops into
--   space-leaking monsters. See the discussion here: <a>GHC issue
--   13080</a> for more details, or <a>this blog post about space leaks in
--   nested loops</a>
--   
--   These functions in this module <b><i>might</i></b> help, at least in
--   conjunction with the <tt>-fno-full-laziness</tt> GHC option.
--   
--   There is a unit test in the sources of this module, which can be used
--   to do a comperative heap profiling of these function vs. their
--   counterparts in the <tt>base</tt> package.
--   
--   Here are the images of the profiling results, the images show that the
--   functions in this module do not leak space, compared to the original
--   functions (<a>forever</a> and <a>replicateM_</a>):
--   
module Control.Eff.Loop

-- | A version of <a>forever</a> that hopefully tricks GHC into
--   <b><i>not</i></b> creating a space leak. The intuition is, that we
--   want to do something that is <i>cheap</i>, and hence should be
--   <b>recomputed</b> instead of shared.
foreverCheap :: Monad m => m a -> m ()

-- | A version of <a>replicateM_</a> that hopefully tricks GHC into
--   <b><i>not</i></b> creating a space leak. The intuition is, that we
--   want to do something that is <i>cheap</i>, and hence should be
--   <b>recomputed</b> instead of shared.
replicateCheapM_ :: Monad m => Int -> m a -> m ()


-- | Erlang style processes with message passing concurrency based on
--   (more) <tt>extensible-effects</tt>.
module Control.Eff.Concurrent

-- | Each process is identified by a single process id, that stays constant
--   throughout the life cycle of a process. Also, message sending relies
--   on these values to address messages to processes.
newtype ProcessId
ProcessId :: Int -> ProcessId
[_fromProcessId] :: ProcessId -> Int

-- | Every function for <a>Process</a> things needs such a proxy value for
--   the low-level effect list, i.e. the effects identified by
--   <tt><b>r</b></tt> in <tt><a>Process</a> r : r</tt>, this might be
--   dependent on the scheduler implementation.
data SchedulerProxy :: [Type -> Type] -> Type

-- | Tell the typechecker what effects we have below <a>Process</a>
[SchedulerProxy] :: SchedulerProxy q

-- | Like <a>SchedulerProxy</a> but shorter
[SP] :: SchedulerProxy q

-- | <i>Cons</i> <a>Process</a> onto a list of effects.
type ConsProcess r = Process r : r

-- | Every <a>Process</a> action returns it's actual result wrapped in this
--   type. It will allow to signal errors as well as pass on normal results
--   such as incoming messages.
data ResumeProcess v

-- | The process is required to exit.
[ShutdownRequested] :: ResumeProcess v

-- | The process is required to exit from an error condition, that cannot
--   be recovered from.
[OnError] :: String -> ResumeProcess v

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

-- | This indicates that the action did not complete, and maybe retried
[RetryLastAction] :: ResumeProcess v

-- | The process effect is the basis for message passing concurrency. This
--   effect describes an interface for concurrent, communicating isolated
--   processes identified uniquely by a process-id.
--   
--   Processes can raise exceptions that can be caught, exit gracefully or
--   with an error, or be killed by other processes, with the option of
--   ignoring the shutdown request.
--   
--   Process Scheduling is implemented in different modules. All scheduler
--   implementations should follow some basic rules:
--   
--   <ul>
--   <li>fair scheduling</li>
--   <li>sending a message does not block</li>
--   <li>receiving a message does block</li>
--   <li>spawning a child blocks only a very moment</li>
--   <li>a newly spawned process shall be scheduled before the parent
--   process after</li>
--   <li>the spawn</li>
--   <li>when the first process exists, all process should be killed
--   immediately</li>
--   </ul>
data Process (r :: [Type -> Type]) b

-- | In cooperative schedulers, this will give processing time to the
--   scheduler. Every other operation implicitly serves the same purpose.
[YieldProcess] :: Process r (ResumeProcess ())

-- | Return the current <a>ProcessId</a>
[SelfPid] :: Process r (ResumeProcess ProcessId)

-- | Start a new process, the new process will execute an effect, the
--   function will return immediately with a <a>ProcessId</a>.
[Spawn] :: Eff (Process r : r) () -> Process r (ResumeProcess ProcessId)

-- | Process exit, this is the same as if the function that was applied to
--   a spawn function returned.
[Shutdown] :: Process r a

-- | Exit the process due to an error, this cannot be caught.
[ExitWithError] :: String -> Process r b

-- | Raise an error, that can be handled.
[RaiseError] :: String -> Process r b

-- | Request that another a process exits. The targeted process is
--   interrupted and gets a <a>ShutdownRequested</a>, the target process
--   may decide to ignore the shutdown requests.
[SendShutdown] :: ProcessId -> Process r (ResumeProcess Bool)

-- | Send a message to a process addressed by the <a>ProcessId</a>. 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.
[SendMessage] :: ProcessId -> Dynamic -> Process r (ResumeProcess Bool)

-- | Receive a message. This should block until an a message was received.
--   The pure function may convert the incoming message into something, and
--   the result is returned as <tt>ProcessMessage</tt> value. Another
--   reason why this function returns, is if a process control message was
--   sent to the process. This can only occur from inside the runtime
--   system, aka the effect handler implementation. (Currently there is one
--   in <a>ForkIOScheduler</a>.)
[ReceiveMessage] :: Process r (ResumeProcess Dynamic)

-- | Execute a <a>Process</a> action and resume the process, retry the
--   action or exit the process when a shutdown was requested.
executeAndResume :: forall r q v. (SetMember Process (Process q) r, HasCallStack) => Process q (ResumeProcess v) -> Eff r v

-- | Execute a and action and resume the process, retry the action,
--   shutdown the process or return an error.
executeAndCatch :: forall q r v. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> Eff r (ResumeProcess v) -> Eff r (Either String v)

-- | Return a <a>SchedulerProxy</a> for a <a>Process</a> effect.
thisSchedulerProxy :: Eff (Process r : r) (SchedulerProxy r)

-- | Use <a>executeAndResume</a> to execute <a>YieldProcess</a>. Refer to
--   <a>YieldProcess</a> for more information.
yieldProcess :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r ()

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>.
sendMessage :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ProcessId -> Dynamic -> Eff r ()

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>. Return <tt>True</tt> if the process existed. I you
--   don't care, just <a>sendMessage</a> instead.
sendMessageChecked :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ProcessId -> Dynamic -> Eff r Bool

-- | Send a message to a process addressed by the <a>ProcessId</a>. See
--   <a>SendMessage</a>.
sendMessageAs :: forall o r q. (HasCallStack, SetMember Process (Process q) r, Typeable o) => SchedulerProxy q -> ProcessId -> o -> Eff r ()

-- | Exit a process addressed by the <a>ProcessId</a>. See
--   <a>SendShutdown</a>.
sendShutdown :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ProcessId -> Eff r ()

-- | Like <a>sendShutdown</a>, but also return <tt>True</tt> iff the
--   process to exit exists.
sendShutdownChecked :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> ProcessId -> Eff r Bool

-- | Start a new process, the new process will execute an effect, the
--   function will return immediately with a <a>ProcessId</a>.
spawn :: forall r q. (HasCallStack, SetMember Process (Process q) r) => Eff (Process q : q) () -> Eff r ProcessId

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

-- | Block until a message was received.
receiveMessage :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r Dynamic

-- | Receive and cast the message to some <a>Typeable</a> instance.
receiveMessageAs :: forall a r q. (HasCallStack, Typeable a, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a

-- | Enter a loop to receive messages and pass them to a callback, until
--   the function returns <a>False</a>.
receiveLoop :: forall r q. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> (Either (Maybe String) Dynamic -> Eff r ()) -> Eff r ()

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

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

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

-- | Thrown an error, can be caught by <a>catchRaisedError</a>.
raiseError :: forall r q b. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> String -> Eff r b

-- | Catch and handle an error raised by <a>raiseError</a>. Works
--   independent of the handler implementation.
catchRaisedError :: forall r q w. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> (String -> Eff r w) -> Eff r w -> Eff r w

-- | Like <a>catchRaisedError</a> it catches <a>raiseError</a>, but instead
--   of invoking a user provided handler, the result is wrapped into an
--   <a>Either</a>.
ignoreProcessError :: (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff r a -> Eff r (Either String a)
fromProcessId :: Iso' ProcessId Int

-- | This is a tag-type that wraps around a <a>ProcessId</a> and holds an
--   <a>Api</a> index type.
newtype Server api
Server :: ProcessId -> Server api
[_fromServer] :: Server api -> ProcessId

-- | The (promoted) constructors of this type specify (at the type level)
--   the reply behavior of a specific constructor of an <tt>Api</tt>
--   instance.
data Synchronicity

-- | Specify that handling a request is a blocking operation with a
--   specific return type, e.g. <tt>('Synchronous (Either RentalError
--   RentalId))</tt>
Synchronous :: Type -> Synchronicity

-- | Non-blocking, asynchronous, request handling
Asynchronous :: Synchronicity

-- | This data family defines an API, a communication interface description
--   between at least two processes. The processes act as <b>servers</b> or
--   <b>client(s)</b> regarding a specific instance of this type.
--   
--   The first parameter is usually a user defined phantom type that
--   identifies the <a>Api</a> instance.
--   
--   The second parameter specifies if a specific constructor of an
--   (GADT-like) <tt>Api</tt> instance is <a>Synchronous</a>, i.e. returns
--   a result and blocks the caller or if it is <a>Asynchronous</a>
--   
--   Example:
--   
--   <pre>
--   data BookShop deriving Typeable
--   
--   data instance Api BookShop r where
--     RentBook  :: BookId   -&gt; Api BookShop ('Synchronous (Either RentalError RentalId))
--     BringBack :: RentalId -&gt; Api BookShop 'Asynchronous
--   
--   type BookId = Int
--   type RentalId = Int
--   type RentalError = String
--   </pre>
fromServer :: forall api_aoVK api_ap5G. Iso (Server api_aoVK) (Server api_ap5G) ProcessId ProcessId

-- | Tag a <a>ProcessId</a> with an <a>Api</a> type index to mark it a
--   <a>Server</a> process handling that API
proxyAsServer :: proxy api -> ProcessId -> Server api

-- | Tag a <a>ProcessId</a> with an <a>Api</a> type index to mark it a
--   <a>Server</a> process handling that API
asServer :: forall api. ProcessId -> Server api

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

-- | Send an <a>Api</a> request that has no return value and return as fast
--   as possible. The type signature enforces that the corresponding
--   <a>Api</a> clause is <a>Asynchronous</a>. Return <tt>True</tt> if the
--   message was sent to the process. Note that this is totally not the
--   same as that the request was successfully handled. If that is
--   important, use <a>call</a> instead.
castChecked :: forall r q o. (HasCallStack, SetMember Process (Process q) r, Typeable o, Typeable (Api o  'Asynchronous)) => SchedulerProxy q -> Server o -> Api o  'Asynchronous -> Eff r Bool

-- | Send an <a>Api</a> request that has no return value and return as fast
--   as possible. The type signature enforces that the corresponding
--   <a>Api</a> clause is <a>Asynchronous</a>.
cast :: forall r q o. (HasCallStack, SetMember Process (Process q) r, Typeable o, Typeable (Api o  'Asynchronous)) => SchedulerProxy q -> Server o -> Api o  'Asynchronous -> Eff r ()

-- | Send an <a>Api</a> request and wait for the server to return a result
--   value.
--   
--   The type signature enforces that the corresponding <a>Api</a> clause
--   is <a>Synchronous</a>.
call :: forall result api r q. (SetMember Process (Process q) r, Typeable api, Typeable (Api api ( 'Synchronous result)), Typeable result, HasCallStack) => SchedulerProxy q -> Server api -> Api api ( 'Synchronous result) -> Eff r result

-- | Run a reader effect that contains <b>the one</b> server handling a
--   specific <a>Api</a> instance.
registerServer :: Server o -> Eff (Reader (Server o) : r) a -> Eff r a

-- | Like <a>call</a> but take the <a>Server</a> from the reader provided
--   by <a>registerServer</a>.
callRegistered :: (Typeable reply, ServesApi o r q) => SchedulerProxy q -> Api o ( 'Synchronous reply) -> Eff r reply

-- | Like <a>callRegistered</a> but also catch errors raised if e.g. the
--   server crashed. By allowing <a>Alternative</a> instances to contain
--   the reply, application level errors can be combined with errors rising
--   from inter process communication.
callRegisteredA :: forall r q o f reply. (Alternative f, Typeable f, Typeable reply, ServesApi o r q) => SchedulerProxy q -> Api o ( 'Synchronous (f reply)) -> Eff r (f reply)

-- | Like <a>cast</a> but take the <a>Server</a> from the reader provided
--   by <a>registerServer</a>.
castRegistered :: (Typeable o, ServesApi o r q) => SchedulerProxy q -> Api o  'Asynchronous -> Eff r ()

-- | An exception that is used by the mechanism that chains together
--   multiple different <a>ApiHandler</a> allowing a single process to
--   implement multiple <a>Api</a>s. This exception is thrown by
--   <a>requestFromDynamic</a>. This exception can be caught with
--   <a>catchUnhandled</a>, this way, several distinct <a>ApiHandler</a>
--   can be tried until one <i>fits</i> or until the <a>exitUnhandled</a>
--   is invoked.
data UnhandledRequest

-- | A record of callbacks, handling requests sent to a <i>server</i>
--   <a>Process</a>, all belonging to a specific <a>Api</a> family
--   instance.
data ApiHandler p r
[ApiHandler] :: {_handleCast :: HasCallStack => Api p  'Asynchronous -> Eff r ()  A cast will not return a result directly. This is used for async methods., _handleCall :: forall x. HasCallStack => Api p ( 'Synchronous x) -> (x -> Eff r ()) -> Eff r ()  A call is a blocking operation, the caller is blocked until this handler calls the reply continuation., _handleTerminate :: HasCallStack => Maybe String -> Eff r ()  This callback is called with @Nothing@ if the process exits peacefully, or @Just "error message..."@ if the process exits with an error. This function is responsible to exit the process if necessary. The default behavior is defined in 'defaultTermination'.} -> ApiHandler p r

-- | Receive and process incoming requests until the process exits, using
--   an <a>ApiHandler</a>.
serve :: forall r q p. (Typeable p, SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> ApiHandler p r -> Eff r ()

-- | A default handler to use in <a>_handleCall</a> in <a>ApiHandler</a>.
--   It will call <a>raiseError</a> with a nice error message.
unhandledCallError :: forall p x r q. (Show (Api p ( 'Synchronous x)), Typeable p, HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Api p ( 'Synchronous x) -> (x -> Eff r ()) -> Eff r ()

-- | A default handler to use in <a>_handleCast</a> in <a>ApiHandler</a>.
--   It will call <a>raiseError</a> with a nice error message.
unhandledCastError :: forall p r q. (Show (Api p  'Asynchronous), Typeable p, HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Api p  'Asynchronous -> Eff r ()

-- | Exit the process either normally of the error message is
--   <tt>Nothing</tt> or with <a>exitWithError</a> otherwise.
defaultTermination :: forall q r. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Maybe String -> Eff r ()

-- | <a>serve</a> two <a>ApiHandler</a>s at once. The first handler is used
--   for termination handling.
serveBoth :: forall r q p1 p2. (Typeable p1, Typeable p2, SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> ApiHandler p1 r -> ApiHandler p2 r -> Eff r ()

-- | <a>serve</a> three <a>ApiHandler</a>s at once. The first handler is
--   used for termination handling.
serve3 :: forall r q p1 p2 p3. (Typeable p1, Typeable p2, Typeable p3, SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> ApiHandler p1 r -> ApiHandler p2 r -> ApiHandler p3 r -> Eff r ()

-- | The basic building block of the combination of <a>ApiHandler</a>s is
--   this function, which can not only be passed to <a>receiveLoop</a>, but
--   also throws an <a>UnhandledRequest</a> exception if
--   <a>requestFromDynamic</a> failed, such that multiple invokation of
--   this function for different <a>ApiHandler</a>s can be tried, by using
--   <a>catchUnhandled</a>.
--   
--   <pre>
--   tryApiHandler px handlers1 message
--     `catchUnhandled`
--   tryApiHandler px handlers2
--     `catchUnhandled`
--   tryApiHandler px handlers3
--   </pre>
tryApiHandler :: forall r q p. (Typeable p, SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> ApiHandler p r -> Dynamic -> Eff (Exc UnhandledRequest : r) ()

-- | If <a>requestFromDynamic</a> failes to cast the message to a
--   <a>Request</a> for a certain <a>ApiHandler</a> it throws an
--   <a>UnhandledRequest</a> exception. That exception is caught by this
--   function and the raw message is given to the handler function. This is
--   the basis for chaining <a>ApiHandler</a>s.
catchUnhandled :: forall r a. (Member (Exc UnhandledRequest) r, HasCallStack) => Eff r a -> (Dynamic -> Eff r a) -> Eff r a

-- | Catch <a>UnhandledRequest</a>s and terminate the process with an
--   error, if necessary.
ensureAllHandled :: forall r q. (HasCallStack, SetMember Process (Process q) r) => SchedulerProxy q -> Eff (Exc UnhandledRequest : r) () -> Eff r ()

-- | Cast a <a>Dynamic</a> value, and if that fails, throw an
--   <a>UnhandledRequest</a> error.
requestFromDynamic :: forall r a. (HasCallStack, Typeable a, Member (Exc UnhandledRequest) r) => Dynamic -> Eff r a

-- | If an incoming message could not be casted to a <a>Request</a>
--   corresponding to an <a>ApiHandler</a> (e.g. with
--   <a>requestFromDynamic</a>) one should use this function to exit the
--   process with a corresponding error.
exitUnhandled :: forall r q. (SetMember Process (Process q) r, HasCallStack) => SchedulerProxy q -> Dynamic -> Eff r ()

-- | An <a>Observer</a> that schedules the observations to an effectful
--   callback.
data CallbackObserver o

-- | Internal state for <tt>manageobservers</tt>
data Observers o

-- | An existential wrapper around a <a>Server</a> of an <a>Observer</a>.
--   Needed to support different types of observers to observe the same
--   <a>Observable</a> in a general fashion.
data SomeObserver o
[SomeObserver] :: (Show (Server p), Typeable p, Observer p o) => Server p -> SomeObserver o

-- | An <a>Api</a> index that supports registration and de-registration of
--   <a>Observer</a>s.
class (Typeable o, Typeable (Observation o)) => Observable o where {
    data family Observation o;
}

-- | Return the <a>Api</a> value for the <tt>cast_</tt> that registeres an
--   observer
registerObserverMessage :: Observable o => SomeObserver o -> Api o  'Asynchronous

-- | Return the <a>Api</a> value for the <tt>cast_</tt> that de-registeres
--   an observer
forgetObserverMessage :: Observable o => SomeObserver o -> Api o  'Asynchronous

-- | An <a>Api</a> index that support observation of the another <a>Api</a>
--   that is <a>Observable</a>.
class (Typeable p, Observable o) => Observer p o

-- | Wrap the <a>Observation</a> and the <a>ProcessId</a> (i.e. the
--   <a>Server</a>) that caused the observation into a <a>Api</a> value
--   that the <a>Observable</a> understands.
observationMessage :: Observer p o => Server o -> Observation o -> Api p  'Asynchronous

-- | Send an <a>Observation</a> to an <a>Observer</a>
notifyObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack) => SchedulerProxy q -> Server p -> Server o -> Observation o -> Eff r ()

-- | Send the <a>registerObserverMessage</a>
registerObserver :: (SetMember Process (Process q) r, Observable o, Observer p o, HasCallStack) => SchedulerProxy q -> Server p -> Server o -> Eff r ()

-- | Send the <a>forgetObserverMessage</a>
forgetObserver :: (SetMember Process (Process q) r, Observable o, Observer p o) => SchedulerProxy q -> Server p -> Server o -> Eff r ()

-- | Send an <a>Observation</a> to <a>SomeObserver</a>.
notifySomeObserver :: (SetMember Process (Process q) r, Observable o, HasCallStack) => SchedulerProxy q -> Server o -> Observation o -> SomeObserver o -> Eff r ()

-- | Keep track of registered <a>Observer</a>s Observers can be added and
--   removed, and an <a>Observation</a> can be sent to all registerd
--   observers at once.
manageObservers :: Eff (State (Observers o) : r) a -> Eff r a

-- | Add an <a>Observer</a> to the <a>Observers</a> managed by
--   <a>manageObservers</a>.
addObserver :: (SetMember Process (Process q) r, Member (State (Observers o)) r, Observable o) => SomeObserver o -> Eff r ()

-- | Delete an <a>Observer</a> from the <a>Observers</a> managed by
--   <a>manageObservers</a>.
removeObserver :: (SetMember Process (Process q) r, Member (State (Observers o)) r, Observable o) => SomeObserver o -> Eff r ()

-- | Send an <a>Observation</a> to all <a>SomeObserver</a>s in the
--   <a>Observers</a> state.
notifyObservers :: forall o r q. (Observable o, SetMember Process (Process q) r, Member (State (Observers o)) r) => SchedulerProxy q -> Observation o -> Eff r ()

-- | Start a new process for an <a>Observer</a> that schedules all
--   observations to an effectful callback.
spawnCallbackObserver :: forall o r q. (SetMember Process (Process q) r, Typeable o, Show (Observation o), Observable o, Member (Logs LogMessage) q) => SchedulerProxy q -> (Server o -> Observation o -> Eff (Process q : q) Bool) -> Eff r (Server (CallbackObserver o))

-- | Use <a>spawnCallbackObserver</a> to create a universal logging
--   observer, using the <a>Show</a> instance of the <a>Observation</a>. |
--   Start a new process for an <a>Observer</a> 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) => SchedulerProxy q -> Eff r (Server (CallbackObserver o))

-- | The concrete list of <a>Eff</a>ects for this scheduler implementation.
--   See HasSchedulerIO
type SchedulerIO = '[Reader SchedulerVar, Logs LogMessage, Lift IO]

-- | An alias for the constraints for the effects essential to this
--   scheduler implementation, i.e. these effects allow <a>spawn</a>ing new
--   <a>Process</a>es. See SchedulerIO
type HasSchedulerIO r = (HasCallStack, SetMember Lift (Lift IO) r, Member (Logs LogMessage) r, Member (Reader SchedulerVar) r)

-- | A sum-type with errors that can occur when scheduleing messages.
data SchedulerError

-- | No process info was found for a <a>ProcessId</a> during internal
--   processing. NOTE: This is **ONLY** caused by internal errors, probably
--   by an incorrect <tt>MessagePassing</tt> handler in this module.
--   **Sending a message to a process ALWAYS succeeds!** Even if the
--   process does not exist.
ProcessNotFound :: ProcessId -> SchedulerError

-- | A process called <a>raiseError</a>.
ProcessRaisedError :: String -> SchedulerError

-- | A process called <a>exitWithError</a>.
ProcessExitError :: String -> SchedulerError

-- | A process exits.
ProcessShuttingDown :: SchedulerError

-- | An action was not performed while the scheduler was exiting.
SchedulerShuttingDown :: SchedulerError

-- | A <a>SchedulerProxy</a> for <a>SchedulerIO</a>
forkIoScheduler :: SchedulerProxy SchedulerIO

-- | This is the main entry point to running a message passing concurrency
--   application. This function takes a <a>Process</a> on top of the
--   <a>SchedulerIO</a> effect and a <a>LogChannel</a> for concurrent
--   logging.
schedule :: Eff (ConsProcess SchedulerIO) () -> LogChannel LogMessage -> IO ()

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

-- | Start the message passing concurrency system then execute a
--   <a>Process</a> on top of <a>SchedulerIO</a> effect. All logging is
--   sent to standard output.
defaultMainWithLogChannel :: LogChannel LogMessage -> Eff (ConsProcess SchedulerIO) () -> IO ()

-- | Like <tt>schedule</tt> but <i>pure</i>. The <tt>yield</tt> effect is
--   just <tt>return ()</tt>. <tt>schedulePure == runIdentity .
--   <a>scheduleM</a> (Identity . run) (return ())</tt>
schedulePure :: Eff (ConsProcess '[]) a -> Either String a