FRP.Reactive.Behavior

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 http://conal.net/blog/posts/simplifying-semantics-with-type-class-morphisms/.

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

Instances

Eq (Behavior b)

Floating b => Floating (Behavior b)

Fractional b => Fractional (Behavior b)

Num b => Num (Behavior b)

Ord b => Ord (Behavior b)

Show (Behavior b)

VectorSpace v => VectorSpace (Behavior v)

AdditiveGroup v => AdditiveGroup (Behavior v)

Functor (BehaviorG tr tf)

Ord tr => Applicative (BehaviorG tr tf)

(Ord tr, Monoid a) => Monoid (BehaviorG tr tf a)

type Behavior = BehaviorG ITime TimeT

Source

Time-specialized behaviors. Note: The signatures of all of the behavior functions can be generalized. Is the interface generality worth the complexity?

time :: Behavior TimeT

Source

The identity generalized behavior. Has value t at time t.

stepper :: a -> Event a -> Behavior a

Source

Discretely changing behavior, based on an initial value and a new-value event.

switcher :: Behavior a -> Event (Behavior a) -> Behavior a

Source

Switch between behaviors.

snapshotWith :: (a -> b -> c) -> Event a -> Behavior b -> Event c

Source

Snapshots a behavior whenever an event occurs and combines the values using the combining function passed.

snapshot :: Event a -> Behavior b -> Event (a, b)

Source

Snapshot a behavior whenever an event occurs. See also snapshotWith.

snapshot_ :: Event a -> Behavior b -> Event b

Source

Like snapshot but discarding event data (often a is '()').

accumB :: a -> Event (a -> a) -> Behavior a

Source

Behavior from an initial value and an updater event. See also accumE.

scanlB :: forall a. (Behavior a -> Behavior a -> Behavior a) -> Behavior a -> Event (Behavior a) -> Behavior a

Source

Like scanl for behaviors. See also scanlE.

monoidB :: Monoid a => Event (Behavior a) -> Behavior a

Source

Accumulate values from a monoid-valued event. Specialization of scanlB, using mappend and mempty. See also monoidE.

maybeB :: Event a -> Event b -> Behavior (Maybe a)

Source

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.

flipFlop :: Event a -> Event b -> Behavior Bool

Source

Flip-flopping behavior. Turns true whenever first event occurs and false whenever the second event occurs.

countB :: Num n => Event a -> Behavior n

Source

Count occurrences of an event. See also countE.

sumB :: VectorSpace v => Event v -> Behavior v

Source

Like sum for behaviors.

integral :: (VectorSpace v, Scalar v ~ TimeT) => Event () -> Behavior v -> Behavior v

Source

Euler integral.

Produced by Haddock version 2.3.0