reactive-0.9.0: Simple foundation for functional reactive programmingSource codeContentsIndex
FRP.Reactive.Internal.Reactive
Stabilityexperimental
Maintainerconal@conal.net
Description

Representation for Reactive and Event types. Combined here, because they're mutually recursive.

The representation used in this module is based on a close connection between these two types. A reactive value is defined by an initial value and an event that yields future values; while an event is given as a future reactive value.

Synopsis
newtype EventG t a = Event {
eFuture :: FutureG t (ReactiveG t a)
}
inEvent :: (FutureG s (ReactiveG s a) -> FutureG t (ReactiveG t b)) -> EventG s a -> EventG t b
inEvent2 :: (FutureG t (ReactiveG t a) -> FutureG t (ReactiveG t b) -> FutureG t (ReactiveG t c)) -> EventG t a -> EventG t b -> EventG t c
eFutures :: EventG t a -> [FutureG t a]
data ReactiveG t a = a Stepper (EventG t a)
inREvent :: (EventG s a -> EventG t a) -> ReactiveG s a -> ReactiveG t a
inFutR :: (FutureG s (ReactiveG s b) -> FutureG t (ReactiveG t b)) -> ReactiveG s b -> ReactiveG t b
runE :: forall t. Ord t => Sink t -> Sink (EventG t Action)
runR :: Ord t => Sink t -> Sink (ReactiveG t Action)
forkE :: Ord t => Sink t -> EventG t Action -> IO ThreadId
forkR :: Ord t => Sink t -> ReactiveG t Action -> IO ThreadId
Documentation
newtype EventG t a Source

Events. Semantically: time-ordered list of future values. Instances:

  • 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 e.
  • 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 event.
Constructors
Event
eFuture :: FutureG t (ReactiveG t a)
show/hide Instances
Ord t => Monad (EventG t)
Functor (EventG t)
Ord t => MonadPlus (EventG t)
Ord t => Applicative (EventG t)
Unpair (EventG t)
Ord t => Monoid_f (EventG t)
Ord t => Alternative (EventG t)
(Show a, Show b) => Show (EventG a b)
(Arbitrary t, Ord t, Num t, Arbitrary a) => Arbitrary (EventG t a)
Ord t => Monoid (EventG t a)
(Eq a, Eq b, EqProp a, EqProp b) => EqProp (EventG a b)
inEvent :: (FutureG s (ReactiveG s a) -> FutureG t (ReactiveG t b)) -> EventG s a -> EventG t bSource
Apply a unary function inside an EventG representation.
inEvent2 :: (FutureG t (ReactiveG t a) -> FutureG t (ReactiveG t b) -> FutureG t (ReactiveG t c)) -> EventG t a -> EventG t b -> EventG t cSource
Apply a unary function inside an EventG representation.
eFutures :: EventG t a -> [FutureG t a]Source
Make the event into a list of futures
data ReactiveG t a Source

Reactive value: a discretely changing value. Reactive values can be understood in terms of (a) a simple denotational semantics of reactive values as functions of time, and (b) the corresponding instances for functions. The semantics is given by the function at :: ReactiveG t a -> (t -> a). A reactive value may also be thought of (and in this module is implemented as) a current value and an event (stream of future values).

The semantics of ReactiveG instances are given by corresponding instances for the semantic model (functions):

  • 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).
Constructors
a Stepper (EventG t a)
show/hide Instances
Ord t => Monad (ReactiveG t)
Functor (ReactiveG t)
Ord t => Applicative (ReactiveG t)
Ord t => Pair (ReactiveG t)
Unpair (ReactiveG t)
(Show x, Show y) => Show (ReactiveG x y)
(Arbitrary t, Arbitrary a, Num t, Ord t) => Arbitrary (ReactiveG t a)
(Ord t, Monoid a) => Monoid (ReactiveG t a)
(Ord t, Arbitrary t, Show t, EqProp a) => EqProp (ReactiveG t a)
Ord t => Model (ReactiveG t a) (t -> a)
inREvent :: (EventG s a -> EventG t a) -> ReactiveG s a -> ReactiveG t aSource
Apply a unary function inside the rEvent part of a Reactive representation.
inFutR :: (FutureG s (ReactiveG s b) -> FutureG t (ReactiveG t b)) -> ReactiveG s b -> ReactiveG t bSource
Apply a unary function inside the future reactive inside a Reactive representation.
runE :: forall t. Ord t => Sink t -> Sink (EventG t Action)Source
Run an event in the current thread. Use the given time sink to sync time, i.e., to wait for an output time before performing the action.
runR :: Ord t => Sink t -> Sink (ReactiveG t Action)Source
Run a reactive value in the current thread, using the given time sink to sync time.
forkE :: Ord t => Sink t -> EventG t Action -> IO ThreadIdSource
Run an event in a new thread, using the given time sink to sync time.
forkR :: Ord t => Sink t -> ReactiveG t Action -> IO ThreadIdSource
Run a reactive value in a new thread, using the given time sink to sync time. The initial action happens in the current thread.
Produced by Haddock version 2.3.0