Old-reactive

From HaskellWiki

1 Abstract

Note: I'm retiring the old version of Reactive on darcs.haskell.org. The new version (on code.haskell.org) is not quite ready to use yet, though it's getting there.

Reactive is a simple foundation for programming reactive systems functionally. Like Fran/FRP, it has a notions of (reactive) behaviors and events. Like DataDriven, Reactive has an efficient, data-driven implementation. The main difference between Reactive and DataDriven are

• Reactive provides and builds on "functional futures", which in turn build on Concurrent Haskell threads, while DataDriven builds on continuation-based computations; and
• The algebras of events and reactive values (called events and sources in DataDriven) are purely functional. I couldn't figure out how to accomplish that in DataDriven.
• Reactive manages (I hope) to get the efficiency of data-driven computation with a (sort-of) demand-driven architecture. For that reason, Reactive is garbage-collector-friendly, while DataDriven depends on weak references (because GC favors demand-driven computation.)
• Reactive elegantly and efficiently caches values.
• Reactive uses the term "reactive values" (
  Reactive
  ), where DataDriven uses "sources" (
  Source
  ).

Besides this wiki page, here are more ways to find out about Reactive:

• Read the Haddock docs.
• Get the code repository: darcs get http://darcs.haskell.org/packages/old-reactive/. (Old version, to be replaced in September 08.)
• Install from Hackage.
• See the version history.

Also, the paper Simply Efficient Functional Reactivity, and its blog post with discussion, describe a (not-yet-released) successor to Reactive that solves the determinacy problem mentioned below.

Please leave comments at the Talk page.

2 Modules

2.1 Data.Future

A future is a value that will become knowable only later. Primitive futures can be things like "the value of the next key you press", or "the value of LambdaPix stock at noon next Monday". The term "promise" might be more fitting.

• Monoid
  :
  mempty
  is a future that never becomes knowable.
  a `mappend` b
  is whichever of
  a
  and
  b
  is knowable first.
• Functor
  : apply a function to a future. The result is knowable when the given future is knowable.
• Applicative
  :
  pure
  gives value knowable since the beginning of time.
  (<*>)
  applies a future function to a future argument. Result available when both are available, i.e., it becomes knowable when the later of the two futures becomes knowable.
• Monad:
  return
  is the same as
  pure
  (as always).
  (>>=)
  cascades futures.
  join
  resolves a future future value into a future value.

2.1.1 Garbage collection of futures

2.1.2 Concurrent Haskell vs STM

2.2 Data.SFuture

A target denotational semantics for Data.Future -- simple, precise, and deterministic, in terms of time/value pairs.

2.3 Data.Reactive

This module defines events and reactive values. An event is stream of future values in order of availability. A reactive value is a discretly time-varying value. These two types are closely linked: a reactive value is defined by an initial value and an event that yields future values; while an event is simply a future reactive value.

data Reactive a = a `Stepper` Event a
newtype Event a = Event (Future (Reactive a))

Many of the operations on events and reactive values are packaged as instances of standard classes, as described below. See the module documentation for the other operations.

2.3.1 Instances for Event

• Monoid
  :
  mempty
  is the event that never occurs, and
  e `mappend` e'
  is the event that combines occurrences from
  e
  and
  e'
  . (Fran's
  neverE
  and
  (.|.)
  .)
• 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
  . (Fran's
  (==>)
  .)
• Applicative
  :
  pure a
  is an event with a single occurrence, available from the beginning of time.
  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
  max tf tx
  .
• Monad
  :
  return a
  is the same as
  pure a
  (as always). 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 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".

2.3.2 Instances for Reactive

• Monoid
  : a typical lifted monoid. If
  o
  is a monoid, then
  Reactive o
  is a monoid, with
  mempty = pure mempty
  , and
  mappend = liftA2 mappend
  . In other words,
  mempty `at` t == mempty
  , and
  (r `mappend` s) `at` t == (r `at` t) `mappend` (s `at` t).
• Functor
  :
  fmap f r `at` t == f (r `at` t)
  .
• Applicative
  :
  pure a `at` t == a
  , and
  (s <*> r) `at` t == (s `at` t) (r `at` t)
  .
• Monad
  :
  return a `at` t == a
  , and
  join rr `at` t == (rr `at` t) `at` t
  . As always,
  (r >>= f) == join (fmap f r)
  .

2.3.3 Continuous reactive behaviors

type Time = Double
type ReactiveB = Reactive :. Fun Time

2.4 Data.Fun

Categories: Events | Reactivity | FRP | Packages