Copyright | (c) 2015 Schell Scivally |
---|---|
License | MIT |
Maintainer | Schell Scivally <schell.scivally@synapsegroup.com> |
Safe Haskell | None |
Language | Haskell2010 |
- data Event a
- toMaybe :: Event a -> Maybe a
- isEvent :: Event a -> Bool
- latchWith :: Monad m => (b -> c -> d) -> Var m a (Event b) -> Var m a (Event c) -> Var m a (Event d)
- orE :: Monad m => Var m a b -> Var m a (Event b) -> Var m a b
- tagOn :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b)
- tagM :: Monad m => (b -> m c) -> Var m a (Event b) -> Var m a (Event c)
- use :: (Functor f, Functor e) => a -> f (e b) -> f (e a)
- onTrue :: Monad m => Var m Bool (Event ())
- onJust :: Monad m => Var m (Maybe a) (Event a)
- onUnique :: (Monad m, Eq a) => Var m a (Event a)
- onWhen :: Applicative m => (a -> Bool) -> Var m a (Event a)
- toEvent :: Monad m => Var m a b -> Var m a (Event b)
- collect :: Monad m => Var m (Event a) [a]
- hold :: Monad m => Var m a (Event b) -> b -> Var m a b
- holdWith :: Monad m => b -> Var m a (Event b) -> Var m a b
- startingWith :: Monad m => a -> Var m (Event a) a
- startWith :: Monad m => a -> Var m (Event a) a
- between :: Monad m => Var m a (Event b) -> Var m a (Event c) -> Var m a (Event ())
- until :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b)
- after :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b)
- beforeWith :: Monad m => Var m a b -> (Var m a (Event b), b -> Var m a (Event b)) -> Var m a (Event b)
- beforeOne :: Monad m => Var m a b -> Var m a (Event b) -> Var m a (Event b)
- before :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b)
- filterE :: Monad m => (b -> Bool) -> Var m a (Event b) -> Var m a (Event b)
- takeE :: Monad m => Int -> Var m a (Event b) -> Var m a (Event b)
- once :: Monad m => b -> Var m a (Event b)
- always :: Monad m => b -> Var m a (Event b)
- never :: Monad m => Var m b (Event c)
- andThen :: Monad m => Var m a (Event b) -> Var m a b -> Var m a b
- andThenWith :: Monad m => Var m a (Event b) -> (Maybe b -> Var m a b) -> Var m a b
- andThenE :: Monad m => Var m a (Event b) -> Var m a (Event b) -> Var m a (Event b)
- switchByMode :: (Monad m, Eq b) => Var m a b -> (b -> Var m a c) -> Var m a c
- combineWith :: Monad m => (b -> c -> d) -> Var m a (Event b) -> Var m a (Event c) -> Var m a (Event d)
- combine :: Monad m => Var m a (Event b) -> Var m a (Event c) -> Var m a (Event (b, c))
Documentation
For all intents and purposes you can think of an Event as a Maybe.
A value of Event ()
means that an event has occurred and that the
result is a ()
. A value of NoEvent
means that an event did not
occur.
Event streams (like Var m a (Event b)
) describe events that may occur over
varying a
(also known as the series of a
). Usually a
would be some
form of time or some user input type.
Transforming event values.
Combining event streams and value streams
latchWith :: Monad m => (b -> c -> d) -> Var m a (Event b) -> Var m a (Event c) -> Var m a (Event d) Source
Holds the last value of one event stream while waiting for another event stream to produce a value. Once both streams have produced a value, combine the two using the given combine function and emit an event with the value.
orE :: Monad m => Var m a b -> Var m a (Event b) -> Var m a b Source
Produces values from the first unless the second produces event values and if so, produces the values of those events.
tagOn :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b) Source
Injects the values of the vb
into the events of ve
.
tagM :: Monad m => (b -> m c) -> Var m a (Event b) -> Var m a (Event c) Source
Injects a monadic computation into an event stream, using the event
values of type b
as a parameter to produce an event stream of type
c
. After the first time an event is generated the result of the
previous event is used in a clean up function.
This is like tagM
but performs a cleanup function first.
ringM :: Monad m
=> (c -> m ()) -> (b -> m c) -> Var m a (Event b) -> Var m a (Event c)
ringM cln = (go (const $ return ()) .) . tagM
where go f ve = Var $ a -> do (ec, ve') <- runVar ve a
case ec of
NoEvent -> return (ec, go f ve')
Event c -> do f c
return (ec, go cln ve')
Injects a monadic computation into the events of vb
, providing a way
to perform side-effects inside an Event
inside a Var
.
Generating events from values
use :: (Functor f, Functor e) => a -> f (e b) -> f (e a) Source
Populates a varying Event with a value. This is meant to be used with
the various 'on...' event triggers. For example
use 1 onTrue
produces values of `Event 1` when the input value is True
.
onTrue :: Monad m => Var m Bool (Event ()) Source
Triggers an `Event ()` when the input value is True.
onJust :: Monad m => Var m (Maybe a) (Event a) Source
Triggers an `Event a` when the input is `Just a`.
onUnique :: (Monad m, Eq a) => Var m a (Event a) Source
Triggers an `Event a` when the input is a unique value.
onWhen :: Applicative m => (a -> Bool) -> Var m a (Event a) Source
Triggers an `Event a` when the condition is met.
toEvent :: Monad m => Var m a b -> Var m a (Event b) Source
Wraps all produced values of the given var with events.
Using event streams
startingWith :: Monad m => a -> Var m (Event a) a Source
Produces the given value until the input events produce a value, then
produce that value until a new input event produces. This always holds
the last produced value, starting with the given value.
time ~> after 3 ~> startingWith 0
This is similar to hold
except that it takes events from its input value
instead of another Var
.
startWith :: Monad m => a -> Var m (Event a) a Source
Produces the given value until the input events produce a value, then
produce that value until a new input event produces. This always holds
the last produced value, starting with the given value.
time ~> after 3 ~> startingWith 0
This is similar to hold
except that it takes events from its input value
instead of another Var
.
Temporal operations (time - related)
between :: Monad m => Var m a (Event b) -> Var m a (Event c) -> Var m a (Event ()) Source
Produce events after the first until the second. After a successful cycle it will start over.
until :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b) Source
Produce events with the initial varying value until the input event stream
ve
produces its first event, then never produce any events.
after :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b) Source
Produce events with the initial value only after the input stream has produced one event.
beforeWith :: Monad m => Var m a b -> (Var m a (Event b), b -> Var m a (Event b)) -> Var m a (Event b) Source
Like before, but use the value produced by the switching stream to create a stream to switch to.
beforeOne :: Monad m => Var m a b -> Var m a (Event b) -> Var m a (Event b) Source
Like before, but sample the value of the second stream once before inhibiting.
before :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b) Source
Produce events with the initial varying value only before the second stream has produced one event.
filterE :: Monad m => (b -> Bool) -> Var m a (Event b) -> Var m a (Event b) Source
Inhibit all events that don't pass the predicate.
takeE :: Monad m => Int -> Var m a (Event b) -> Var m a (Event b) Source
Stream through some number of successful events and then inhibit forever.
once :: Monad m => b -> Var m a (Event b) Source
Produce the given value once and then inhibit forever.
never :: Monad m => Var m b (Event c) Source
TODO: | Produce events of a stream only when both streams produce events. | Combine simultaneous events.
Never produces any event values.
Switching and chaining events
andThenWith :: Monad m => Var m a (Event b) -> (Maybe b -> Var m a b) -> Var m a b Source
Switches from one event stream when that stream stops producing. A new
stream is created using the last produced value (or Nothing
) and used
as the second stream.
andThenE :: Monad m => Var m a (Event b) -> Var m a (Event b) -> Var m a (Event b) Source
Switches from one event stream to another once the first stops producing.
switchByMode :: (Monad m, Eq b) => Var m a b -> (b -> Var m a c) -> Var m a c Source
Switches using a mode signal. Signals maintain state for the duration of the mode.