Update on value change

[yha]

latest_change(obs) to only observe value changes. Ref #5

[twavv]

I don't think latest_change is the best name for this.

Maybe value_change? Still not a fan of that either...

[twavv]

Maybe just rename the function to observe_value (to match observe).

[yha]

Maybe just rename the function to observe_value (to match observe).

observe is not documented, and looking at its implementation, I'm not sure what it's for, or what the connection is.
latest_change matches async_latest. But I think value_change works too.
Perhaps each_change? on(each_change(obs)) reads nicely, but it also kind of suggests an iterable.

[timholy]

Maybe notify_changed or monitor_changed?

[yha]

I think the most important aspect for the name to be discoverable and reasonably intuitive is that it includes the word "change".
If the name is to contain a verb, I would prefer observe over notify or monitor, because the latter seem to me to suggest it does something extra beside an Observable transformation (notify in particular suggest it has something to do with tasks).
I think observe_changes is fine, as is value_change/value_changes, or simply changes.

[twavv]

I don't care that much, I think we've entered bikeshedding territory.

... but while we're here, how about debounce_value? I think keeping value is important.

[yha]

how about debounce_value?

I don't understand what that means. "debounce"?

I think keeping value is important.

Why? The default for eq compares by value, but you can pass other functions (like ===).

[yha]

So after searching for that term, it looks like debounce in JS is basically the same thing as async_latest here. I can see now how debounce_value is similar (which is why I used "latest"). But it seems odd to use the term here and not in async_latest.

[timholy]

Since there's no consensus, how about we let the author @yha make the decision? I'll throw out filter_changed, follow_changes, and changes_only as additional menu items for you to choose from. I like each_change and observe_changes. I'd only ask that we not choose anything with debounce in it as I find that term almost incomprehensible upon first look.

[twavv]

I was actually thinking about this yesterday.

I think it should be a new type (whether that be ChangeObservable or ValueObservable or whatever else). Not using a type seems to disallow off-ing the observable (at least it won't off the inner/wrapped observable).

I'll also defer to whatever y'all think, but I don't like using "latest". Maybe go see what Rx calls this and copy that.

[yha]

Not using a type seems to disallow off-ing the observable (at least it won't off the inner/wrapped observable).

Do you mean removing removing the connection to the wrapped observable? i.e. calling off on the result of on inside the implementation? This is also not possible with map, async_latest, and throttle.
How does using a type make this easier?

Maybe go see what Rx calls this and copy that.

Rx calls this distinct_until_changed, as you have noted in the original issue. I don't think that's a good name either. Seems pretty opaque unless you are already familiar with Rx's distinct.

[timholy]

Let's give others a short window to comment and then merge. (Bump if I forget to come back.)