|A library for programming with functional reactive behaviors.
|type TimeT = Double|
|type ITime = Improving TimeT|
|data EventG t a|
|type Event = EventG ITime|
|accumE :: a -> EventG t (a -> a) -> EventG t a|
|withTimeE :: Event a -> Event (a, TimeT)|
|pairE :: Ord t => (c, d) -> (EventG t c, EventG t d) -> EventG t (c, d)|
|scanlE :: Ord t => (a -> b -> a) -> a -> EventG t b -> EventG t a|
|monoidE :: (Ord t, Monoid o) => EventG t o -> EventG t o|
|stateE :: Ord t => s -> (s -> s) -> EventG t b -> EventG t (b, s)|
|stateE_ :: Ord t => s -> (s -> s) -> EventG t b -> EventG t s|
|countE :: (Ord t, Num n) => EventG t b -> EventG t (b, n)|
|countE_ :: (Ord t, Num n) => EventG t b -> EventG t n|
|diffE :: (Ord t, Num n) => EventG t n -> EventG t n|
|withPrevE :: Ord t => EventG t a -> EventG t (a, a)|
|withPrevEWith :: Ord t => (a -> a -> b) -> EventG t a -> EventG t b|
|whenE :: Ord t => EventG t a -> ReactiveG t Bool -> EventG t a|
|eitherE :: Ord t => EventG t a -> EventG t b -> EventG t (Either a b)|
|listE :: [(TimeT, a)] -> Event a|
|atTimes :: [TimeT] -> Event ()|
|atTime :: TimeT -> Event ()|
|once :: Ord t => EventG t a -> EventG t a|
|firstRestE :: Ord t => EventG t a -> (a, EventG t a)|
|firstE :: Ord t => EventG t a -> a|
|restE :: Ord t => EventG t a -> EventG t a|
|withRestE :: EventG t a -> EventG t (a, EventG t a)|
|untilE :: Ord t => EventG t a -> EventG t b -> EventG t a|
|splitE :: Ord t => EventG t a -> EventG t b -> EventG t (a, EventG t b)|
|switchE :: Event (Event a) -> Event a|
|joinMaybes :: MonadPlus m => m (Maybe a) -> m a|
|filterMP :: MonadPlus m => (a -> Bool) -> m a -> m a|
|data BehaviorG tr tf a|
|type Behavior = BehaviorG ITime TimeT|
|time :: Behavior TimeT|
|stepper :: a -> Event a -> Behavior a|
|switcher :: Behavior a -> Event (Behavior a) -> Behavior a|
|snapshotWith :: (a -> b -> c) -> Event a -> Behavior b -> Event c|
|snapshot :: Event a -> Behavior b -> Event (a, b)|
|snapshot_ :: Event a -> Behavior b -> Event b|
|accumB :: a -> Event (a -> a) -> Behavior a|
|scanlB :: (a -> b -> a) -> a -> Event b -> Behavior a|
|monoidB :: Monoid a => Event a -> Behavior a|
|maybeB :: Event a -> Event b -> Behavior (Maybe a)|
|flipFlop :: Event a -> Event b -> Behavior Bool|
|countB :: Num n => Event a -> Behavior n|
|sumB :: VectorSpace v s => Event v -> Behavior v|
|integral :: VectorSpace v TimeT => Event () -> Behavior v -> Behavior v|
|The type of finite time values.
|Improving doubles, as used for time values in Event, Reactive,
Events. Semantically: time-ordered list of future values.
- Monoid: mempty is the event that never occurs, and e mappend
e' is the event that combines occurrences from e and e'.
- Functor: fmap f e is the event that occurs whenever e occurs,
and whose occurrence values come from applying f to the values from
- Applicative: pure a is an event with a single occurrence at time
-Infinity. ef <*> ex is an event whose occurrences are made from
the product of the occurrences of ef and ex. For every occurrence
f at time tf of ef and occurrence x at time tx of ex, ef
<*> ex has an occurrence f x at time tf max tx. N.B.: I
don't expect this instance to be very useful. If ef has nf
instances and ex has nx instances, then ef <*> ex has nf*nx
instances. However, there are only nf+nx possibilities for tf
max tx, so many of the occurrences are simultaneous. If you think
you want to use this instance, consider using Reactive instead.
- Monad: return a is the same as pure a (as usual). In e >>= f,
each occurrence of e leads, through f, to a new event. Similarly
for join ee, which is somehow simpler for me to think about. The
occurrences of e >>= f (or join ee) correspond to the union of the
occurrences (temporal interleaving) of all such events. For example,
suppose we're playing Asteroids and tracking collisions. Each collision
can break an asteroid into more of them, each of which has to be tracked
for more collisions. Another example: A chat room has an enter event,
whose occurrences contain new events like speak. An especially useful
monad-based function is joinMaybes, which filters a Maybe-valued
|Events, specialized to improving doubles for time
|Accumulating event, starting from an initial value and a
update-function event. See also accumR.
Example: (using a list rempresentation for events, for clarity
[(5 seconds, (+2)),(10 seconds, (subtract 30)),(20 seconds,(*10))]
= [(5 seconds, 12),(10 seconds, -18),(20 seconds, -180)]
If you want an initial occurance at -infinity you can use pure a
mappend accumE a e
|Access occurrence times in an event. See withTimeGE for more
general notions of time.
|Generate a pair-valued event, given a pair of initial values and a
pair of events. See also pair on Reactive.
|Like scanl for events.
|Accumulate values from a monoid-typed event. Specialization of
scanlE, using mappend and mempty.
|State machine, given initial value and transition function. Carries
along event data. See also stateE_. TODO: better name.
|State machine, given initial value and transition function. See also
|Count occurrences of an event, remembering the occurrence values.
See also countE_.
|Count occurrences of an event, forgetting the occurrence values. See
|Difference of successive event occurrences. See withPrevE for a
trick to supply an initial previous value.
|Pair each event value with the previous one. The second result is
the old one. Nothing will come out for the first occurrence of e,
but if you have an initial value a, you can do withPrevE (pure a
|Same as withPrevE, but allow a function to combine the values.
Provided for convenience.
|Filter an event according to whether a reactive boolean is true.
|Combine two events into one.
|Convert a temporally monotonic list of timed values to an event. See also
the generalization listEG
|Event occuring at given times. See also atTime and atTimeG.
|Single-occurrence event at given time. See atTimes and atTimeG.
|Just the first occurrence of an event.
|Decompose an event into its first occurrence value and a remainder
event. See also firstE and restE.
|Extract the first occurrence value of an event. See also
firstRestE and restE.
|Extract the remainder an event, after its first occurrence. See also
firstRestE and firstE.
|Access the remainder with each event occurrence.
|Truncate first event at first occurrence of second event.
|Partition an event into segments.
|Switch from one event to another, as they occur. (Doesn't merge, as
|Useful with events.
|Pass through Just occurrences.
|Pass through values satisfying p.
Reactive behaviors. They can be understood in terms of a simple
model (denotational semantics) as functions of time, namely at ::
BehaviorG t a -> (t -> a).
The semantics of BehaviorG instances are given by corresponding
instances for the semantic model (functions). See
- Functor: at (fmap f r) == fmap f (at r), i.e., fmap f r at
t == f (r at t).
- Applicative: at (pure a) == pure a, and at (s <*> r) == at s
<*> at t. That is, pure a at t == a, and (s <*> r) at t
== (s at t) (r at t).
- Monad: at (return a) == return a, and at (join rr) == join (at
. at rr). That is, return a at t == a, and join rr at t ==
(rr at t) at t. As always, (r >>= f) == join (fmap f r).
at (r >>= f) == at r >>= at . f.
- Monoid: a typical lifted monoid. If o is a monoid, then
Reactive o is a monoid, with mempty == pure mempty, and mappend
== liftA2 mappend. That is, mempty at t == mempty, and (r
mappend s) at t == (r at t) mappend (s at t).
Note: The signatures of all of the behavior functions can be generalized. Is
the interface generality worth the complexity?
|The identity generalized behavior. Has value t at time t.
|Discretely changing behavior, based on an initial value and a
|Switch between behaviors.
|Snapshots a behavior whenever an event occurs and combines the values
using the combining function passed.
|Snapshot a behavior whenever an event occurs. See also snapshotWith.
|Like snapshot but discarding event data (often a is '()').
|Behavior from an initial value and an updater event. See also
|Like scanl for behaviors. See also scanlE.
|Accumulate values from a monoid-valued event. Specialization of
scanlE, using mappend and mempty. See also monoidE.
|Start out blank (Nothing), latching onto each new a, and blanking
on each b. If you just want to latch and not blank, then use
mempty for the second event.
|Flip-flopping behavior. Turns true whenever first event occurs and
false whenever the second event occurs.
|Count occurrences of an event. See also countE.
|Like sum for behaviors.
|Produced by Haddock version 2.3.0|