Split operator<=> into two layers

Author: saki7

include/iris/compare.hpp

@@ -22,7 +22,7 @@ struct synth_three_way_result_impl
     using type = std::weak_ordering;
 };
 
-template<class T, class U> requires std::three_way_comparable<T, U>
+template<class T, class U> requires std::three_way_comparable_with<T, U>
 struct synth_three_way_result_impl<T, U>
 {
     using type = std::invoke_result_t<std::compare_three_way, T const&, U const&>;

include/iris/indirect.hpp

@@ -422,9 +422,13 @@ constexpr bool operator==(indirect<T, Allocator> const& lhs, U const& rhs)
     }
 }
 
-template<class T, class Allocator, class U> requires (!is_ttp_specialization_of_v<U, indirect>)
-constexpr auto operator<=>(indirect<T, Allocator> const& lhs, U const& rhs)
-    noexcept(synth_three_way_noexcept<T, U>) -> synth_three_way_result_t<T, U>
+
+namespace detail {
+
+template<class T, class A, class U>
+constexpr auto three_way_compare_impl(indirect<T, A> const& lhs, U const& rhs)
+    noexcept(synth_three_way_noexcept<T, U>)
+    -> synth_three_way_result_t<T, U>
 {
     if (lhs.valueless_after_move()) [[unlikely]] {
         return std::strong_ordering::less;
@@ -433,6 +437,16 @@ constexpr auto operator<=>(indirect<T, Allocator> const& lhs, U const& rhs)
     }
 }
 
+} // detail
+
+template<class T, class A, class U>
+constexpr auto operator<=>(indirect<T, A> const& lhs, U const& rhs)
+    noexcept(synth_three_way_noexcept<T, U>)
+    // no explicit return type
+{
+    return detail::three_way_compare_impl(lhs, rhs);
+}
+
 }  // iris
 
 

include/iris/rvariant/recursive_wrapper.hpp

@@ -199,8 +199,12 @@ constexpr bool operator==(recursive_wrapper<T, A> const& lhs, U const& rhs)
     }
 }
 
+namespace detail {
+
 template<class T, class A, class U>
-constexpr auto operator<=>(recursive_wrapper<T, A> const& lhs, U const& rhs) noexcept(synth_three_way_noexcept<T, U>) -> synth_three_way_result_t<T, U>
+constexpr auto three_way_compare_impl(recursive_wrapper<T, A> const& lhs, U const& rhs)
+    noexcept(synth_three_way_noexcept<T, U>)
+    -> synth_three_way_result_t<T, U>
 {
     if (lhs.valueless_after_move()) [[unlikely]] {
         return std::strong_ordering::less;
@@ -209,6 +213,16 @@ constexpr auto operator<=>(recursive_wrapper<T, A> const& lhs, U const& rhs) noe
     }
 }
 
+} // detail
+
+template<class T, class A, class U>
+constexpr auto operator<=>(recursive_wrapper<T, A> const& lhs, U const& rhs)
+    noexcept(synth_three_way_noexcept<T, U>)
+    // no explicit return type
+{
+    return detail::three_way_compare_impl(lhs, rhs);
+}
+
 }  // iris
 
 namespace std {