Eve

Documentation

eve :: App () -> IO AppState

type App a = Action AppState a

data Action zoomed a

Instances

MonadState zoomed (Action zoomed)

Methods

get :: Action zoomed zoomed

put :: zoomed -> Action zoomed ()

state :: (zoomed -> (a, zoomed)) -> Action zoomed a

MonadFree ActionF (Action zoomed)

Methods

wrap :: ActionF (Action zoomed a) -> Action zoomed a

Monad (Action zoomed)

Methods

(>>=) :: Action zoomed a -> (a -> Action zoomed b) -> Action zoomed b

(>>) :: Action zoomed a -> Action zoomed b -> Action zoomed b

return :: a -> Action zoomed a

fail :: String -> Action zoomed a

Functor (Action zoomed)

Methods

fmap :: (a -> b) -> Action zoomed a -> Action zoomed b

(<$) :: a -> Action zoomed b -> Action zoomed a

Applicative (Action zoomed)

Methods

pure :: a -> Action zoomed a

(<*>) :: Action zoomed (a -> b) -> Action zoomed a -> Action zoomed b

(*>) :: Action zoomed a -> Action zoomed b -> Action zoomed b

(<*) :: Action zoomed a -> Action zoomed b -> Action zoomed a

MonadIO (Action zoomed)

Methods

liftIO :: IO a -> Action zoomed a

Zoom (Action s) (Action t) s t

Methods

zoom :: LensLike' (Zoomed (Action s) c) t s -> Action s c -> Action t c

type Zoomed (Action s)

type Zoomed (Action s) = Zoomed (FreeT ActionF (StateT s IO))

liftAction :: Action AppState a -> Action zoomed a

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.

dispatchActionAsync :: IO (App ()) -> App ()

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 ()

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 ()

asyncActionProvider :: ((App () -> IO ()) -> IO ()) -> App ()

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

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

class HasExts s where

Represents a state which can be extended. exts is a Lens' which points to the state's Exts

Minimal complete definition

exts

Methods

exts :: Lens' s Exts

Instances

HasExts AppState

Methods

exts :: Lens' AppState Exts

type Exts = Map TypeRep Ext

A map of extension types to their current value.

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

ext :: forall a e. (Show a, Typeable a, Default a, HasExts e) => Lens' e a

A polymorphic lens which accesses extensions in the extension state. It returns the default value (def) if a state has not yet been set.

runAction :: Zoom m n s t => LensLike' (Zoomed m c) t s -> m c -> n c

exit :: App ()