allow cyclic reactors as long as equilibrium is reached

[wvanderdeijl]

This has been discussed before in #22 and #8
Hopefully this proposed solution is something you can accept.

I'll try to describe the (simplified) use case why we need this:

1. we have a (client side) atom that defines which graphs (aka data sets) are in memory. This is initialised with an initial set.
2. we also have queries on this client side data set (aka derivables) that define which data sets should be available on the client
3. when the query for data sets returns new results, we fetch these graphs/data sets from the server and add these to the atom from the first step (a cyclic reactor)
4. once we add more data sets to the atom the derivable and reactor might trigger again as more data sets are needed. After 1 or 2 iterations this reaches an equilibrium

[ds300]

There is nothing wrong with the workflow you describe. That is an asynchronous cycle because it involves going away and querying another system like the server in your example. However, even when the query can be done synchronously, for example if you have a local cache, DerivableJS requires that you insert an asynchronous step in there using setImmediate or equivalent. This should be easy to do in all cases.

It might seem like this is required because of implementation details, but in fact it is because synchronous cyclical reactions are dangerous. They allow inconsistency to creep in to the state graph, and I can't let that kind of thing slide, sorry. You've already read my other explanations of this so I won't go into more detail, and I'll have to decline this PR. Thanks for the contribution anyway. It is good to know that people are making use of the library :)