Partial equivalence

[ironcev]

This is a tracking issue for Partial equivalence.
The experimental feature flag for the issue is partial_eq.

Description

Currently, core::ops provides only the Eq trait, thus, allowing expressing equivalence, but not partial equivalence. In simple terms, we expect that for every type that supports comparison, each instance of the type is always equal to itself, a property called reflexivity. While this assumption holds for majority of types used in blockchain development, we want to lift this restriction and support partial equivalence. A typical example of a type supporting partial equivalence, but not equivalence, is a floating point number, where NaN is different from any other number, including itself: NaN != NaN.

The need for partial equivalence is first expressed in #6668.

Breaking Changes

Replace Eq trait implementations with PartialEq and Eq implementations

Partial equivalence feature renames the current Eq trait to PartialEq and adds a new, empty Eq trait with PartialEq as a supertrait.

Every existing Eq trait implementation needs to be renamed to PartialEq, and in addition, an empty Eq implementations needs to be added.

E.g., this implementation:

impl Eq for SomeType {
    fn eq(self, other: Self) -> bool {
        self.x == other.x
    }
}

will become:

impl PartialEq for SomeType {
    fn eq(self, other: Self) -> bool {
        self.x == other.x
    }
}

impl Eq for SomeType {}

If the original implementation implements Eq for a generic type and in addition has Eq on trait constraints, those Eq trait constraints must be replaced by PartialEq in the new PartialEq impl, and remain Eq in the new, empty, Eq impl.

E.g., this implementation:

impl<A, B> Eq for (A, B)
where
    A: Eq,
    B: Eq,
{
    fn eq(self, other: Self) -> bool {
        self.0 == other.0 && self.1 == other.1
    }
}

will become:

impl<A, B> PartialEq for (A, B)
where
    A: PartialEq,
    B: PartialEq,
{
    fn eq(self, other: Self) -> bool {
        self.0 == other.0 && self.1 == other.1
    }
}

impl<A, B> Eq for (A, B)
where
    A: Eq,
    B: Eq,
{}

After doing these replacements for Eq trait impls, consider looking at trait constraints (where keywords) in other impls that use Eq as a trait constraint, and eventually lowering the constraint by replacing it with the PartialEq. Note that this is not strictly necessary, because the above change did not change the existing semantics of Eq. It is just that some of the constraints might be lowered, if the full equivalence is not strictly needed.

If you decide to review the usages of Eq in wheres, the following regex-search will give you these usages: [^:]:[^:]\s*Eq.

Check name clashes with existing types called Error or Enum

The partial_eq feature introduces a new traits in the core prelude: core::ops::PartialEq.

If the existing code already has a type with that name, and only if that type is imported via glob (*) import the "Multiple bindings exist for symbol in the scope" error will be emitted.

E.g., suppose that we have a type my::impls::PartialEq, and import it in scope by use my::impls::*. After migrating to partial equivalence, the following error will appear:

error: Multiple bindings exist for symbol in the scope
   --> /src/main.sw:118:51
  |
1 | my_fn::<PartialEq>(14);
  |         ^^^^^ The following paths are all valid bindings for symbol "PartialEq": "core::ops::PartialEq" and "my::impls::PartialEq".
  |
  = help: Consider using a fully qualified name, e.g., `my::impls::PartialEq`.

The solution is, as proposed in the help message, to either fully qualify the PartialEq symbol, or to import it by specifying its full path: use my::impls::PartialEq.

Steps

• Replace Eq trait with PartialEq + Eq
• Fix compiler stack overflow when compiling code with PartialEq and Eq in trait constraints #6898
• Fix "no method found" issues when compiling code with PartialEq and Eq #6899