Do we have equal operators?

[bglgwyng]

I mean List.of(1,2,3).equals(2,4) things.
It seems not. I think it's quite basic operator for collections, so do we have any reason excluding it?

[vitoke]

Hi, thanks for creating the issue. Do I understand correctly that you would like the equals operator to compare the contents of the list to the values provided in the equals parameters?

The philosophy behind Rimbu is that nearly everything can be converted to a Stream to abstract away from specific collections and allow more generic processing. As such, the way content comparison could be done, as an example, is as follows:

import { List } from '@rimbu/core';

const list = List.of(1, 2, 3);

console.log({
  equal1: list.stream().equals([2, 4]),
  equal2: list.stream().equals([1, 2, 3]),
});

==> { equal1: false, equal2: true }

In this way the equals function does not need to be added to every collection type, and therefore is also very generic in having options like providing a custom comparator and to negate the equality.

One note is that, since a Stream does not have a size or length method, it cannot quickly reject collections that have a different length. To circumvent this if needed, a custom function could be written to first compare the lengths and then use Stream.equals.

Feel free to let me know if this suits your need or have other considerations.

[bglgwyng]

Indeed, my original problem was comparing two HashSet. And I'm not sure that the HashSet case can be generalized as comparison between stream.

[vitoke]

I see, for HashSet, the implementation using Stream would be difficult, because hash collisions can change the order of items. I think the following implementation would be the most efficient:

import { HashSet, RSet } from "@rimbu/core";

function areEqual<T>(set1: RSet<T>, set2: RSet<T>): boolean {
  if (set1.size !== set2.size) {
    return false;
  }

  const set1Iterator = set1[Symbol.iterator]();
  const done = Symbol();
  let value: T | typeof done;

  while ((value = set1Iterator.fastNext(done)) !== done) {
    if (!set2.has(value)) {
      return false;
    }
  }

  return true;
}

console.log(areEqual(HashSet.of(1, 2, 3), HashSet.of(1, 3, 2)));
// => true
console.log(areEqual(HashSet.of(1, 2, 3), HashSet.of(1, 2))); // different size
// => false
console.log(areEqual(HashSet.of(1, 2, 3), HashSet.of(4, 1, 2))); // differen contents
// => false

I'll indeed keep the issue open, since it does seem that there's value in adding an equals method for similar types of collections.

[bglgwyng]

import type { HashSet } from "@rimbu/hashed";

export function compareSet<T>(xs: HashSet<T>, ys: HashSet<T>): boolean {
	return xs.symDifference(ys).isEmpty;
}

Indeed I was using this definition. In my use case, performance wasn't that important so I didn't even consider it.
However, after reading your code, canonical areEquals definition is really necessary, since the fast implementation can be more complicated than expected.