An Ocaml implementation of Transparent Synchronous Dataflow

1. Ocaml 4.05.0 +
2. oasis2opam package
3. In order to run the benchmarks for ReactiveML and JaneStreet Incremental Library, please make sure the following are installed.
   • ReactiveML: http://rml.lri.fr/
   • Inc: incremental package in opam
   • Zelus: http://zelus.di.ens.fr/

1. To pin and install the TSD package, run make install and follows the instruction.
2. To uninstall, run make uninstall

Run ocamlfind ocamlc -package tsd,tsd.ppx -o $TARGET -linkpkg $SOURCE to compile your favourite programs.

1. To build all the examples, simply run make examples. The compiled executable can be found in examples/build/$TARGET/$TARGET.
2. To execute the benchmarks, simply run make benchmarks.

1. Run #ppx "tsd_ext";;
2. Run #require "tsd";;
3. Run open Tsd;;
4. Try running let x = [%dfg 1];; and it should work!

An extensive description of the language and the underlying calculus can be found in the report Transparent Synchronous Dataflow. Here is a quick recap:

• val peek : 'a graph -> 'a : takes a node in a graph, evaluates it, and returns its value
• val root : 'a graph -> 'a graph : returns the dependencies of a cell (if it is not a cell it gives a runtime error)
• val cell : 'a graph -> 'a graph : takes a node in a graph as argument and returns a new cell dependent on the node
• val link : 'a graph -> 'a graph -> unit : takes a cell and a node and makes the node the (new) dependency of the cell (if the first argument is not a cell it gives a runtime error)
• val (<~) : 'a graph -> 'a graph -> unit : alias for link
• val assign : 'a graph -> 'a -> unit : change the value of a cell (runtime error if argument not a cell)
• val (<:=) : 'a graph -> 'a -> unit : alias for assign
• val set : 'a graph -> 'a -> unit : combination of link and assign
• val (<:~) : 'a graph -> 'a -> unit : alias for set
• val init : unit -> unit : deletes the dataflow graph
• val step : unit -> bool : propagates changes until every cell is changed at most once. It returns true if changes were made.

The tag [%dfg t] always returns a node in a graph that corresponds to t. Note that this node is not a cell. For example let x = [%dfg 1] creates a constant graph with node 1. This let f = [%dfg fun x y -> x * y] creates a function from graphs to graphs which can be used as follows:

let ( * ) = lift ( * );;
let f = [%dfg fun x y -> x * y];;
let x = cell [%dfg 1] ;;
let y = cell [%dfg 2] ;;
let m = [%dfg f x y];;

This creates a dataflow graph with two cells, initialised to 1 and 2, connected via multiplication to the node x (which is not a cell).