SmartReactives: a .NET library that detects when an expression changes its value (opens in new tab)

Check out MobX, as it comes with React bindings to re-render components when their reactive dependencies change: https://github.com/mobxjs/mobx

There is Baobab[1] - it is a single state-tree approach, while supporting computed values in the tree and has a react adapter[2].

[1]: https://github.com/Yomguithereal/baobab#computed-data-or-mon...

[2]: https://github.com/Yomguithereal/baobab-react

How about RxJS?

https://github.com/Reactive-Extensions/RxJS

As another poster said, you can use Meteor's Tracker and ReactiveVar modules to do it. Here's a standalone package that doesn't require the Meteor platform: https://www.npmjs.com/package/meteor-standalone-tracker

Wouldn't it be backwards to do this in React? Everything is controlled by a state object you manually set, so you already know when values are going to change.

Check out https://www.npmjs.com/package/watchjs

There are also Continuous LINQ [1][2], Bindable LINQ [3], Obtics [4] and OLinq [5], some predating Rx [6][7]. Besides OLinq they all seem no longer maintained but in case somebody is interested in other existing implementations, there you go. Also note that they don't all solve the exact same but similar problems.

[1] http://clinq.codeplex.com [2] https://github.com/ismell/Continuous-LINQ [3] https://bindablelinq.codeplex.com [4] http://obtics.codeplex.com [5] https://github.com/wasabii/OLinq [6] https://msdn.microsoft.com/en-us/data/gg577609.aspx [7] https://github.com/Reactive-Extensions/Rx.NET

This is not a replacement for Rx, actually it relies on Rx. SmartReactives is an addition to Rx which allows you to get an IObservable from an expression for free, while with just Rx you'd have to instrument your expression.

There are many application-specific scenarios that are enabled by RX that would still take quite a bit of hand-rolling a deep knowledge of RX to get right.

A favorite of mine right now is https://github.com/RolandPheasant/DynamicData which I use for easily "deriving" from in-memory collections to create new collections that are actually "live views" onto the source collection. Makes things like mapping, sorting, filtering, paging, and so on super-simple while letting you avoid creating unnecessary state.

Rx.net is probably the most well used one.

I like componentized functionalities a lot, and i think .NET shines for that.

Yes Meteor's reactive system seems to be almost identical. Thanks for sharing.

Thanks. Yes you can use it to help with INotifyPropertyChanged. The example 'SmartNotifyPropertyChanged' demonstrates one way to do this.

Alright. Where can I find your project? You can let me know in Gitter or e-mail.

My perception is that there's almost no overlap in scope between the two libraries. In Incremental you have to be explicit about which variables your computations depends on, while SmartReactives' sole purpose is discovering these dependencies automatically. SmartReactives discovers dependencies as a side-effect of evaluating variables while evaluating expressions. OCaml on the other hand is a mostly pure language so side-effects are not allowed.

Incremental on the other hand does cool stuff like use the result of the first computation to make the second computation faster, which SmartReactives does not do at all.

So I'd say although the projects are related they don't overlap in scope.