[libcxx] adds remaining callable concepts

[cjdb]

Summary

• std::predicate
• std::relation
• std::equivalence_relation
• std::strict_weak_order

Implements parts of:

• P0898R3 Standard Library Concepts
• P1754 Rename concepts to standard_case for C++20, while we still can

[curdeius]

Nits only for the moment.

libcxx/test/std/concepts/callable/functions.h

8 ↗

(On Diff #322890)

LAND_ should be removed, nope?

libcxx/test/std/concepts/callable/predicate.compile.pass.cpp

94 ↗

(On Diff #322890)

Nit: newline.

libcxx/test/std/concepts/callable/strictweakorder.compile.pass.cpp

102 ↗

(On Diff #322890)

Newline.

[cjdb]

libcxx/test/std/concepts/callable/functions.h

8 ↗

(On Diff #322890)

See @ldionne's request in D96230.

libcxx/test/std/concepts/callable/predicate.compile.pass.cpp

94 ↗

(On Diff #322890)

Done, but not pushing to remote since it's not worth activating CI for this.

libcxx/test/std/concepts/callable/strictweakorder.compile.pass.cpp

102 ↗

(On Diff #322890)

Done, as above.

[curdeius]

libcxx/test/std/concepts/callable/functions.h

8 ↗

(On Diff #322890)

You mean this https://reviews.llvm.org/D96230#inline-902629? There was "lang" in the path and a typo in the guard macro.

[cjdb]

libcxx/test/std/concepts/callable/functions.h

8 ↗

(On Diff #322890)

Ah, good point. I'll fix both up, but won't commit since it's not worth impacting CI times for more important patches.

[Mordante]

libcxx/include/concepts

261

I'm somewhat surprised the concept is define like this in the Standard, but http://eel.is/c++draft/concept.booleantestable#2 has additional constrains.
Did I miss the tests for this concept? I'd like some tests, https://en.cppreference.com/w/cpp/concepts/boolean-testable has some examples of valid types: bool, std::true_type, std::bitset<N>::reference, and int*.

libcxx/test/std/concepts/callable/equiv.compile.pass.cpp

13 ↗

(On Diff #322890)

Copy-paste.

libcxx/test/std/concepts/callable/functions.h

57 ↗

(On Diff #322890)

The .Value = isn't required right?I think this makes it harder to read.

libcxx/test/std/concepts/callable/strictweakorder.compile.pass.cpp

13 ↗

(On Diff #322890)

Copy-paste.

[cjdb]

addresses comments by @Mordante and @curdeius

[cjdb]

applies final feedback from @Mordante

libcxx/include/concepts

261

It's an implementation detail, so I'm not motivated to directly test it. All the predicate-based concepts are tested for bool, Bool, and int, but I've expand to include std::true_type and int*.

[cjdb]

Ping. This one's been open for a long while now.

[• Quuxplusone]

libcxx/include/concepts

253

Moving copy_constructible upward is a severable change you can just land right away without review, if you want to. (IMHO. I mean if it were me, I'd land it. Maybe someone else will chime in to agree/disagree.)

419

You changed this comment, but line 152 implies that you shouldn't have. Also, insert blank line.

libcxx/test/std/concepts/callable/equiv.compile.pass.cpp

25 ↗

(On Diff #328363)

Please indent the requires line by one indent-level (which I guess is 2 spaces, in the style used by this file, blecch).
However, as I say below, I'd rather eliminate these functions altogether...

29 ↗

(On Diff #328363)

51 ↗

(On Diff #328363)

I'd prefer to see

static_assert(!std::equivalence_relation<decltype(&A::F), int, int>);

It's not significantly harder to read or reason about, and I think it's a little simpler when it comes to testing lvalue parameter types (which are woefully absent from the current tests). That is, I'd like to see at least one instance of

static_assert(!std::equivalence_relation<decltype(&A::F), int&, int&>);

In fact, I'd like to see a test case where

static_assert(std::equivalence_relation<X, int, int>);
static_assert(!std::equivalence_relation<X, int&, int&>);

and another test case where

static_assert(!std::equivalence_relation<X, int, int>);
static_assert(std::equivalence_relation<X, int&, int&>);

88 ↗

(On Diff #328363)

I don't think it's useful to keep these as comments.
What is your understanding of the requirements on libc++ as a conforming implementation of C++20? Is libc++ permitted to reject these lines if they were to be uncommented?
If we're not permitted to reject them, then we must accept them, and so you might as well uncomment them permanently. OTOH, if they're supposed to be some sort of "library IFNDR," such that a conforming library might reject them, then it makes sense not to uncomment them (but in that case I'd just delete these lines permanently).

libcxx/test/std/concepts/callable/functions.h

27–28 ↗

(On Diff #328363)

[cjdb]

rebases because this patch is super old

[cjdb]

libcxx/test/std/concepts/callable/functions.h

27–28 ↗

(On Diff #328363)

No, this is definitely correct as-is.

[• Quuxplusone]

libcxx/test/std/concepts/callable/functions.h

27–28 ↗

(On Diff #328363)

There is no conceivable library bug that could cause us to treat int Value = false; and int Value = 0; any differently.
Also, you don't want to return int Value from operator bool; you want to return a bool.

Maybe you meant to write bool Value = false; instead of int Value = false;, is that the issue?

[EricWF]

Can we please change the .compile.cpp to just .pass.cpp. There's very little to no cost to actually run the test, and doing so seems safer to me.
It avoids allowing runtime tests to be mistakenly added to these files without anybody noticing.

libcxx/test/std/concepts/callable/strictweakorder.compile.pass.cpp

82 ↗

(On Diff #331625)

Commented out tests?

[cjdb]

fixes out of date thing

[cjdb]

libcxx/test/std/concepts/callable/equiv.compile.pass.cpp

25 ↗

(On Diff #328363)

I'm not interested in arguing over whitespace. Once clang-format handles concepts properly, I'll remove the more offensive // clang-format off.

88 ↗

(On Diff #328363)

They're INFDR, and I want to document that they're not forgotten. See http://eel.is/c++draft/res.on.requirements.

[zoecarver]

libcxx/test/std/concepts/callable/functions.h

27–28 ↗

(On Diff #328363)

@Quuxplusone why do you want to remove noexcept?

[• Quuxplusone]

libcxx/test/std/concepts/callable/functions.h

27–28 ↗

(On Diff #328363)

Well, I'm always on the side of "keep it simple/short." Nothing in C++ cares about whether your conversion-to-bool operator is noexcept, so there's no reason to make it noexcept. (Also, it'll rarely if ever be noexcept in real-world code, so one could argue that testing shorter code is also testing more realistic code.)

[zoecarver]

libcxx/test/std/concepts/callable/equiv.compile.pass.cpp

88 ↗

(On Diff #328363)

There's no other place that we'd say, "here are all the ways we can get this to compile with incorrect semantics." Your comment with Relation::Greater doesn't make sense because it's not reflexive, transitive, or symmetric. If we had some way to test that Relation::Greater didn't model equivalence_relation, that would make sense, but, because this is purely semantic, we can't do that.

I don't think it's a bad idea to clarify that these relations haven't been forgotten and have instead been explicitly omitted. But, I think the comment could be more clear/concise about it. I think you should either put a comment at the top (like you have) stating that these relations are explicitly not tested, or update the comments to say NotEquivalenceRelation or !std::equivalence_relation so it's clear that they're semantically not equivalence relations.

[zoecarver]

libcxx/test/std/concepts/callable/functions.h

27–28 ↗

(On Diff #328363)

Fair enough. FWIW I don't feel strongly one way or another about the noexcept.

[cjdb]

libcxx/test/std/concepts/callable/equiv.compile.pass.cpp

88 ↗

(On Diff #328363)

@zoecarver I'm confused about whether or not you're saying what's present is sufficient, or if you'd like something else.

libcxx/test/std/concepts/callable/functions.h

27–28 ↗

(On Diff #328363)

There is no conceivable library bug that could cause us to treat int Value = false; and int Value = 0; any differently.

That appears to have been integrated (I don't recall whether I meant bool Value or int Value, but the point is moot either way).

I was referring to the suggested addition of explicit, which is not desirable, since __boolean_testable requires Bool to be both implicitly and explicitly convertible.

Well, I'm always on the side of "keep it simple/short."

I don't think noexcept changes this in either direction.

Also, it'll rarely if ever be noexcept in real-world code, so one could argue that testing shorter code is also testing more realistic code.

Citation needed. I certainly apply noexcept to everything that's conceivable.

[cjdb]

reboots testing for this patch

[• Quuxplusone]

Generally looks good!

libcxx/test/std/concepts/concepts.callable/concepts.equiv/equivalence_relation.pass.cpp

18–24

So bool(...) is always a relation but bool (*)(...) is never a relation? ;)

libcxx/test/std/concepts/concepts.callable/concepts.equiv/equivalence_relation.subsumption.pass.cpp

28

IIUC, the point of this test is that equivalence_relation<F&, T, U> subsumes relation<F&, T, U>.
Is it also mandated that relation<F&, T, U> subsumes equivalence_relation<F&, T, U>? (I think it is.) If so, let's add a test for that.
I'd like to remove those redundant ampersands at the same time — i.e., change F& to F everywhere it appears, unless the & is significant.

I would also like to see a test that equivalence_relation<F, T, U> [subsumes|does not subsume] equivalence_relation<F, T, T>.

libcxx/test/std/concepts/concepts.callable/concepts.predicate/predicate.pass.cpp

31

Here I do think it's worth testing std::predicate<int (S::*)(), S&> as well.

43

Here it's worth testing !std::predicate<const Predicate, int, double, char>.

libcxx/test/std/concepts/concepts.callable/concepts.predicate/predicate.subsumption.pass.cpp

44

This test confuses me. I think you're saying "a regular-invocable callable whose return value is not convertible to bool, is not a predicate; here is an example." However, that doesn't really have anything to do with subsumption, right? The second overload (lines 21–28) simply drops out of overload resolution entirely because it's not viable. Also, line 41 could be deleted from this test and nothing would change — the existence of that explicit conversion to bool doesn't matter to the test.

I recommend deleting lines 40–43, and just making sure you have the equivalent of
static_assert(!std::predicate<explicit_bool()>) in predicate.pass.cpp. Arguably even better, add the __boolean_testable tests requested by @Mordante, and make sure that !std::__boolean_testable<explicit_bool>. (But that would be a libcxx/-only test, so maybe you'd want to keep the test for !std::predicate<explicit_bool()> as well, for the benefit of people testing non-libc++ libraries against the libc++ test suite.)

libcxx/test/std/concepts/concepts.callable/concepts.relation/relation.subsumption.pass.cpp

25

Again I'm confused by the 5 redundant &s in this file. I recommend removing them (unless that makes the test fail, in which case I'd want to know why).

[Mordante]

LGTM, approved so @Quuxplusone can give his final approval after addressing his comments.

[cjdb]

applies all of @Quuxplusone's feedback (please confirm nothing was missed)

[cjdb]

libcxx/test/std/concepts/concepts.callable/concepts.predicate/predicate.pass.cpp

43

Wow, I didn't even realise I left off the const.

libcxx/test/std/concepts/concepts.callable/concepts.predicate/predicate.subsumption.pass.cpp

44

However, that doesn't really have anything to do with subsumption, right?

Good point, moved.

Also, line 41 could be deleted from this test and nothing would change — the existence of that explicit conversion to bool doesn't matter to the test.

It does, because the "don't directly test the implementation detail" model of testing I follow requires I check that the result of the invocable has a return type that satisfies convertible_to<bool> (as opposed to something conceptifying just is_convertible_v<bool>). However, ...

Arguably even better, add the __boolean_testable tests requested by @Mordante, and make sure that !std::__boolean_testable<explicit_bool>. (But that would be a libcxx/-only test, so maybe you'd want to keep the test for !std::predicate<explicit_bool()> as well, for the benefit of people testing non-libc++ libraries against the libc++ test suite.)

...I'm not a fan of adding tests for implementation details, but if we've got a history of doing this in libcxx/test/libcxx/, I'll make a separate patch for that before signing off on P0898. @ldionne which would you prefer?

libcxx/test/std/concepts/concepts.callable/concepts.relation/relation.subsumption.pass.cpp

25

This might be a relic from the Ranges TS. I didn't look too hard, but I can't find any mention of the & in standard wording, but this was a thing way back when. I've deleted them across all files (please check this).

[• Quuxplusone]

libcxx/include/concepts

419

Gratuitous removal of one space character here

libcxx/test/std/concepts/concepts.callable/concepts.equiv/equivalence_relation.subsumption.pass.cpp

22–24

I don't think you ever use this overload, do you? (Notice that it takes only two template parameters, not three.)

I recommend avoiding overload sets as much as possible (in real life as well as in libc++ tests ;))

53

This template is never used.

[• Quuxplusone]

libcxx/test/std/concepts/concepts.callable/concepts.strictweakorder/strict_weak_order.pass.cpp

29

FWIW, I have no idea what this assertion is testing. It's asking whether you can use a pointer-to-data-member as a callable, passing it an S1* and nullptr, and get back a boolean answer? Isn't the answer obviously "no"?

Vice versa, it occurs to me that

static_assert(std::relation<bool (S::*)(S*), S*, S*>);
static_assert(std::relation<bool (S::*)(S&), S&, S&>);

might be considered non-obvious.

libcxx/test/std/concepts/concepts.callable/concepts.strictweakorder/strict_weak_order.subsumption.pass.cpp

18–24

Two instances of F& that could be F, here.
(Also, I'd prefer to see you remove the gratuituous clang-format comments; they don't add anything.)

[cjdb]

applies most of @Quuxplusone's feedback

[cjdb]

libcxx/test/std/concepts/concepts.callable/concepts.strictweakorder/strict_weak_order.pass.cpp

29

Agreed on both counts, changed in all three files.

libcxx/test/std/concepts/concepts.callable/concepts.strictweakorder/strict_weak_order.subsumption.pass.cpp

18–24

Two instances of F& that could be F, here.

Thanks for checking, I had a feeling I'd missed a couple.

(Also, I'd prefer to see you remove the gratuituous clang-format comments; they don't add anything.)

On the contrary; without disabling, the formatting becomes

template <class F, class T, class U>
requires std::relation<F, T, U> [[nodiscard]] constexpr bool
check_subsumption() {
  return false;
}

template <class F, class T, class U>
    requires std::strict_weak_order<F, T, U> &&
    true [[nodiscard]] constexpr bool check_subsumption() {
  return true;
}

which is not only unreadable: it's inconsistent.

clang-format doesn't properly understand requires-clauses. Once it does, I'll go back and erase all the clang-format off/clang-format on guards in this corner of testing.

[cjdb]

missed a few de-ampersandifications

[zoecarver]

This LGTM. I like these tests a lot better :)

Only question: why do we need a separate test file for "subsumption" tests? WDYT about merging those into the "main" test file?

libcxx/include/concepts

402

Do we need to update the synopsis with these?

[cjdb]

In D96477#2666439, @zoecarver wrote:

This LGTM. I like these tests a lot better :)

Only question: why do we need a separate test file for "subsumption" tests? WDYT about merging those into the "main" test file?

I plan to go back at some point and add subsumption tests for all concepts. I think there are quite a few that would benefit from being in their own source files for brevity's sake, and wanna keep that consistent.
Consider this a pilot?

libcxx/include/concepts

402

I added these in the very first <concepts> commit (which is different to how I'm doing things for <iterator> and <ranges>). Unless there's some divergence between synopsis and code that you're pointing out that I'm missing?

[cjdb]

updates status paper

[zoecarver]

I plan to go back at some point and add subsumption tests for all concepts. I think there are quite a few that would benefit from being in their own source files for brevity's sake, and wanna keep that consistent.
Consider this a pilot?

As discussed offline, I'm OK a) with these tests and b) with doing them in another file.

Just for the sake of posterity: in general, I don't like tests that say "here is the implementation re-written exactly the same way, assert these two implementations look the same." That's what I thought this was at first (and there's an argument to be made that it is still that to a certain degree), but I think it's OK here because the constraints need to be entirely identical. Essentially what we're testing is that std::relation (for example) is implemented using std::predicate and not some helper concept that looks exactly like std::predicate.

I'll let @Quuxplusone give the final approval.

libcxx/include/concepts

402

Ah, missed that. This looks good then.

[• Quuxplusone]

Line 429/447 still contains a gratuitous whitespace diff.

I suggest fixing that space, then removing the .subsumption.pass.cpp tests from this PR, then landing it.
I think it would be reasonable to take the subsumption tests (with my suggested approach above) into a fresh PR.

libcxx/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.pass.cpp

17 ↗

(On Diff #334986)

I would strongly prefer to see as much of the "cruft" removed from this test as possible, so that we could have a bunch of subsumption tests. The extreme form of that would be to use the SUBSUMES macro from https://quuxplusone.github.io/blog/2018/09/23/member-concepts-ii/ . But I think we should actually do more like
https://godbolt.org/z/51edrGrM8

bool model(int, int) { return true; }

constexpr bool relation_subsumes_predicate(std::relation auto) requires true { return true; }
constexpr void relation_subsumes_predicate(std::predicate auto) { }
static_assert( relation_subsumes_predicate(model) );

in a single .compile.fail.cpp file, so that we can verify easily also when a subsumption relationship does not exist.

If anyone knows a clever way to detect non-subsumption in a .compile.pass.cpp test, ping me in #meta-programming or something. ;)

[cjdb]

In D96477#2666733, @Quuxplusone wrote:

Line 429/447 still contains a gratuitous whitespace diff.

I suggest fixing that space, then removing the .subsumption.pass.cpp tests from this PR, then landing it.
I think it would be reasonable to take the subsumption tests (with my suggested approach above) into a fresh PR.

I don't see why this is blocking.

We should have a discussion on Discord to address this suggested approach because I don't understand why you consider it to be "better", but it can be landed in a future patch at any time if we agree on that path.
I don't like the idea of removing coverage that shows something is working.

libcxx/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.pass.cpp

17 ↗

(On Diff #334986)

I would strongly prefer to see as much of the "cruft" removed from this test as possible, so that we could have a bunch of subsumption tests.

It's not exactly clear to me what "cruft" you're referring to.

[cjdb]

rebases to activate CI

[• Quuxplusone]

libcxx/docs/Cxx2aStatusPaperStatus.csv

79 ↗

(On Diff #335175)

Should this say "13.0"?

libcxx/include/concepts

419

Please take the edit before landing.

libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.pass.cpp

22–24 ↗

(On Diff #335175)

This template-of-two-parameters is never used. Please remove it from this patch.

51–53 ↗

(On Diff #335175)

This template check_no_subsumption is never used. Please remove it from this patch.

libcxx/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.pass.cpp

17 ↗

(On Diff #334986)

It's not exactly clear to me what "cruft" you're referring to.

For the record: // clang-format off, [[nodiscard]], // clang-format on... Basically anything that doesn't appear in the three-line version I posted above. (I'd even prefer to find a way to eliminate constexpr, but I don't think that's feasible.)

[cjdb]

changes incorrect version from 14.0 to 13.0 and renames incorrectly-named overload

[cjdb]

This patch has been open for almost two months now, so if there's nothing else that urgently needs attention, I'd like to see it merged today.

libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.pass.cpp

22–24 ↗

(On Diff #335175)

This was added at your request. Please confirm you understand what you're asking to be removed (or provide a technical argument explaining why it doesn't meet the conditions of your original request), and I'll remove it between libc++ approval and pushing to main.

51–53 ↗

(On Diff #335175)

In order for subsumption to be checked, one must have overloads to choose from. I've renamed it to check_reverse_subsumption instead of deleting.

[• Quuxplusone]

As I said on Discord, there's nothing here that can't be "fixed in post." We use version control; it's easy to make changes to what's been committed. So since I'm the only one still reviewing this patch, okay, go ahead, I take no further responsibility for its correctness. If @ldionne or anyone else objects to my resigning as reviewer on this revision, they can step in and review it themselves.

libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.pass.cpp

22–24 ↗

(On Diff #335175)

Look, you agree that this two-argument function template is never a candidate in any of the calls below, and is therefore useless, right?

And I did not request that you add a useless function template that was never a candidate, right? I suggested that you should add a test that "equivalence_relation<F, T, U> [subsumes|does not subsume] equivalence_relation<F, T, T>." You haven't done that.

[ldionne]

LGTM with nitpick applied.

Until we enforce the use of clang-format, please consider format-related comments as non-blocking, unless not fixing them really hinders the readability of the code.

libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.pass.cpp

22 ↗

(On Diff #335274)

I agree, I think this can be removed since it's never used (unless I'm missing something).

[cjdb]

corrects self-subsumption test

[cjdb]

libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.pass.cpp

22 ↗

(On Diff #335274)

I made a mistake here by forgetting to preserve the third type parameter. I think the most appropriate thing to do here is to fix my error, not to remove the test.
Fix applied everywhere (generalisation courtesy of @rsmith).

PTAL.

[curdeius]

libcxx/include/concepts

70–72

Please rename this concept in synopsis (it's already renamed in the implementation) to default_initializable. I let you choose in which patch (or non-patch NFC commit) you do it.

[curdeius]

libcxx/include/concepts

83–86

Also, concept boolean is not present in the standard. Please remove it from the synopsis.

[ldionne]

Ship it with nitpicks applied. Feel free to fix @curdeius 's nitpicks in this patch too as fly-by's, those are really small.

libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.compile.pass.cpp

78 ↗

(On Diff #335364)

iteself -> itself? There's a few other occurrences of that in other test files.

libcxx/include/concepts

namespace std {
   // [concept.destructible], concept destructible
   template<class T>
     concept destructible = see below;
 
   // [concept.constructible], concept constructible_from
   template<class T, class... Args>
     concept constructible_from = see below;
 
   // [concept.defaultconstructible], concept default_constructible
   template<class T>
     concept default_constructible = see below;
 
   // [concept.moveconstructible], concept move_constructible
   template<class T>
     concept move_constructible = see below;
 
   // [concept.copyconstructible], concept copy_constructible
   template<class T>
     concept copy_constructible = see below;
 
   // [concepts.compare], comparison concepts
   // [concept.boolean], concept boolean
   template<class B>
     concept boolean = see below;
 
   // [concept.equalitycomparable], concept equality_comparable
   template<class T>
     concept equality_comparable = see below;
   template<class T, class U>
     concept equality_comparable_with = see below;
 
   // [concept.totallyordered], concept totally_ordered
   template<class T>

 
 // [concept.copyconstructible]
 template<class _Tp>
 concept copy_constructible =
   move_constructible<_Tp> &&
   constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
   constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
   constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
 
 // [concept.swappable]
 namespace ranges::__swap {
   // Deleted to inhibit ADL
   template<class _Tp>
   void swap(_Tp&, _Tp&) = delete;
 
   template<class _Tp>
   concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;
 
   // [1]
   template<class _Tp, class _Up>
   concept __unqualified_swappable_with =
     (__class_or_enum<remove_cvref_t<_Tp>> || __class_or_enum<remove_cvref_t<_Up>>) &&
     requires(_Tp&& __t, _Up&& __u) {
       swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
     };

 concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
   _VSTD::invoke(_VSTD::forward<_Fn>(__fn), _VSTD::forward<_Args>(__args)...); // not required to be equality preserving
 };
 
 // [concept.regular.invocable]
 template<class _Fn, class... _Args>
 concept regular_invocable = invocable<_Fn, _Args...>;
 
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+// [concept.predicate]
+template<class _Fn, class... _Args>
+concept predicate =
+  regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>;
+
+// [concept.relation]
+template<class _Rp, class _Tp, class _Up>
+concept relation =
+  predicate<_Rp, _Tp, _Tp> && predicate<_Rp, _Up, _Up> &&
+  predicate<_Rp, _Tp, _Up> && predicate<_Rp, _Up, _Tp>;
+
+// [concept.equiv]
+template<class _Rp, class _Tp, class _Up>
+concept equivalence_relation = relation<_Rp, _Tp, _Up>;
+
+// [concept.strictweakorder]
+template<class _Rp, class _Tp, class _Up>
+concept strict_weak_order = relation<_Rp, _Tp, _Up>;
+#endif //_LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CONCEPTS

libcxx/test/std/concepts/concepts.callable/concepts.equiv/equivalence_relation.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class F, class... Args>
+// concept equivalence_relation;
+
+#include <concepts>
+
+static_assert(std::equivalence_relation<bool(int, int), int, int>);
+static_assert(std::equivalence_relation<bool(int, int), double, double>);
+static_assert(std::equivalence_relation<bool(int, double), double, double>);
+
+static_assert(!std::equivalence_relation<bool (*)(), int, double>);
+static_assert(!std::equivalence_relation<bool (*)(int), int, double>);
+static_assert(!std::equivalence_relation<bool (*)(double), int, double>);
+
+static_assert(
+    !std::equivalence_relation<bool(double, double*), double, double*>);
+static_assert(!std::equivalence_relation<bool(int&, int&), double&, double&>);
+
+struct S1 {};
+static_assert(!std::equivalence_relation<int S1::*, S1*, std::nullptr_t>);
+
+struct S2 {};
+
+struct P1 {
+  bool operator()(S1, S1) const;
+};
+static_assert(std::equivalence_relation<P1, S1, S1>);
+
+struct P2 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+};
+static_assert(!std::equivalence_relation<P2, S1, S2>);
+
+struct P3 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+};
+static_assert(!std::equivalence_relation<P3, S1, S2>);
+
+struct P4 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+static_assert(std::equivalence_relation<P4, S1, S2>);
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.callable/concepts.equiv/equivalence_relation.subsumption.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class F, class... Args>
+// concept equivalence_relation;
+
+#include <concepts>
+
+// clang-format off
+template<class F, class T, class U>
+requires std::relation<F, T, U>
+[[nodiscard]] constexpr bool check_subsumption() { return false; }
+
+template<class F, class T>
+requires std::equivalence_relation<F, T, T> && true
+[[nodiscard]] constexpr bool check_subsumption() { return false; }
+
+template<class F, class T, class U>
+requires std::equivalence_relation<F, T, U> && true
+[[nodiscard]] constexpr bool check_subsumption() { return true; }
+// clang-format on
+
+static_assert(check_subsumption<int (*)(int, int), int, int>());
+static_assert(check_subsumption<int (*)(int, double), int, double>());
+
+struct S1 {};
+struct S2 {};
+
+struct R {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+static_assert(check_subsumption<R, S1, S1>());
+static_assert(check_subsumption<R, S1, S2>());
+
+// clang-format off
+template<class F, class T, class U>
+requires std::relation<F, T, U> && true
+[[nodiscard]] constexpr bool check_reverse_subsumption() { return true; }
+
+template<class F, class T, class U>
+requires std::equivalence_relation<F, T, U>
+[[nodiscard]] constexpr bool check_no_subsumption() { return false; }
+// clang-format on
+
+static_assert(check_reverse_subsumption<int (*)(int, int), int, int>());
+static_assert(check_reverse_subsumption<int (*)(int, double), int, double>());
+static_assert(check_reverse_subsumption<R, S1, S1>());
+static_assert(check_reverse_subsumption<R, S1, S2>());
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.callable/concepts.predicate/predicate.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class F, class... Args>
+// concept predicate;
+
+#include <concepts>
+
+static_assert(std::predicate<bool()>);
+static_assert(std::predicate<bool (*)()>);
+static_assert(std::predicate<bool (&)()>);
+
+static_assert(!std::predicate<void()>);
+static_assert(!std::predicate<void (*)()>);
+static_assert(!std::predicate<void (&)()>);
+
+struct S {};
+
+static_assert(!std::predicate<S(int), int>);
+static_assert(!std::predicate<S(double), double>);
+static_assert(std::predicate<int S::*, S*>);
+static_assert(std::predicate<int (S::*)(), S*>);
+static_assert(std::predicate<int (S::*)(), S&>);
+static_assert(!std::predicate<void (S::*)(), S*>);
+static_assert(!std::predicate<void (S::*)(), S&>);
+
+static_assert(!std::predicate<bool(S)>);
+static_assert(!std::predicate<bool(S&), S>);
+static_assert(!std::predicate<bool(S&), S const&>);
+static_assert(std::predicate<bool(S&), S&>);
+
+struct Predicate {
+  bool operator()(int, double, char);
+};
+static_assert(std::predicate<Predicate, int, double, char>);
+static_assert(std::predicate<Predicate&, int, double, char>);
+static_assert(!std::predicate<const Predicate, int, double, char>);
+static_assert(!std::predicate<const Predicate&, int, double, char>);
+
+[[nodiscard]] constexpr bool check_lambda(auto) { return false; }
+
+[[nodiscard]] constexpr bool check_lambda(std::predicate auto) { return true; }
+
+static_assert(check_lambda([] { return std::true_type(); }));
+static_assert(check_lambda([]() -> int* { return nullptr; }));
+
+struct boolean {
+  operator bool() const noexcept;
+};
+static_assert(check_lambda([] { return boolean(); }));
+
+struct explicit_bool {
+  explicit operator bool() const noexcept;
+};
+static_assert(!check_lambda([] { return explicit_bool(); }));
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.callable/concepts.predicate/predicate.subsumption.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class F, class... Args>
+// concept predicate;
+
+#include <concepts>
+
+[[nodiscard]] constexpr bool check_subsumption(std::regular_invocable auto) {
+  return false;
+}
+
+// clang-format off
+template<class F>
+requires std::predicate<F> && true
+[[nodiscard]] constexpr bool check_subsumption(F)
+{
+  return true;
+}
+// clang-format on
+
+static_assert(!check_subsumption([] {}));
+static_assert(check_subsumption([] { return true; }));
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.callable/concepts.relation/relation.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class F, class... Args>
+// concept relation;
+
+#include <concepts>
+
+static_assert(std::relation<bool(int, int), int, int>);
+static_assert(std::relation<bool(int, int), double, double>);
+static_assert(std::relation<bool(int, double), double, double>);
+
+static_assert(!std::relation<bool(), int, double>);
+static_assert(!std::relation<bool(int), int, double>);
+static_assert(!std::relation<bool(double), int, double>);
+static_assert(!std::relation<bool(double, double*), double, double*>);
+static_assert(!std::relation<bool(int&, int&), double&, double&>);
+
+struct S1 {};
+static_assert(!std::relation<int S1::*, S1*, std::nullptr_t>);
+
+struct S2 {};
+
+struct P1 {
+  bool operator()(S1, S1) const;
+};
+static_assert(std::relation<P1, S1, S1>);
+
+struct P2 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+};
+static_assert(!std::relation<P2, S1, S2>);
+
+struct P3 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+};
+static_assert(!std::relation<P3, S1, S2>);
+
+struct P4 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+static_assert(std::relation<P4, S1, S2>);
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.callable/concepts.relation/relation.subsumption.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class F, class... Args>
+// concept relation;
+
+#include <concepts>
+
+// clang-format off
+template<class F, class T, class U>
+requires std::predicate<F&, T, T> && std::predicate<F&, T, U> &&
+         std::predicate<F&, U, T> && std::predicate<F&, U, U>
+[[nodiscard]] constexpr bool check_subsumption() { return false; }
+
+template<class F, class T, class U>
+requires std::relation<F&, T, U> && true
+[[nodiscard]] constexpr bool check_subsumption() { return true; }
+// clang-format on
+
+static_assert(check_subsumption<int (*)(int, double), int, double>());
+
+struct S1 {};
+struct S2 {};
+
+struct R {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+static_assert(check_subsumption<R, S1, S2>());
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.callable/concepts.strictweakorder/strict_weak_order.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class F, class... Args>
+// concept strict_weak_order;
+
+#include <concepts>
+
+static_assert(std::strict_weak_order<bool(int, int), int, int>);
+static_assert(std::strict_weak_order<bool(int, int), double, double>);
+static_assert(std::strict_weak_order<bool(int, double), double, double>);
+
+static_assert(!std::strict_weak_order<bool (*)(), int, double>);
+static_assert(!std::strict_weak_order<bool (*)(int), int, double>);
+static_assert(!std::strict_weak_order<bool (*)(double), int, double>);
+
+static_assert(!std::strict_weak_order<bool(double, double*), double, double*>);
+static_assert(!std::strict_weak_order<bool(int&, int&), double&, double&>);
+
+struct S1 {};
+static_assert(!std::strict_weak_order<int S1::*, S1*, std::nullptr_t>);
+
+struct S2 {};
+
+struct P1 {
+  bool operator()(S1, S1) const;
+};
+static_assert(std::strict_weak_order<P1, S1, S1>);
+
+struct P2 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+};
+static_assert(!std::strict_weak_order<P2, S1, S2>);
+
+struct P3 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+};
+static_assert(!std::strict_weak_order<P3, S1, S2>);
+
+struct P4 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+static_assert(std::strict_weak_order<P4, S1, S2>);
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.callable/concepts.strictweakorder/strict_weak_order.subsumption.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class F, class... Args>
+// concept strict_weak_order;
+
+#include <concepts>
+
+// clang-format off
+template<class F, class T, class U>
+requires std::relation<F&, T, U>
+[[nodiscard]] constexpr bool check_subsumption() { return false; }
+
+template<class F, class T, class U>
+requires std::strict_weak_order<F&, T, U> && true
+[[nodiscard]] constexpr bool check_subsumption() { return true; }
+// clang-format on
+
+static_assert(check_subsumption<int (*)(int, double), int, double>());
+
+struct S1 {};
+struct S2 {};
+
+struct R {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+static_assert(check_subsumption<R, S1, S2>());
+
+int main(int, char**) { return 0; }