reactive: Simple foundation for functional reactive programming

[ frp, reactivity ] [ Propose Tags ] [ Report a vulnerability ]

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 a data-driven implementation. The main difference between Reactive and DataDriven is that Reactive builds on functional "futures" (using threading), while DataDriven builds on continuation-based computations.

Warning: executables using this library must be built with -threaded. Otherwise, reactions will be delayed significantly.

Please see the project wiki page: http://haskell.org/haskellwiki/reactive

The module documentation pages have links to colorized source code and to wiki pages where you can read and contribute user comments. Enjoy!

[Skip to Readme]

Modules

[Index]

Data

Downloads

reactive-0.0.tar.gz [browse] (Cabal source package)
Package description (as included in the package)

Maintainer's Corner

Package maintainers

ConalElliott, RussellOConnor

For package maintainers and hackage trustees

edit package information

Candidates

No Candidates

Versions [RSS]	0.0, 0.2, 0.3, 0.5, 0.5.0.1, 0.8.3, 0.8.6, 0.8.8, 0.9.0, 0.9.1, 0.9.3, 0.9.4, 0.9.5, 0.9.6, 0.9.7, 0.9.8, 0.9.9, 0.9.10, 0.10.0, 0.10.1, 0.10.2, 0.10.3, 0.10.4, 0.10.5, 0.10.7, 0.11, 0.11.2, 0.11.3, 0.11.4, 0.11.5
Dependencies	base, TypeCompose [details]
License	BSD-3-Clause
Copyright	(c) 2007 by Conal Elliott
Author	Conal Elliott
Maintainer	conal@conal.net
Category	reactivity, FRP
Home page	http://haskell.org/haskellwiki/reactive
Uploaded	by ConalElliott at 2007-12-28T01:09:48Z
Distributions
Reverse Dependencies	4 direct, 4 indirect [details]
Downloads	20848 total (77 in the last 30 days)
Rating	(no votes yet) [estimated by Bayesian average]
Your Rating	λ λ λ
Status	Docs uploaded by user Build status unknown [no reports yet]

Readme for reactive-0.0

[back to package description]

_Reactive_ [1] is a simple foundation for programming reactive systems
functionally.  Like Fran/FRP, it has a notions of (reactive) behaviors and
events.  Like DataDriven [2], Reactive has a data-driven implementation.
The main difference between Reactive and DataDriven is that Reactive
builds on MVar-based "futures", while DataDriven builds on
continuation-based computations.

The inspiration for Reactive was Mike Sperber's Lula [3] implementation of
FRP.  Mike used blocking threads, which I had never considered for FRP.
While playing with the idea, I realized that I could give a very elegant
and efficient solution to caching, which DataDriven doesn't do.  (For an
application "f <*> a" of a varying function to a varying argument, caching
remembers the latest function to apply to a new argument and the last
argument to which to apply a new function.)

Please share any comments & suggestions on the discussion (talk) page
there.

You can configure, build, and install all in the usual way with Cabal
commands.

  runhaskell Setup.lhs configure
  runhaskell Setup.lhs build
  runhaskell Setup.lhs install


References:

[1] http://haskell.org/haskellwiki/Reactive
[2] http://haskell.org/haskellwiki/DataDriven
[3] http://www-pu.informatik.uni-tuebingen.de/lula/deutsch/publications.html