Hi Jeffrey,

There's not a straightforward answer, since there so many
implementations of Cells floating around now.

The original implementation, written by Ken Tilton for Common Lisp,
*does* handle circular dependencies.  It is single-threaded and
synchronous.  It uses a global time counter to make sure that all
cells finish calculating one state before moving on to the next state.

The Clojure implementations I posted to this list a while ago also
handle circular dependencies, using refs and agents.

My latest implementation, at clojure.contrib.auto-agents, does *not*
handle circular dependencies.  It uses Agents and Watchers to
implement the updates.

There's at least one other Clojure implementation out there, not sure
how that works.

-Stuart Sierra


On Feb 9, 11:26 am, Jeffrey Straszheim <straszheimjeff...@gmail.com>
wrote:
> I know I could just go read the docs, but I hope someone familiar with this
> Cells stuff could save me some time:
>  1. Does Cells handle circular dependencies in your computation?  If so,
> (briefly) how?
>
>   (e.g. if the value of X depends on Y, and Y depends on X, can it handle
> it?)
>
>  2. How is state handled?  Does each cell maintain its value statefully?
>  Are some stateful and others not?  How are updates cascaded?
>
> Thanks in advance.
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To post to this group, send email to clojure@googlegroups.com
To unsubscribe from this group, send email to 
clojure+unsubscr...@googlegroups.com
For more options, visit this group at 
http://groups.google.com/group/clojure?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to