Netwire

From HaskellWiki

Netwire is a library for functional reactive programming, which uses the concept of arrows for modelling an embedded domain-specific language. This language lets you express reactive systems, which means systems that change over time. It shares the basic concept with Yampa and its fork Animas, but it is itself not a fork and has many additional features.

• Download netwire

This wiki page corresponds to Netwire version 3 and is currently a work in progress.

Contents 1 Features 2 Basics 2.1 The inhibition monoid 2.2 Base arrows 3 Running wires 3.1 Testing wires 4 Predefined wires 4.1 Composing wires 4.2 Choice

1 Features

Here is a list of some of the features of Netwire:

• arrow interface (or optionally an applicative interface),
• signal inhibition (ArrowZero / Alternative),
• signal selection (ArrowPlus / Alternative),
• self-adjusting wires (ArrowChoice),
• rich set of event wires,
• signal analysis wires (average, peak, etc.),
• effectful wires.

2 Basics

The Netwire library is based around a data type called . You need to import the module to work with wires: For some arrows and all monoids the type is an arrow. Only certain arrows are allowed for , because is actually a data family. These arrows are called base arrows in Netwire. Values of type are time-varying functions, which resemble the following type: So it's a function that takes a value of type and either produces a value of type or produces no value, but instead inhibits with a value of type . The act of running a wire is called stepping and the process is called an instant. You can step a wire through one of the stepping functions, which we will cover later. When you step a wire, it will return a new version of itself along with its result. You are supposed to call the new version the next time you step.

2.1 The inhibition monoid

The argument to is called the inhibition monoid. For simple applications you can just use here, but you may want to actually assign exception values to inhibition. We will cover that later. For now just use .

2.2 Base arrows

The argument to is called the base arrow. In most cases you will use a arrow here, and this is currently the only type of arrow supported, though more will be added in the future. For simple applications you can just use the monad, and it is useful to define a type alias for your custom wire type:

3 Running wires

For running a wire you can use the stepping functions available in the module. There is no need to import that module. It is automatically imported with . For Kleisli-based wires you will want to use the function: In our case we have , so our type signature is simply: This function takes a wire and an input value. It passes the input value to the wire and returns its result value of type . Along with the result it also returns a new wire. Normally you would call in a loop, which performs instant after instant. This is the basic structure:

Note: Even though the FRP idea suggests it, there is no reason to run wires continuously or even regularly. You can totally have an instant depending on user input, a GUI event or network traffic, so instants can be minutes apart.

3.1 Testing wires

There is a convenient function for testing wires, which does all the plumbing for you. It's called : For wires returning a string, you can easily test them using this function. The first argument is a FPS/accuracy tradeoff. If it's 100, it will only print the output of every 100th instant. The second argument is an input generator action. At each instant, this action is run and its result is passed as input to the wire. The wire's output is then printed. prints the output continuously on a single line:

4 Predefined wires

There are numerous predefined wires, which you can compose using the arrow interface. We will practice that with three very simple predefined wires (the type signatures are simplified for the sake of learning):

The constant function takes an output value and produces a wire which produces that value constantly. So the wire will output 15 constantly at every instant. In other words, will return along with a new wire that outputs 15 again: Note the fully polymorphic input type . This basically means that the wire disregards its input, so whatever is, it is ignored. The identity wire is slightly more interesting. It has input and output of type . What it does is: It simply outputs its input value at every instant:

Both identity and constant wires are examples of stateless wires. They don't change over time. You can see this in the stepping examples above. They always return themselves for the next instant.

The countFrom function takes a starting value and returns a wire that returns sequential values instant by instant. This is the first example of a stateful wire, because it changes over time:

4.1 Composing wires

The main feature of wires is that you can compose them using the arrow interface. There is a rich set of ways for composing, and you will want to use arrow notation for your convenience:

In applications it is common to write wires that ignore their input. For those wires you should make the input type fully polymorphic to indicate this. Running this wire produces:

Note: You can use the testWireM function with this wire. The following action will run the wire continuously printing its result at every 1000th instant:

In the FRP context we often talk about signals. Particularly in the context of arrowized FRP (AFRP) like Netwire we talk about signal networks and signals passing through them. The system wire is your first signal network. It ignores its input signal and passes the signal to the two counters (which ignore their input signals, too). It takes the output signals and and makes a formatted string out of them. Finally this string is passed to the wire. This is the last wire in the signal network system, so its output signal is the output signal of system. As a side note the identity wire behaves like returnA.

The main feature to note here is that all of the subwires in the composition evolve individually. So in the second instant, each of the two counters will have gone up by one. This alone gives you a powerful abstraction for stateful computations. The equivalent when using a state monad or mutable variables would be to have a global state value with two counter values. By having time-varying functions you can have something called local state. Each of the two counters (or as many as you use) have their own individual local state, which is the current counter value. This is way more convenient and composable than a state monad or other imperative state abstractions.

4.2 Choice

In traditional AFRP solutions like Yampa the path of a signal is fully determined by the structure of the signal network. In Netwire a signal can choose one of multiple paths by using the and :

Category: FRP