Control.Concurrent.Actor

Documentation

data ActionT message m a

A type that contains the actions that Actors will do.

Instances

(MonadWriter w m, MonadReader r m, MonadState s m) => MonadRWS r w s (ActionT message m)

Defined in Control.Concurrent.Actor

MonadWriter w m => MonadWriter w (ActionT message m)

Defined in Control.Concurrent.Actor

Methods

writer :: (a, w) -> ActionT message m a

tell :: w -> ActionT message m ()

listen :: ActionT message m a -> ActionT message m (a, w)

pass :: ActionT message m (a, w -> w) -> ActionT message m a

MonadState s m => MonadState s (ActionT message m)

Defined in Control.Concurrent.Actor

Methods

get :: ActionT message m s

put :: s -> ActionT message m ()

state :: (s -> (a, s)) -> ActionT message m a

MonadReader r m => MonadReader r (ActionT message m)

Defined in Control.Concurrent.Actor

Methods

ask :: ActionT message m r

local :: (r -> r) -> ActionT message m a -> ActionT message m a

reader :: (r -> a) -> ActionT message m a

MonadError e m => MonadError e (ActionT message m)

Defined in Control.Concurrent.Actor

Methods

throwError :: e -> ActionT message m a

catchError :: ActionT message m a -> (e -> ActionT message m a) -> ActionT message m a

MonadTrans (ActionT message)

Defined in Control.Concurrent.Actor

Methods

lift :: Monad m => m a -> ActionT message m a

Monad m => Monad (ActionT message m)

Defined in Control.Concurrent.Actor

Methods

(>>=) :: ActionT message m a -> (a -> ActionT message m b) -> ActionT message m b

(>>) :: ActionT message m a -> ActionT message m b -> ActionT message m b

return :: a -> ActionT message m a

Functor m => Functor (ActionT message m)

Defined in Control.Concurrent.Actor

Methods

fmap :: (a -> b) -> ActionT message m a -> ActionT message m b

(<$) :: a -> ActionT message m b -> ActionT message m a

Applicative m => Applicative (ActionT message m)

Defined in Control.Concurrent.Actor

Methods

pure :: a -> ActionT message m a

(<*>) :: ActionT message m (a -> b) -> ActionT message m a -> ActionT message m b

liftA2 :: (a -> b -> c) -> ActionT message m a -> ActionT message m b -> ActionT message m c

(*>) :: ActionT message m a -> ActionT message m b -> ActionT message m b

(<*) :: ActionT message m a -> ActionT message m b -> ActionT message m a

MonadIO m => MonadIO (ActionT message m)

Defined in Control.Concurrent.Actor

Methods

liftIO :: IO a -> ActionT message m a

MonadCont m => MonadCont (ActionT message m)

Defined in Control.Concurrent.Actor

Methods

callCC :: ((a -> ActionT message m b) -> ActionT message m a) -> ActionT message m a

MonadUnliftIO m => MonadUnliftIO (ActionT message m)

Defined in Control.Concurrent.Actor

Methods

withRunInIO :: ((forall a. ActionT message m a -> IO a) -> IO b) -> ActionT message m b

data Actor message

A handle to do things to actors, like sending them messages, fiddling with their threads, or adding an effect that will occur after they've finished executing.

Instances

Contravariant Actor

Defined in Control.Concurrent.Actor

Methods

contramap :: (a -> b) -> Actor b -> Actor a

(>$) :: b -> Actor b -> Actor a

Eq (Actor message)

Defined in Control.Concurrent.Actor

Methods

(==) :: Actor message -> Actor message -> Bool

(/=) :: Actor message -> Actor message -> Bool

Show (Actor message)

Defined in Control.Concurrent.Actor

Methods

showsPrec :: Int -> Actor message -> ShowS

show :: Actor message -> String

showList :: [Actor message] -> ShowS

send :: Actor message -> message -> STM ()

Send a message to this Actor.

addAfterEffect :: Actor message -> (Maybe SomeException -> IO ()) -> STM ()

Once the Actor dies, all of the effects that have been added via this function will run. This is how you can implement your own functions like link or linkSTM.

threadId :: Actor message -> ThreadId

Retrieve the ThreadId associated with this Actor.

livenessCheck :: Actor message -> STM Liveness

Checks the Liveness of a particular Actor

withLivenessCheck :: (Actor message -> x -> STM ()) -> Actor message -> x -> STM ()

Allows us to wrap addAfterEffect, send, and any other custom combinators in a liveness check. This causes contention on the underlying TVar that contains the status report of the Actor, and thus should be avoided where possible. That being said, it is also useful to avoid sending messages or add after effects to dead actors, which will certainly be lost forever. If the Actor is Completed or ThrewException, then we throw an ActorDead exception with Nothing or Just the exception, respectively.

data Liveness

The liveness state of a particular Actor.

Constructors

Alive

Completed

ThrewException SomeException

Instances

Show Liveness

Defined in Control.Concurrent.Actor

Methods

showsPrec :: Int -> Liveness -> ShowS

show :: Liveness -> String

showList :: [Liveness] -> ShowS

data ActorDead

The exception thrown when we run an action wrapped in withLivenessCheck on an Actor which has died.

Constructors

ActorDead (Maybe SomeException)

Instances

Show ActorDead

Defined in Control.Concurrent.Actor

Methods

showsPrec :: Int -> ActorDead -> ShowS

show :: ActorDead -> String

showList :: [ActorDead] -> ShowS

Exception ActorDead

Defined in Control.Concurrent.Actor

Methods

toException :: ActorDead -> SomeException

fromException :: SomeException -> Maybe ActorDead

displayException :: ActorDead -> String

actFinally :: (Either SomeException a -> IO ()) -> ActionT message IO a -> IO (Actor message)

Perform some ActionT in a thread, with some cleanup afterwards.

act :: ActionT message IO a -> IO (Actor message)

Perform some ActionT in a thread.

receiveSTM :: MonadIO m => (message -> STM a) -> ActionT message m a

Receive a message and, in the same transaction, produce some result.

receive :: MonadIO m => (message -> ActionT message m a) -> ActionT message m a

Receive a message and do some ActionT with it.

hoistActionT :: (forall x. m x -> n x) -> ActionT message m a -> ActionT message n a

Use a natural transformation to transform an ActionT on one base monad to another.

link :: MonadIO m => Actor message -> ActionT message' m ()

Link the lifetime of the given actor to this one. If the given actor dies, it will throw a LinkKill exception to us with its ThreadId attached to it.

linkSTM :: Actor message -> Actor message' -> STM ()

Links the lifetime of the first actor to the second. If the second actor's thread dies, it will throw a LinkKill exception to the first with its ThreadId attached to it.

data LinkKill

The exception thrown when an actor we've linked with has died.

Constructors

LinkKill ThreadId

Instances

Show LinkKill

Defined in Control.Concurrent.Actor

Methods

showsPrec :: Int -> LinkKill -> ShowS

show :: LinkKill -> String

showList :: [LinkKill] -> ShowS

Exception LinkKill

Defined in Control.Concurrent.Actor

Methods

toException :: LinkKill -> SomeException

fromException :: SomeException -> Maybe LinkKill

displayException :: LinkKill -> String

self :: Applicative m => ActionT message m (Actor message)

Returns the Actor handle of the actor executing this action.

murder :: MonadIO m => Actor message -> m ()

Throws a MurderKill exception to the given Actor.

data MurderKill

The exception thrown when we murder an Actor.

Constructors

MurderKill ThreadId

Instances

Show MurderKill

Defined in Control.Concurrent.Actor

Methods

showsPrec :: Int -> MurderKill -> ShowS

show :: MurderKill -> String

showList :: [MurderKill] -> ShowS

Exception MurderKill

Defined in Control.Concurrent.Actor

Methods

toException :: MurderKill -> SomeException

fromException :: SomeException -> Maybe MurderKill

displayException :: MurderKill -> String