[libc++] P2944R3: Constrained comparisions - `variant` #141396

H-G-Hristov · 2025-05-25T06:55:06Z

This is a follow-up and depends on #139368 being merged first.

Implements P2944R3 partially, which adds constrained comparisons to std::variant

Closes #136769

Depends on #139368

References

variant.relops

…rapper Implements `variant`: https://wg21.link/P2944R3 Closes llvm#136769

github-actions · 2025-05-25T06:57:25Z

✅ With the latest revision this PR passed the C/C++ code formatter.

llvmbot · 2025-05-25T07:28:36Z

@llvm/pr-subscribers-libcxx

Author: Hristo Hristov (H-G-Hristov)

Changes

This is a follow-up and depends on #139368 being merged first.

Implements P2944R3 partially, which adds constrained comparisons to std::variant and std::tuple.

The missing overloads introduced in P2165R4 are not implemented.

Relates to #136765
Closes #136769

Relates to: #139368

References

tuple.rel
variant.relops

Full diff: https://github.com/llvm/llvm-project/pull/141396.diff

6 Files Affected:

(modified) libcxx/include/tuple (+7)
(modified) libcxx/include/variant (+31)
(modified) libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp (+21-2)
(modified) libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_comparison.verify.cpp (+6)
(modified) libcxx/test/std/utilities/variant/variant.relops/relops.pass.cpp (+49)
(modified) libcxx/test/support/test_comparisons.h (+65-1)

diff --git a/libcxx/include/tuple b/libcxx/include/tuple
index 8dd62ae624f5e..35ea37a5ea5ed 100644
--- a/libcxx/include/tuple
+++ b/libcxx/include/tuple
@@ -1161,9 +1161,16 @@ struct __tuple_equal<0> {
 };
 
 template <class... _Tp, class... _Up>
+#    if _LIBCPP_STD_VER >= 26
+  requires(requires(const _Tp& __t, const _Up& __u) {
+            { __t == __u } -> __boolean_testable;
+          } && ...) && (sizeof...(_Tp) == sizeof...(_Up))
+#    endif
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
 operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
+#    if _LIBCPP_STD_VER < 26
   static_assert(sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
+#    endif
   return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
 }
 
diff --git a/libcxx/include/variant b/libcxx/include/variant
index bf611aec704ca..f33058b708528 100644
--- a/libcxx/include/variant
+++ b/libcxx/include/variant
@@ -242,6 +242,7 @@ namespace std {
 #  include <__type_traits/is_assignable.h>
 #  include <__type_traits/is_constructible.h>
 #  include <__type_traits/is_convertible.h>
+#  include <__type_traits/is_core_convertible.h>
 #  include <__type_traits/is_destructible.h>
 #  include <__type_traits/is_nothrow_assignable.h>
 #  include <__type_traits/is_nothrow_constructible.h>
@@ -1453,6 +1454,11 @@ struct __convert_to_bool {
 };
 
 template <class... _Types>
+#    if _LIBCPP_STD_VER >= 26
+  requires(requires(const _Types& __t) {
+    { __t == __t } -> __core_convertible_to<bool>;
+  } && ...)
+#    endif
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__lhs.index() != __rhs.index())
@@ -1485,6 +1491,11 @@ operator<=>(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
 #    endif // _LIBCPP_STD_VER >= 20
 
 template <class... _Types>
+#    if _LIBCPP_STD_VER >= 26
+  requires(requires(const _Types& __t) {
+    { __t != __t } -> __core_convertible_to<bool>;
+  } && ...)
+#    endif
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__lhs.index() != __rhs.index())
@@ -1495,6 +1506,11 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const variant<_Types...>& __lhs,
 }
 
 template <class... _Types>
+#    if _LIBCPP_STD_VER >= 26
+  requires(requires(const _Types& __t) {
+    { __t < __t } -> __core_convertible_to<bool>;
+  } && ...)
+#    endif
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__rhs.valueless_by_exception())
@@ -1509,6 +1525,11 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const variant<_Types...>& __lhs,
 }
 
 template <class... _Types>
+#    if _LIBCPP_STD_VER >= 26
+  requires(requires(const _Types& __t) {
+    { __t > __t } -> __core_convertible_to<bool>;
+  } && ...)
+#    endif
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__lhs.valueless_by_exception())
@@ -1523,6 +1544,11 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const variant<_Types...>& __lhs,
 }
 
 template <class... _Types>
+#    if _LIBCPP_STD_VER >= 26
+  requires(requires(const _Types& __t) {
+    { __t <= __t } -> __core_convertible_to<bool>;
+  } && ...)
+#    endif
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__lhs.valueless_by_exception())
@@ -1537,6 +1563,11 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const variant<_Types...>& __lhs,
 }
 
 template <class... _Types>
+#    if _LIBCPP_STD_VER >= 26
+  requires(requires(const _Types& __t) {
+    { __t >= __t } -> __core_convertible_to<bool>;
+  } && ...)
+#    endif
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__rhs.valueless_by_exception())
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
index a8de656313d45..baca362f7783b 100644
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
@@ -16,12 +16,31 @@
 
 // UNSUPPORTED: c++03
 
-#include <tuple>
-#include <string>
+#include <array>
 #include <cassert>
+#include <tuple>
 
+#include "test_comparisons.h"
 #include "test_macros.h"
 
+#if TEST_STD_VER >= 26
+
+// Test SFINAE.
+
+static_assert(std::equality_comparable<std::tuple<EqualityComparable>>);
+static_assert(std::equality_comparable<std::tuple<EqualityComparable, EqualityComparable>>);
+
+static_assert(!std::equality_comparable<std::tuple<NonComparable>>);
+static_assert(!std::equality_comparable<std::tuple<EqualityComparable, NonComparable>>);
+static_assert(!std::equality_comparable<std::tuple<NonComparable, EqualityComparable>>);
+static_assert(!std::equality_comparable_with<std::tuple<EqualityComparable>, std::tuple<NonComparable>>);
+static_assert(!std::equality_comparable_with<std::tuple<NonComparable>, std::tuple<EqualityComparable>>);
+// Size mismatch.
+static_assert(!std::equality_comparable_with<std::tuple<EqualityComparable>, std::tuple<EqualityComparable, EqualityComparable>>);
+static_assert(!std::equality_comparable_with<std::tuple<EqualityComparable, EqualityComparable>, std::tuple<EqualityComparable>>);
+
+#endif
+
 int main(int, char**)
 {
     {
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_comparison.verify.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_comparison.verify.cpp
index 851f6fcd1fbac..a5dbb6b313e6a 100644
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_comparison.verify.cpp
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_comparison.verify.cpp
@@ -21,9 +21,15 @@
 
 #include <tuple>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 26
+// expected-no-diagnostics
+#else
 void f(std::tuple<int> t1, std::tuple<int, long> t2) {
   // We test only the core comparison operators and trust that the others
   // fall back on the same implementations prior to C++20.
   static_cast<void>(t1 == t2); // expected-error@*:* {{}}
   static_cast<void>(t1 < t2); // expected-error@*:* {{}}
 }
+#endif
diff --git a/libcxx/test/std/utilities/variant/variant.relops/relops.pass.cpp b/libcxx/test/std/utilities/variant/variant.relops/relops.pass.cpp
index c1a5b8e474a74..2c00703662687 100644
--- a/libcxx/test/std/utilities/variant/variant.relops/relops.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.relops/relops.pass.cpp
@@ -39,8 +39,57 @@
 #include <utility>
 #include <variant>
 
+#include "test_comparisons.h"
 #include "test_macros.h"
 
+#if TEST_STD_VER >= 26
+
+// Test SFINAE.
+
+// ==
+static_assert(HasOperatorEqual<std::variant<EqualityComparable>>);
+static_assert(HasOperatorEqual<std::variant<EqualityComparable, int, long>>);
+
+static_assert(!HasOperatorEqual<std::variant<NonComparable>>);
+static_assert(!HasOperatorEqual<std::variant<NonComparable, EqualityComparable>>);
+
+// >
+static_assert(HasOperatorGreaterThan<std::variant<ThreeWayComparable>>);
+static_assert(HasOperatorGreaterThan<std::variant<ThreeWayComparable, int, long>>);
+
+static_assert(!HasOperatorGreaterThan<std::variant<NonComparable>>);
+static_assert(!HasOperatorGreaterThan<std::variant<NonComparable, ThreeWayComparable>>);
+
+// >=
+static_assert(HasOperatorGreaterThanEqual<std::variant<ThreeWayComparable>>);
+static_assert(HasOperatorGreaterThanEqual<std::variant<ThreeWayComparable, int, long>>);
+
+static_assert(!HasOperatorGreaterThanEqual<std::variant<NonComparable>>);
+static_assert(!HasOperatorGreaterThanEqual<std::variant<NonComparable, ThreeWayComparable>>);
+
+// <
+static_assert(HasOperatorLessThan<std::variant<ThreeWayComparable>>);
+static_assert(HasOperatorLessThan<std::variant<ThreeWayComparable, int, long>>);
+
+static_assert(!HasOperatorLessThan<std::variant<NonComparable>>);
+static_assert(!HasOperatorLessThan<std::variant<NonComparable, ThreeWayComparable>>);
+
+// <=
+static_assert(HasOperatorLessThanEqual<std::variant<ThreeWayComparable>>);
+static_assert(HasOperatorLessThanEqual<std::variant<ThreeWayComparable, int, long>>);
+
+static_assert(!HasOperatorLessThanEqual<std::variant<NonComparable>>);
+static_assert(!HasOperatorLessThanEqual<std::variant<NonComparable, ThreeWayComparable>>);
+
+// !=
+static_assert(HasOperatorNotEqual<std::variant<EqualityComparable>>);
+static_assert(HasOperatorNotEqual<std::variant<EqualityComparable, int, long>>);
+
+static_assert(!HasOperatorNotEqual<std::variant<NonComparable>>);
+static_assert(!HasOperatorNotEqual<std::variant<NonComparable, EqualityComparable>>);
+
+#endif
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct MakeEmptyT {
   MakeEmptyT() = default;
diff --git a/libcxx/test/support/test_comparisons.h b/libcxx/test/support/test_comparisons.h
index db6977a96a2fe..e37ab44828c70 100644
--- a/libcxx/test/support/test_comparisons.h
+++ b/libcxx/test/support/test_comparisons.h
@@ -268,6 +268,70 @@ struct PartialOrder {
   }
 };
 
-#endif
+template <typename T1, typename T2 = T1>
+concept HasOperatorEqual = requires(T1 t1, T2 t2) { t1 == t2; };
+
+template <typename T1, typename T2 = T1>
+concept HasOperatorGreaterThan = requires(T1 t1, T2 t2) { t1 > t2; };
+
+template <typename T1, typename T2 = T1>
+concept HasOperatorGreaterThanEqual = requires(T1 t1, T2 t2) { t1 >= t2; };
+template <typename T1, typename T2 = T1>
+concept HasOperatorLessThan = requires(T1 t1, T2 t2) { t1 < t2; };
+
+template <typename T1, typename T2 = T1>
+concept HasOperatorLessThanEqual = requires(T1 t1, T2 t2) { t1 <= t2; };
+
+template <typename T1, typename T2 = T1>
+concept HasOperatorNotEqual = requires(T1 t1, T2 t2) { t1 != t2; };
+
+template <typename T1, typename T2 = T1>
+concept HasOperatorSpaceship = requires(T1 t1, T2 t2) { t1 <=> t2; };
+
+struct NonComparable {};
+static_assert(!std::equality_comparable<NonComparable>);
+static_assert(!HasOperatorEqual<NonComparable>);
+static_assert(!HasOperatorGreaterThan<NonComparable>);
+static_assert(!HasOperatorGreaterThanEqual<NonComparable>);
+static_assert(!HasOperatorLessThan<NonComparable>);
+static_assert(!HasOperatorLessThanEqual<NonComparable>);
+static_assert(!HasOperatorNotEqual<NonComparable>);
+static_assert(!HasOperatorSpaceship<NonComparable>);
+
+class EqualityComparable {
+public:
+  constexpr EqualityComparable(int value) : value_{value} {};
+
+  friend constexpr bool operator==(const EqualityComparable&, const EqualityComparable&) noexcept = default;
+
+private:
+  int value_;
+};
+static_assert(std::equality_comparable<EqualityComparable>);
+static_assert(HasOperatorEqual<EqualityComparable>);
+static_assert(HasOperatorNotEqual<EqualityComparable>);
+
+class ThreeWayComparable {
+public:
+  constexpr ThreeWayComparable(int value) : value_{value} {};
+
+  friend constexpr bool operator==(const ThreeWayComparable&, const ThreeWayComparable&) noexcept = default;
+  friend constexpr std::strong_ordering
+  operator<=>(const ThreeWayComparable&, const ThreeWayComparable&) noexcept = default;
+
+private:
+  int value_;
+};
+static_assert(std::equality_comparable<ThreeWayComparable>);
+static_assert(std::three_way_comparable<ThreeWayComparable>);
+static_assert(HasOperatorEqual<ThreeWayComparable>);
+static_assert(HasOperatorGreaterThan<ThreeWayComparable>);
+static_assert(HasOperatorGreaterThanEqual<ThreeWayComparable>);
+static_assert(HasOperatorLessThan<ThreeWayComparable>);
+static_assert(HasOperatorLessThanEqual<ThreeWayComparable>);
+static_assert(HasOperatorNotEqual<ThreeWayComparable>);
+static_assert(HasOperatorSpaceship<ThreeWayComparable>);
+
+#endif // TEST_STD_VER >= 20
 
 #endif // TEST_COMPARISONS_H

libcxx/include/tuple

libcxx/test/support/test_comparisons.h

libcxx/test/std/utilities/variant/variant.relops/relops_bool_conv.verify.cpp

…onv.verify.cpp

philnik777 · 2025-06-23T09:34:18Z

libcxx/include/tuple

+#    if _LIBCPP_STD_VER < 26
  static_assert(sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
+#    endif


I'm not sure guarding this buys us much.

I believe guarding this doesn't won't noticeably improve throughput because sizeof...(_Tp) == sizeof...(_Up) is already checked. But it seems to me that the guarding will clearly tell code readers that there won't be redundant size check, and possibly reduce mental burden.

I'm seeing this from the other side actually. It's guarded, so my first instinct is to wonder whether this restriction has been lifted in C++26. Just having the static_assert unconditionally tells the reader that it's always a requirement. Whether this is enforced through a constraint as well doesn't really bother me that much.

From a maintainace point of view IMO this guard tells that if in year 2042, C++29 becomes the min supported mode, this could be easily removed.
Anyway I will remove the guard.

philnik777 · 2025-06-23T09:38:29Z

libcxx/include/tuple

+#    if _LIBCPP_STD_VER >= 26
+  requires(requires(const _Tp& __t, const _Up& __u) {
+            { __t == __u } -> __boolean_testable;
+          } && ...) && (sizeof...(_Tp) == sizeof...(_Up))


I think we should use __all here. Otherwise we're potentially breaking currently working code, since fold expressions have a significantly lower limit than the number of allowed template arguments.

Doesn't this patch resolve your concerns: #132021

It does, but it's not yet available in most compilers. Note that I'm only asking for tuple to be changed, since it's notorious for being instantiated with a huge number of arguments.

OK. In that case. I'll split tuple in a separate patch.

philnik777

Please update the title. Otherwise LGTM

Zingam · 2025-06-25T09:12:05Z

Thanks! The test failures seem unrelated. Merging.

This is a follow-up and depends on llvm#139368 being merged first. Implements [P2944R3](https://wg21.link/P2944R3) partially, which adds constrained comparisons to `std::variant` Closes llvm#136769 Depends on llvm#139368 # References [variant.relops](https://wg21.link/variant.relops)

Implements P2944R3 partially, which adds constrained comparisons `std::tuple`. The missing overloads introduced in [P2165R4](https://wg21.link/P2165R4) are not implemented. Uses [`__all`](https://github.com/llvm/llvm-project/blob/f7af33a9eb5b3876f219075023dc9c565d75849b/libcxx/include/__type_traits/conjunction.h#L45) instead of a fold expression, see comment: #141396 (comment) Relates to #136765 # References [tuple.rel](https://wg21.link//tuple.rel)

…677) Implements P2944R3 partially, which adds constrained comparisons `std::tuple`. The missing overloads introduced in [P2165R4](https://wg21.link/P2165R4) are not implemented. Uses [`__all`](https://github.com/llvm/llvm-project/blob/f7af33a9eb5b3876f219075023dc9c565d75849b/libcxx/include/__type_traits/conjunction.h#L45) instead of a fold expression, see comment: llvm/llvm-project#141396 (comment) Relates to #136765 # References [tuple.rel](https://wg21.link//tuple.rel)

This is a follow-up and depends on llvm#139368 being merged first. Implements [P2944R3](https://wg21.link/P2944R3) partially, which adds constrained comparisons to `std::variant` Closes llvm#136769 Depends on llvm#139368 # References [variant.relops](https://wg21.link/variant.relops)

Implements P2944R3 partially, which adds constrained comparisons `std::tuple`. The missing overloads introduced in [P2165R4](https://wg21.link/P2165R4) are not implemented. Uses [`__all`](https://github.com/llvm/llvm-project/blob/f7af33a9eb5b3876f219075023dc9c565d75849b/libcxx/include/__type_traits/conjunction.h#L45) instead of a fold expression, see comment: llvm#141396 (comment) Relates to llvm#136765 # References [tuple.rel](https://wg21.link//tuple.rel)

H-G-Hristov added 4 commits May 25, 2025 09:42

[libc++] P2944R3: Constrained comparisions - optional and reference_w…

a7517fd

…rapper Implements `variant`: https://wg21.link/P2944R3 Closes llvm#136769

Implement tuple

ab710f4

Cleanup

dd32d6c

variant more tests

23ebfd7

Zingam linked an issue May 25, 2025 that may be closed by this pull request

P2944R3: Constrained equality - std::tuple #136765

Open

Zingam added libc++ libc++ C++ Standard Library. Not GNU libstdc++. Not libc++abi. c++26 labels May 25, 2025

Zingam removed a link to an issue May 25, 2025

P2944R3: Constrained equality - std::tuple #136765

Open

Zingam mentioned this pull request May 25, 2025

P2944R3: Constrained equality - std::tuple #136765

Open

frederick-vs-ja reviewed Jun 4, 2025

View reviewed changes

libcxx/include/tuple Outdated Show resolved Hide resolved

libcxx/test/support/test_comparisons.h Show resolved Hide resolved

H-G-Hristov added 7 commits June 5, 2025 06:48

Added missing include

f862580

Merge branch 'main' into hgh/libcxx/P2944R3-constrained-equality-variant

ba27f7f

Formatting

8483790

Fix

98b05c4

Merge branch 'main' into hgh/libcxx/P2944R3-constrained-equality-variant

c64a4ec

Merge branch 'main' into hgh/libcxx/P2944R3-constrained-equality-variant

6e11bf0

Cleanup

2b671b5

H-G-Hristov changed the title ~~WIP [libc++]P2944R3: Constrained comparisions - variant and tuple~~ [libc++]P2944R3: Constrained comparisions - variant and tuple Jun 15, 2025

H-G-Hristov changed the title ~~[libc++]P2944R3: Constrained comparisions - variant and tuple~~ [libc++] P2944R3: Constrained comparisions - variant and tuple Jun 15, 2025

H-G-Hristov added 2 commits June 15, 2025 09:31

Fix CI

3cb270b

Merge branch 'main' into hgh/libcxx/P2944R3-constrained-equality-variant

475d1f3

H-G-Hristov commented Jun 15, 2025

View reviewed changes

libcxx/test/std/utilities/variant/variant.relops/relops_bool_conv.verify.cpp Outdated Show resolved Hide resolved

H-G-Hristov and others added 3 commits June 15, 2025 09:55

Update libcxx/test/std/utilities/variant/variant.relops/relops_bool_c…

d1cfb12

…onv.verify.cpp

Fix formatting

3c9e9c3

Merge branch 'main' into hgh/libcxx/P2944R3-constrained-equality-variant

7d5ff27

H-G-Hristov marked this pull request as ready for review June 15, 2025 19:57

H-G-Hristov requested a review from a team as a code owner June 15, 2025 19:57

frederick-vs-ja approved these changes Jun 23, 2025

View reviewed changes

philnik777 reviewed Jun 23, 2025

View reviewed changes

H-G-Hristov added 2 commits June 25, 2025 00:57

Removed tuple

df79b72

Updated status pages

e08025e

H-G-Hristov requested a review from philnik777 June 24, 2025 22:01

philnik777 reviewed Jun 25, 2025

View reviewed changes

philnik777 approved these changes Jun 25, 2025

View reviewed changes

Zingam changed the title ~~[libc++] P2944R3: Constrained comparisions - variant and tuple~~ [libc++] P2944R3: Constrained comparisions - variant Jun 25, 2025

Zingam merged commit f2f4b55 into llvm:main Jun 25, 2025
61 of 64 checks passed

H-G-Hristov deleted the hgh/libcxx/P2944R3-constrained-equality-variant branch June 25, 2025 10:06

H-G-Hristov mentioned this pull request Jun 25, 2025

[libc++] P2944R3: Constrained comparisions - tuple #145677

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

[libc++] P2944R3: Constrained comparisions - `variant` #141396

[libc++] P2944R3: Constrained comparisions - `variant` #141396

H-G-Hristov commented May 25, 2025 •

edited

Loading

Uh oh!

github-actions bot commented May 25, 2025 •

edited

Loading

Uh oh!

llvmbot commented May 25, 2025

References

Uh oh!

Uh oh!

Uh oh!

Uh oh!

philnik777 Jun 23, 2025

Uh oh!

frederick-vs-ja Jun 24, 2025

Uh oh!

philnik777 Jun 24, 2025

Uh oh!

Zingam Jun 24, 2025

Uh oh!

philnik777 Jun 23, 2025

Uh oh!

Zingam Jun 23, 2025

Uh oh!

philnik777 Jun 24, 2025

Uh oh!

Zingam Jun 24, 2025

Uh oh!

philnik777 left a comment

Uh oh!

Zingam commented Jun 25, 2025

Uh oh!

Uh oh!

Uh oh!

[libc++] P2944R3: Constrained comparisions - variant #141396

[libc++] P2944R3: Constrained comparisions - variant #141396

Conversation

H-G-Hristov commented May 25, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

References

Uh oh!

github-actions bot commented May 25, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

llvmbot commented May 25, 2025

References

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

philnik777 left a comment

Choose a reason for hiding this comment

Uh oh!

Zingam commented Jun 25, 2025

Uh oh!

Uh oh!

Uh oh!

[libc++] P2944R3: Constrained comparisions - `variant` #141396

[libc++] P2944R3: Constrained comparisions - `variant` #141396

H-G-Hristov commented May 25, 2025 •

edited

Loading

github-actions bot commented May 25, 2025 •

edited

Loading