Every Variable has an identifier in the data flow graph.

Variables are internally numbered by Node = Int and have an alternative value Representation alt. Futher each variable has a Pandoc description (set by <?) and optionally a shortname set by named which is a String to be used in hyperlinks.

Register a new variable in the VariableStore. This variable has neither description, shortname nor valueRendering.

var = varM . pure 

Register a new variable with content from a monadic action in the VariableStore. This variable has neither description, shortname nor valueRendering.

Register a static input variable which is immediately rendered.

Register a static input variable with content from a monad action which is immediately rendered.

Combination of var and <? that can be used for immediate function application, e.g.

x  <- input 1
y  <- input 2
xy <- func (*) (renderDefault "*") <%> x <%> y

Action on the VariableStore

The what is this?-operator. Changes the description of the computation's result.

>>> v <- var 99
>>> v <? renderDefault "bottles of beer on the wall"

Provides a shortname symbol for the Variable, for use in hyperlinks and other references.

>>> v <- var 99
>>> v `named` "beer"

Render a hyperlink to a Variable, to be used e.g. in descriptions of downstream variables. Make sure to provide a short name via named before calling linkto.

render = renderWith renderDefault. You can use this function without providing a DefaultRender instance by using a conversion function to a type that is member of DefaultRender:

\f -> render . fmap f

Supply the valueRendering and altRep for the variable.

Use the show method to render a value as Plain text.

Class of types with a default rendering method. For the basic types renderDefault equals renderShow.

Internationalization of the keywords used in renderStore.

English version

German version

Render the store with Pandoc. For each Variable the following data is written:

1. The variable name given with named,
2. The variables linking to this one (if any),
3. The edge labels linking to this variable,
4. The variables depending on this one (if any),
5. The description provided with <?,
6. A rendering of the value as provided by one of the render family functions.

When the alternative representation is in terms of spreadsheet rows, we can assemble the VariableStore into a spreadheet. This is analogous to renderStore but only places the data underneath the shortname, thus omitting any formatted descriptions.

Obtain a graph of all the Variables alternative representations

Obtain a graph of all the Variables short names

A Monad transformer that keeps track of data dependencies

Provenience = ProvenienceT () Identity

Applicative-style application operator. Replaces the function Variable with its (partial) application and creates an edge from the argument to the result Variable that is labeled with the function description.

f <- func succ (renderDefault "successor")
x <- input (5 :: Int)
y <- pure f <%> x
x <? renderDefault "input data"
y <? renderDefault "The successor of 5"
render y

The above creates the following graph.

"input data"  "successor"  "The successor of 5"
     5        ----------->        6

If you want to re-use a function in several applications then bind f to the Provenience action rather the Variable like below.

let f = func succ (renderDefault "successor")
x <- input (5 :: Int)
y <- f <%> x
z <- f <%> y

Like above but permit side-effects in the base monad.

Run the Provenience monad and return the value of the result variable together with the VariableStore and its next unused Node. Initialize the VariableStore with an empty graph and start with the given Node identifier.

run the Provenience monad and return the data dependency graph

run the Provenience monad and return the data dependency graph

run the Provenience monad and return the resulting value.

run the Provenience monad and return the resulting value.

Run multiple ProvenienceT actions using the same pool of Nodes but returning seperate VariableStores. This is useful when several data flow graphs get embedded into the same document, where hyperlink targets must be unique.