Eve.Internal.Listeners

Documentation

class (Typeable s, HasExts s) => HasEvents s

A typeclass to ensure people don't dispatch events to states which shouldn't accept them.

To allow dispatching events in an action over your state simply define the empty instance:

instance HasEvents MyState where

• - Don't need anything here.

Instances

HasEvents AppState

dispatchEvent :: forall result eventType m s. (MonadState s m, HasEvents s, Monoid result, Typeable m, Typeable eventType, Typeable result) => eventType -> m result

dispatchEvent_ :: forall eventType m s. (MonadState s m, HasEvents s, Typeable m, Typeable eventType) => eventType -> m ()

dispatchEventAsync :: Typeable event => IO event -> App ()

This function takes an IO which results in some event, it runs the IO asynchronously and dispatches the event. Note that any listeners which are registered for the resulting event will still be run syncronously, only the code which generates the event is asynchronous.

addListener :: forall result eventType m s. (MonadState s m, HasEvents s, Typeable m, Typeable eventType, Typeable result, Monoid result) => (eventType -> m result) -> m ListenerId

addListener_ :: forall result eventType m s. (MonadState s m, HasEvents s, Typeable m, Typeable eventType, Typeable result, Monoid result) => (eventType -> m result) -> m ()

removeListener :: (MonadState s m, HasEvents s) => ListenerId -> m ()

asyncEventProvider :: (Dispatcher -> IO ()) -> App ()

This allows long-running IO processes to provide Events to the App asyncronously.

Don't let the type signature confuse you; it's much simpler than it seems.

Let's break it down:

Using the Dispatcher type with asyncEventProvider requires the RankNTypes language pragma.

This type as a whole represents a function which accepts a Dispatcher and returns an IO; the dispatcher itself accepts data of ANY Typeable type and emits it as an event.

When you call asyncEventProvider you pass it a function which accepts a dispatch function as an argument and then calls it with various events within the resulting IO.

Note that this function calls forkIO internally, so there's no need to do that yourself.

Here's an example which fires a Timer event every second.

{-# language RankNTypes #-}
data Timer = Timer
myTimer :: Dispatcher -> IO ()
myTimer dispatch = forever $ dispatch Timer >> threadDelay 1000000

myAction :: Action s ()
myAction = onInit $ asyncEventProvider myTimer

onInit :: App result -> App ()

Registers an action to be performed during the Initialization phase.

This phase occurs exactly ONCE when the app starts up. Though arbitrary actions may be performed in the configuration block; it's recommended to embed such actions in the onInit event listener so that all event listeners are registered before any dispatches occur.

afterInit :: App a -> App ()

beforeEvent :: App a -> App ListenerId

Registers an action to be performed BEFORE each event phase.

beforeEvent_ :: App a -> App ()

afterEvent :: App a -> App ListenerId

Registers an action to be performed BEFORE each event phase.

afterEvent_ :: App a -> App ()

onExit :: App a -> App ()

data Listener

A wrapper around event listeners so they can be stored in Listeners.

Instances

Show Listener

Methods

showsPrec :: Int -> Listener -> ShowS

show :: Listener -> String

showList :: [Listener] -> ShowS

data ListenerId

An opaque reverence to a specific registered event-listener. A ListenerId is used only to remove listeners later with removeListener.

Instances

Eq ListenerId

Methods

(==) :: ListenerId -> ListenerId -> Bool

(/=) :: ListenerId -> ListenerId -> Bool

Show ListenerId

Methods

showsPrec :: Int -> ListenerId -> ShowS

show :: ListenerId -> String

showList :: [ListenerId] -> ShowS