diff --git a/stl/inc/compare b/stl/inc/compare
index 46bdfd0371f..ab47a879606 100644
--- a/stl/inc/compare
+++ b/stl/inc/compare
@@ -342,6 +342,35 @@ struct compare_three_way {
 };
 // clang-format on
 
+// STRUCT _Synth_three_way
+struct _Synth_three_way {
+    // clang-format off
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(const _Ty1& _Left, const _Ty2& _Right) const
+    requires requires {
+        { _Left < _Right } -> _Boolean_testable;
+        { _Right < _Left } -> _Boolean_testable;
+    }
+    // clang-format on
+    {
+        if constexpr (three_way_comparable_with<_Ty1, _Ty2>) {
+            return _Left <=> _Right;
+        } else {
+            if (_Left < _Right) {
+                return weak_ordering::less;
+            } else if (_Right < _Left) {
+                return weak_ordering::greater;
+            } else {
+                return weak_ordering::equivalent;
+            }
+        }
+    }
+};
+
+// ALIAS TEMPLATE _Synth_three_way_result
+template <class _Ty1, class _Ty2 = _Ty1>
+using _Synth_three_way_result = decltype(_Synth_three_way{}(_STD declval<_Ty1&>(), _STD declval<_Ty2&>()));
+
 // Note: The following CPOs are passing arguments as lvalues; see GH-1374.
 
 // CUSTOMIZATION POINT OBJECT strong_order
diff --git a/stl/inc/optional b/stl/inc/optional
index 04e36c0c10b..81d2639a164 100644
--- a/stl/inc/optional
+++ b/stl/inc/optional
@@ -11,6 +11,9 @@
 #if !_HAS_CXX17
 #pragma message("The contents of <optional> are available only with C++17 or later.")
 #else // ^^^ !_HAS_CXX17 / _HAS_CXX17 vvv
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
 #include <exception>
 #include <initializer_list>
 #include <type_traits>
@@ -480,11 +483,30 @@ _NODISCARD constexpr bool operator>=(const optional<_Ty1>& _Left, const optional
     return !_Right.has_value() || (_Left.has_value() && *_Left >= *_Right);
 }
 
+#ifdef __cpp_lib_concepts
+template <class _Ty1, three_way_comparable_with<_Ty1> _Ty2>
+_NODISCARD constexpr compare_three_way_result_t<_Ty1, _Ty2> operator<=>(
+    const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) {
+    if (_Left && _Right) {
+        return *_Left <=> *_Right;
+    }
+
+    return _Left.has_value() <=> _Right.has_value();
+}
+#endif // __cpp_lib_concepts
+
 // COMPARISONS WITH nullopt [optional.nullops]
 template <class _Ty>
 _NODISCARD constexpr bool operator==(const optional<_Ty>& _Left, nullopt_t) noexcept {
     return !_Left.has_value();
 }
+
+#if _HAS_CXX20
+template <class _Ty>
+_NODISCARD constexpr strong_ordering operator<=>(const optional<_Ty>& _Left, nullopt_t) noexcept {
+    return _Left.has_value() <=> false;
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
 template <class _Ty>
 _NODISCARD constexpr bool operator==(nullopt_t, const optional<_Ty>& _Right) noexcept {
     return !_Right.has_value();
@@ -534,6 +556,7 @@ template <class _Ty>
 _NODISCARD constexpr bool operator>=(nullopt_t, const optional<_Ty>& _Right) noexcept {
     return !_Right.has_value();
 }
+#endif // !_HAS_CXX20
 
 // COMPARISONS WITH T [optional.comp_with_t]
 template <class _Ty>
@@ -567,6 +590,7 @@ template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> =
 _NODISCARD constexpr bool operator==(const optional<_Ty1>& _Left, const _Ty2& _Right) {
     return _Left ? *_Left == _Right : false;
 }
+
 template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator==(const _Ty1& _Left, const optional<_Ty2>& _Right) {
     return _Right ? _Left == *_Right : false;
@@ -617,6 +641,22 @@ _NODISCARD constexpr bool operator>=(const _Ty1& _Left, const optional<_Ty2>& _R
     return _Right ? _Left >= *_Right : true;
 }
 
+#ifdef __cpp_lib_concepts
+// clang-format off
+template <class _Ty1, class _Ty2>
+    requires (!_Is_specialization_v<_Ty2, optional>) // TRANSITION, GH-1674
+        && three_way_comparable_with<_Ty1, _Ty2>
+_NODISCARD constexpr compare_three_way_result_t<_Ty1, _Ty2>
+    operator<=>(const optional<_Ty1>& _Left, const _Ty2& _Right) {
+    // clang-format on
+    if (_Left) {
+        return *_Left <=> _Right;
+    }
+
+    return strong_ordering::less;
+}
+#endif // __cpp_lib_concepts
+
 // FUNCTION TEMPLATE swap [optional.specalg]
 template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_swappable_v<_Ty>, int> = 0>
 void swap(optional<_Ty>& _Left, optional<_Ty>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
diff --git a/stl/inc/regex b/stl/inc/regex
index 84ff2ce169d..2f2949e2683 100644
--- a/stl/inc/regex
+++ b/stl/inc/regex
@@ -730,35 +730,6 @@ template <class _BidIt>
 _NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
 }
-
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-900973
-// The compiler incorrectly performs overload resolution by preferring implicit conversions over rewrites.
-// In C++20 mode the only required comparison operators should be == and <=>.
-template <class _BidIt>
-_NODISCARD bool operator!=(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<=(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-#endif // TRANSITION, VSO-900973
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
 template <class _BidIt>
 _NODISCARD bool operator!=(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
@@ -797,70 +768,6 @@ template <class _BidIt>
 _NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
 }
-
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-900973
-// The compiler incorrectly performs overload resolution by preferring implicit conversions over rewrites.
-// In C++20 mode the only required comparison operators should be == and <=>.
-template <class _BidIt>
-_NODISCARD auto operator<=>(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return static_cast<typename sub_match<_BidIt>::_Comparison_category>(0 <=> (_Right <=> _Left));
-}
-
-template <class _BidIt>
-_NODISCARD bool operator==(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return _Right._Match_equal(_Left);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator!=(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<=(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>=(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator!=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-#endif // TRANSTITION, VSO-900973
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
 template <class _BidIt>
 _NODISCARD bool operator==(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
@@ -930,70 +837,6 @@ _NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const _Iter_value_t<
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(
         _Left._Compare(_STD addressof(_Right), 1) <=> 0);
 }
-
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-900973
-// The compiler incorrectly performs overload resolution by preferring implicit conversions over rewrites.
-// In C++20 mode the only required comparison operators should be == and <=>.
-template <class _BidIt>
-_NODISCARD auto operator<=>(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return static_cast<typename sub_match<_BidIt>::_Comparison_category>(0 <=> (_Right <=> _Left));
-}
-
-template <class _BidIt>
-_NODISCARD bool operator==(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return _Right._Match_equal(_STD addressof(_Left), 1);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator!=(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<=(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>=(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator!=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-#endif // TRANSITION, VSO-900973
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
 template <class _BidIt>
 _NODISCARD bool operator==(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
@@ -1064,82 +907,6 @@ _NODISCARD auto operator<=>(
     const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
 }
-
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-900973
-// The compiler incorrectly performs overload resolution by preferring implicit conversions over rewrites.
-// In C++20 mode the only required comparison operators should be == and <=>.
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD auto operator<=>(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return static_cast<typename sub_match<_BidIt>::_Comparison_category>(0 <=> (_Right <=> _Left));
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator==(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return _Right._Match_equal(_Left.data(), _Left.size());
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator!=(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator<(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator>(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator<=(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator>=(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator!=(
-    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator<(
-    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator>(
-    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator<=(
-    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator>=(
-    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-#endif // TRANSITION, VSO-900973
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
 template <class _BidIt, class _Traits, class _Alloc>
 _NODISCARD bool operator==(
diff --git a/stl/inc/tuple b/stl/inc/tuple
index d0734801e84..7fb6e3402fc 100644
--- a/stl/inc/tuple
+++ b/stl/inc/tuple
@@ -8,6 +8,9 @@
 #define _TUPLE_
 #include <yvals_core.h>
 #if _STL_COMPILER_PREPROCESSOR
+#ifdef __cpp_lib_concepts
+#include <compare>
+#endif // __cpp_lib_concepts
 #include <type_traits>
 #include <xutility>
 
@@ -233,9 +236,15 @@ public:
         return true;
     }
 
-    constexpr bool _Less(const tuple&) const noexcept {
+#ifdef __cpp_lib_concepts
+    _NODISCARD constexpr strong_ordering _Three_way_compare(const tuple&) const noexcept {
+        return strong_ordering::equal;
+    }
+#else // ^^^ defined(__cpp_lib_concepts) / !defined(__cpp_lib_concepts) vvv
+    _NODISCARD constexpr bool _Less(const tuple&) const noexcept {
         return false;
     }
+#endif // !defined(__cpp_lib_concepts)
 };
 
 template <class _This, class... _Rest>
@@ -673,11 +682,23 @@ public:
         return _Myfirst._Val == _Right._Myfirst._Val && _Mybase::_Equals(_Right._Get_rest());
     }
 
+#ifdef __cpp_lib_concepts
+    template <class _First, class... _Other,
+        class _Ret = common_comparison_category_t<_Synth_three_way_result<_This, _First>, // TRANSITION, DevCom-1344701
+            _Synth_three_way_result<_Rest, _Other>...>> // (should be a normal or trailing return type)
+    _NODISCARD constexpr _Ret _Three_way_compare(const tuple<_First, _Other...>& _Right) const {
+        if (auto _Result = _Synth_three_way{}(_Myfirst._Val, _Right._Myfirst._Val); _Result != 0) {
+            return _Result;
+        }
+        return _Mybase::_Three_way_compare(_Right._Get_rest());
+    }
+#else // ^^^ defined(__cpp_lib_concepts) / !defined(__cpp_lib_concepts) vvv
     template <class... _Other>
-    constexpr bool _Less(const tuple<_Other...>& _Right) const {
+    _NODISCARD constexpr bool _Less(const tuple<_Other...>& _Right) const {
         return _Myfirst._Val < _Right._Myfirst._Val
             || (!(_Right._Myfirst._Val < _Myfirst._Val) && _Mybase::_Less(_Right._Get_rest()));
     }
+#endif // !defined(__cpp_lib_concepts)
 
     template <size_t _Index, class... _Types>
     friend constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept;
@@ -733,10 +754,20 @@ _NODISCARD constexpr bool operator==(const tuple<_Types1...>& _Left, const tuple
     return _Left._Equals(_Right);
 }
 
+#ifdef __cpp_lib_concepts
+template <class... _Types1, class... _Types2>
+_NODISCARD constexpr common_comparison_category_t<_Synth_three_way_result<_Types1, _Types2>...> operator<=>(
+    const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    static_assert(sizeof...(_Types1) == sizeof...(_Types2), "cannot compare tuples of different sizes");
+    return _Left._Three_way_compare(_Right);
+}
+#else // ^^^ defined(__cpp_lib_concepts) / !defined(__cpp_lib_concepts) vvv
+#if !_HAS_CXX20
 template <class... _Types1, class... _Types2>
 _NODISCARD constexpr bool operator!=(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
     return !(_Left == _Right);
 }
+#endif // !_HAS_CXX20
 
 template <class... _Types1, class... _Types2>
 _NODISCARD constexpr bool operator<(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
@@ -758,6 +789,7 @@ template <class... _Types1, class... _Types2>
 _NODISCARD constexpr bool operator<=(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
     return !(_Right < _Left);
 }
+#endif // !defined(__cpp_lib_concepts)
 
 template <class... _Types, enable_if_t<conjunction_v<_STD _Is_swappable<_Types>...>, int> = 0>
 _CONSTEXPR20 void swap(tuple<_Types...>& _Left, tuple<_Types...>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
diff --git a/stl/inc/utility b/stl/inc/utility
index f14d1cf9bf5..54f6c0f149a 100644
--- a/stl/inc/utility
+++ b/stl/inc/utility
@@ -347,10 +347,22 @@ _NODISCARD constexpr bool operator==(const pair<_Ty1, _Ty2>& _Left, const pair<_
     return _Left.first == _Right.first && _Left.second == _Right.second;
 }
 
+#ifdef __cpp_lib_concepts
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr common_comparison_category_t<_Synth_three_way_result<_Ty1>, _Synth_three_way_result<_Ty2>>
+    operator<=>(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) {
+    if (auto _Result = _Synth_three_way{}(_Left.first, _Right.first); _Result != 0) {
+        return _Result;
+    }
+    return _Synth_three_way{}(_Left.second, _Right.second);
+}
+#else // ^^^ defined(__cpp_lib_concepts) / !defined(__cpp_lib_concepts) vvv
+#if !_HAS_CXX20
 template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool operator!=(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) {
     return !(_Left == _Right);
 }
+#endif // !_HAS_CXX20
 
 template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool operator<(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) {
@@ -371,6 +383,7 @@ template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool operator>=(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) {
     return !(_Left < _Right);
 }
+#endif // !defined(__cpp_lib_concepts)
 
 // ALIAS TEMPLATE _Unrefwrap_t
 template <class _Ty>
@@ -700,37 +713,6 @@ _NODISCARD constexpr bool cmp_greater_equal(const _Ty1 _Left, const _Ty2 _Right)
     return !_STD cmp_less(_Left, _Right);
 }
 
-#ifdef __cpp_lib_concepts
-// STRUCT _Synth_three_way
-struct _Synth_three_way {
-    // clang-format off
-    template <class _Ty1, class _Ty2>
-    _NODISCARD constexpr auto operator()(const _Ty1& _Left, const _Ty2& _Right) const
-    requires requires {
-        { _Left < _Right } -> _Boolean_testable;
-        { _Right < _Left } -> _Boolean_testable;
-    }
-    // clang-format on
-    {
-        if constexpr (three_way_comparable_with<_Ty1, _Ty2>) {
-            return _Left <=> _Right;
-        } else {
-            if (_Left < _Right) {
-                return weak_ordering::less;
-            } else if (_Right < _Left) {
-                return weak_ordering::greater;
-            } else {
-                return weak_ordering::equivalent;
-            }
-        }
-    }
-};
-
-// ALIAS TEMPLATE _Synth_three_way_result
-template <class _Ty1, class _Ty2 = _Ty1>
-using _Synth_three_way_result = decltype(_Synth_three_way{}(_STD declval<_Ty1&>(), _STD declval<_Ty2&>()));
-#endif // __cpp_lib_concepts
-
 // FUNCTION TEMPLATE in_range
 template <class _Ty>
 _NODISCARD _CONSTEVAL _Ty _Min_limit() noexcept { // same as (numeric_limits<_Ty>::min)(), less throughput cost
diff --git a/tests/std/tests/P1614R2_spaceship/test.cpp b/tests/std/tests/P1614R2_spaceship/test.cpp
index 4d88d87262b..2b2e73691e5 100644
--- a/tests/std/tests/P1614R2_spaceship/test.cpp
+++ b/tests/std/tests/P1614R2_spaceship/test.cpp
@@ -19,6 +19,7 @@
 #include <memory>
 #include <memory_resource>
 #include <new>
+#include <optional>
 #include <queue>
 #include <ranges>
 #include <ratio>
@@ -30,6 +31,7 @@
 #include <string_view>
 #include <system_error>
 #include <thread>
+#include <tuple>
 #include <type_traits>
 #include <typeindex>
 #include <typeinfo>
@@ -40,9 +42,6 @@
 #include <variant>
 #include <vector>
 
-template <class T>
-using SpaceshipType = decltype(std::declval<T>() <=> std::declval<T>());
-
 template <class T, class U>
 concept HasSpaceshipWith = requires {
     std::declval<T>() <=> std::declval<U>();
@@ -173,15 +172,17 @@ constexpr bool spaceship_test(const SmallType& smaller, const EqualType& smaller
 }
 
 template <class T>
-inline constexpr bool is_pair = false;
-template <class A, class B>
-inline constexpr bool is_pair<std::pair<A, B>> = true; // TRANSITION, std::pair spaceship not yet implemented
+inline constexpr bool has_synth_ordered = false;
+template <class V>
+inline constexpr bool has_synth_ordered<std::pair<const SynthOrdered, V>> = true;
+template <>
+inline constexpr bool has_synth_ordered<SynthOrdered> = true;
 
 template <class Container>
 void ordered_containers_test(const Container& smaller, const Container& smaller_equal, const Container& larger) {
     using Elem = typename Container::value_type;
-    if constexpr (is_pair<Elem> // TRANSITION, std::pair spaceship not yet implemented
-                  || std::is_same_v<Elem, SynthOrdered>) {
+
+    if constexpr (has_synth_ordered<Elem>) {
         spaceship_test<std::weak_ordering>(smaller, smaller_equal, larger);
     } else {
         spaceship_test<std::strong_ordering>(smaller, smaller_equal, larger);
@@ -246,6 +247,83 @@ void diagnostics_test() {
     }
 }
 
+template <template <class...> class TupleLike>
+constexpr bool tuple_like_test() {
+    {
+        constexpr TupleLike<int, int> t1{1, 1};
+        constexpr TupleLike<int, int> t1_equal{1, 1};
+        constexpr TupleLike<int, int> t2{2, 1};
+
+        assert(spaceship_test<std::strong_ordering>(t1, t1_equal, t2));
+    }
+    {
+        constexpr TupleLike<int, double> t1{1, 1.0};
+        constexpr TupleLike<int, double> t1_equal{1, 1.0};
+        constexpr TupleLike<int, double> t2{2, 1.0};
+
+        assert(spaceship_test<std::partial_ordering>(t1, t1_equal, t2));
+    }
+
+    if constexpr (std::is_same_v<TupleLike<int, int>, std::tuple<int, int>>) {
+        {
+            constexpr TupleLike<int, double> t1{1, 1.0};
+            constexpr TupleLike<double, double> t1_equal{1.0, 1.0};
+            constexpr TupleLike<int, double> t2{2, 1.0};
+
+            assert(spaceship_test<std::partial_ordering>(t1, t1_equal, t2));
+        }
+        {
+            constexpr TupleLike<int, double> t1{1, 1.0};
+            constexpr TupleLike<int, double> t1_equal{1, 1.0};
+            constexpr TupleLike<double, double> t2{2.0, 1.0};
+
+            assert(spaceship_test<std::partial_ordering>(t1, t1_equal, t2));
+        }
+    }
+
+    static_assert(std::is_same_v<std::compare_three_way_result_t<TupleLike<PartiallyOrdered, PartiallyOrdered>>,
+        std::partial_ordering>);
+    static_assert(
+        std::is_same_v<std::compare_three_way_result_t<TupleLike<WeaklyOrdered, WeaklyOrdered>>, std::weak_ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<TupleLike<StronglyOrdered, StronglyOrdered>>,
+        std::strong_ordering>);
+
+    return true;
+}
+
+template <auto SmallVal, decltype(SmallVal) EqualVal, decltype(EqualVal) LargeVal>
+constexpr bool optional_test() {
+    using ReturnType = std::compare_three_way_result_t<decltype(SmallVal)>;
+
+    {
+        constexpr std::optional o1(SmallVal);
+        constexpr std::optional o1_equal(EqualVal);
+        constexpr std::optional o2(LargeVal);
+
+        assert(spaceship_test<ReturnType>(o1, o1_equal, o2));
+    }
+    {
+        constexpr std::optional<decltype(SmallVal)> o1(std::nullopt);
+        constexpr std::optional<decltype(EqualVal)> o1_equal(std::nullopt);
+        constexpr std::optional o2(LargeVal);
+
+        assert(spaceship_test<ReturnType>(o1, o1_equal, o2));
+    }
+    {
+        constexpr std::optional o1(SmallVal);
+
+        assert(spaceship_test<ReturnType>(o1, EqualVal, LargeVal));
+    }
+    {
+        constexpr std::optional<decltype(SmallVal)> o1(std::nullopt);
+        constexpr std::optional o2(LargeVal);
+
+        assert(spaceship_test<ReturnType>(o1, std::nullopt, o2));
+    }
+
+    return true;
+}
+
 template <bool Equal>
 struct compare_resource final : std::pmr::memory_resource {
 private:
@@ -571,10 +649,10 @@ void ordering_test_cases() {
             std::sub_match<std::basic_string<WeaklyOrderedByOmissionChar>::const_iterator>;
         using PartiallyOrderedMatch = std::sub_match<std::basic_string<PartiallyOrderedChar>::const_iterator>;
 
-        static_assert(std::is_same_v<SpaceshipType<StronglyOrderedMatch>, std::strong_ordering>);
-        static_assert(std::is_same_v<SpaceshipType<WeaklyOrderedMatch>, std::weak_ordering>);
-        static_assert(std::is_same_v<SpaceshipType<WeaklyOrderdByOmissionMatch>, std::weak_ordering>);
-        static_assert(std::is_same_v<SpaceshipType<PartiallyOrderedMatch>, std::partial_ordering>);
+        static_assert(std::is_same_v<std::compare_three_way_result_t<StronglyOrderedMatch>, std::strong_ordering>);
+        static_assert(std::is_same_v<std::compare_three_way_result_t<WeaklyOrderedMatch>, std::weak_ordering>);
+        static_assert(std::is_same_v<std::compare_three_way_result_t<WeaklyOrderdByOmissionMatch>, std::weak_ordering>);
+        static_assert(std::is_same_v<std::compare_three_way_result_t<PartiallyOrderedMatch>, std::partial_ordering>);
     }
     { // char_traits
         static_assert(std::is_same_v<std::char_traits<char>::comparison_category, std::strong_ordering>);
@@ -836,6 +914,39 @@ void ordering_test_cases() {
 
         spaceship_test<std::strong_ordering>(c_mem[0], c_mem[0], c_mem[1]);
     }
+    { // optional
+        optional_test<0, 0, 1>();
+        static_assert(optional_test<0, 0, 1>());
+
+#if defined(__cpp_nontype_template_args) && __cpp_nontype_template_args >= 201911
+        optional_test<0.0, 0.0, 1.0>();
+        static_assert(optional_test<0.0, 0.0, 1.0>());
+#endif
+
+        static_assert(
+            std::is_same_v<std::compare_three_way_result_t<std::optional<WeaklyOrdered>, std::optional<WeaklyOrdered>>,
+                std::weak_ordering>);
+        static_assert(std::is_same_v<std::compare_three_way_result_t<std::optional<WeaklyOrdered>, WeaklyOrdered>,
+            std::weak_ordering>);
+        static_assert(std::is_same_v<std::compare_three_way_result_t<std::optional<WeaklyOrdered>, std::nullopt_t>,
+            std::strong_ordering>);
+    }
+    { // tuple
+        tuple_like_test<std::tuple>();
+        static_assert(tuple_like_test<std::tuple>());
+
+        {
+            constexpr std::tuple<> empty1;
+            constexpr std::tuple<> empty2;
+
+            static_assert(std::is_same_v<decltype(empty1 <=> empty2), std::strong_ordering>);
+            static_assert((empty1 <=> empty2) == std::strong_ordering::equal);
+        }
+    }
+    { // pair
+        tuple_like_test<std::pair>();
+        static_assert(tuple_like_test<std::pair>());
+    }
     { // variant
         using V = std::variant<int, long>;
         constexpr V v0_0(std::in_place_index<0>, 0);
@@ -1004,24 +1115,23 @@ void ordering_test_cases() {
 template <class Element, class Ordering>
 void test_element_ordering() {
     if constexpr (!std::is_same_v<Element, SynthOrdered>) { // SynthOrdered inherently doesn't support <=> directly
-        static_assert(std::is_same_v<SpaceshipType<Element>, Ordering>);
+        static_assert(std::is_same_v<std::compare_three_way_result_t<Element>, Ordering>);
     }
 
-    static_assert(std::is_same_v<SpaceshipType<std::array<Element, 3>>, Ordering>);
-    static_assert(std::is_same_v<SpaceshipType<std::deque<Element>>, Ordering>);
-    static_assert(std::is_same_v<SpaceshipType<std::list<Element>>, Ordering>);
-    static_assert(std::is_same_v<SpaceshipType<std::vector<Element>>, Ordering>);
-    static_assert(std::is_same_v<SpaceshipType<std::forward_list<Element>>, Ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<std::array<Element, 3>>, Ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<std::deque<Element>>, Ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<std::list<Element>>, Ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<std::vector<Element>>, Ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<std::forward_list<Element>>, Ordering>);
 
-    // TRANSITION, std::pair spaceship not yet implemented
-    static_assert(std::is_same_v<SpaceshipType<std::map<Element, Element>>, std::weak_ordering>);
-    static_assert(std::is_same_v<SpaceshipType<std::multimap<Element, Element>>, std::weak_ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<std::map<Element, Element>>, Ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<std::multimap<Element, Element>>, Ordering>);
 
-    static_assert(std::is_same_v<SpaceshipType<std::set<Element>>, Ordering>);
-    static_assert(std::is_same_v<SpaceshipType<std::multiset<Element>>, Ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<std::set<Element>>, Ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<std::multiset<Element>>, Ordering>);
 
-    static_assert(std::is_same_v<SpaceshipType<std::queue<Element>>, Ordering>);
-    static_assert(std::is_same_v<SpaceshipType<std::stack<Element>>, Ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<std::queue<Element>>, Ordering>);
+    static_assert(std::is_same_v<std::compare_three_way_result_t<std::stack<Element>>, Ordering>);
 }
 
 int main() {