Updater

Signals

data Signal a

Signal is the portable Signal they can be exchanged between any parts of your program. Internally, they are just a variable and a list of change hooks.

newSignal :: Updater (a -> Updater (), Signal a)

Creates a new signal and gives you a way to update it. It is important to note that because the signal and the update function are separate, you can easily have readonly, writeonly permissions.

getValue :: Signal a -> Updater (Maybe a)

Gets the current value. Return Nothing if the signal is uninitialized.

Updater Monad

data Updater a

This monad works very similar to a continuation monad on top of stm. You can do any basic stm computation you want simply using liftSTM. However, if you use getEvent everything after that call will be executed everytime the Signal given to getEvent is changed.

You can also use the Alternative instance to make a union of events.

You can also use the Applicative instance to run two things 'parallel'. Parallel meaning that events on one side will not cause the other side to be reevaluated completely.

Instances

Monad Updater

Functor Updater

Applicative Updater

Alternative Updater

runUpdater :: Updater a -> IO a

This will evaluate the Updater Monad. It will block until the first run reaches the end. After that, it will return the result and free everything. To prevent signals from reaching the end use stop or getEvent with some exit signal.

getEvent :: Signal a -> Updater a

Runs everything below it everytime its input signal is updated.

onCommit :: IO () -> Updater ()

IO actions given here will be executed once a signal update has been completed. They keep the order in which they are inserted.

onCleanup :: Updater () -> Updater ()

doesn't really work yet

Helpers

stop :: Updater a

Just a synonym for empty from Alternative. It basically prevents signals from ever progressing beyond this point. You can use this to make a filter for instance

when (condition) stop

getBehavior :: Signal a -> Updater a

Similar to getEvent except that it also fires an event immediately, if the input signal is already initialized. It can be created using getEvent and Alternative

local :: Updater a -> Updater ()

Returns immediately after registering the given computation. However, events from inside will not spread outside, except for the initial one.

It is implemented like this

local computation = return () <|> (computation >> stop)

liftSTM :: STM a -> Updater a

putLine :: String -> Updater ()

Just for some quick debugging

putLine = onCommit . putStrLn