diff --git a/include/iris/compare.hpp b/include/iris/compare.hpp
index f5421ef..c0595d5 100644
--- a/include/iris/compare.hpp
+++ b/include/iris/compare.hpp
@@ -14,44 +14,14 @@ namespace iris {
 // Utilities defined in [library]
 // https://eel.is/c++draft/library
 
-namespace detail {
-
-template<class T, class U>
-struct synth_three_way_result_impl
-{
-    using type = std::weak_ordering;
-};
-
-template<class T, class U> requires std::three_way_comparable<T, U>
-struct synth_three_way_result_impl<T, U>
-{
-    using type = std::invoke_result_t<std::compare_three_way, T const&, U const&>;
-};
-
-} // detail
-
-template<class T, class U = T>
-using synth_three_way_result_t = detail::synth_three_way_result_impl<T, U>::type;
-
-template<class T, class U = T>
-inline constexpr bool synth_three_way_noexcept =
-    std::conditional_t<
-        std::three_way_comparable_with<T, U>,
-        std::is_nothrow_invocable<std::compare_three_way, T const&, U const&>,
-        std::conjunction<
-            std::is_nothrow_invocable<std::less<>, T const&, U const&>,
-            std::is_nothrow_invocable<std::less<>, U const&, T const&>
-        >
-    >::value;
-
-constexpr auto synth_three_way = []<class T, class U>(T const& t, U const& u) noexcept(synth_three_way_noexcept<T, U>)
-    -> synth_three_way_result_t<T, U>
+constexpr auto synth_three_way = []<class T, class U>(T const& t, U const& u)
     requires requires {
         { t < u } -> req::boolean_testable;
         { u < t } -> req::boolean_testable;
     }
 {
-    if constexpr (std::three_way_comparable_with<T, U>) {
+    //if constexpr (std::three_way_comparable_with<T, U>) {
+    if constexpr (requires { t <=> u; }) {
         return t <=> u;
     } else {
         if (t < u) return std::weak_ordering::less;
@@ -60,6 +30,10 @@ constexpr auto synth_three_way = []<class T, class U>(T const& t, U const& u) no
     }
 };
 
+template<class T, class U = T>
+using synth_three_way_result_t = decltype(synth_three_way(std::declval<T&>(), std::declval<U&>()));
+
+
 namespace cmp {
 
 template<class Compare, class T>
diff --git a/include/iris/indirect.hpp b/include/iris/indirect.hpp
index 1a78a63..9e78964 100644
--- a/include/iris/indirect.hpp
+++ b/include/iris/indirect.hpp
@@ -51,13 +51,10 @@ class scoped_allocation
     pointer ptr_;
 };
 
-}  // detail
-
-
 // Polyfill for the C++26 `std::indirect`
 // https://eel.is/c++draft/indirect
 template<class T, class Allocator = std::allocator<T>>
-class indirect
+class indirect_base
 {
     static_assert(std::is_object_v<T>);
     static_assert(!std::is_array_v<T>);
@@ -72,36 +69,36 @@ class indirect
     using pointer = std::allocator_traits<Allocator>::pointer;
     using const_pointer = std::allocator_traits<Allocator>::const_pointer;
 
-    constexpr explicit indirect() requires std::is_default_constructible_v<Allocator>
+    constexpr explicit indirect_base() requires std::is_default_constructible_v<Allocator>
         : ptr_(make_obj())
     {}
 
-    constexpr indirect(indirect const& other)
-        : indirect(
+    constexpr indirect_base(indirect_base const& other)
+        : indirect_base(
             std::allocator_arg,
             std::allocator_traits<Allocator>::select_on_container_copy_construction(other.alloc_),
             other
         )
     {}
 
-    constexpr explicit indirect(std::allocator_arg_t, Allocator const& a)
+    constexpr explicit indirect_base(std::allocator_arg_t, Allocator const& a)
         : alloc_(a)
         , ptr_(make_obj())
     {}
 
-    constexpr indirect(std::allocator_arg_t, Allocator const& a, indirect const& other)
+    constexpr indirect_base(std::allocator_arg_t, Allocator const& a, indirect_base const& other)
         : alloc_(a)
         , ptr_(other.ptr_ ? make_obj(std::as_const(*other.ptr_)) : nullptr)
     {
         static_assert(std::is_copy_constructible_v<T>);
     }
 
-    constexpr indirect(indirect&& other) noexcept
+    constexpr indirect_base(indirect_base&& other) noexcept
         : alloc_(std::move(other.alloc_))
         , ptr_(std::exchange(other.ptr_, nullptr))
     {}
 
-    constexpr indirect(std::allocator_arg_t, Allocator const& a, indirect&& other)
+    constexpr indirect_base(std::allocator_arg_t, Allocator const& a, indirect_base&& other)
         noexcept(std::allocator_traits<Allocator>::is_always_equal::value)
         : alloc_(a)
         , ptr_(alloc_ == other.alloc_
@@ -112,20 +109,20 @@ class indirect
 
     template<class U = T>
         requires
-            (!std::is_same_v<std::remove_cvref_t<U>, indirect>) &&
+            (!std::is_same_v<std::remove_cvref_t<U>, indirect_base>) &&
             (!std::is_same_v<std::remove_cvref_t<U>, std::in_place_t>) &&
             std::is_constructible_v<T, U> &&
             std::is_default_constructible_v<Allocator>
-    constexpr explicit indirect(U&& u)
+    constexpr explicit indirect_base(U&& u)
         : ptr_(make_obj(std::forward<U>(u)))
     {}
 
     template<class U = T>
         requires
-            (!std::is_same_v<std::remove_cvref_t<U>, indirect>) &&
+            (!std::is_same_v<std::remove_cvref_t<U>, indirect_base>) &&
             (!std::is_same_v<std::remove_cvref_t<U>, std::in_place_t>) &&
             std::is_constructible_v<T, U>
-    constexpr explicit indirect(std::allocator_arg_t, Allocator const& a, U&& u)
+    constexpr explicit indirect_base(std::allocator_arg_t, Allocator const& a, U&& u)
         : alloc_(a)
         , ptr_(make_obj(std::forward<U>(u)))
     {}
@@ -134,14 +131,14 @@ class indirect
         requires
             std::is_constructible_v<T, Us...> &&
             std::is_default_constructible_v<Allocator>
-    constexpr explicit indirect(std::in_place_t, Us&&... us)
+    constexpr explicit indirect_base(std::in_place_t, Us&&... us)
         : ptr_(make_obj(std::forward<Us>(us)...))
     {}
 
     template<class... Us>
         requires
             std::is_constructible_v<T, Us...>
-    constexpr explicit indirect(std::allocator_arg_t, Allocator const& a, std::in_place_t, Us&&... us)
+    constexpr explicit indirect_base(std::allocator_arg_t, Allocator const& a, std::in_place_t, Us&&... us)
         : alloc_(a)
         , ptr_(make_obj(std::forward<Us>(us)...))
     {}
@@ -150,26 +147,26 @@ class indirect
         requires
             std::is_constructible_v<T, std::initializer_list<I>&, Us...> &&
             std::is_default_constructible_v<Allocator>
-    constexpr explicit indirect(std::in_place_t, std::initializer_list<I> il, Us&&... us)
+    constexpr explicit indirect_base(std::in_place_t, std::initializer_list<I> il, Us&&... us)
         : ptr_(make_obj(il, std::forward<Us>(us)...))
     {}
 
     template<class I, class... Us>
         requires
             std::is_constructible_v<T, std::initializer_list<I>&, Us...>
-    constexpr explicit indirect(std::allocator_arg_t, Allocator const& a, std::in_place_t, std::initializer_list<I> il, Us&&... us)
+    constexpr explicit indirect_base(std::allocator_arg_t, Allocator const& a, std::in_place_t, std::initializer_list<I> il, Us&&... us)
         : alloc_(a)
         , ptr_(make_obj(il, std::forward<Us>(us)...))
     {}
 
-    constexpr ~indirect() noexcept
+    constexpr ~indirect_base() noexcept
     {
         if (ptr_) [[likely]] {
             destroy_deallocate();
         }
     }
 
-    constexpr indirect& operator=(indirect const& other)
+    constexpr indirect_base& operator=(indirect_base const& other)
     {
         static_assert(std::is_copy_assignable_v<T>);
         static_assert(std::is_copy_constructible_v<T>);
@@ -247,7 +244,7 @@ class indirect
         }
     }
 
-    constexpr indirect& operator=(indirect&& other)
+    constexpr indirect_base& operator=(indirect_base&& other)
         noexcept(
             std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
             std::allocator_traits<Allocator>::is_always_equal::value
@@ -308,10 +305,10 @@ class indirect
 
     template<class U = T>
         requires
-            (!std::is_same_v<std::remove_cvref_t<U>, indirect>) &&
+            (!std::is_same_v<std::remove_cvref_t<U>, indirect_base>) &&
             std::is_constructible_v<T, U> &&
             std::is_assignable_v<T&, U>
-    constexpr indirect& operator=(U&& u)
+    constexpr indirect_base& operator=(U&& u)
     {
         if (ptr_) [[likely]] {
             **this = std::forward<U>(u);
@@ -334,7 +331,7 @@ class indirect
 
     [[nodiscard]] constexpr allocator_type get_allocator() const noexcept { return alloc_; }
 
-    constexpr void swap(indirect& other)
+    constexpr void swap(indirect_base& other)
         noexcept(
             std::allocator_traits<Allocator>::propagate_on_container_swap::value ||
             std::allocator_traits<Allocator>::is_always_equal::value
@@ -348,7 +345,7 @@ class indirect
         }
     }
 
-    friend constexpr void swap(indirect& lhs, indirect& rhs) noexcept(noexcept(lhs.swap(rhs)))
+    friend constexpr void swap(indirect_base& lhs, indirect_base& rhs) noexcept(noexcept(lhs.swap(rhs)))
     {
         return lhs.swap(rhs);
     }
@@ -372,6 +369,17 @@ class indirect
     pointer ptr_;
 };
 
+} // detail
+
+// Polyfill for the C++26 `std::indirect`
+// https://eel.is/c++draft/indirect
+template<class T, class Allocator = std::allocator<T>>
+class indirect : public detail::indirect_base<T, Allocator>
+{
+public:
+    using detail::indirect_base<T, Allocator>::indirect_base;
+};
+
 template<class Value>
 indirect(Value)
     -> indirect<Value>;
@@ -392,17 +400,6 @@ constexpr bool operator==(indirect<T, Allocator> const& lhs, indirect<U, AA> con
     }
 }
 
-template<class T, class Allocator, class U, class AA>
-constexpr auto operator<=>(indirect<T, Allocator> const& lhs, indirect<U, AA> const& rhs)
-    noexcept(synth_three_way_noexcept<T, U>) -> synth_three_way_result_t<T, U>
-{
-    if (lhs.valueless_after_move() || rhs.valueless_after_move()) [[unlikely]] {
-        return !lhs.valueless_after_move() <=> !rhs.valueless_after_move();
-    } else [[likely]] {
-        return synth_three_way(*lhs, *rhs);
-    }
-}
-
 template<class T, class Allocator, class U>
 constexpr bool operator==(indirect<T, Allocator> const& lhs, U const& rhs)
     noexcept(noexcept(*lhs == rhs))
@@ -414,9 +411,26 @@ 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 {
+
+// These cannot be overloaded with the same function name, as it
+// breaks MSVC's overload resolution on recursive types (possibly bug)
+
+template<class T, class Allocator, class U, class AA>
+constexpr auto indirect_three_way_impl_00(indirect<T, Allocator> const& lhs, indirect<U, AA> const& rhs)
+    -> synth_three_way_result_t<T, U>
+{
+    if (lhs.valueless_after_move() || rhs.valueless_after_move()) [[unlikely]] {
+        return !lhs.valueless_after_move() <=> !rhs.valueless_after_move();
+    } else [[likely]] {
+        return synth_three_way(*lhs, *rhs);
+    }
+}
+
+template<class T, class A, class U>
+constexpr auto indirect_three_way_impl_01(indirect<T, A> const& lhs, U const& rhs)
+    -> synth_three_way_result_t<T, U>
 {
     if (lhs.valueless_after_move()) [[unlikely]] {
         return std::strong_ordering::less;
@@ -425,6 +439,22 @@ constexpr auto operator<=>(indirect<T, Allocator> const& lhs, U const& rhs)
     }
 }
 
+} // detail
+
+template<class T, class Allocator, class U, class AA>
+constexpr auto operator<=>(indirect<T, Allocator> const& lhs, indirect<U, AA> const& rhs)
+    // no explicit return type
+{
+    return detail::indirect_three_way_impl_00(lhs, rhs);
+}
+
+template<class T, class A, class U>
+constexpr auto operator<=>(indirect<T, A> const& lhs, U const& rhs)
+    // no explicit return type
+{
+    return detail::indirect_three_way_impl_01(lhs, rhs);
+}
+
 }  // iris
 
 
diff --git a/include/iris/rvariant/recursive_wrapper.hpp b/include/iris/rvariant/recursive_wrapper.hpp
index fb60c56..1f0bbad 100644
--- a/include/iris/rvariant/recursive_wrapper.hpp
+++ b/include/iris/rvariant/recursive_wrapper.hpp
@@ -16,7 +16,7 @@ namespace iris {
 
 template<class T, class Allocator = std::allocator<T>>
 class recursive_wrapper
-    : private iris::indirect<T, Allocator>
+    : private iris::detail::indirect_base<T, Allocator>
 {
     static_assert(std::is_object_v<T>);
     static_assert(!std::is_array_v<T>);
@@ -25,7 +25,7 @@ class recursive_wrapper
     static_assert(!std::is_const_v<T> && !std::is_volatile_v<T>);
     static_assert(std::is_same_v<T, typename std::allocator_traits<Allocator>::value_type>);
 
-    using base_type = iris::indirect<T, Allocator>;
+    using base_type = iris::detail::indirect_base<T, Allocator>;
 
 public:
     using typename base_type::allocator_type;
@@ -177,8 +177,24 @@ constexpr bool operator==(recursive_wrapper<T, TA> const& lhs, recursive_wrapper
     }
 }
 
+template<class T, class A, class U>
+constexpr bool operator==(recursive_wrapper<T, A> const& lhs, U const& rhs)
+    noexcept(noexcept(*lhs == rhs))
+{
+    if (lhs.valueless_after_move()) [[unlikely]] {
+        return false;
+    } else [[likely]] {
+        return *lhs == rhs;
+    }
+}
+
+namespace detail {
+
+// These cannot be overloaded with the same function name, as it
+// breaks MSVC's overload resolution on recursive types (possibly bug)
+
 template<class T, class TA, class U, class UA>
-constexpr auto operator<=>(recursive_wrapper<T, TA> const& lhs, recursive_wrapper<U, UA> const& rhs) noexcept(synth_three_way_noexcept<T, U>)
+constexpr auto rw_three_way_impl_00(recursive_wrapper<T, TA> const& lhs, recursive_wrapper<U, UA> const& rhs)
     -> synth_three_way_result_t<T, U>
 {
     if (lhs.valueless_after_move() || rhs.valueless_after_move()) [[unlikely]] {
@@ -189,24 +205,30 @@ constexpr auto operator<=>(recursive_wrapper<T, TA> const& lhs, recursive_wrappe
 }
 
 template<class T, class A, class U>
-constexpr bool operator==(recursive_wrapper<T, A> const& lhs, U const& rhs)
-    noexcept(noexcept(*lhs == rhs))
+constexpr auto rw_three_way_impl_01(recursive_wrapper<T, A> const& lhs, U const& rhs)
+    -> synth_three_way_result_t<T, U>
 {
     if (lhs.valueless_after_move()) [[unlikely]] {
-        return false;
+        return std::strong_ordering::less;
     } else [[likely]] {
-        return *lhs == rhs;
+        return synth_three_way(*lhs, rhs);
     }
 }
 
+} // detail
+
+template<class T, class TA, class U, class UA>
+constexpr auto operator<=>(recursive_wrapper<T, TA> const& lhs, recursive_wrapper<U, UA> const& rhs)
+    // no explicit return type
+{
+    return detail::rw_three_way_impl_00(lhs, rhs);
+}
+
 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 operator<=>(recursive_wrapper<T, A> const& lhs, U const& rhs)
+    // no explicit return type
 {
-    if (lhs.valueless_after_move()) [[unlikely]] {
-        return std::strong_ordering::less;
-    } else [[likely]] {
-        return synth_three_way(*lhs, rhs);
-    }
+    return detail::rw_three_way_impl_01(lhs, rhs);
 }
 
 }  // iris
diff --git a/include/iris/rvariant/rvariant.hpp b/include/iris/rvariant/rvariant.hpp
index 891ee81..6d59d3c 100644
--- a/include/iris/rvariant/rvariant.hpp
+++ b/include/iris/rvariant/rvariant.hpp
@@ -32,7 +32,7 @@ namespace iris {
 
 namespace detail {
 
-template<class Compare, class... Ts>
+template<class R, class Compare, class... Ts>
 struct relops_visitor;
 
 template<class... Ts>
@@ -1036,7 +1036,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
     detail::raw_visit_i(std::size_t, Variant&&, Visitor&&)  // NOLINT(clang-diagnostic-microsoft-exception-spec)
         noexcept(detail::raw_visit_noexcept_all<Visitor, detail::forward_storage_t<Variant>>);
 
-    template<class Compare, class... Ts_>
+    template<class R, class Compare, class... Ts_>
     friend struct detail::relops_visitor;
 
     template<class... Ts_>
@@ -1334,7 +1334,7 @@ get_if(rvariant<Ts...> const* v) noexcept
 
 namespace detail {
 
-template<class Compare, class... Ts>
+template<class R, class Compare, class... Ts>
 struct relops_visitor
 {
     static_assert(sizeof...(Ts) > 0);
@@ -1342,12 +1342,6 @@ struct relops_visitor
     using Storage = make_variadic_union_t<Ts...>;
     Storage const& v_storage;  // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
 
-    using R = std::conditional_t<
-        std::is_same_v<Compare, std::compare_three_way>,
-        std::common_comparison_category_t<std::compare_three_way_result_t<Ts>...>,
-        bool
-    >;
-
     template<std::size_t i, class T>
     [[nodiscard]] IRIS_FORCEINLINE constexpr R operator()(std::in_place_index_t<i>, T const& w_alt) const
         noexcept(std::disjunction_v<
@@ -1374,7 +1368,7 @@ template<class... Ts>
 {
     auto const vi = detail::valueless_bias<rvariant<Ts...>>(v.index_);
     auto const wi = detail::valueless_bias<rvariant<Ts...>>(w.index_);
-    return vi == wi && detail::raw_visit_i(wi, w, detail::relops_visitor<std::equal_to<>, Ts...>{v.storage_});
+    return vi == wi && detail::raw_visit_i(wi, w, detail::relops_visitor<bool, std::equal_to<>, Ts...>{v.storage_});
 }
 
 template<class... Ts>
@@ -1384,7 +1378,7 @@ template<class... Ts>
 {
     auto const vi = detail::valueless_bias<rvariant<Ts...>>(v.index_);
     auto const wi = detail::valueless_bias<rvariant<Ts...>>(w.index_);
-    return vi != wi || detail::raw_visit_i(wi, w, detail::relops_visitor<std::not_equal_to<>, Ts...>{v.storage_});
+    return vi != wi || detail::raw_visit_i(wi, w, detail::relops_visitor<bool, std::not_equal_to<>, Ts...>{v.storage_});
 }
 
 template<class... Ts>
@@ -1424,7 +1418,7 @@ template<class... Ts>
     // enabling more aggressive optimization, which actually
     // introduces extra branch (unfortunately).
     return (vi < wi) |
-        ((vi == wi) && detail::raw_visit_i(wi, w, detail::relops_visitor<std::less<>, Ts...>{v.storage_}));
+        ((vi == wi) && detail::raw_visit_i(wi, w, detail::relops_visitor<bool, std::less<>, Ts...>{v.storage_}));
 }
 
 template<class... Ts>
@@ -1435,7 +1429,7 @@ template<class... Ts>
     auto const vi = detail::valueless_bias<rvariant<Ts...>>(v.index_);
     auto const wi = detail::valueless_bias<rvariant<Ts...>>(w.index_);
     return (vi > wi) |
-        ((vi == wi) && detail::raw_visit_i(wi, w, detail::relops_visitor<std::greater<>, Ts...>{v.storage_}));
+        ((vi == wi) && detail::raw_visit_i(wi, w, detail::relops_visitor<bool, std::greater<>, Ts...>{v.storage_}));
 }
 
 template<class... Ts>
@@ -1446,7 +1440,7 @@ template<class... Ts>
     auto const vi = detail::valueless_bias<rvariant<Ts...>>(v.index_);
     auto const wi = detail::valueless_bias<rvariant<Ts...>>(w.index_);
     return (vi < wi) |
-        ((vi == wi) && detail::raw_visit_i(wi, w, detail::relops_visitor<std::less_equal<>, Ts...>{v.storage_}));
+        ((vi == wi) && detail::raw_visit_i(wi, w, detail::relops_visitor<bool, std::less_equal<>, Ts...>{v.storage_}));
 }
 
 template<class... Ts>
@@ -1457,7 +1451,7 @@ template<class... Ts>
     auto const vi = detail::valueless_bias<rvariant<Ts...>>(v.index_);
     auto const wi = detail::valueless_bias<rvariant<Ts...>>(w.index_);
     return (vi > wi) |
-        ((vi == wi) && detail::raw_visit_i(wi, w, detail::relops_visitor<std::greater_equal<>, Ts...>{v.storage_}));
+        ((vi == wi) && detail::raw_visit_i(wi, w, detail::relops_visitor<bool, std::greater_equal<>, Ts...>{v.storage_}));
 }
 
 
@@ -1474,7 +1468,14 @@ operator<=>(rvariant<Ts...> const& v, rvariant<Ts...> const& w)
     auto const wi = detail::valueless_bias<rvariant<Ts...>>(w.index_);
     auto const comp = vi <=> wi;
     return comp != 0 ? comp :
-        detail::raw_visit_i(wi, w, detail::relops_visitor<std::compare_three_way, Ts...>{v.storage_});
+        detail::raw_visit_i(
+            wi, w,
+            detail::relops_visitor<
+                std::common_comparison_category_t<std::compare_three_way_result_t<Ts>...>,
+                std::compare_three_way,
+                Ts...
+            >{v.storage_}
+        );
 }
 
 }  // iris
diff --git a/test/rvariant/indirect_test.cpp b/test/rvariant/indirect_test.cpp
index 5b55c1d..da7ab50 100644
--- a/test/rvariant/indirect_test.cpp
+++ b/test/rvariant/indirect_test.cpp
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: MIT
 
 #include "iris/indirect.hpp"
 
diff --git a/test/rvariant/truly_recursive_test.cpp b/test/rvariant/truly_recursive_test.cpp
index 462a428..7350ba1 100644
--- a/test/rvariant/truly_recursive_test.cpp
+++ b/test/rvariant/truly_recursive_test.cpp
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: MIT
 
 #include "iris/rvariant.hpp"
 
@@ -7,6 +7,7 @@
 #include <type_traits>
 #include <utility>
 #include <variant>
+#include <vector>
 
 namespace unit_test {
 
@@ -136,6 +137,84 @@ TEST_CASE("truly recursive", "[wrapper][recursive]")
     }
 }
 
+namespace {
+
+struct NodeArray;
+
+using Node = iris::rvariant<int, iris::recursive_wrapper<NodeArray>>;
+
+struct NodeArray : std::vector<Node>
+{
+    using std::vector<Node>::vector;
+};
+
+bool operator==(NodeArray const& a, NodeArray const& b);
+bool operator!=(NodeArray const& a, NodeArray const& b);
+bool operator<(NodeArray const& a, NodeArray const& b);
+bool operator>(NodeArray const& a, NodeArray const& b);
+bool operator<=(NodeArray const& a, NodeArray const& b);
+bool operator>=(NodeArray const& a, NodeArray const& b);
+std::strong_ordering operator<=>(NodeArray const& a, NodeArray const& b);
+
+static_assert(std::three_way_comparable<NodeArray>);
+
+bool operator==(NodeArray const& a, NodeArray const& b)
+{
+    return static_cast<std::vector<Node> const&>(a) == static_cast<std::vector<Node> const&>(b);
+}
+
+bool operator!=(NodeArray const& a, NodeArray const& b)
+{
+    return static_cast<std::vector<Node> const&>(a) != static_cast<std::vector<Node> const&>(b);
+}
+
+bool operator<(NodeArray const& a, NodeArray const& b)
+{
+    return static_cast<std::vector<Node> const&>(a) < static_cast<std::vector<Node> const&>(b);
+}
+
+bool operator>(NodeArray const& a, NodeArray const& b)
+{
+    return static_cast<std::vector<Node> const&>(a) > static_cast<std::vector<Node> const&>(b);
+}
+
+bool operator<=(NodeArray const& a, NodeArray const& b)
+{
+    return static_cast<std::vector<Node> const&>(a) <= static_cast<std::vector<Node> const&>(b);
+}
+
+bool operator>=(NodeArray const& a, NodeArray const& b)
+{
+    return static_cast<std::vector<Node> const&>(a) >= static_cast<std::vector<Node> const&>(b);
+}
+
+std::strong_ordering operator<=>(NodeArray const& a, NodeArray const& b)
+{
+    return static_cast<std::vector<Node> const&>(a) <=> static_cast<std::vector<Node> const&>(b);
+}
+
+} // anonymous
+
+TEST_CASE("recursive vector", "[wrapper][recursive]")
+{
+    // ReSharper disable CppIdenticalOperandsInBinaryExpression
+    // NOLINTBEGIN(misc-redundant-expression)
+    {
+        NodeArray node_arr;
+        (void)(node_arr == node_arr);
+        (void)(node_arr <=> node_arr);
+        (void)(node_arr < node_arr);
+    }
+    {
+        iris::recursive_wrapper<NodeArray> node_arr_rw;
+        (void)(node_arr_rw == node_arr_rw);
+        (void)(node_arr_rw <=> node_arr_rw);
+        (void)(node_arr_rw < node_arr_rw);
+    }
+    // NOLINTEND(misc-redundant-expression)
+    // ReSharper restore CppIdenticalOperandsInBinaryExpression
+}
+
 #ifdef _MSC_VER
 # pragma warning(pop)
 #endif