| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
UnliftIO.MessageBox.Class
Description
This module contains a type class that describes exchangable operations on messages boxes.
Synopsis
- class (IsMessageBox (MessageBox argument), IsInput (Input (MessageBox argument))) => IsMessageBoxArg argument where
- type MessageBox argument :: Type -> Type
- getConfiguredMessageLimit :: argument -> Maybe Int
- newMessageBox :: MonadUnliftIO m => argument -> m (MessageBox argument a)
- class IsInput (Input box) => IsMessageBox box where
- type Input box :: Type -> Type
- receive :: MonadUnliftIO m => box a -> m (Maybe a)
- tryReceive :: MonadUnliftIO m => box a -> m (Future a)
- receiveAfter :: MonadUnliftIO m => box a -> Int -> m (Maybe a)
- newInput :: MonadUnliftIO m => box a -> m (Input box a)
- class IsInput input where
- deliver :: MonadUnliftIO m => input a -> a -> m Bool
- deliver_ :: MonadUnliftIO m => input a -> a -> m ()
- handleMessage :: (MonadUnliftIO m, IsMessageBox box) => box message -> (message -> m b) -> m (Maybe b)
Documentation
class (IsMessageBox (MessageBox argument), IsInput (Input (MessageBox argument))) => IsMessageBoxArg argument where Source #
Types that configure and allow the creation of a MessageBox.
Create IsMessageBox instances from a parameter.
Types that determine MessageBox values.
For a limited message box this might be the limit of the message queue.
Associated Types
type MessageBox argument :: Type -> Type Source #
The message box that can be created from the message box argument
Methods
getConfiguredMessageLimit :: argument -> Maybe Int Source #
Return a message limit.
NOTE: This method was added for unit tests. Although the method is totally valid, it might not be super useful in production code. Also note that the naming follows the rule: Reserve short names for entities that are used often.
newMessageBox :: MonadUnliftIO m => argument -> m (MessageBox argument a) Source #
Create a new msgBox according to the argument.
This is required to receive a message.
NOTE: Only one process may receive on an msgBox.
Instances
class IsInput (Input box) => IsMessageBox box where Source #
A type class for msgBox types. A common interface for receiving messages.
Minimal complete definition
Methods
receive :: MonadUnliftIO m => box a -> m (Maybe a) Source #
Receive a message. Take whatever time it takes.
Return Just the value or Nothing when an error
occurred.
NOTE: Nothing may sporadically be returned, especially when there is a lot of load, so please make sure to build your application in such a way, that it anticipates failure.
tryReceive :: MonadUnliftIO m => box a -> m (Future a) Source #
Return a Future that can be used to wait for the
arrival of the next message.
NOTE: Each future value represents the next slot in the queue
so one future corresponds to exactly that message (should it arrive)
and if that future value is dropped, that message will be lost!
Arguments
| :: MonadUnliftIO m | |
| => box a | Message box |
| -> Int | Time in micro seconds to wait until the action is invoked. |
| -> m (Maybe a) |
Wait for an incoming message or return Nothing.
The default implementation uses tryReceive to get a
Future on which awaitFuture inside a timeout is called.
Instances might override this with more performant implementations especially non-blocking Unagi channel based implementation.
NOTE: Nothing may sporadically be returned, especially when there is a lot of load, so please make sure to build your application in such a way, that it anticipates failure.
newInput :: MonadUnliftIO m => box a -> m (Input box a) Source #
Create a new input that enqueus messages,
which are received by the box
Instances
class IsInput input where Source #
A type class for input types. A common interface for delivering messages.
Minimal complete definition
Methods
deliver :: MonadUnliftIO m => input a -> a -> m Bool Source #
Send a message. Take whatever time it takes. Depending on the implementation, this might be a non-blocking operation. Return if the operation was successful.
NOTE: False may sporadically be returned, especially
when there is a lot of load, so please make sure to
build your application in such a way, that it
anticipates failure.
deliver_ :: MonadUnliftIO m => input a -> a -> m () Source #
Instances
handleMessage :: (MonadUnliftIO m, IsMessageBox box) => box message -> (message -> m b) -> m (Maybe b) Source #
Receive a message and apply a function to it.