Atom().Change fires always

[mozesa]

var atom = Atom(Set("A", "B", "C"));

atom.Change += value => Console.WriteLine(string.Join(',', value)); 

atom.Swap(old => old.Add("D"));
atom.Swap(old => old.Add("E"));
atom.Swap(old => old);

A,B,C,D
A,B,C,D,E
A,B,C,D,E

Actually, I would like to use atom in the following context: var status = Atom(ConnectionStatus.Connected);

Now the problem is that the AtomChangedEvent<A> fires always, even if I provide swap(status, _ => ConnectionStatus.Connected).

I would like to have AtomChangedEvent<A> only when there is new value.

[louthy]

Atom uses references internally (and reference equality to check for changes).

Set is a value-type and therefore is boxed when stored in an Atom, this will generate a new box every time. You could use the Observable extensions for Atom to keep a window of the last and current update, then use structural equality to check for changes.

The alternative would be to use AtomHashMap<string, Unit> (sorry, I haven't got around to writing AtomHashSet and AtomSet yet).

var atom = AtomHashMap(("A", unit), ("B", unit), ("C", unit));

atom.Change += value => Console.WriteLine(string.Join(',', value.Changes));

atom.AddOrUpdate("D", default);
atom.AddOrUpdate("E", default);
atom.AddOrUpdate("E", default);  // no event thrown

It can properly track changes to individual keys, and knows how to produce patches of what's changed.

[mozesa]

It is strange, that I get AtomChangedEvent event when there is reference equality.

var x = new { Test = "Test" };
var x2 = x;

Console.WriteLine(ReferenceEquals(x, x2));

var atom = Atom(x);

atom.Change += value => Console.WriteLine(value);

atom.Swap(_ => x2);
atom.Swap(_ => x2);
atom.Swap(_ => x2);

True
{ Test = Test }
{ Test = Test }
{ Test = Test }

Btw, extensive usage of Observable, is problematic?

using var sub1 = readings.OnChange()
    .Where(s => s.StartsWith("DM"))
    .Subscribe(_ => status.Swap(_ => ConnectionStatus.Connected));

using var sub2 = readings.OnChange()
    .Where(s => !s.StartsWith("DM"))
    .Timestamp()
    .Subscribe(data => Console.WriteLine($"{data.Timestamp} | {data.Value}"));

[louthy]

No, you're right, I've just checked the code and it's not doing any equality checks (reference or otherwise), it's just announcing every update. I'll convert this to a bug, but I probably won't get to it super quickly unfortunately.

[CK-LinoPro]

Changing this behavior might result in breaking some user code.
The way I get this is issue is by using IObservable<T>.DistinctUntilChanged() whenever I'm only interested in true value changes.

[StefanBertels]

Any change like this potentially breaks user code. But on the other hand it might actually fix user code. Atom* stuff is still relatively new and IMHO it's better to get it "right" now to avoid future misconception.

I expect that a method named OnChange does an equality check (.Equals) -- as does .DistinctUntilChanged. Anything else could be named OnUpdate or OnSwap.
Maybe giving an EQ type argument is an option here, too?

Having some default(EqReference<T>) and some default(EqNever<T>) could be useful to just have one method but all kind of equality checks. I'm not sure the latter one is generally valid with .Equals(a,a) == false.

Just some thoughts.

[louthy]

There's no absolute right answer here. Equality is problematic, even with reference-equality, because not everything in an Atom will be a reference. Calling .Equals() may be slow, which is problematic for atomic updates that don't want to cause lots of retries. A specific opt-in equality (as suggested by @StefanBertels) may be the best option here. That means no breaking changes for those using Atom today.

However, it might make sense to rename Change to Update or something that indicates its not about difference, it's about action.