netwire alternatives and similar packages
Based on the "FRP" category.
Alternatively, view netwire alternatives based on common mentions on social networks and blogs.

reflex
Interactive programs without callbacks or sideeffects. Functional Reactive Programming (FRP) uses composable events and timevarying values to describe interactive systems as pure functions. Just like other pure functional code, functional reactive code is easier to get right on the first try, maintain, and reuse. 
sodium
Sodium  Functional Reactive Programming (FRP) Library for multiple languages 
reactivebanana
Library for functional reactive programming in Haskell. 
reflexdom
Web applications without callbacks or sideeffects. ReflexDOM brings the power of functional reactive programming (FRP) to the web. Build HTML and other Document Object Model (DOM) data with a pure functional interface. 
Yampa
Functional Reactive Programming domainspecific language for efficient hybrid systems 
dunai
Classic FRP, Arrowized FRP, Reactive Programming, and Stream Programming, all via Monadic Stream Functions 
rhine
Haskell Functional Reactive Programming framework with typelevel clocks 
essenceoflivecodinggloss
Universal Live Coding & Functional Reactive Programming Framework 
reactivebacon
FRP (functional reactive programming) framework inspired by RX and Iteratee 
reflexfsnotify
Watch files and directories for changes using a functionalreactive interface! 
drClickOn
Code accompanying the paper "Monadic Functional Reactive Programming" 
ordrea
Pushpull implementation of discrete FRP with totallyordered switchers 
reflextransformers
Switchable monad transformers and collections for reflex 
reflexglossscene
A simple scenegraph using reflex and gloss 
Yampacore
Domainspecific language embedded in Haskell for programming hybrid (mixed discretetime and continuoustime) systems. Yampa is based on the concepts of Functional Reactive Programming (FRP) and is structured using arrow combinators. 
broccoli
Small experimental library for interactive functional programs. 
dunaicore
Functional Reactive Programming using Monadic Stream Functions (forked core library) 
reflexdynamiccontainers
dynamic containers for reflex
Access the most powerful time series database as a service
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of netwire or a related project?
README
Netwire
Netwire is a functional reactive programming (FRP) library with signal inhibition. It implements three related concepts, wires, intervals and events, the most important of which is the wire. To work with wires we will need a few imports:
import FRP.Netwire
import Prelude hiding ((.), id)
The FRP.Netwire
module exports the basic types and helper functions.
It also has some convenience reexports you will pretty much always need
when working with wires, including Control.Category
. This is why we
need the explicit Prelude
import.
In general wires are generalized automaton arrows, so you can express
many design patterns using them. The FRP.Netwire
module provides a
proper FRP framework based on them, which strictly respects continuous
time and discrete event semantics. When developing a framework based on
Netwire, e.g. a GUI library or a game engine, you may want to import
Control.Wire
instead.
Introduction
The following type is central to the entire library:
data Wire s e m a b
Don't worry about the large number of type arguments. They all have very simple meanings, which will be explained below.
A value of this type is called a wire and represents a reactive
value of type b
, that is a value that may change over time. It may
depend on a reactive value of type a
. In a sense a wire is a function
from a reactive value of type a
to a reactive value of type b
, so
whenever you see something of type Wire s e m a b
your mind should
draw an arrow from a
to b
. In FRP terminology a reactive value is
called a behavior.
A constant reactive value can be constructed using pure
:
pure 15
This wire is the reactive value 15. It does not depend on other reactive values and does not change over time. This suggests that there is an applicative interface to wires, which is indeed the case:
liftA2 (+) (pure 15) (pure 17)
This reactive value is the sum of two reactive values, each of which is just a constant, 15 and 17 respectively. So this is the constant reactive value 32. Let's spell out its type:
myWire :: (Monad m, Num b) => Wire s e m a b
myWire = liftA2 (+) (pure 15) (pure 17)
This indicates that m
is some kind of underlying monad. As an
application developer you don't have to concern yourself much about it.
Framework developers can use it to allow wires to access environment
values through a reader monad or to produce something (like a GUI)
through a writer monad.
The wires we have seen so far are rather boring. Let's look at a more interesting one:
time :: (HasTime t s) => Wire s e m a t
This wire represents the current local time, which starts at zero when
execution begins. It does not make any assumptions about the time type
other than that it is a numeric type with a Real
instance. This is
enforced implicitly by the HasTime
constraint.
The type of this wire gives some insight into the s
parameter. Wires
are generally pure and do not have access to the system clock or other
runtime information. The timing information has to come from outside
and is passed to the wire through a value of type s
, called the state
delta. We will learn more about this in the next section about
executing wires.
Since there is an applicative interface you can also apply fmap
to a
wire to apply a function to its value:
fmap (2*) time
This reactive value is a clock that is twice as fast as the regular
local time clock. If you use system time as your clock, then the time
type t
will most likely be NominalDiffTime
from Data.Time.Clock
.
However, you will usually want to have time of type Double
or some
other floating point type. There is a predefined wire for this:
timeF :: (Fractional b, HasTime t s, Monad m) => Wire s e m a b
timeF = fmap realToFrac time
If you think of reactive values as graphs with the horizontal axis
representing time, then the time
wire is just a straight diagonal line
and constant wires (constructed by pure
) are just horizontal lines.
You can use the applicative interface to perform arithmetic on them:
liftA2 (\t c > c  2*t) time (pure 60)
This gives you a countdown clock that starts at 60 and runs twice as fast as the regular clock. So it after two seconds its value will be 56, decreasing by 2 each second.
Testing wires
Enough theory, we wanna see some performance now! Let's write a simple
program to test a constant (pure
) wire:
import Control.Wire
import Prelude hiding ((.), id)
wire :: (Monad m) => Wire s () m a Integer
wire = pure 15
main :: IO ()
main = testWire (pure ()) wire
This should just display the value 15. Abort the program by pressing
CtrlC. The testWire
function is a convenience to examine wires. It
just executes the wire and continuously prints its value to stdout:
testWire ::
(MonadIO m, Show b, Show e)
=> Session m s
> (forall a. Wire s e Identity a b)
> m c
The type signatures in Netwire are known to be scary. =) But like most of the library the underlying meaning is actually very simple. Conceptually the wire is run continuously step by step, at each step increasing its local time slightly. This process is traditionally called stepping.
As an FRP developer you assume a continuous time model, so you don't observe this stepping process from the point of view of your reactive application, but it can be useful to know that wire execution is actually a discrete process.
The first argument of testWire
needs some explanation. It is a recipe
for state deltas. In the above example we have just used pure ()
,
meaning that we don't use anything stateful from the outside world,
particularly we don't use a clock. From the type signature it is also
clear that this sets s = ()
.
The second argument is the wire to run. The input type is quantified
meaning that it needs to be polymorphic in its input type. In other
words it means that the wire does not depend on any other reactive
value. The underlying monad is Identity
with the obvious meaning that
this wire cannot have any monadic effects.
The following application just displays the number of seconds passed since program start (with some subsecond precision):
wire :: (HasTime t s) => Wire s () m a t
wire = time
main :: IO ()
main = testWire clockSession_ wire
Since this time the wire actually needs a clock we use clockSession_
as the second argument:
clockSession_ ::
(Applicative m, MonadIO m)
=> Session m (Timed NominalDiffTime ())
It will instantiate s
to be Timed NominalDiffTime ()
. This type
indeed has a HasTime
instance with t
being NominalDiffTime
. In
simpler words it provides a clock to the wire. At first it may seem
weird to use NominalDiffTime
instead of something like UTCTime
, but
this is reasonable, because time is relative to the wire's start time.
Also later in the section about switching we will see that a wire does
not necessarily start when the program starts.
Constructing wires
Now that we know how to test wires we can start constructing more
complicated wires. First of all it is handy that there are many
convenience instances, including Num
. Instead of pure 15
we can
simply write 15
. Also instead of
liftA2 (+) time (pure 17)
we can simply write:
time + 17
This clock starts at 17 instead of zero. Let's make it run twice as fast:
2*time + 17
If you have trouble wrapping your head around such an expression it may
help to read a*b + c
mathematically as a(t)*b(t) + c(t)
and read
time
as simply t
.
So far we have seen wires that ignore their input. The following wire uses its input:
integral 5
It literally integrates its input value with respect to time. Its argument is the integration constant, i.e. the start value. To supply an input simply compose it:
integral 5 . 3
Remember that 3
really means pure 3
, a constant wire. The integral
of the constant 3 is 3*t + c
and here c = 5
. Here is another
example:
integral 5 . time
Since time
denotes t
the integral will be t^2/2 + c
, again with c
= 5
. This may sound like a complicated, sophisticated wire, but it's
really not. Surprisingly there is no crazy algebra or complicated
numerical algorithm going on under the hood. Integrating over time
requires one addition and one division each frame. So there is nothing
wrong with using it extensively to animate a scene or to move objects in
a game.
Sometimes categorical composition and the applicative interface can be inconvenient, in which case you may choose to use the arrow interface. The above integration can be expressed the following way:
proc _ > do
t < time < ()
integral 5 < t
Since time
ignores its input signal, we just give it a constant signal
with value ()
. We name time's value t
and pass it as the input
signal to integral
.
Intervals
Wires may choose to produce a signal only for a limited amount of time. We refer to those wires as intervals. When a wire does not produce, then it inhibits. Example:
for 3
This wire acts like the identity wire in that it passes its input signal through unchanged:
for 3 . "yes"
The signal of this wire will be "yes", but after three seconds it will stop to act like the identity wire and will inhibit forever.
When you use testWire
inhibition will be displayed as "I:" followed by
a value, the inhibition value. This is what the e
parameter to
Wire
is. It's called the inhibition monoid:
for :: (HasTime t s, Monoid e) => t > Wire s e m a a
As you can see the input and output types are the same and fully
polymorphic, hinting at the identitylike behavior. All predefined
intervals inhibit with the mempty
value. When the wire inhibits, you
don't get a signal of type a
, but rather an inhibition value of type
e
. Netwire does not interpret this value in any way and in most cases
you would simply use e = ()
.
Intervals give you a very elegant way to combine wires:
for 3 . "yes" <> "no"
This wire produces "yes" for three seconds. Then the wire to the left
of <>
will stop producing, so <>
will use the wire to its right
instead. You can read the operator as a leftbiased "or". The signal
of the wire w1 <> w2
will be the signal of the leftmost component
wire that actually produced a signal. There are a number of predefined
interval wires. The above signal can be written equivalently as:
after 3 . "no" <> "yes"
The left wire will inhibit for the first three seconds, so during that
interval the right wire is chosen. After that, as suggested by its
name, the after
wire starts acting like the identity wire, so the left
side takes precedence. Once the time period has passed the after
wire
will produce forever, leaving the "yes" wire never to be reached again.
However, you can easily combine intervals:
after 5 . for 6 . "Blip!" <> "Look at me..."
The left wire will produce after five seconds from the beginning for six seconds from the beginning, so effectively it will produce for one second. When you animate this wire, you will see the string "Look at me..." for five seconds, then you will see "Blip!" for one second, then finally it will go back to "Look at me..." and display that one forever.
Events
Events are things that happen at certain points in time. Examples
include button presses, network packets or even just reaching a certain
point in time. As such they can be thought of as lists of values
together with their occurrence times. Events are actually first class
signals of the Event
type:
data Event a
For example the predefined never
event is the event that never occurs:
never :: Wire s e m a (Event b)
As suggested by the type events contain a value. Netwire does not
export the constructors of the Event
type by default. If you are a
framework developer you can import the Control.Wire.Unsafe.Event
module to implement your own events. A game engine may include events
for key presses or certain things happening in the scene. However, as
an application developer you should view this type as being opaque.
This is necessary in order to protect continuous time semantics. You
cannot access event values directly.
There are a number of ways to respond to an event. The primary way to
do this in Netwire is to turn events into intervals. There are a number
of predefined wires for that purpose, for example asSoonAs
:
asSoonAs :: (Monoid e) => Wire s e m (Event a) a
This wire takes an event signal as its input. Initially it inhibits,
but as soon as the event occurs for the first time, it produces the
event's last value forever. The at
event will occur only once after
the given time period has passed:
at :: (HasTime t s) => t > Wire s e m a (Event a)
Example:
at 3 . "blubb"
This event will occur after three seconds, and the event's value will be
"blubb". Using asSoonAs
we can turn this into an interval:
asSoonAs . at 3 . "blubb"
This wire will inhibit for three seconds and then start producing. It will produce the value "blubb" forever. That's the event's last value after three seconds, and it will never change, because the event does not occur ever again. Here is an example that may be more representative of that property:
asSoonAs . at 3 . time
This wire inhibits for three seconds, then it produces the value 3 (or a
value close to it) forever. Notice that this is not a clock. It does
not produce the current time, but the time
at the point in time when
the event occurred.
To combine multiple events there are a number of options. In principle you should think of event values to form a semigroup (of your choice), because events can occur simultaneously. However, in many cases the actual value of the event is not that interesting, so there is an easy way to get a left or rightbiased combination:
(at 2 <& at 3) . time
This event occurs two times, namely once after two seconds and once after three seconds. In each case the event value will be the occurrence time. Here is an interesting case:
at 2 . "blah" <& at 2 . "blubb"
These events will occur simultaneously. The value will be "blah",
because <&
means leftbiased combination. There is also &>
for
rightbiased combination. If event values actually form a semigroup,
then you can just use monoidal composition:
at 2 . "blah" <> at 2 . "blubb"
Again these events occur at the same time, but this time the event value will be "blahblubb". Note that you are using two Monoid instances and one Semigroup instance here. If the signals of two wires form a monoid, then wires themselves form a monoid:
w1 <> w2 = liftA2 (<>) w1 w2
There are many predefined eventwires and many combinators for
manipulating events in the Control.Wire.Event
module. A common events
is the now
event:
now :: Wire s e m a (Event a)
This event occurs once at the beginning.
Switching
We still lack a meaningful way to respond to events. This is where
switching comes in, sometimes also called dynamic switching. The
most important combinator for switching is >
:
w1 > w2
The idea is really straightforward: This wire acts like w1
as long as
it produces. As soon as it stops producing it is discarded and w2
takes its place. Example:
for 3 . "yes" > "no"
In this case the behavior will be the same as in the intervals section, but with two major differences: Firstly when the first interval ends, it is completely discarded and garbagecollected, never to be seen again. Secondly and more importantly the point in time of switching will be the beginning for the new wire. Example:
for 3 . time > time
This wire will show a clock counting to three seconds, then it will start over from zero. This is why we usually refer to time as local time.
Recursion is fully supported. Here is a fun example:
netwireIsCool =
for 2 . "Once upon a time..." >
for 3 . "... games were completely imperative..." >
for 2 . "... but then..." >
for 10 . ("Netwire 5! " <> anim) >
netwireIsCool
where
anim =
holdFor 0.5 . periodic 1 . "Hoo..." <>
"...ray!"