implement cross-capacity comparison

remove extra line

Author: ChronoInferna

include/beman/inplace_vector/inplace_vector.hpp

@@ -284,6 +284,7 @@ struct inplace_vector_base : private storage::storage_for<T, N> {
   }
 
   // [containers.sequences.inplace_vector.data], data access
+
   constexpr T *data() noexcept { return storage_data(); }
   constexpr const T *data() const noexcept { return storage_data(); }
 
@@ -398,11 +399,6 @@ struct inplace_vector_base : private storage::storage_for<T, N> {
     }
   }
 
-  constexpr friend bool operator==(const inplace_vector_base &x,
-                                   const inplace_vector_base &y) {
-    return x.size() == y.size() && std::ranges::equal(x, y);
-  }
-
   constexpr void swap(inplace_vector_base &x) noexcept(
       N == 0 || (std::is_nothrow_swappable_v<T> &&
                  std::is_nothrow_move_constructible_v<T>))
@@ -420,20 +416,37 @@ struct inplace_vector_base : private storage::storage_for<T, N> {
     x.swap(y);
   }
 
+  // [inplace.vector.comparison], comparison
+
+  template <std::size_t M>
+  constexpr friend bool operator==(const inplace_vector_base &x,
+                                   const inplace_vector_base<T, M> &y) {
+    const auto sz = std::min(x.size(), y.size());
+
+    return x.size() == y.size() &&
+           std::ranges::equal(x.begin(), x.begin() + sz, y.begin(),
+                              y.begin() + sz);
+  }
+
+  template <std::size_t M>
+    requires std::three_way_comparable<T> || lessthan_comparable<T>
   constexpr friend auto operator<=>(const inplace_vector_base &x,
-                                    const inplace_vector_base &y)
-    requires(details::lessthan_comparable<T>)
-  {
+                                    const inplace_vector_base<T, M> &y) {
+    using result_t = std::conditional_t<std::three_way_comparable<T>,
+                                        std::compare_three_way_result<T>,
+                                        std::strong_ordering>;
+
     if constexpr (std::three_way_comparable<T>) {
-      return std::lexicographical_compare_three_way(x.begin(), x.end(),
-                                                    y.begin(), y.end());
+      return std::lexicographical_compare_three_way(
+          x.begin(), x.end(), y.begin(), y.end(), std::compare_three_way());
     } else {
       const auto sz = std::min(x.size(), y.size());
+
       for (std::size_t i = 0; i < sz; ++i) {
         if (x[i] < y[i])
-          return std::strong_ordering::less;
+          return result_t::less;
         if (y[i] < x[i])
-          return std::strong_ordering::greater;
+          return result_t::greater;
         // [container.opt.reqmts] < must be total ordering relationship
       }
 
@@ -925,6 +938,8 @@ struct inplace_vector : public details::inplace_vector_base<T, N> {
 
 } // namespace freestanding
 
+// [inplace.vector.erasure], erasure
+
 template <typename T, std::size_t N, typename U = T>
 constexpr std::size_t erase(details::inplace_vector_base<T, N> &c,
                             const U &value) {

tests/beman/inplace_vector/compare.test.cpp

@@ -330,7 +330,6 @@ TEST(Compare, threeway_uncomparable) {
 
 // In accordance with P3698R0, we compare vectors with identical elements but
 // different capacities
-
 TEST(Compare, threeway_cross_capacity_smaller) {
   vec_list<inplace_vector<int, 4>, inplace_vector<int, 5>> list{
       .empty{},