Equatable, Freezed, ... use FIC ==

[ihadabs]

How to tell Freezed or Equatable to utilize the == for IList?

As for now, Freezed use DeepCollectionEquality().equals which is very slow.
and Equatable use their custom code:

bool iterableEquals(Iterable<Object?> a, Iterable<Object?> b) {
  assert(
    a is! Set && b is! Set,
    "iterableEquals doesn't support Sets. Use setEquals instead.",
  );
  if (identical(a, b)) return true;
  if (a.length != b.length) return false;
  for (var i = 0; i < a.length; i++) {
    if (!objectsEquals(a.elementAt(i), b.elementAt(i))) return false;
  }
  return true;
}

bool objectsEquals(Object? a, Object? b) {
  if (identical(a, b)) return true;
  if (a is num && b is num) {
    return numEquals(a, b);
  } else if (_isEquatable(a) && _isEquatable(b)) {
    return a == b;
  } else if (a is Set && b is Set) {
    return setEquals(a, b);
  } else if (a is Iterable && b is Iterable) {
    return iterableEquals(a, b);
  } else if (a is Map && b is Map) {
    return mapEquals(a, b);
  } else if (a?.runtimeType != b?.runtimeType) {
    return false;
  } else if (a != b) {
    return false;
  }
  return true;
}

[marcglasberg]

It's unlikely that a solution exists without the cooperation of the authors of those packages.

In my state management solution AsyncRedux I solve a similar problem when I need to compare view-models. I define an abstract class called VmEquals like so:

/// Each state passed in the [Vm.equals] parameter in the in view-model will be
/// compared by equality (==), unless it is of type [VmEquals], when it will be
/// compared by the [VmEquals.vmEquals] method, which by default is a comparison
/// by identity (but can be overridden).
abstract class VmEquals<T> {
  bool vmEquals(T other) => identical(this, other);
}

Any class that wishes to be compared in its own way can do so by extending VmEquals to provide its own comparison.

I can publish a separate, very small package with a similar interface, but better named for example DeepEquatable, and then the user code could simply do:

 if (a is DeepEquatable && b is DeepEquatable) { // Here!
    return a.deepEquals(b);

For example:

bool objectsEquals(Object? a, Object? b) {
  if (identical(a, b)) return true;
 if (a is DeepEquatable && b is DeepEquatable) { // Here!
    return a.deepEquals(b);
  } else if (a is num && b is num) {
    return numEquals(a, b);
  } else if (_isEquatable(a) && _isEquatable(b)) {
    return a == b;
  } else if (a is Set && b is Set) {
    return setEquals(a, b);
  } else if (a is Iterable && b is Iterable) {
    return iterableEquals(a, b);
  } else if (a is Map && b is Map) {
    return mapEquals(a, b);
  } else if (a?.runtimeType != b?.runtimeType) {
    return false;
  } else if (a != b) {
    return false;
  }
  return true;
}

You would then need to contact Remi and Felix to ask them to use this interface.

Note this solution is general. It's not only for FIC, but for any class that wants to be compared with its own fast equality.

What do you think of this solution?

[ihadabs]

great solution @marcglasberg

Expecting Freezed or Equatable to directly support custom equality for types like IList (from FIC) might be too much unless they offer some extensibility mechanism. Your approach with VmEquals (or in this case, DeepEquatable) feels like a clean workaround.

It would be nice if the community could converge on a small, standard package with a single interface — maybe something like ThisClassHasItsOwnEquality — to mark classes wanting to control how they're compared. Then packages like Equatable, Freezed, etc., could check:

if (a is ThisClassHasItsOwnEquality && b is ThisClassHasItsOwnEquality) {
  return a == b; // or a.deepEquals(b)
}

That way, we avoid deep equality on heavy structures unless explicitly opted into. Would love to see something like that adopted as a standard convention. @felangel @rrousselGit wish this would work 😂