libstdc++-v3/libsupc++/compare

   1 // -*- C++ -*- operator<=> three-way comparison support.
   2
   3 // Copyright (C) 2019-2023 Free Software Foundation, Inc.
   4 //
   5 // This file is part of GCC.
   6 //
   7 // GCC is free software; you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by
   9 // the Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11 //
  12 // GCC is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16 //
  17 // Under Section 7 of GPL version 3, you are granted additional
  18 // permissions described in the GCC Runtime Library Exception, version
  19 // 3.1, as published by the Free Software Foundation.
  20
  21 // You should have received a copy of the GNU General Public License and
  22 // a copy of the GCC Runtime Library Exception along with this program;
  23 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 // <http://www.gnu.org/licenses/>.
  25
  26 /** @file compare
  27  *  This is a Standard C++ Library header.
  28  */
  29
  30 #ifndef _COMPARE
  31 #define _COMPARE
  32
  33 #pragma GCC system_header
  34
  35 #define __glibcxx_want_three_way_comparison
  36 #include <bits/version.h>
  37
  38 #if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
  39
  40 #include <concepts>
  41
  42 namespace std _GLIBCXX_VISIBILITY(default)
  43 {
  44   // [cmp.categories], comparison category types
  45
  46   namespace __cmp_cat
  47   {
  48     using type = signed char;
  49
  50     enum class _Ord : type { equivalent = 0, less = -1, greater = 1 };
  51
  52     enum class _Ncmp : type { _Unordered = 2 };
  53
  54     struct __unspec
  55     {
  56       consteval __unspec(__unspec*) noexcept { }
  57     };
  58   }
  59
  60   class partial_ordering
  61   {
  62     // less=0xff, equiv=0x00, greater=0x01, unordered=0x02
  63     __cmp_cat::type _M_value;
  64
  65     constexpr explicit
  66     partial_ordering(__cmp_cat::_Ord __v) noexcept
  67     : _M_value(__cmp_cat::type(__v))
  68     { }
  69
  70     constexpr explicit
  71     partial_ordering(__cmp_cat::_Ncmp __v) noexcept
  72     : _M_value(__cmp_cat::type(__v))
  73     { }
  74
  75     friend class weak_ordering;
  76     friend class strong_ordering;
  77
  78   public:
  79     // valid values
  80     static const partial_ordering less;
  81     static const partial_ordering equivalent;
  82     static const partial_ordering greater;
  83     static const partial_ordering unordered;
  84
  85     // comparisons
  86     [[nodiscard]]
  87     friend constexpr bool
  88     operator==(partial_ordering __v, __cmp_cat::__unspec) noexcept
  89     { return __v._M_value == 0; }
  90
  91     [[nodiscard]]
  92     friend constexpr bool
  93     operator==(partial_ordering, partial_ordering) noexcept = default;
  94
  95     [[nodiscard]]
  96     friend constexpr bool
  97     operator< (partial_ordering __v, __cmp_cat::__unspec) noexcept
  98     { return __v._M_value == -1; }
  99
 100     [[nodiscard]]
 101     friend constexpr bool
 102     operator> (partial_ordering __v, __cmp_cat::__unspec) noexcept
 103     { return __v._M_value == 1; }
 104
 105     [[nodiscard]]
 106     friend constexpr bool
 107     operator<=(partial_ordering __v, __cmp_cat::__unspec) noexcept
 108     { return __v._M_value <= 0; }
 109
 110     [[nodiscard]]
 111     friend constexpr bool
 112     operator>=(partial_ordering __v, __cmp_cat::__unspec) noexcept
 113     { return __cmp_cat::type(__v._M_value & 1) == __v._M_value; }
 114
 115     [[nodiscard]]
 116     friend constexpr bool
 117     operator< (__cmp_cat::__unspec, partial_ordering __v) noexcept
 118     { return __v._M_value == 1; }
 119
 120     [[nodiscard]]
 121     friend constexpr bool
 122     operator> (__cmp_cat::__unspec, partial_ordering __v) noexcept
 123     { return __v._M_value == -1; }
 124
 125     [[nodiscard]]
 126     friend constexpr bool
 127     operator<=(__cmp_cat::__unspec, partial_ordering __v) noexcept
 128     { return __cmp_cat::type(__v._M_value & 1) == __v._M_value; }
 129
 130     [[nodiscard]]
 131     friend constexpr bool
 132     operator>=(__cmp_cat::__unspec, partial_ordering __v) noexcept
 133     { return 0 >= __v._M_value; }
 134
 135     [[nodiscard]]
 136     friend constexpr partial_ordering
 137     operator<=>(partial_ordering __v, __cmp_cat::__unspec) noexcept
 138     { return __v; }
 139
 140     [[nodiscard]]
 141     friend constexpr partial_ordering
 142     operator<=>(__cmp_cat::__unspec, partial_ordering __v) noexcept
 143     {
 144       if (__v._M_value & 1)
 145         return partial_ordering(__cmp_cat::_Ord(-__v._M_value));
 146       else
 147         return __v;
 148     }
 149   };
 150
 151   // valid values' definitions
 152   inline constexpr partial_ordering
 153   partial_ordering::less(__cmp_cat::_Ord::less);
 154
 155   inline constexpr partial_ordering
 156   partial_ordering::equivalent(__cmp_cat::_Ord::equivalent);
 157
 158   inline constexpr partial_ordering
 159   partial_ordering::greater(__cmp_cat::_Ord::greater);
 160
 161   inline constexpr partial_ordering
 162   partial_ordering::unordered(__cmp_cat::_Ncmp::_Unordered);
 163
 164   class weak_ordering
 165   {
 166     __cmp_cat::type _M_value;
 167
 168     constexpr explicit
 169     weak_ordering(__cmp_cat::_Ord __v) noexcept : _M_value(__cmp_cat::type(__v))
 170     { }
 171
 172     friend class strong_ordering;
 173
 174   public:
 175     // valid values
 176     static const weak_ordering less;
 177     static const weak_ordering equivalent;
 178     static const weak_ordering greater;
 179
 180     [[nodiscard]]
 181     constexpr operator partial_ordering() const noexcept
 182     { return partial_ordering(__cmp_cat::_Ord(_M_value)); }
 183
 184     // comparisons
 185     [[nodiscard]]
 186     friend constexpr bool
 187     operator==(weak_ordering __v, __cmp_cat::__unspec) noexcept
 188     { return __v._M_value == 0; }
 189
 190     [[nodiscard]]
 191     friend constexpr bool
 192     operator==(weak_ordering, weak_ordering) noexcept = default;
 193
 194     [[nodiscard]]
 195     friend constexpr bool
 196     operator< (weak_ordering __v, __cmp_cat::__unspec) noexcept
 197     { return __v._M_value < 0; }
 198
 199     [[nodiscard]]
 200     friend constexpr bool
 201     operator> (weak_ordering __v, __cmp_cat::__unspec) noexcept
 202     { return __v._M_value > 0; }
 203
 204     [[nodiscard]]
 205     friend constexpr bool
 206     operator<=(weak_ordering __v, __cmp_cat::__unspec) noexcept
 207     { return __v._M_value <= 0; }
 208
 209     [[nodiscard]]
 210     friend constexpr bool
 211     operator>=(weak_ordering __v, __cmp_cat::__unspec) noexcept
 212     { return __v._M_value >= 0; }
 213
 214     [[nodiscard]]
 215     friend constexpr bool
 216     operator< (__cmp_cat::__unspec, weak_ordering __v) noexcept
 217     { return 0 < __v._M_value; }
 218
 219     [[nodiscard]]
 220     friend constexpr bool
 221     operator> (__cmp_cat::__unspec, weak_ordering __v) noexcept
 222     { return 0 > __v._M_value; }
 223
 224     [[nodiscard]]
 225     friend constexpr bool
 226     operator<=(__cmp_cat::__unspec, weak_ordering __v) noexcept
 227     { return 0 <= __v._M_value; }
 228
 229     [[nodiscard]]
 230     friend constexpr bool
 231     operator>=(__cmp_cat::__unspec, weak_ordering __v) noexcept
 232     { return 0 >= __v._M_value; }
 233
 234     [[nodiscard]]
 235     friend constexpr weak_ordering
 236     operator<=>(weak_ordering __v, __cmp_cat::__unspec) noexcept
 237     { return __v; }
 238
 239     [[nodiscard]]
 240     friend constexpr weak_ordering
 241     operator<=>(__cmp_cat::__unspec, weak_ordering __v) noexcept
 242     { return weak_ordering(__cmp_cat::_Ord(-__v._M_value)); }
 243   };
 244
 245   // valid values' definitions
 246   inline constexpr weak_ordering
 247   weak_ordering::less(__cmp_cat::_Ord::less);
 248
 249   inline constexpr weak_ordering
 250   weak_ordering::equivalent(__cmp_cat::_Ord::equivalent);
 251
 252   inline constexpr weak_ordering
 253   weak_ordering::greater(__cmp_cat::_Ord::greater);
 254
 255   class strong_ordering
 256   {
 257     __cmp_cat::type _M_value;
 258
 259     constexpr explicit
 260     strong_ordering(__cmp_cat::_Ord __v) noexcept
 261     : _M_value(__cmp_cat::type(__v))
 262     { }
 263
 264   public:
 265     // valid values
 266     static const strong_ordering less;
 267     static const strong_ordering equal;
 268     static const strong_ordering equivalent;
 269     static const strong_ordering greater;
 270
 271     [[nodiscard]]
 272     constexpr operator partial_ordering() const noexcept
 273     { return partial_ordering(__cmp_cat::_Ord(_M_value)); }
 274
 275     [[nodiscard]]
 276     constexpr operator weak_ordering() const noexcept
 277     { return weak_ordering(__cmp_cat::_Ord(_M_value)); }
 278
 279     // comparisons
 280     [[nodiscard]]
 281     friend constexpr bool
 282     operator==(strong_ordering __v, __cmp_cat::__unspec) noexcept
 283     { return __v._M_value == 0; }
 284
 285     [[nodiscard]]
 286     friend constexpr bool
 287     operator==(strong_ordering, strong_ordering) noexcept = default;
 288
 289     [[nodiscard]]
 290     friend constexpr bool
 291     operator< (strong_ordering __v, __cmp_cat::__unspec) noexcept
 292     { return __v._M_value < 0; }
 293
 294     [[nodiscard]]
 295     friend constexpr bool
 296     operator> (strong_ordering __v, __cmp_cat::__unspec) noexcept
 297     { return __v._M_value > 0; }
 298
 299     [[nodiscard]]
 300     friend constexpr bool
 301     operator<=(strong_ordering __v, __cmp_cat::__unspec) noexcept
 302     { return __v._M_value <= 0; }
 303
 304     [[nodiscard]]
 305     friend constexpr bool
 306     operator>=(strong_ordering __v, __cmp_cat::__unspec) noexcept
 307     { return __v._M_value >= 0; }
 308
 309     [[nodiscard]]
 310     friend constexpr bool
 311     operator< (__cmp_cat::__unspec, strong_ordering __v) noexcept
 312     { return 0 < __v._M_value; }
 313
 314     [[nodiscard]]
 315     friend constexpr bool
 316     operator> (__cmp_cat::__unspec, strong_ordering __v) noexcept
 317     { return 0 > __v._M_value; }
 318
 319     [[nodiscard]]
 320     friend constexpr bool
 321     operator<=(__cmp_cat::__unspec, strong_ordering __v) noexcept
 322     { return 0 <= __v._M_value; }
 323
 324     [[nodiscard]]
 325     friend constexpr bool
 326     operator>=(__cmp_cat::__unspec, strong_ordering __v) noexcept
 327     { return 0 >= __v._M_value; }
 328
 329     [[nodiscard]]
 330     friend constexpr strong_ordering
 331     operator<=>(strong_ordering __v, __cmp_cat::__unspec) noexcept
 332     { return __v; }
 333
 334     [[nodiscard]]
 335     friend constexpr strong_ordering
 336     operator<=>(__cmp_cat::__unspec, strong_ordering __v) noexcept
 337     { return strong_ordering(__cmp_cat::_Ord(-__v._M_value)); }
 338   };
 339
 340   // valid values' definitions
 341   inline constexpr strong_ordering
 342   strong_ordering::less(__cmp_cat::_Ord::less);
 343
 344   inline constexpr strong_ordering
 345   strong_ordering::equal(__cmp_cat::_Ord::equivalent);
 346
 347   inline constexpr strong_ordering
 348   strong_ordering::equivalent(__cmp_cat::_Ord::equivalent);
 349
 350   inline constexpr strong_ordering
 351   strong_ordering::greater(__cmp_cat::_Ord::greater);
 352
 353
 354   // named comparison functions
 355   [[nodiscard]]
 356   constexpr bool
 357   is_eq(partial_ordering __cmp) noexcept
 358   { return __cmp == 0; }
 359
 360   [[nodiscard]]
 361   constexpr bool
 362   is_neq(partial_ordering __cmp) noexcept
 363   { return __cmp != 0; }
 364
 365   [[nodiscard]]
 366   constexpr bool
 367   is_lt  (partial_ordering __cmp) noexcept
 368   { return __cmp < 0; }
 369
 370   [[nodiscard]]
 371   constexpr bool
 372   is_lteq(partial_ordering __cmp) noexcept
 373   { return __cmp <= 0; }
 374
 375   [[nodiscard]]
 376   constexpr bool
 377   is_gt  (partial_ordering __cmp) noexcept
 378   { return __cmp > 0; }
 379
 380   [[nodiscard]]
 381   constexpr bool
 382   is_gteq(partial_ordering __cmp) noexcept
 383   { return __cmp >= 0; }
 384
 385   namespace __detail
 386   {
 387     template<typename _Tp>
 388       inline constexpr unsigned __cmp_cat_id = 1;
 389     template<>
 390       inline constexpr unsigned __cmp_cat_id<partial_ordering> = 2;
 391     template<>
 392       inline constexpr unsigned __cmp_cat_id<weak_ordering> = 4;
 393     template<>
 394       inline constexpr unsigned __cmp_cat_id<strong_ordering> = 8;
 395
 396     template<typename... _Ts>
 397       constexpr auto __common_cmp_cat()
 398       {
 399         constexpr unsigned __cats = (__cmp_cat_id<_Ts> | ...);
 400         // If any Ti is not a comparison category type, U is void.
 401         if constexpr (__cats & 1)
 402           return;
 403         // Otherwise, if at least one Ti is std::partial_ordering,
 404         // U is std::partial_ordering.
 405         else if constexpr (bool(__cats & __cmp_cat_id<partial_ordering>))
 406           return partial_ordering::equivalent;
 407         // Otherwise, if at least one Ti is std::weak_ordering,
 408         // U is std::weak_ordering.
 409         else if constexpr (bool(__cats & __cmp_cat_id<weak_ordering>))
 410           return weak_ordering::equivalent;
 411         // Otherwise, U is std::strong_ordering.
 412         else
 413           return strong_ordering::equivalent;
 414       }
 415   } // namespace __detail
 416
 417   // [cmp.common], common comparison category type
 418   template<typename... _Ts>
 419     struct common_comparison_category
 420     {
 421       using type = decltype(__detail::__common_cmp_cat<_Ts...>());
 422     };
 423
 424   // Partial specializations for one and zero argument cases.
 425
 426   template<typename _Tp>
 427     struct common_comparison_category<_Tp>
 428     { using type = void; };
 429
 430   template<>
 431     struct common_comparison_category<partial_ordering>
 432     { using type = partial_ordering; };
 433
 434   template<>
 435     struct common_comparison_category<weak_ordering>
 436     { using type = weak_ordering; };
 437
 438   template<>
 439     struct common_comparison_category<strong_ordering>
 440     { using type = strong_ordering; };
 441
 442   template<>
 443     struct common_comparison_category<>
 444     { using type = strong_ordering; };
 445
 446   template<typename... _Ts>
 447     using common_comparison_category_t
 448       = typename common_comparison_category<_Ts...>::type;
 449
 450 #if __cpp_lib_three_way_comparison >= 201907L
 451   // C++ >= 20 && impl_3way_comparison >= 201907 && lib_concepts
 452   namespace __detail
 453   {
 454     template<typename _Tp, typename _Cat>
 455       concept __compares_as
 456         = same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
 457   } // namespace __detail
 458
 459   // [cmp.concept], concept three_way_comparable
 460   template<typename _Tp, typename _Cat = partial_ordering>
 461     concept three_way_comparable
 462       = __detail::__weakly_eq_cmp_with<_Tp, _Tp>
 463       && __detail::__partially_ordered_with<_Tp, _Tp>
 464       && requires(const remove_reference_t<_Tp>& __a,
 465                   const remove_reference_t<_Tp>& __b)
 466       {
 467         { __a <=> __b } -> __detail::__compares_as<_Cat>;
 468       };
 469
 470   template<typename _Tp, typename _Up, typename _Cat = partial_ordering>
 471     concept three_way_comparable_with
 472       = three_way_comparable<_Tp, _Cat>
 473       && three_way_comparable<_Up, _Cat>
 474       && common_reference_with<const remove_reference_t<_Tp>&,
 475                                const remove_reference_t<_Up>&>
 476       && three_way_comparable<
 477           common_reference_t<const remove_reference_t<_Tp>&,
 478                              const remove_reference_t<_Up>&>, _Cat>
 479       && __detail::__weakly_eq_cmp_with<_Tp, _Up>
 480       && __detail::__partially_ordered_with<_Tp, _Up>
 481       && requires(const remove_reference_t<_Tp>& __t,
 482                   const remove_reference_t<_Up>& __u)
 483       {
 484         { __t <=> __u } -> __detail::__compares_as<_Cat>;
 485         { __u <=> __t } -> __detail::__compares_as<_Cat>;
 486       };
 487
 488   namespace __detail
 489   {
 490     template<typename _Tp, typename _Up>
 491       using __cmp3way_res_t
 492         = decltype(std::declval<_Tp>() <=> std::declval<_Up>());
 493
 494     // Implementation of std::compare_three_way_result.
 495     // It is undefined for a program to add specializations of
 496     // std::compare_three_way_result, so the std::compare_three_way_result_t
 497     // alias ignores std::compare_three_way_result and uses
 498     // __detail::__cmp3way_res_impl directly instead.
 499     template<typename _Tp, typename _Up>
 500       struct __cmp3way_res_impl
 501       { };
 502
 503     template<typename _Tp, typename _Up>
 504       requires requires { typename __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>; }
 505       struct __cmp3way_res_impl<_Tp, _Up>
 506       {
 507         using type = __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>;
 508       };
 509   } // namespace __detail
 510
 511   /// [cmp.result], result of three-way comparison
 512   template<typename _Tp, typename _Up = _Tp>
 513     struct compare_three_way_result
 514     : __detail::__cmp3way_res_impl<_Tp, _Up>
 515     { };
 516
 517   /// [cmp.result], result of three-way comparison
 518   template<typename _Tp, typename _Up = _Tp>
 519     using compare_three_way_result_t
 520       = typename __detail::__cmp3way_res_impl<_Tp, _Up>::type;
 521
 522   namespace __detail
 523   {
 524     // BUILTIN-PTR-THREE-WAY(T, U)
 525     // This determines whether t <=> u results in a call to a built-in
 526     // operator<=> comparing pointers. It doesn't work for function pointers
 527     // (PR 93628).
 528     template<typename _Tp, typename _Up>
 529       concept __3way_builtin_ptr_cmp
 530         = requires(_Tp&& __t, _Up&& __u)
 531           { static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u); }
 532           && convertible_to<_Tp, const volatile void*>
 533           && convertible_to<_Up, const volatile void*>
 534           && ! requires(_Tp&& __t, _Up&& __u)
 535           { operator<=>(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); }
 536           && ! requires(_Tp&& __t, _Up&& __u)
 537           { static_cast<_Tp&&>(__t).operator<=>(static_cast<_Up&&>(__u)); };
 538   } // namespace __detail
 539
 540   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 541   // 3530 BUILTIN-PTR-MEOW should not opt the type out of syntactic checks
 542
 543   // [cmp.object], typename compare_three_way
 544   struct compare_three_way
 545   {
 546     template<typename _Tp, typename _Up>
 547       requires three_way_comparable_with<_Tp, _Up>
 548       constexpr auto
 549       operator() [[nodiscard]] (_Tp&& __t, _Up&& __u) const
 550       noexcept(noexcept(std::declval<_Tp>() <=> std::declval<_Up>()))
 551       {
 552         if constexpr (__detail::__3way_builtin_ptr_cmp<_Tp, _Up>)
 553           {
 554             auto __pt = static_cast<const volatile void*>(__t);
 555             auto __pu = static_cast<const volatile void*>(__u);
 556             if (std::__is_constant_evaluated())
 557               return __pt <=> __pu;
 558             auto __it = reinterpret_cast<__UINTPTR_TYPE__>(__pt);
 559             auto __iu = reinterpret_cast<__UINTPTR_TYPE__>(__pu);
 560             return __it <=> __iu;
 561           }
 562         else
 563           return static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u);
 564       }
 565
 566     using is_transparent = void;
 567   };
 568
 569   namespace __cmp_cust
 570   {
 571     template<floating_point _Tp>
 572       constexpr weak_ordering
 573       __fp_weak_ordering(_Tp __e, _Tp __f)
 574       {
 575         // Returns an integer with the same sign as the argument, and magnitude
 576         // indicating the classification: zero=1 subnorm=2 norm=3 inf=4 nan=5
 577         auto __cat = [](_Tp __fp) -> int {
 578           const int __sign = __builtin_signbit(__fp) ? -1 : 1;
 579           if (__builtin_isnormal(__fp))
 580             return (__fp == 0 ? 1 : 3) * __sign;
 581           if (__builtin_isnan(__fp))
 582             return 5 * __sign;
 583           if (int __inf = __builtin_isinf_sign(__fp))
 584             return 4 * __inf;
 585           return 2 * __sign;
 586         };
 587
 588         auto __po = __e <=> __f;
 589         if (is_lt(__po))
 590           return weak_ordering::less;
 591         else if (is_gt(__po))
 592           return weak_ordering::greater;
 593         else if (__po == partial_ordering::equivalent)
 594           return weak_ordering::equivalent;
 595         else  // unordered, at least one argument is NaN
 596           {
 597             // return -1 for negative nan, +1 for positive nan, 0 otherwise.
 598             auto __isnan_sign = [](_Tp __fp) -> int {
 599               return __builtin_isnan(__fp)
 600                 ? __builtin_signbit(__fp) ? -1 : 1
 601                 : 0;
 602             };
 603             auto __ord = __isnan_sign(__e) <=> __isnan_sign(__f);
 604             if (is_eq(__ord))
 605               return weak_ordering::equivalent;
 606             else if (is_lt(__ord))
 607               return weak_ordering::less;
 608             else
 609               return weak_ordering::greater;
 610           }
 611       }
 612
 613     template<typename _Tp, typename _Up>
 614       concept __adl_strong = requires(_Tp&& __t, _Up&& __u)
 615         {
 616           strong_ordering(strong_order(static_cast<_Tp&&>(__t),
 617                                        static_cast<_Up&&>(__u)));
 618         };
 619
 620     template<typename _Tp, typename _Up>
 621       concept __adl_weak = requires(_Tp&& __t, _Up&& __u)
 622         {
 623           weak_ordering(weak_order(static_cast<_Tp&&>(__t),
 624                                    static_cast<_Up&&>(__u)));
 625         };
 626
 627     template<typename _Tp, typename _Up>
 628       concept __adl_partial = requires(_Tp&& __t, _Up&& __u)
 629         {
 630           partial_ordering(partial_order(static_cast<_Tp&&>(__t),
 631                                          static_cast<_Up&&>(__u)));
 632         };
 633
 634     template<typename _Ord, typename _Tp, typename _Up>
 635       concept __cmp3way = requires(_Tp&& __t, _Up&& __u, compare_three_way __c)
 636         {
 637           _Ord(__c(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)));
 638         };
 639
 640     template<typename _Tp, typename _Up>
 641       concept __strongly_ordered
 642         = __adl_strong<_Tp, _Up>
 643           || floating_point<remove_reference_t<_Tp>>
 644           || __cmp3way<strong_ordering, _Tp, _Up>;
 645
 646     template<typename _Tp, typename _Up>
 647       concept __decayed_same_as = same_as<decay_t<_Tp>, decay_t<_Up>>;
 648
 649     class _Strong_order
 650     {
 651       template<typename _Tp, typename _Up>
 652         static constexpr bool
 653         _S_noexcept()
 654         {
 655           if constexpr (floating_point<decay_t<_Tp>>)
 656             return true;
 657           else if constexpr (__adl_strong<_Tp, _Up>)
 658             return noexcept(strong_ordering(strong_order(std::declval<_Tp>(),
 659                                                          std::declval<_Up>())));
 660           else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
 661             return noexcept(compare_three_way()(std::declval<_Tp>(),
 662                                                 std::declval<_Up>()));
 663         }
 664
 665       friend class _Weak_order;
 666       friend class _Strong_fallback;
 667
 668       // Names for the supported floating-point representations.
 669       enum class _Fp_fmt
 670       {
 671         _Binary16, _Binary32, _Binary64, _Binary128, // IEEE
 672         _X86_80bit,  // x86 80-bit extended precision
 673         _M68k_80bit, // m68k 80-bit extended precision
 674         _Dbldbl, // IBM 128-bit double-double
 675         _Bfloat16,   // std::bfloat16_t
 676       };
 677
 678 #ifndef __cpp_using_enum
 679       // XXX Remove these once 'using enum' support is ubiquitous.
 680       static constexpr _Fp_fmt _Binary16 = _Fp_fmt::_Binary16;
 681       static constexpr _Fp_fmt _Binary32 = _Fp_fmt::_Binary32;
 682       static constexpr _Fp_fmt _Binary64 = _Fp_fmt::_Binary64;
 683       static constexpr _Fp_fmt _Binary128 = _Fp_fmt::_Binary128;
 684       static constexpr _Fp_fmt _X86_80bit = _Fp_fmt::_X86_80bit;
 685       static constexpr _Fp_fmt _M68k_80bit = _Fp_fmt::_M68k_80bit;
 686       static constexpr _Fp_fmt _Dbldbl = _Fp_fmt::_Dbldbl;
 687       static constexpr _Fp_fmt _Bfloat16 = _Fp_fmt::_Bfloat16;
 688 #endif
 689
 690       // Identify the format used by a floating-point type.
 691       template<typename _Tp>
 692         static consteval _Fp_fmt
 693         _S_fp_fmt() noexcept
 694         {
 695 #ifdef __cpp_using_enum
 696           using enum _Fp_fmt;
 697 #endif
 698
 699           // Identify these formats first, then assume anything else is IEEE.
 700           // N.B. ARM __fp16 alternative format can be handled as binary16.
 701
 702 #ifdef __LONG_DOUBLE_IBM128__
 703           if constexpr (__is_same(_Tp, long double))
 704             return _Dbldbl;
 705 #elif defined __LONG_DOUBLE_IEEE128__ && defined __SIZEOF_IBM128__
 706           if constexpr (__is_same(_Tp, __ibm128))
 707             return _Dbldbl;
 708 #endif
 709
 710 #if __LDBL_MANT_DIG__ == 64
 711           if constexpr (__is_same(_Tp, long double))
 712             return __LDBL_MIN_EXP__ == -16381 ? _X86_80bit : _M68k_80bit;
 713 #endif
 714 #ifdef __SIZEOF_FLOAT80__
 715           if constexpr (__is_same(_Tp, __float80))
 716             return _X86_80bit;
 717 #endif
 718 #ifdef __STDCPP_BFLOAT16_T__
 719           if constexpr (__is_same(_Tp, decltype(0.0bf16)))
 720             return _Bfloat16;
 721 #endif
 722
 723           constexpr int __width = sizeof(_Tp) * __CHAR_BIT__;
 724
 725           if constexpr (__width == 16)       // IEEE binary16 (or ARM fp16).
 726             return _Binary16;
 727           else if constexpr (__width == 32)  // IEEE binary32
 728             return _Binary32;
 729           else if constexpr (__width == 64)  // IEEE binary64
 730             return _Binary64;
 731           else if constexpr (__width == 128) // IEEE binary128
 732             return _Binary128;
 733         }
 734
 735       // So we don't need to include <stdint.h> and pollute the namespace.
 736       using int64_t = __INT64_TYPE__;
 737       using int32_t = __INT32_TYPE__;
 738       using int16_t = __INT16_TYPE__;
 739       using uint64_t = __UINT64_TYPE__;
 740       using uint16_t = __UINT16_TYPE__;
 741
 742       // Used to unpack floating-point types that do not fit into an integer.
 743       template<typename _Tp>
 744         struct _Int
 745         {
 746 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 747           uint64_t _M_lo;
 748           _Tp _M_hi;
 749 #else
 750           _Tp _M_hi;
 751           uint64_t _M_lo;
 752 #endif
 753
 754           constexpr explicit
 755           _Int(_Tp __hi, uint64_t __lo) noexcept : _M_hi(__hi)
 756           { _M_lo = __lo; }
 757
 758           constexpr explicit
 759           _Int(uint64_t __lo) noexcept : _M_hi(0)
 760           { _M_lo = __lo; }
 761
 762           constexpr bool operator==(const _Int&) const = default;
 763
 764 #if defined __hppa__ || (defined __mips__ && !defined __mips_nan2008)
 765           consteval _Int
 766           operator<<(int __n) const noexcept
 767           {
 768             // XXX this assumes n >= 64, which is true for the use below.
 769             return _Int(static_cast<_Tp>(_M_lo << (__n - 64)), 0);
 770           }
 771 #endif
 772
 773           constexpr _Int&
 774           operator^=(const _Int& __rhs) noexcept
 775           {
 776             _M_hi ^= __rhs._M_hi;
 777             _M_lo ^= __rhs._M_lo;
 778             return *this;
 779           }
 780
 781           constexpr strong_ordering
 782           operator<=>(const _Int& __rhs) const noexcept
 783           {
 784             strong_ordering __cmp = _M_hi <=> __rhs._M_hi;
 785             if (__cmp != strong_ordering::equal)
 786               return __cmp;
 787             return _M_lo <=> __rhs._M_lo;
 788           }
 789         };
 790
 791       template<typename _Tp>
 792         static constexpr _Tp
 793         _S_compl(_Tp __t) noexcept
 794         {
 795           constexpr int __width = sizeof(_Tp) * __CHAR_BIT__;
 796           // Sign extend to get all ones or all zeros.
 797           make_unsigned_t<_Tp> __sign = __t >> (__width - 1);
 798           // If the sign bit was set, this flips all bits below it.
 799           // This converts ones' complement to two's complement.
 800           return __t ^ (__sign >> 1);
 801         }
 802
 803       // As above but works on both parts of _Int<T>.
 804       template<typename _Tp>
 805         static constexpr _Int<_Tp>
 806         _S_compl(_Int<_Tp> __t) noexcept
 807         {
 808           constexpr int __width = sizeof(_Tp) * __CHAR_BIT__;
 809           make_unsigned_t<_Tp> __sign = __t._M_hi >> (__width - 1);
 810           __t._M_hi ^= (__sign >> 1 );
 811           uint64_t __sign64 = (_Tp)__sign;
 812           __t._M_lo ^= __sign64;
 813           return __t;
 814         }
 815
 816       // Bit-cast a floating-point value to an unsigned integer.
 817       template<typename _Tp>
 818         constexpr static auto
 819         _S_fp_bits(_Tp __val) noexcept
 820         {
 821           if constexpr (sizeof(_Tp) == sizeof(int64_t))
 822             return __builtin_bit_cast(int64_t, __val);
 823           else if constexpr (sizeof(_Tp) == sizeof(int32_t))
 824             return __builtin_bit_cast(int32_t, __val);
 825           else if constexpr (sizeof(_Tp) == sizeof(int16_t))
 826             return __builtin_bit_cast(int16_t, __val);
 827           else
 828             {
 829 #ifdef __cpp_using_enum
 830               using enum _Fp_fmt;
 831 #endif
 832               constexpr auto __fmt = _S_fp_fmt<_Tp>();
 833               if constexpr (__fmt == _X86_80bit || __fmt == _M68k_80bit)
 834                 {
 835                   if constexpr (sizeof(_Tp) == 3 * sizeof(int32_t))
 836                     {
 837                       auto __ival = __builtin_bit_cast(_Int<int32_t>, __val);
 838                       return _Int<int16_t>(__ival._M_hi, __ival._M_lo);
 839                     }
 840                   else
 841                     {
 842                       auto __ival = __builtin_bit_cast(_Int<int64_t>, __val);
 843                       return _Int<int16_t>(__ival._M_hi, __ival._M_lo);
 844                     }
 845                 }
 846               else if constexpr (sizeof(_Tp) == 2 * sizeof(int64_t))
 847                 {
 848 #if __SIZEOF_INT128__
 849                   return __builtin_bit_cast(__int128, __val);
 850 #else
 851                   return __builtin_bit_cast(_Int<int64_t>, __val);
 852 #endif
 853                 }
 854               else
 855                 static_assert(sizeof(_Tp) == sizeof(int64_t),
 856                               "unsupported floating-point type");
 857             }
 858         }
 859
 860       template<typename _Tp>
 861         static constexpr strong_ordering
 862         _S_fp_cmp(_Tp __x, _Tp __y) noexcept
 863         {
 864 #ifdef __vax__
 865           if (__builtin_isnan(__x) || __builtin_isnan(__y))
 866             {
 867               int __ix = (bool) __builtin_isnan(__x);
 868               int __iy = (bool) __builtin_isnan(__y);
 869               __ix *= __builtin_signbit(__x) ? -1 : 1;
 870               __iy *= __builtin_signbit(__y) ? -1 : 1;
 871               return __ix <=> __iy;
 872             }
 873           else
 874             return __builtin_bit_cast(strong_ordering, __x <=> __y);
 875 #endif
 876
 877           auto __ix = _S_fp_bits(__x);
 878           auto __iy = _S_fp_bits(__y);
 879
 880           if (__ix == __iy)
 881             return strong_ordering::equal; // All bits are equal, we're done.
 882
 883 #ifdef __cpp_using_enum
 884           using enum _Fp_fmt;
 885 #endif
 886           constexpr auto __fmt = _S_fp_fmt<_Tp>();
 887
 888           if constexpr (__fmt == _Dbldbl) // double-double
 889             {
 890               // Unpack the double-double into two parts.
 891               // We never inspect the low double as a double, cast to integer.
 892               struct _Unpacked { double _M_hi; int64_t _M_lo; };
 893               auto __x2 = __builtin_bit_cast(_Unpacked, __x);
 894               auto __y2 = __builtin_bit_cast(_Unpacked, __y);
 895
 896               // Compare the high doubles first and use result if unequal.
 897               auto __cmp = _S_fp_cmp(__x2._M_hi, __y2._M_hi);
 898               if (__cmp != strong_ordering::equal)
 899                 return __cmp;
 900
 901               // For NaN the low double is unused, so if the high doubles
 902               // are the same NaN, we don't need to compare the low doubles.
 903               if (__builtin_isnan(__x2._M_hi))
 904                 return strong_ordering::equal;
 905               // Similarly, if the low doubles are +zero or -zero (which is
 906               // true for all infinities and some other values), we're done.
 907               if (((__x2._M_lo | __y2._M_lo) & 0x7fffffffffffffffULL) == 0)
 908                 return strong_ordering::equal;
 909
 910               // Otherwise, compare the low parts.
 911               return _S_compl(__x2._M_lo) <=> _S_compl(__y2._M_lo);
 912             }
 913           else
 914             {
 915               if constexpr (__fmt == _M68k_80bit)
 916                 {
 917                   // For m68k the MSB of the significand is ignored for the
 918                   // greatest exponent, so either 0 or 1 is valid there.
 919                   // Set it before comparing, so that we never have 0 there.
 920                   constexpr uint16_t __maxexp = 0x7fff;
 921                   if ((__ix._M_hi & __maxexp) == __maxexp)
 922                     __ix._M_lo |= 1ull << 63;
 923                   if ((__iy._M_hi & __maxexp) == __maxexp)
 924                     __iy._M_lo |= 1ull << 63;
 925                 }
 926               else
 927                 {
 928 #if defined __hppa__ || (defined __mips__ && !defined __mips_nan2008)
 929                   // IEEE 754-1985 allowed the meaning of the quiet/signaling
 930                   // bit to be reversed. Flip that to give desired ordering.
 931                   if (__builtin_isnan(__x) && __builtin_isnan(__y))
 932                     {
 933                       using _Int = decltype(__ix);
 934
 935                       constexpr int __nantype = __fmt == _Binary32  ?  22
 936                                               : __fmt == _Binary64  ?  51
 937                                               : __fmt == _Binary128 ? 111
 938                                               : -1;
 939                       constexpr _Int __bit = _Int(1) << __nantype;
 940                       __ix ^= __bit;
 941                       __iy ^= __bit;
 942                     }
 943 #endif
 944                 }
 945               return _S_compl(__ix) <=> _S_compl(__iy);
 946             }
 947         }
 948
 949     public:
 950       template<typename _Tp, __decayed_same_as<_Tp> _Up>
 951         requires __strongly_ordered<_Tp, _Up>
 952         constexpr strong_ordering
 953         operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
 954         noexcept(_S_noexcept<_Tp, _Up>())
 955         {
 956           if constexpr (floating_point<decay_t<_Tp>>)
 957             return _S_fp_cmp(__e, __f);
 958           else if constexpr (__adl_strong<_Tp, _Up>)
 959             return strong_ordering(strong_order(static_cast<_Tp&&>(__e),
 960                                                 static_cast<_Up&&>(__f)));
 961           else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
 962             return compare_three_way()(static_cast<_Tp&&>(__e),
 963                                        static_cast<_Up&&>(__f));
 964         }
 965     };
 966
 967     template<typename _Tp, typename _Up>
 968       concept __weakly_ordered
 969         = floating_point<remove_reference_t<_Tp>>
 970           || __adl_weak<_Tp, _Up>
 971           || __cmp3way<weak_ordering, _Tp, _Up>
 972           || __strongly_ordered<_Tp, _Up>;
 973
 974     class _Weak_order
 975     {
 976       template<typename _Tp, typename _Up>
 977         static constexpr bool
 978         _S_noexcept()
 979         {
 980           if constexpr (floating_point<decay_t<_Tp>>)
 981             return true;
 982           else if constexpr (__adl_weak<_Tp, _Up>)
 983             return noexcept(weak_ordering(weak_order(std::declval<_Tp>(),
 984                                                      std::declval<_Up>())));
 985           else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
 986             return noexcept(compare_three_way()(std::declval<_Tp>(),
 987                                                 std::declval<_Up>()));
 988           else if constexpr (__strongly_ordered<_Tp, _Up>)
 989             return _Strong_order::_S_noexcept<_Tp, _Up>();
 990         }
 991
 992       friend class _Partial_order;
 993       friend class _Weak_fallback;
 994
 995     public:
 996       template<typename _Tp, __decayed_same_as<_Tp> _Up>
 997         requires __weakly_ordered<_Tp, _Up>
 998         constexpr weak_ordering
 999         operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
1000         noexcept(_S_noexcept<_Tp, _Up>())
1001         {
1002           if constexpr (floating_point<decay_t<_Tp>>)
1003             return __cmp_cust::__fp_weak_ordering(__e, __f);
1004           else if constexpr (__adl_weak<_Tp, _Up>)
1005             return weak_ordering(weak_order(static_cast<_Tp&&>(__e),
1006                                             static_cast<_Up&&>(__f)));
1007           else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
1008             return compare_three_way()(static_cast<_Tp&&>(__e),
1009                                        static_cast<_Up&&>(__f));
1010           else if constexpr (__strongly_ordered<_Tp, _Up>)
1011             return _Strong_order{}(static_cast<_Tp&&>(__e),
1012                                    static_cast<_Up&&>(__f));
1013         }
1014     };
1015
1016     template<typename _Tp, typename _Up>
1017       concept __partially_ordered
1018         = __adl_partial<_Tp, _Up>
1019         || __cmp3way<partial_ordering, _Tp, _Up>
1020         || __weakly_ordered<_Tp, _Up>;
1021
1022     class _Partial_order
1023     {
1024       template<typename _Tp, typename _Up>
1025         static constexpr bool
1026         _S_noexcept()
1027         {
1028           if constexpr (__adl_partial<_Tp, _Up>)
1029             return noexcept(partial_ordering(partial_order(std::declval<_Tp>(),
1030                                                          std::declval<_Up>())));
1031           else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
1032             return noexcept(compare_three_way()(std::declval<_Tp>(),
1033                                                 std::declval<_Up>()));
1034           else if constexpr (__weakly_ordered<_Tp, _Up>)
1035             return _Weak_order::_S_noexcept<_Tp, _Up>();
1036         }
1037
1038       friend class _Partial_fallback;
1039
1040     public:
1041       template<typename _Tp, __decayed_same_as<_Tp> _Up>
1042         requires __partially_ordered<_Tp, _Up>
1043         constexpr partial_ordering
1044         operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
1045         noexcept(_S_noexcept<_Tp, _Up>())
1046         {
1047           if constexpr (__adl_partial<_Tp, _Up>)
1048             return partial_ordering(partial_order(static_cast<_Tp&&>(__e),
1049                                                   static_cast<_Up&&>(__f)));
1050           else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
1051             return compare_three_way()(static_cast<_Tp&&>(__e),
1052                                        static_cast<_Up&&>(__f));
1053           else if constexpr (__weakly_ordered<_Tp, _Up>)
1054             return _Weak_order{}(static_cast<_Tp&&>(__e),
1055                                  static_cast<_Up&&>(__f));
1056         }
1057     };
1058
1059     template<typename _Tp, typename _Up>
1060       concept __op_eq_lt = requires(_Tp&& __t, _Up&& __u)
1061         {
1062           { static_cast<_Tp&&>(__t) == static_cast<_Up&&>(__u) }
1063             -> convertible_to<bool>;
1064           { static_cast<_Tp&&>(__t) < static_cast<_Up&&>(__u) }
1065             -> convertible_to<bool>;
1066         };
1067
1068     class _Strong_fallback
1069     {
1070       template<typename _Tp, typename _Up>
1071         static constexpr bool
1072         _S_noexcept()
1073         {
1074           if constexpr (__strongly_ordered<_Tp, _Up>)
1075             return _Strong_order::_S_noexcept<_Tp, _Up>();
1076           else
1077             return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
1078               && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
1079         }
1080
1081     public:
1082       template<typename _Tp, __decayed_same_as<_Tp> _Up>
1083         requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
1084         constexpr strong_ordering
1085         operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
1086         noexcept(_S_noexcept<_Tp, _Up>())
1087         {
1088           if constexpr (__strongly_ordered<_Tp, _Up>)
1089             return _Strong_order{}(static_cast<_Tp&&>(__e),
1090                                    static_cast<_Up&&>(__f));
1091           else // __op_eq_lt<_Tp, _Up>
1092             return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
1093               ? strong_ordering::equal
1094               : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
1095               ? strong_ordering::less
1096               : strong_ordering::greater;
1097         }
1098     };
1099
1100     class _Weak_fallback
1101     {
1102       template<typename _Tp, typename _Up>
1103         static constexpr bool
1104         _S_noexcept()
1105         {
1106           if constexpr (__weakly_ordered<_Tp, _Up>)
1107             return _Weak_order::_S_noexcept<_Tp, _Up>();
1108           else
1109             return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
1110               && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
1111         }
1112
1113     public:
1114       template<typename _Tp, __decayed_same_as<_Tp> _Up>
1115         requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
1116         constexpr weak_ordering
1117         operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
1118         noexcept(_S_noexcept<_Tp, _Up>())
1119         {
1120           if constexpr (__weakly_ordered<_Tp, _Up>)
1121             return _Weak_order{}(static_cast<_Tp&&>(__e),
1122                                  static_cast<_Up&&>(__f));
1123           else // __op_eq_lt<_Tp, _Up>
1124             return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
1125               ? weak_ordering::equivalent
1126               : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
1127               ? weak_ordering::less
1128               : weak_ordering::greater;
1129         }
1130     };
1131
1132     // _GLIBCXX_RESOLVE_LIB_DEFECTS
1133     // 3465. compare_partial_order_fallback requires F < E
1134     template<typename _Tp, typename _Up>
1135       concept __op_eq_lt_lt = __op_eq_lt<_Tp, _Up>
1136         && requires(_Tp&& __t, _Up&& __u)
1137         {
1138           { static_cast<_Up&&>(__u) < static_cast<_Tp&&>(__t) }
1139             -> convertible_to<bool>;
1140         };
1141
1142     class _Partial_fallback
1143     {
1144       template<typename _Tp, typename _Up>
1145         static constexpr bool
1146         _S_noexcept()
1147         {
1148           if constexpr (__partially_ordered<_Tp, _Up>)
1149             return _Partial_order::_S_noexcept<_Tp, _Up>();
1150           else
1151             return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
1152               && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
1153         }
1154
1155     public:
1156       template<typename _Tp, __decayed_same_as<_Tp> _Up>
1157         requires __partially_ordered<_Tp, _Up> || __op_eq_lt_lt<_Tp, _Up>
1158         constexpr partial_ordering
1159         operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
1160         noexcept(_S_noexcept<_Tp, _Up>())
1161         {
1162           if constexpr (__partially_ordered<_Tp, _Up>)
1163             return _Partial_order{}(static_cast<_Tp&&>(__e),
1164                                     static_cast<_Up&&>(__f));
1165           else // __op_eq_lt_lt<_Tp, _Up>
1166             return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
1167               ? partial_ordering::equivalent
1168               : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
1169               ? partial_ordering::less
1170               : static_cast<_Up&&>(__f) < static_cast<_Tp&&>(__e)
1171               ? partial_ordering::greater
1172               : partial_ordering::unordered;
1173         }
1174     };
1175   } // namespace __cmp_cust
1176
1177   // [cmp.alg], comparison algorithms
1178   inline namespace __cmp_alg
1179   {
1180     inline constexpr __cmp_cust::_Strong_order strong_order{};
1181
1182     inline constexpr __cmp_cust::_Weak_order weak_order{};
1183
1184     inline constexpr __cmp_cust::_Partial_order partial_order{};
1185
1186     inline constexpr __cmp_cust::_Strong_fallback
1187     compare_strong_order_fallback{};
1188
1189     inline constexpr __cmp_cust::_Weak_fallback
1190     compare_weak_order_fallback{};
1191
1192     inline constexpr __cmp_cust::_Partial_fallback
1193     compare_partial_order_fallback{};
1194   }
1195
1196   namespace __detail
1197   {
1198     // [expos.only.func] synth-three-way
1199     inline constexpr struct _Synth3way
1200     {
1201       template<typename _Tp, typename _Up>
1202         static constexpr bool
1203         _S_noexcept(const _Tp* __t = nullptr, const _Up* __u = nullptr)
1204         {
1205           if constexpr (three_way_comparable_with<_Tp, _Up>)
1206             return noexcept(*__t <=> *__u);
1207           else
1208             return noexcept(*__t < *__u) && noexcept(*__u < *__t);
1209         }
1210
1211       template<typename _Tp, typename _Up>
1212         [[nodiscard]]
1213         constexpr auto
1214         operator()(const _Tp& __t, const _Up& __u) const
1215         noexcept(_S_noexcept<_Tp, _Up>())
1216         requires requires
1217         {
1218           { __t < __u } -> __boolean_testable;
1219           { __u < __t } -> __boolean_testable;
1220         }
1221         {
1222           if constexpr (three_way_comparable_with<_Tp, _Up>)
1223             return __t <=> __u;
1224           else
1225             {
1226               if (__t < __u)
1227                 return weak_ordering::less;
1228               else if (__u < __t)
1229                 return weak_ordering::greater;
1230               else
1231                 return weak_ordering::equivalent;
1232             }
1233         }
1234     } __synth3way = {};
1235
1236     // [expos.only.func] synth-three-way-result
1237     template<typename _Tp, typename _Up = _Tp>
1238       using __synth3way_t
1239         = decltype(__detail::__synth3way(std::declval<_Tp&>(),
1240                                          std::declval<_Up&>()));
1241   } // namespace __detail
1242 #endif // __cpp_lib_three_way_comparison >= 201907L
1243 } // namespace std
1244
1245 #endif // C++20
1246
1247 #endif // _COMPARE