Add array comparison operators

Author: danakj

containers/array.h

@@ -25,6 +25,7 @@
 #include "marker/unsafe.h"
 #include "mem/move.h"
 #include "mem/relocate.h"
+#include "num/num_concepts.h"
 
 namespace sus::containers {
 
@@ -91,9 +92,7 @@ class Array final {
   }
 
   /// Returns the number of elements in the array.
-  constexpr const /* TODO: usize */ size_t len() const& noexcept {
-    return N;
-  }
+  constexpr const /* TODO: usize */ size_t len() const& noexcept { return N; }
 
   constexpr const T& get(/* TODO: usize */ size_t i) const& noexcept
     requires(N > 0)
@@ -123,7 +122,11 @@ class Array final {
     return storage_.data_;
   }
 
-  // TODO: Eq and Ord (like Option and Tuple).
+  /// sus::num::Eq<Array<U, N>> trait.
+  template <::sus::num::Eq<T> U>
+  constexpr bool operator==(const Array<U, N>& r) const& noexcept {
+    return eq_impl(r, std::make_index_sequence<N>());
+  }
 
  private:
   enum WithInitializer { kWithInitializer };
@@ -150,6 +153,12 @@ class Array final {
     new (a + index) T(move(t1));
   }
 
+  template <class U, size_t... Is>
+  constexpr inline auto eq_impl(const Array<U, N>& r,
+                                std::index_sequence<Is...>) const& noexcept {
+    return (true && ... && (get(Is) == r.get(Is)));
+  };
+
   // Using a union ensures that the default constructor doesn't initialize
   // anything.
   union {
@@ -160,6 +169,56 @@ class Array final {
                                       ::sus::mem::relocate_array_by_memcpy<T>);
 };
 
+namespace __private {
+
+template <size_t I, class O, class T, class U, size_t N>
+constexpr inline bool array_cmp_impl(O& val, const Array<T, N>& l,
+                                     const Array<U, N>& r) noexcept {
+  auto cmp = l.get(I) <=> r.get(I);
+  // Allow downgrading from equal to equivalent, but not the inverse.
+  if (cmp != 0) val = cmp;
+  // Short circuit by returning true when we find a difference.
+  return val == 0;
+};
+
+template <class T, class U, size_t N, size_t... Is>
+constexpr inline auto array_cmp(auto equal, const Array<T, N>& l,
+                                const Array<U, N>& r,
+                                std::index_sequence<Is...>) noexcept {
+  auto val = equal;
+  (true && ... && (array_cmp_impl<Is>(val, l, r)));
+  return val;
+};
+
+}  // namespace __private
+
+/// sus::num::Ord<Option<U>> trait.
+template <class T, class U, size_t N>
+  requires(::sus::num::ExclusiveOrd<T, U>)
+constexpr inline auto operator<=>(const Array<T, N>& l,
+                                  const Array<U, N>& r) noexcept {
+  return __private::array_cmp(std::strong_ordering::equivalent, l, r,
+                              std::make_index_sequence<N>());
+}
+
+/// sus::num::Ord<Option<U>> trait.
+template <class T, class U, size_t N>
+  requires(::sus::num::ExclusiveWeakOrd<T, U>)
+constexpr inline auto operator<=>(const Array<T, N>& l,
+                                  const Array<U, N>& r) noexcept {
+  return __private::array_cmp(std::weak_ordering::equivalent, l, r,
+                              std::make_index_sequence<N>());
+}
+
+/// sus::num::Ord<Option<U>> trait.
+template <class T, class U, size_t N>
+  requires(::sus::num::ExclusivePartialOrd<T, U>)
+constexpr inline auto operator<=>(const Array<T, N>& l,
+                                  const Array<U, N>& r) noexcept {
+  return __private::array_cmp(std::partial_ordering::equivalent, l, r,
+                              std::make_index_sequence<N>());
+}
+
 }  // namespace sus::containers
 
 namespace sus {

containers/array_unittest.cc

@@ -197,4 +197,58 @@ TEST(Array, AsPtrMut) {
   EXPECT_EQ(101, *(r + 2));
 }
 
+TEST(Array, Eq) {
+  auto a = Array<int, 5>::with_initializer([i = 0]() mutable { return ++i; });
+  auto b = Array<int, 5>::with_initializer([i = 0]() mutable { return ++i; });
+  EXPECT_EQ(a, b);
+  b.get_mut(3) += 1;
+  EXPECT_NE(a, b);
+}
+
+TEST(Array, Ord) {
+  auto a = Array<int, 5>::with_initializer([i = 0]() mutable { return ++i; });
+  auto b = Array<int, 5>::with_initializer([i = 0]() mutable { return ++i; });
+  EXPECT_LE(a, b);
+  EXPECT_GE(a, b);
+  b.get_mut(3) += 1;
+  EXPECT_LT(a, b);
+}
+
+TEST(Array, StrongOrder) {
+  auto a = Array<int, 5>::with_initializer([i = 0]() mutable { return ++i; });
+  auto b = Array<int, 5>::with_initializer([i = 0]() mutable { return ++i; });
+  EXPECT_EQ(std::strong_order(a, b), std::strong_ordering::equal);
+  b.get_mut(3) += 1;
+  EXPECT_EQ(std::strong_order(a, b), std::strong_ordering::less);
+}
+
+struct Weak final {
+  auto operator==(Weak const& o) const& { return a == o.a && b == o.b; }
+  auto operator<=>(Weak const& o) const& {
+    if (a == o.a) return std::weak_ordering::equivalent;
+    if (a < o.a) return std::weak_ordering::less;
+    return std::weak_ordering::greater;
+  }
+
+  Weak(int a, int b) : a(a), b(b) {}
+  int a;
+  int b;
+};
+
+TEST(Array, WeakOrder) {
+  auto a = Array<Weak, 5>::with_initializer([i = 0]() mutable { return Weak(++i, 2); });
+  auto b = Array<Weak, 5>::with_initializer([i = 0]() mutable { return Weak(++i, 2); });
+  EXPECT_EQ(std::weak_order(a, b), std::weak_ordering::equivalent);
+  b.get_mut(3).a += 1;
+  EXPECT_EQ(std::weak_order(a, b), std::weak_ordering::less);
+}
+
+TEST(Array, PartialOrder) {
+  auto a = Array<float, 5>::with_initializer([i = 0.f]() mutable { return ++i; });
+  auto b = Array<float, 5>::with_initializer([i = 0.f]() mutable { return ++i; });
+  EXPECT_EQ(std::partial_order(a, b), std::partial_ordering::equivalent);
+  b.get_mut(3) += 1;
+  EXPECT_EQ(std::partial_order(a, b), std::partial_ordering::less);
+}
+
 }  // namespace

num/f32_unittest.cc

@@ -980,24 +980,14 @@ TEST(f32, ToBeBytes) {
   auto array = (12.5_f32).to_be_bytes();
   auto expected =
       sus::Array<u8, 4>::with_values(0x41_u8, 0x48_u8, 0x00_u8, 0x00_u8);
-  // TODO: Use Array::operator== via EXPECT_EQ.
-  EXPECT_EQ(array.len(), expected.len());
-  for (size_t i = 0; i < array.len(); i += 1) {
-    SCOPED_TRACE(i);
-    EXPECT_EQ(array.get(i), expected.get(i));
-  }
+  EXPECT_EQ(array, expected);
 }
 
 TEST(f32, ToLeBytes) {
   auto array = (12.5_f32).to_le_bytes();
   auto expected =
       sus::Array<u8, 4>::with_values(0x00_u8, 0x00_u8, 0x48_u8, 0x41_u8);
-  // TODO: Use Array::operator== via EXPECT_EQ.
-  EXPECT_EQ(array.len(), expected.len());
-  for (size_t i = 0; i < array.len(); i += 1) {
-    SCOPED_TRACE(i);
-    EXPECT_EQ(array.get(i), expected.get(i));
-  }
+  EXPECT_EQ(array, expected);
 }
 
 TEST(f32, ToNeBytes) {
@@ -1006,12 +996,7 @@ TEST(f32, ToNeBytes) {
       sus::assertions::is_big_endian()
           ? sus::Array<u8, 4>::with_values(0x41_u8, 0x48_u8, 0x00_u8, 0x00_u8)
           : sus::Array<u8, 4>::with_values(0x00_u8, 0x00_u8, 0x48_u8, 0x41_u8);
-  // TODO: Use Array::operator== via EXPECT_EQ.
-  EXPECT_EQ(array.len(), expected.len());
-  for (size_t i = 0; i < array.len(); i += 1) {
-    SCOPED_TRACE(i);
-    EXPECT_EQ(array.get(i), expected.get(i));
-  }
+  EXPECT_EQ(array, expected);
 }
 
 TEST(f32, FromBeBytes) {

num/num_concepts.h

@@ -153,15 +153,15 @@ concept PartialOrd = WeakOrd<Lhs, Rhs> || Ord<Lhs, Rhs> ||
 template <class Lhs, class Rhs>
 concept ExclusiveOrd = Ord<Lhs, Rhs>;
 template <class Lhs, class Rhs>
-concept ExclusiveWeakOrd = !
-Ord<Lhs, Rhs>&& WeakOrd<Lhs, Rhs>;
+concept ExclusiveWeakOrd = (!Ord<Lhs, Rhs> && WeakOrd<Lhs, Rhs>);
 template <class Lhs, class Rhs>
-concept ExclusivePartialOrd = !
-Ord<Lhs, Rhs> && !WeakOrd<Lhs, Rhs> && PartialOrd<Lhs, Rhs>;
+concept ExclusivePartialOrd = (!Ord<Lhs, Rhs> && !WeakOrd<Lhs, Rhs> &&
+                               PartialOrd<Lhs, Rhs>);
 
 // TODO: Move this out of ::num.
 //
-// TODO: How do we do PartialEq? Can we even? Can we require Ord to be Eq? But then it depends on ::num?
+// TODO: How do we do PartialEq? Can we even? Can we require Ord to be Eq? But
+// then it depends on ::num?
 template <class Lhs, class Rhs>
 concept Eq = requires(const Lhs& lhs, const Rhs& rhs) {
                { lhs == rhs } -> std::same_as<bool>;