Date

3 June 2009

Author

Anand Patil

Contact

anand.prabhakar.patil@gmail.com

Copyright

Anand Patil, 2009.

License

See LICENSE

Selfless provides stateless, lazy dataflow for Clojure. It separates the dataflow model and the state, so many states can be updated concurrently.

NOTE: The 'delay' branch (which you are using) requires the par branch of clojure, available from http://github.com/richhickey/clojure/tree/par. To build it, you'll need Rich Hickey's build of the jsr166 from http://cloud.github.com/downloads/richhickey/clojure/jsr166y.jar on your classpath.

Usage

First, build a dataflow:

(defn fn2 [a b c d e] [a b c d e])     
(defn fn3 [fn2] (apply + fn2))

(def flow (add-root {} :fn1))
(def flow2 (add-node flow :fn2 fn2 [:fn1 17 :fn1 2 5]))
(def flow3 (add-oblivious flow2 :fn3 fn3 [:fn2]))

The arguments of add-node and add-oblivious are [flow key fun & [args]]. The resulting dataflow is a {:key node} map. Nodes hold functions, parents, children, and timing slots. Timing can be lazy (the default) and oblivious, meaning a node does not do anything in response to parent updates. add-root is a version of add-node that assumes the node has no parents & that a value for it must be provided.

Having created the dataflow, you can create functions flow3-init, flow3-forget and flow3-change with:

(def-flosures flow3)

or if you don't want to bind the functions to vars you can create them in a map keyed by :init, :forget and :change with:

(flosures flow3)

Then you can use the with-flosures macro, which creates a context within which the functions init, forget and change are understood to pertain to the given flow:

(with-flosures (flosures flow3)
    (let
        [init-state (init {:fn1 3})
        init-vals (force-state init-state)
        partial-state (forget init-state :fn2)
        altered-state (change new-state {:fn1 3})]
        [init-state init-vals altered-state]))

Concurrency

Nodes' values are wrapped in delays. When you force a value, it forces its parents' values, and so on. Evaluations are done concurrently (using pmap) where possible. The force-state function evaluates the entire state and strips away the delays.