libstdc++-v3/libsupc++/compare

   1 // -*- C++ -*- operator<=> three-way comparison support.
   2
   3 // Copyright (C) 2019-2021 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 #if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
  36
  37 #pragma GCC visibility push(default)
  38
  39 #include <concepts>
  40
  41 #if __cpp_lib_concepts
  42 # define __cpp_lib_three_way_comparison 201907L
  43 #endif
  44
  45 namespace std
  46 {
  47   // [cmp.categories], comparison category types
  48
  49   namespace __cmp_cat
  50   {
  51     using type = signed char;
  52
  53     enum class _Ord : type { equivalent = 0, less = -1, greater = 1 };
  54
  55     enum class _Ncmp : type { _Unordered = 2 };
  56
  57     struct __unspec
  58     {
  59       constexpr __unspec(__unspec*) noexcept { }
  60     };
  61   }
  62
  63   class partial_ordering
  64   {
  65     // less=0xff, equiv=0x00, greater=0x01, unordered=0x02
  66     __cmp_cat::type _M_value;
  67
  68     constexpr explicit
  69     partial_ordering(__cmp_cat::_Ord __v) noexcept
  70     : _M_value(__cmp_cat::type(__v))
  71     { }
  72
  73     constexpr explicit
  74     partial_ordering(__cmp_cat::_Ncmp __v) noexcept
  75     : _M_value(__cmp_cat::type(__v))
  76     { }
  77
  78     friend class weak_ordering;
  79     friend class strong_ordering;
  80
  81   public:
  82     // valid values
  83     static const partial_ordering less;
  84     static const partial_ordering equivalent;
  85     static const partial_ordering greater;
  86     static const partial_ordering unordered;
  87
  88     // comparisons
  89     [[nodiscard]]
  90     friend constexpr bool
  91     operator==(partial_ordering __v, __cmp_cat::__unspec) noexcept
  92     { return __v._M_value == 0; }
  93
  94     [[nodiscard]]
  95     friend constexpr bool
  96     operator==(partial_ordering, partial_ordering) noexcept = default;
  97
  98     [[nodiscard]]
  99     friend constexpr bool
 100     operator< (partial_ordering __v, __cmp_cat::__unspec) noexcept
 101     { return __v._M_value == -1; }
 102
 103     [[nodiscard]]
 104     friend constexpr bool
 105     operator> (partial_ordering __v, __cmp_cat::__unspec) noexcept
 106     { return __v._M_value == 1; }
 107
 108     [[nodiscard]]
 109     friend constexpr bool
 110     operator<=(partial_ordering __v, __cmp_cat::__unspec) noexcept
 111     { return __v._M_value <= 0; }
 112
 113     [[nodiscard]]
 114     friend constexpr bool
 115     operator>=(partial_ordering __v, __cmp_cat::__unspec) noexcept
 116     { return __cmp_cat::type(__v._M_value & 1) == __v._M_value; }
 117
 118     [[nodiscard]]
 119     friend constexpr bool
 120     operator< (__cmp_cat::__unspec, partial_ordering __v) noexcept
 121     { return __v._M_value == 1; }
 122
 123     [[nodiscard]]
 124     friend constexpr bool
 125     operator> (__cmp_cat::__unspec, partial_ordering __v) noexcept
 126     { return __v._M_value == -1; }
 127
 128     [[nodiscard]]
 129     friend constexpr bool
 130     operator<=(__cmp_cat::__unspec, partial_ordering __v) noexcept
 131     { return __cmp_cat::type(__v._M_value & 1) == __v._M_value; }
 132
 133     [[nodiscard]]
 134     friend constexpr bool
 135     operator>=(__cmp_cat::__unspec, partial_ordering __v) noexcept
 136     { return 0 >= __v._M_value; }
 137
 138     [[nodiscard]]
 139     friend constexpr partial_ordering
 140     operator<=>(partial_ordering __v, __cmp_cat::__unspec) noexcept
 141     { return __v; }
 142
 143     [[nodiscard]]
 144     friend constexpr partial_ordering
 145     operator<=>(__cmp_cat::__unspec, partial_ordering __v) noexcept
 146     {
 147       if (__v._M_value & 1)
 148         return partial_ordering(__cmp_cat::_Ord(-__v._M_value));
 149       else
 150         return __v;
 151     }
 152   };
 153
 154   // valid values' definitions
 155   inline constexpr partial_ordering
 156   partial_ordering::less(__cmp_cat::_Ord::less);
 157
 158   inline constexpr partial_ordering
 159   partial_ordering::equivalent(__cmp_cat::_Ord::equivalent);
 160
 161   inline constexpr partial_ordering
 162   partial_ordering::greater(__cmp_cat::_Ord::greater);
 163
 164   inline constexpr partial_ordering
 165   partial_ordering::unordered(__cmp_cat::_Ncmp::_Unordered);
 166
 167   class weak_ordering
 168   {
 169     __cmp_cat::type _M_value;
 170
 171     constexpr explicit
 172     weak_ordering(__cmp_cat::_Ord __v) noexcept : _M_value(__cmp_cat::type(__v))
 173     { }
 174
 175     friend class strong_ordering;
 176
 177   public:
 178     // valid values
 179     static const weak_ordering less;
 180     static const weak_ordering equivalent;
 181     static const weak_ordering greater;
 182
 183     [[nodiscard]]
 184     constexpr operator partial_ordering() const noexcept
 185     { return partial_ordering(__cmp_cat::_Ord(_M_value)); }
 186
 187     // comparisons
 188     [[nodiscard]]
 189     friend constexpr bool
 190     operator==(weak_ordering __v, __cmp_cat::__unspec) noexcept
 191     { return __v._M_value == 0; }
 192
 193     [[nodiscard]]
 194     friend constexpr bool
 195     operator==(weak_ordering, weak_ordering) noexcept = default;
 196
 197     [[nodiscard]]
 198     friend constexpr bool
 199     operator< (weak_ordering __v, __cmp_cat::__unspec) noexcept
 200     { return __v._M_value < 0; }
 201
 202     [[nodiscard]]
 203     friend constexpr bool
 204     operator> (weak_ordering __v, __cmp_cat::__unspec) noexcept
 205     { return __v._M_value > 0; }
 206
 207     [[nodiscard]]
 208     friend constexpr bool
 209     operator<=(weak_ordering __v, __cmp_cat::__unspec) noexcept
 210     { return __v._M_value <= 0; }
 211
 212     [[nodiscard]]
 213     friend constexpr bool
 214     operator>=(weak_ordering __v, __cmp_cat::__unspec) noexcept
 215     { return __v._M_value >= 0; }
 216
 217     [[nodiscard]]
 218     friend constexpr bool
 219     operator< (__cmp_cat::__unspec, weak_ordering __v) noexcept
 220     { return 0 < __v._M_value; }
 221
 222     [[nodiscard]]
 223     friend constexpr bool
 224     operator> (__cmp_cat::__unspec, weak_ordering __v) noexcept
 225     { return 0 > __v._M_value; }
 226
 227     [[nodiscard]]
 228     friend constexpr bool
 229     operator<=(__cmp_cat::__unspec, weak_ordering __v) noexcept
 230     { return 0 <= __v._M_value; }
 231
 232     [[nodiscard]]
 233     friend constexpr bool
 234     operator>=(__cmp_cat::__unspec, weak_ordering __v) noexcept
 235     { return 0 >= __v._M_value; }
 236
 237     [[nodiscard]]
 238     friend constexpr weak_ordering
 239     operator<=>(weak_ordering __v, __cmp_cat::__unspec) noexcept
 240     { return __v; }
 241
 242     [[nodiscard]]
 243     friend constexpr weak_ordering
 244     operator<=>(__cmp_cat::__unspec, weak_ordering __v) noexcept
 245     { return weak_ordering(__cmp_cat::_Ord(-__v._M_value)); }
 246   };
 247
 248   // valid values' definitions
 249   inline constexpr weak_ordering
 250   weak_ordering::less(__cmp_cat::_Ord::less);
 251
 252   inline constexpr weak_ordering
 253   weak_ordering::equivalent(__cmp_cat::_Ord::equivalent);
 254
 255   inline constexpr weak_ordering
 256   weak_ordering::greater(__cmp_cat::_Ord::greater);
 257
 258   class strong_ordering
 259   {
 260     __cmp_cat::type _M_value;
 261
 262     constexpr explicit
 263     strong_ordering(__cmp_cat::_Ord __v) noexcept
 264     : _M_value(__cmp_cat::type(__v))
 265     { }
 266
 267   public:
 268     // valid values
 269     static const strong_ordering less;
 270     static const strong_ordering equal;
 271     static const strong_ordering equivalent;
 272     static const strong_ordering greater;
 273
 274     [[nodiscard]]
 275     constexpr operator partial_ordering() const noexcept
 276     { return partial_ordering(__cmp_cat::_Ord(_M_value)); }
 277
 278     [[nodiscard]]
 279     constexpr operator weak_ordering() const noexcept
 280     { return weak_ordering(__cmp_cat::_Ord(_M_value)); }
 281
 282     // comparisons
 283     [[nodiscard]]
 284     friend constexpr bool
 285     operator==(strong_ordering __v, __cmp_cat::__unspec) noexcept
 286     { return __v._M_value == 0; }
 287
 288     [[nodiscard]]
 289     friend constexpr bool
 290     operator==(strong_ordering, strong_ordering) noexcept = default;
 291
 292     [[nodiscard]]
 293     friend constexpr bool
 294     operator< (strong_ordering __v, __cmp_cat::__unspec) noexcept
 295     { return __v._M_value < 0; }
 296
 297     [[nodiscard]]
 298     friend constexpr bool
 299     operator> (strong_ordering __v, __cmp_cat::__unspec) noexcept
 300     { return __v._M_value > 0; }
 301
 302     [[nodiscard]]
 303     friend constexpr bool
 304     operator<=(strong_ordering __v, __cmp_cat::__unspec) noexcept
 305     { return __v._M_value <= 0; }
 306
 307     [[nodiscard]]
 308     friend constexpr bool
 309     operator>=(strong_ordering __v, __cmp_cat::__unspec) noexcept
 310     { return __v._M_value >= 0; }
 311
 312     [[nodiscard]]
 313     friend constexpr bool
 314     operator< (__cmp_cat::__unspec, strong_ordering __v) noexcept
 315     { return 0 < __v._M_value; }
 316
 317     [[nodiscard]]
 318     friend constexpr bool
 319     operator> (__cmp_cat::__unspec, strong_ordering __v) noexcept
 320     { return 0 > __v._M_value; }
 321
 322     [[nodiscard]]
 323     friend constexpr bool
 324     operator<=(__cmp_cat::__unspec, strong_ordering __v) noexcept
 325     { return 0 <= __v._M_value; }
 326
 327     [[nodiscard]]
 328     friend constexpr bool
 329     operator>=(__cmp_cat::__unspec, strong_ordering __v) noexcept
 330     { return 0 >= __v._M_value; }
 331
 332     [[nodiscard]]
 333     friend constexpr strong_ordering
 334     operator<=>(strong_ordering __v, __cmp_cat::__unspec) noexcept
 335     { return __v; }
 336
 337     [[nodiscard]]
 338     friend constexpr strong_ordering
 339     operator<=>(__cmp_cat::__unspec, strong_ordering __v) noexcept
 340     { return strong_ordering(__cmp_cat::_Ord(-__v._M_value)); }
 341   };
 342
 343   // valid values' definitions
 344   inline constexpr strong_ordering
 345   strong_ordering::less(__cmp_cat::_Ord::less);
 346
 347   inline constexpr strong_ordering
 348   strong_ordering::equal(__cmp_cat::_Ord::equivalent);
 349
 350   inline constexpr strong_ordering
 351   strong_ordering::equivalent(__cmp_cat::_Ord::equivalent);
 352
 353   inline constexpr strong_ordering
 354   strong_ordering::greater(__cmp_cat::_Ord::greater);
 355
 356
 357   // named comparison functions
 358   [[nodiscard]]
 359   constexpr bool
 360   is_eq(partial_ordering __cmp) noexcept
 361   { return __cmp == 0; }
 362
 363   [[nodiscard]]
 364   constexpr bool
 365   is_neq(partial_ordering __cmp) noexcept
 366   { return __cmp != 0; }
 367
 368   [[nodiscard]]
 369   constexpr bool
 370   is_lt  (partial_ordering __cmp) noexcept
 371   { return __cmp < 0; }
 372
 373   [[nodiscard]]
 374   constexpr bool
 375   is_lteq(partial_ordering __cmp) noexcept
 376   { return __cmp <= 0; }
 377
 378   [[nodiscard]]
 379   constexpr bool
 380   is_gt  (partial_ordering __cmp) noexcept
 381   { return __cmp > 0; }
 382
 383   [[nodiscard]]
 384   constexpr bool
 385   is_gteq(partial_ordering __cmp) noexcept
 386   { return __cmp >= 0; }
 387
 388   namespace __detail
 389   {
 390     template<typename _Tp>
 391       inline constexpr unsigned __cmp_cat_id = 1;
 392     template<>
 393       inline constexpr unsigned __cmp_cat_id<partial_ordering> = 2;
 394     template<>
 395       inline constexpr unsigned __cmp_cat_id<weak_ordering> = 4;
 396     template<>
 397       inline constexpr unsigned __cmp_cat_id<strong_ordering> = 8;
 398
 399     template<typename... _Ts>
 400       constexpr auto __common_cmp_cat()
 401       {
 402         constexpr unsigned __cats = (__cmp_cat_id<_Ts> | ...);
 403         // If any Ti is not a comparison category type, U is void.
 404         if constexpr (__cats & 1)
 405           return;
 406         // Otherwise, if at least one Ti is std::partial_ordering,
 407         // U is std::partial_ordering.
 408         else if constexpr (bool(__cats & __cmp_cat_id<partial_ordering>))
 409           return partial_ordering::equivalent;
 410         // Otherwise, if at least one Ti is std::weak_ordering,
 411         // U is std::weak_ordering.
 412         else if constexpr (bool(__cats & __cmp_cat_id<weak_ordering>))
 413           return weak_ordering::equivalent;
 414         // Otherwise, U is std::strong_ordering.
 415         else
 416           return strong_ordering::equivalent;
 417       }
 418   } // namespace __detail
 419
 420   // [cmp.common], common comparison category type
 421   template<typename... _Ts>
 422     struct common_comparison_category
 423     {
 424       using type = decltype(__detail::__common_cmp_cat<_Ts...>());
 425     };
 426
 427   // Partial specializations for one and zero argument cases.
 428
 429   template<typename _Tp>
 430     struct common_comparison_category<_Tp>
 431     { using type = void; };
 432
 433   template<>
 434     struct common_comparison_category<partial_ordering>
 435     { using type = partial_ordering; };
 436
 437   template<>
 438     struct common_comparison_category<weak_ordering>
 439     { using type = weak_ordering; };
 440
 441   template<>
 442     struct common_comparison_category<strong_ordering>
 443     { using type = strong_ordering; };
 444
 445   template<>
 446     struct common_comparison_category<>
 447     { using type = strong_ordering; };
 448
 449   template<typename... _Ts>
 450     using common_comparison_category_t
 451       = typename common_comparison_category<_Ts...>::type;
 452
 453 #if __cpp_lib_concepts
 454   namespace __detail
 455   {
 456     template<typename _Tp, typename _Cat>
 457       concept __compares_as
 458         = same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
 459   } // namespace __detail
 460
 461   // [cmp.concept], concept three_way_comparable
 462   template<typename _Tp, typename _Cat = partial_ordering>
 463     concept three_way_comparable
 464       = __detail::__weakly_eq_cmp_with<_Tp, _Tp>
 465       && __detail::__partially_ordered_with<_Tp, _Tp>
 466       && requires(const remove_reference_t<_Tp>& __a,
 467                   const remove_reference_t<_Tp>& __b)
 468       {
 469         { __a <=> __b } -> __detail::__compares_as<_Cat>;
 470       };
 471
 472   template<typename _Tp, typename _Up, typename _Cat = partial_ordering>
 473     concept three_way_comparable_with
 474       = three_way_comparable<_Tp, _Cat>
 475       && three_way_comparable<_Up, _Cat>
 476       && common_reference_with<const remove_reference_t<_Tp>&,
 477                                const remove_reference_t<_Up>&>
 478       && three_way_comparable<
 479           common_reference_t<const remove_reference_t<_Tp>&,
 480                              const remove_reference_t<_Up>&>, _Cat>
 481       && __detail::__weakly_eq_cmp_with<_Tp, _Up>
 482       && __detail::__partially_ordered_with<_Tp, _Up>
 483       && requires(const remove_reference_t<_Tp>& __t,
 484                   const remove_reference_t<_Up>& __u)
 485       {
 486         { __t <=> __u } -> __detail::__compares_as<_Cat>;
 487         { __u <=> __t } -> __detail::__compares_as<_Cat>;
 488       };
 489
 490   namespace __detail
 491   {
 492     template<typename _Tp, typename _Up>
 493       using __cmp3way_res_t
 494         = decltype(std::declval<_Tp>() <=> std::declval<_Up>());
 495
 496     // Implementation of std::compare_three_way_result.
 497     // It is undefined for a program to add specializations of
 498     // std::compare_three_way_result, so the std::compare_three_way_result_t
 499     // alias ignores std::compare_three_way_result and uses
 500     // __detail::__cmp3way_res_impl directly instead.
 501     template<typename _Tp, typename _Up>
 502       struct __cmp3way_res_impl
 503       { };
 504
 505     template<typename _Tp, typename _Up>
 506       requires requires { typename __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>; }
 507       struct __cmp3way_res_impl<_Tp, _Up>
 508       {
 509         using type = __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>;
 510       };
 511   } // namespace __detail
 512
 513   /// [cmp.result], result of three-way comparison
 514   template<typename _Tp, typename _Up = _Tp>
 515     struct compare_three_way_result
 516     : __detail::__cmp3way_res_impl<_Tp, _Up>
 517     { };
 518
 519   /// [cmp.result], result of three-way comparison
 520   template<typename _Tp, typename _Up = _Tp>
 521     using compare_three_way_result_t
 522       = typename __detail::__cmp3way_res_impl<_Tp, _Up>::type;
 523
 524   namespace __detail
 525   {
 526     // BUILTIN-PTR-THREE-WAY(T, U)
 527     // This determines whether t <=> u results in a call to a built-in
 528     // operator<=> comparing pointers. It doesn't work for function pointers
 529     // (PR 93628).
 530     template<typename _Tp, typename _Up>
 531       concept __3way_builtin_ptr_cmp
 532         = requires(_Tp&& __t, _Up&& __u)
 533           { static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u); }
 534           && convertible_to<_Tp, const volatile void*>
 535           && convertible_to<_Up, const volatile void*>
 536           && ! requires(_Tp&& __t, _Up&& __u)
 537           { operator<=>(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); }
 538           && ! requires(_Tp&& __t, _Up&& __u)
 539           { static_cast<_Tp&&>(__t).operator<=>(static_cast<_Up&&>(__u)); };
 540   } // namespace __detail
 541
 542   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 543   // 3530 BUILTIN-PTR-MEOW should not opt the type out of syntactic checks
 544
 545   // [cmp.object], typename compare_three_way
 546   struct compare_three_way
 547   {
 548     template<typename _Tp, typename _Up>
 549       requires three_way_comparable_with<_Tp, _Up>
 550       constexpr auto
 551       operator()(_Tp&& __t, _Up&& __u) const
 552       noexcept(noexcept(std::declval<_Tp>() <=> std::declval<_Up>()))
 553       [[nodiscard]]
 554       {
 555         if constexpr (__detail::__3way_builtin_ptr_cmp<_Tp, _Up>)
 556           {
 557             auto __pt = static_cast<const volatile void*>(__t);
 558             auto __pu = static_cast<const volatile void*>(__u);
 559             if (__builtin_is_constant_evaluated())
 560               return __pt <=> __pu;
 561             auto __it = reinterpret_cast<__UINTPTR_TYPE__>(__pt);
 562             auto __iu = reinterpret_cast<__UINTPTR_TYPE__>(__pu);
 563             return __it <=> __iu;
 564           }
 565         else
 566           return static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u);
 567       }
 568
 569     using is_transparent = void;
 570   };
 571
 572   namespace __cmp_cust
 573   {
 574     template<floating_point _Tp>
 575       constexpr weak_ordering
 576       __fp_weak_ordering(_Tp __e, _Tp __f)
 577       {
 578         // Returns an integer with the same sign as the argument, and magnitude
 579         // indicating the classification: zero=1 subnorm=2 norm=3 inf=4 nan=5
 580         auto __cat = [](_Tp __fp) -> int {
 581           const int __sign = __builtin_signbit(__fp) ? -1 : 1;
 582           if (__builtin_isnormal(__fp))
 583             return (__fp == 0 ? 1 : 3) * __sign;
 584           if (__builtin_isnan(__fp))
 585             return 5 * __sign;
 586           if (int __inf = __builtin_isinf_sign(__fp))
 587             return 4 * __inf;
 588           return 2 * __sign;
 589         };
 590
 591         auto __po = __e <=> __f;
 592         if (is_lt(__po))
 593           return weak_ordering::less;
 594         else if (is_gt(__po))
 595           return weak_ordering::greater;
 596         else if (__po == partial_ordering::equivalent)
 597           return weak_ordering::equivalent;
 598         else  // unordered, at least one argument is NaN
 599           {
 600             // return -1 for negative nan, +1 for positive nan, 0 otherwise.
 601             auto __isnan_sign = [](_Tp __fp) -> int {
 602               return __builtin_isnan(__fp)
 603                 ? __builtin_signbit(__fp) ? -1 : 1
 604                 : 0;
 605             };
 606             auto __ord = __isnan_sign(__e) <=> __isnan_sign(__f);
 607             if (is_eq(__ord))
 608               return weak_ordering::equivalent;
 609             else if (is_lt(__ord))
 610               return weak_ordering::less;
 611             else
 612               return weak_ordering::greater;
 613           }
 614       }
 615
 616     template<typename _Tp, typename _Up>
 617       concept __adl_strong = requires(_Tp&& __t, _Up&& __u)
 618         {
 619           strong_ordering(strong_order(static_cast<_Tp&&>(__t),
 620                                        static_cast<_Up&&>(__u)));
 621         };
 622
 623     template<typename _Tp, typename _Up>
 624       concept __adl_weak = requires(_Tp&& __t, _Up&& __u)
 625         {
 626           weak_ordering(weak_order(static_cast<_Tp&&>(__t),
 627                                    static_cast<_Up&&>(__u)));
 628         };
 629
 630     template<typename _Tp, typename _Up>
 631       concept __adl_partial = requires(_Tp&& __t, _Up&& __u)
 632         {
 633           partial_ordering(partial_order(static_cast<_Tp&&>(__t),
 634                                          static_cast<_Up&&>(__u)));
 635         };
 636
 637     template<typename _Ord, typename _Tp, typename _Up>
 638       concept __cmp3way = requires(_Tp&& __t, _Up&& __u, compare_three_way __c)
 639         {
 640           _Ord(__c(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)));
 641         };
 642
 643     template<typename _Tp, typename _Up>
 644       concept __strongly_ordered
 645         = __adl_strong<_Tp, _Up>
 646           // FIXME: || floating_point<remove_reference_t<_Tp>>
 647           || __cmp3way<strong_ordering, _Tp, _Up>;
 648
 649     template<typename _Tp, typename _Up>
 650       concept __decayed_same_as = same_as<decay_t<_Tp>, decay_t<_Up>>;
 651
 652     class _Strong_order
 653     {
 654       template<typename _Tp, typename _Up>
 655         static constexpr bool
 656         _S_noexcept()
 657         {
 658           if constexpr (floating_point<decay_t<_Tp>>)
 659             return true;
 660           else if constexpr (__adl_strong<_Tp, _Up>)
 661             return noexcept(strong_ordering(strong_order(std::declval<_Tp>(),
 662                                                          std::declval<_Up>())));
 663           else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
 664             return noexcept(compare_three_way()(std::declval<_Tp>(),
 665                                                 std::declval<_Up>()));
 666         }
 667
 668       friend class _Weak_order;
 669       friend class _Strong_fallback;
 670
 671     public:
 672       template<typename _Tp, __decayed_same_as<_Tp> _Up>
 673         requires __strongly_ordered<_Tp, _Up>
 674         constexpr strong_ordering
 675         operator()(_Tp&& __e, _Up&& __f) const
 676         noexcept(_S_noexcept<_Tp, _Up>())
 677         [[nodiscard]]
 678         {
 679           /* FIXME:
 680           if constexpr (floating_point<decay_t<_Tp>>)
 681             return __cmp_cust::__fp_strong_order(__e, __f);
 682           else */ if constexpr (__adl_strong<_Tp, _Up>)
 683             return strong_ordering(strong_order(static_cast<_Tp&&>(__e),
 684                                                 static_cast<_Up&&>(__f)));
 685           else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
 686             return compare_three_way()(static_cast<_Tp&&>(__e),
 687                                        static_cast<_Up&&>(__f));
 688         }
 689     };
 690
 691     template<typename _Tp, typename _Up>
 692       concept __weakly_ordered
 693         = floating_point<remove_reference_t<_Tp>>
 694           || __adl_weak<_Tp, _Up>
 695           || __cmp3way<weak_ordering, _Tp, _Up>
 696           || __strongly_ordered<_Tp, _Up>;
 697
 698     class _Weak_order
 699     {
 700       template<typename _Tp, typename _Up>
 701         static constexpr bool
 702         _S_noexcept()
 703         {
 704           if constexpr (floating_point<decay_t<_Tp>>)
 705             return true;
 706           else if constexpr (__adl_weak<_Tp, _Up>)
 707             return noexcept(weak_ordering(weak_order(std::declval<_Tp>(),
 708                                                      std::declval<_Up>())));
 709           else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
 710             return noexcept(compare_three_way()(std::declval<_Tp>(),
 711                                                 std::declval<_Up>()));
 712           else if constexpr (__strongly_ordered<_Tp, _Up>)
 713             return _Strong_order::_S_noexcept<_Tp, _Up>();
 714         }
 715
 716       friend class _Partial_order;
 717       friend class _Weak_fallback;
 718
 719     public:
 720       template<typename _Tp, __decayed_same_as<_Tp> _Up>
 721         requires __weakly_ordered<_Tp, _Up>
 722         constexpr weak_ordering
 723         operator()(_Tp&& __e, _Up&& __f) const
 724         noexcept(_S_noexcept<_Tp, _Up>())
 725         [[nodiscard]]
 726         {
 727           if constexpr (floating_point<decay_t<_Tp>>)
 728             return __cmp_cust::__fp_weak_ordering(__e, __f);
 729           else if constexpr (__adl_weak<_Tp, _Up>)
 730             return weak_ordering(weak_order(static_cast<_Tp&&>(__e),
 731                                             static_cast<_Up&&>(__f)));
 732           else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
 733             return compare_three_way()(static_cast<_Tp&&>(__e),
 734                                        static_cast<_Up&&>(__f));
 735           else if constexpr (__strongly_ordered<_Tp, _Up>)
 736             return _Strong_order{}(static_cast<_Tp&&>(__e),
 737                                    static_cast<_Up&&>(__f));
 738         }
 739     };
 740
 741     template<typename _Tp, typename _Up>
 742       concept __partially_ordered
 743         = __adl_partial<_Tp, _Up>
 744         || __cmp3way<partial_ordering, _Tp, _Up>
 745         || __weakly_ordered<_Tp, _Up>;
 746
 747     class _Partial_order
 748     {
 749       template<typename _Tp, typename _Up>
 750         static constexpr bool
 751         _S_noexcept()
 752         {
 753           if constexpr (__adl_partial<_Tp, _Up>)
 754             return noexcept(partial_ordering(partial_order(std::declval<_Tp>(),
 755                                                          std::declval<_Up>())));
 756           else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
 757             return noexcept(compare_three_way()(std::declval<_Tp>(),
 758                                                 std::declval<_Up>()));
 759           else if constexpr (__weakly_ordered<_Tp, _Up>)
 760             return _Weak_order::_S_noexcept<_Tp, _Up>();
 761         }
 762
 763       friend class _Partial_fallback;
 764
 765     public:
 766       template<typename _Tp, __decayed_same_as<_Tp> _Up>
 767         requires __partially_ordered<_Tp, _Up>
 768         constexpr partial_ordering
 769         operator()(_Tp&& __e, _Up&& __f) const
 770         noexcept(_S_noexcept<_Tp, _Up>())
 771         [[nodiscard]]
 772         {
 773           if constexpr (__adl_partial<_Tp, _Up>)
 774             return partial_ordering(partial_order(static_cast<_Tp&&>(__e),
 775                                                   static_cast<_Up&&>(__f)));
 776           else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
 777             return compare_three_way()(static_cast<_Tp&&>(__e),
 778                                        static_cast<_Up&&>(__f));
 779           else if constexpr (__weakly_ordered<_Tp, _Up>)
 780             return _Weak_order{}(static_cast<_Tp&&>(__e),
 781                                  static_cast<_Up&&>(__f));
 782         }
 783     };
 784
 785     template<typename _Tp, typename _Up>
 786       concept __op_eq_lt = requires(_Tp&& __t, _Up&& __u)
 787         {
 788           { static_cast<_Tp&&>(__t) == static_cast<_Up&&>(__u) }
 789             -> convertible_to<bool>;
 790           { static_cast<_Tp&&>(__t) < static_cast<_Up&&>(__u) }
 791             -> convertible_to<bool>;
 792         };
 793
 794     class _Strong_fallback
 795     {
 796       template<typename _Tp, typename _Up>
 797         static constexpr bool
 798         _S_noexcept()
 799         {
 800           if constexpr (__strongly_ordered<_Tp, _Up>)
 801             return _Strong_order::_S_noexcept<_Tp, _Up>();
 802           else
 803             return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
 804               && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
 805         }
 806
 807     public:
 808       template<typename _Tp, __decayed_same_as<_Tp> _Up>
 809         requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
 810         constexpr strong_ordering
 811         operator()(_Tp&& __e, _Up&& __f) const
 812         noexcept(_S_noexcept<_Tp, _Up>())
 813         [[nodiscard]]
 814         {
 815           if constexpr (__strongly_ordered<_Tp, _Up>)
 816             return _Strong_order{}(static_cast<_Tp&&>(__e),
 817                                    static_cast<_Up&&>(__f));
 818           else // __op_eq_lt<_Tp, _Up>
 819             return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
 820               ? strong_ordering::equal
 821               : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
 822               ? strong_ordering::less
 823               : strong_ordering::greater;
 824         }
 825     };
 826
 827     class _Weak_fallback
 828     {
 829       template<typename _Tp, typename _Up>
 830         static constexpr bool
 831         _S_noexcept()
 832         {
 833           if constexpr (__weakly_ordered<_Tp, _Up>)
 834             return _Weak_order::_S_noexcept<_Tp, _Up>();
 835           else
 836             return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
 837               && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
 838         }
 839
 840     public:
 841       template<typename _Tp, __decayed_same_as<_Tp> _Up>
 842         requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
 843         constexpr weak_ordering
 844         operator()(_Tp&& __e, _Up&& __f) const
 845         noexcept(_S_noexcept<_Tp, _Up>())
 846         [[nodiscard]]
 847         {
 848           if constexpr (__weakly_ordered<_Tp, _Up>)
 849             return _Weak_order{}(static_cast<_Tp&&>(__e),
 850                                  static_cast<_Up&&>(__f));
 851           else // __op_eq_lt<_Tp, _Up>
 852             return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
 853               ? weak_ordering::equivalent
 854               : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
 855               ? weak_ordering::less
 856               : weak_ordering::greater;
 857         }
 858     };
 859
 860     // _GLIBCXX_RESOLVE_LIB_DEFECTS
 861     // 3465. compare_partial_order_fallback requires F < E
 862     template<typename _Tp, typename _Up>
 863       concept __op_eq_lt_lt = __op_eq_lt<_Tp, _Up>
 864         && requires(_Tp&& __t, _Up&& __u)
 865         {
 866           { static_cast<_Up&&>(__u) < static_cast<_Tp&&>(__t) }
 867             -> convertible_to<bool>;
 868         };
 869
 870     class _Partial_fallback
 871     {
 872       template<typename _Tp, typename _Up>
 873         static constexpr bool
 874         _S_noexcept()
 875         {
 876           if constexpr (__partially_ordered<_Tp, _Up>)
 877             return _Partial_order::_S_noexcept<_Tp, _Up>();
 878           else
 879             return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
 880               && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
 881         }
 882
 883     public:
 884       template<typename _Tp, __decayed_same_as<_Tp> _Up>
 885         requires __partially_ordered<_Tp, _Up> || __op_eq_lt_lt<_Tp, _Up>
 886         constexpr partial_ordering
 887         operator()(_Tp&& __e, _Up&& __f) const
 888         noexcept(_S_noexcept<_Tp, _Up>())
 889         [[nodiscard]]
 890         {
 891           if constexpr (__partially_ordered<_Tp, _Up>)
 892             return _Partial_order{}(static_cast<_Tp&&>(__e),
 893                                     static_cast<_Up&&>(__f));
 894           else // __op_eq_lt_lt<_Tp, _Up>
 895             return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
 896               ? partial_ordering::equivalent
 897               : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
 898               ? partial_ordering::less
 899               : static_cast<_Up&&>(__f) < static_cast<_Tp&&>(__e)
 900               ? partial_ordering::greater
 901               : partial_ordering::unordered;
 902         }
 903     };
 904   } // namespace __cmp_cust
 905
 906   // [cmp.alg], comparison algorithms
 907   inline namespace __cmp_alg
 908   {
 909     inline constexpr __cmp_cust::_Strong_order strong_order{};
 910
 911     inline constexpr __cmp_cust::_Weak_order weak_order{};
 912
 913     inline constexpr __cmp_cust::_Partial_order partial_order{};
 914
 915     inline constexpr __cmp_cust::_Strong_fallback
 916     compare_strong_order_fallback{};
 917
 918     inline constexpr __cmp_cust::_Weak_fallback
 919     compare_weak_order_fallback{};
 920
 921     inline constexpr __cmp_cust::_Partial_fallback
 922     compare_partial_order_fallback{};
 923   }
 924
 925   namespace __detail
 926   {
 927     // [expos.only.func] synth-three-way
 928     inline constexpr struct _Synth3way
 929     {
 930       template<typename _Tp, typename _Up>
 931         static constexpr bool
 932         _S_noexcept(const _Tp* __t = nullptr, const _Up* __u = nullptr)
 933         {
 934           if constexpr (three_way_comparable_with<_Tp, _Up>)
 935             return noexcept(*__t <=> *__u);
 936           else
 937             return noexcept(*__t < *__u) && noexcept(*__u < *__t);
 938         }
 939
 940       template<typename _Tp, typename _Up>
 941         [[nodiscard]]
 942         constexpr auto
 943         operator()(const _Tp& __t, const _Up& __u) const
 944         noexcept(_S_noexcept<_Tp, _Up>())
 945         requires requires
 946         {
 947           { __t < __u } -> __boolean_testable;
 948           { __u < __t } -> __boolean_testable;
 949         }
 950         {
 951           if constexpr (three_way_comparable_with<_Tp, _Up>)
 952             return __t <=> __u;
 953           else
 954             {
 955               if (__t < __u)
 956                 return weak_ordering::less;
 957               else if (__u < __t)
 958                 return weak_ordering::greater;
 959               else
 960                 return weak_ordering::equivalent;
 961             }
 962         }
 963     } __synth3way = {};
 964
 965     // [expos.only.func] synth-three-way-result
 966     template<typename _Tp, typename _Up = _Tp>
 967       using __synth3way_t
 968         = decltype(__detail::__synth3way(std::declval<_Tp&>(),
 969                                          std::declval<_Up&>()));
 970   } // namespace __detail
 971 #endif // concepts
 972 } // namespace std
 973
 974 #pragma GCC visibility pop
 975
 976 #endif // C++20
 977
 978 #endif // _COMPARE