# std::experimental::ranges::EqualityComparable, std::experimental::ranges::EqualityComparableWith

> C++ Atlas: `cppatlas.com/w/cpp/experimental/ranges/concepts/EqualityComparable` | Source: https://en.cppreference.com/w/cpp/experimental/ranges/concepts/EqualityComparable | Domain: Technical specifications

An expression is equality preserving if it results in equal outputs given equal inputs.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <experimental/ranges/concepts>

template< class T >
concept bool EqualityComparable = WeaklyEqualityComparableWith<T, T>; // (1) (ranges TS)

template< class T, class U >
concept bool EqualityComparableWith =
    EqualityComparable<T> &&
    EqualityComparable<U> &&
    CommonReference<
        const std::remove_reference_t<T>&,
        const std::remove_reference_t<U>&> &&
    EqualityComparable<
        ranges::common_reference_t<
            const std::remove_reference_t<T>&,
            const std::remove_reference_t<U>&>> &&
    WeaklyEqualityComparableWith<T, U>; // (2) (ranges TS)
```

1) The concept `EqualityComparable<T>` specifies that the comparison operators `==` and `!=` on `T` reflects equality: `==` yields `true` if and only if the operands are equal.

`EqualityComparable<T>` is satisfied only if, given objects `a` and `b` of type `T`, `bool(a == b)` is `true` if and only if `a` and `b` are equal. Together with the requirement that `a == b` is equality preserving, this implies that `==` is symmetric and transitive, and further that `==` is reflexive for all objects `a` that are equal to at least one other object.

2) The concept `EqualityComparableWith<T, U>` specifies that the comparison operators `==` and `!=` on (possibly mixed) `T` and `U` operands yield results consistent with equality. Comparing mixed operands yields results equivalent to comparing the operands converted to their common type.

Formally, `EqualityComparableWith<T, U>` is satisfied only if, given any lvalue `t` of type `const std::remove_reference_t<T>` and any lvalue `u` of type `const std::remove_reference_t<U>`, and let `C` be `ranges::common_reference_t<const std::remove_reference_t<T>&, const std::remove_reference_t<U>&>`, `bool(t == u) == bool(C(t) == C(u))`.

### Equality preservation

An expression is *equality preserving* if it results in equal outputs given equal inputs.

- The inputs to an expression consist of its operands.
- The outputs of an expression consist of its result and all operands modified by the expression (if any).

Every expression required to be equality preserving is further required to be *stable*: two evaluations of such an expression with the same input objects must have equal outputs absent any explicit intervening modification of those input objects.

### Implicit expression variations

A *requires-expression* that uses an expression that is non-modifying for some constant lvalue operand also implicitly requires additional variations of that expression that accept a non-constant lvalue or (possibly constant) rvalue for the given operand unless such an expression variation is explicitly required with differing semantics. These *implicit expression variations* must meet the same semantic requirements of the declared expression. The extent to which an implementation validates the syntax of the variations is unspecified.

---
Attribution: content from https://en.cppreference.com/w/cpp/experimental/ranges/concepts/EqualityComparable (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.