[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–12

LAND_ should be removed, nope?

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

96

Nit: newline.

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

104

Newline.

[cjdb]

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

8–12

See @ldionne's request in D96230.

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

96

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

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

104

Done, as above.

[curdeius]

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

8–12

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–12

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

293

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

14

Copy-paste.

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

62

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

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

14

Copy-paste.

[cjdb]

addresses comments by @Mordante and @curdeius

[cjdb]

applies final feedback from @Mordante

libcxx/include/concepts

293

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.)

314

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

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

51

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

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

[cjdb]

rebases because this patch is super old

[cjdb]

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

27–28

No, this is definitely correct as-is.

[• Quuxplusone]

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

27–28

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

83

Commented out tests?

[cjdb]

fixes out of date thing

[cjdb]

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

25

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

88

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

@Quuxplusone why do you want to remove noexcept?

[• Quuxplusone]

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

27–28

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

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

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

@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

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

17–23 ↗

(On Diff #334360)

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

27 ↗

(On Diff #334360)

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

30 ↗

(On Diff #334360)

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

42 ↗

(On Diff #334360)

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

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

43 ↗

(On Diff #334360)

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

24 ↗

(On Diff #334360)

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

42 ↗

(On Diff #334360)

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

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

43 ↗

(On Diff #334360)

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

24 ↗

(On Diff #334360)

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

314

Gratuitous removal of one space character here

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

22–24 ↗

(On Diff #334544)

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 ↗

(On Diff #334544)

This template is never used.

[• Quuxplusone]

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

29 ↗

(On Diff #334544)

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 ↗

(On Diff #334544)

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 ↗

(On Diff #334544)

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 ↗

(On Diff #334544)

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

297

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

297

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

297

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

314

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 default_initializable = constructible_from<_Tp> &&
     requires { _Tp{}; } && __default_initializable<_Tp>;
 
 // [concept.moveconstructible]
 template<class _Tp>
 concept move_constructible =
   constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
 
+// [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.booleantestable]
 template<class _Tp>
 concept __boolean_testable_impl = convertible_to<_Tp, bool>;
 
 template<class _Tp>
 concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
   { !std::forward<_Tp>(__t) } -> __boolean_testable_impl;
 };
concept equality_comparable_with =
   equality_comparable<_Tp> && equality_comparable<_Up> &&
   common_reference_with<const remove_reference_t<_Tp>&, const remove_reference_t<_Up>&> &&
   equality_comparable<
     common_reference_t<
       const remove_reference_t<_Tp>&,
       const remove_reference_t<_Up>&>> &&
   __weakly_equality_comparable_with<_Tp, _Up>;
 
-// [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.invocable]
 template<class _Fn, class... _Args>
 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(__cpp_concepts) && __cpp_concepts >= 201811L
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CONCEPTS

libcxx/test/std/concepts/callable/equiv.compile.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 T, class U>
+// concept equivalence_relation;
+
+#include <concepts>
+#include <functional>
+#include <memory>
+#include <random>
+#include <type_traits>
+
+#include "functions.h"
+
+// clang-format off
+template <class F, class T, class U>
+requires std::equivalence_relation<F, T, U>
+constexpr void ModelsEquivalenceRelation(F, T&&, U&&) noexcept {}
+
+template <class F, class T, class U>
+requires(!std::equivalence_relation<F, T, U>)
+constexpr void NotEquivalenceRelation(F, T&&, U&&) noexcept {}
+// clang-format on
+
+static_assert(!std::equivalence_relation<void, int, int>);
+static_assert(!std::equivalence_relation<void*, void, int>);
+static_assert(!std::equivalence_relation<const void*, void, int>);
+static_assert(!std::equivalence_relation<int, int, int>);
+static_assert(!std::equivalence_relation<const int, int, int>);
+static_assert(!std::equivalence_relation<int&, bool, int>);
+static_assert(!std::equivalence_relation<const int&, bool, int>);
+static_assert(!std::equivalence_relation<int&&, double, void>);
+static_assert(!std::equivalence_relation<const int&&, double, void>);
+static_assert(!std::equivalence_relation<int[10], double, void>);
+
+int main(int, char**) {
+  // The difference between `std::relation` and `std::equivalence_relation` is
+  // purely semantic. Tests that are commented out with /// satisfy
+  // `std::equivalence_relation`, but don't model the semantic requirements.
+  // They're kept here for informational purposes only.
+  {
+    using RegularInvocable::A;
+    NotEquivalenceRelation(&A::F, 0, 0);
+    NotEquivalenceRelation(&A::G, 0, 0);
+    NotEquivalenceRelation(RegularInvocable::F, 0, 0);
+    NotEquivalenceRelation(RegularInvocable::G, 0, 0);
+
+    {
+      auto Up = std::make_unique<A>();
+      NotEquivalenceRelation(&A::I, Up, 0);
+      NotEquivalenceRelation(&A::F, Up, 0);
+      NotEquivalenceRelation(&A::G, Up, 0);
+      NotEquivalenceRelation(&A::H, Up, 0);
+    }
+    {
+      auto Sp = std::make_shared<A>();
+      NotEquivalenceRelation(&A::I, Sp, 0);
+      NotEquivalenceRelation(&A::F, Sp, 0);
+      NotEquivalenceRelation(&A::G, Sp, 0);
+      NotEquivalenceRelation(&A::H, Sp, 0);
+    }
+    {
+      A X;
+      auto Rw = std::reference_wrapper<A>(X);
+      NotEquivalenceRelation(&A::I, Rw, 0);
+      NotEquivalenceRelation(&A::F, Rw, 0);
+      NotEquivalenceRelation(&A::G, Rw, 0);
+      NotEquivalenceRelation(&A::H, Rw, 0);
+    }
+  }
+
+  {
+    NotEquivalenceRelation(Predicate::L2rSorted(), 0, 0.0);
+    NotEquivalenceRelation(Predicate::NotAPredicate(), 0, 0);
+    ModelsEquivalenceRelation(Predicate::LambdaPredicate, 0, 1.0);
+  }
+  {
+    ModelsEquivalenceRelation(Relation::EqualTo, 0, 0);
+    /// ModelsEquivalenceRelation(Relation::Greater, 0, 0);
+    /// ModelsEquivalenceRelation(Relation::Greater, 0.0, 0);
+    ModelsEquivalenceRelation(Relation::MaybeRelation(), 0, 0);
+    ModelsEquivalenceRelation(Relation::MaybeRelation(), 0, 0.0);
+    ModelsEquivalenceRelation(Relation::MaybeRelation(), 0.0, 0);
+    NotEquivalenceRelation(Relation::MaybeRelation(), 0,
+                           Predicate::LambdaPredicate);
+    NotEquivalenceRelation(Relation::MaybeRelation(),
+                           Predicate::LambdaPredicate, 0);
+
+    ModelsEquivalenceRelation(Relation::Equivalent(), 0, 10L);
+    ModelsEquivalenceRelation(Relation::Equivalent(), 0, 1.0L);
+    /// ModelsEquivalenceRelation(Relation::Less(), 0, 10L);
+    /// ModelsEquivalenceRelation(Relation::Less(), 0, 1.0L);
+
+    const Relation::MaybeRelation StillARelation;
+    ModelsEquivalenceRelation(StillARelation, 0, 0);
+  }
+  return 0;
+}

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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
-#ifndef CALLABLE_FUNCTIONS_H
-#define CALLABLE_FUNCTIONS_H
+#ifndef TEST_STD_CONCEPTS_CALLABLE_FUNCTIONS_H
+#define TEST_STD_CONCEPTS_CALLABLE_FUNCTIONS_H
+
+#include <memory>
+#include <type_traits>
 
 namespace RegularInvocable {
 struct A {
   int I = 13;
   constexpr int F() const noexcept { return 42; }
   constexpr int G(int X) { return 2 * X + 1; }
   constexpr int H(int J) && { return I * J; }
 };
 
 constexpr int F() noexcept { return 13; }
 constexpr int G(int I) { return 2 * I + 1; }
 } // namespace RegularInvocable
 
+struct Bool {
+  int Value = false;
+  constexpr operator bool() const noexcept { return Value; }
+};
 namespace Predicate {
 struct L2rSorted {
   template <class T>
   constexpr bool operator()(T const& A, T const& B, T const& C) const noexcept {
     return A <= B && B <= C;
   }
 };
 
+struct L2rSortedWithBooleanTestable {
+  constexpr Bool AlwaysTrue() const noexcept { return Bool(); }
+};
 struct NotAPredicate {
   void operator()() const noexcept {}
+  void operator()(int, int) const noexcept {}
 };
+
+inline constexpr auto LambdaPredicate = [](int, double) {
+  return std::true_type();
+};
+inline constexpr auto ReturnsConvertibleToBool = [] { return LambdaPredicate; };
+inline constexpr auto ReturnsNotAPredicate = [] { return NotAPredicate(); };
 } // namespace Predicate
 
 namespace Relation {
-int Greater(int X, int Y) noexcept { return X > Y; }
+constexpr double EqualTo(long long X, long long Y) noexcept { return X == Y; }
+constexpr int Greater(int X, int Y) noexcept { return X > Y; }
+
+struct MaybeRelation {
+  Bool operator()(int, auto) { return {}; }
+};
+
+struct Equivalent {
+  int* operator()(int X, long Y) const noexcept {
+    static int Result = 0;
+    return X == Y ? &Result : nullptr;
+  }
+};
+
+struct Less {
+  bool operator()(int X, long Y) const noexcept { return X < Y; }
+};
 } // namespace Relation
 
-#endif // CALLABLE_FUNCTIONS_H
+#endif // TEST_STD_CONCEPTS_CALLABLE_FUNCTIONS_H

libcxx/test/std/concepts/callable/invocable.compile.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 T, class U>
+// template<class F, class... Args>
 // concept invocable;
 
 #include <chrono>
 #include <concepts>
 #include <memory>
 #include <random>
 #include <type_traits>
 
int main(int, char**) {
     }
     {
       auto Sp = std::make_shared<A>();
       ModelsInvocable(&A::I, Sp);
       ModelsInvocable(&A::F, Sp);
       ModelsInvocable(&A::G, Sp, 0);
       NotInvocable(&A::H, Sp, 0);
     }
+    {
+      A X;
+      auto Rw = std::reference_wrapper<A>(X);
+      ModelsInvocable(&A::I, Rw);
+      ModelsInvocable(&A::F, Rw);
+      ModelsInvocable(&A::G, Rw, 0);
+      NotInvocable(&A::H, Rw, 0);
+    }
   }
   {
     using namespace Predicate;
     {
       ModelsInvocable(L2rSorted{}, 0, 1, 2);
       NotInvocable(L2rSorted{});
       NotInvocable(L2rSorted{}, 0);
       NotInvocable(L2rSorted{}, 0, 1);
     }
     {
       auto Up = std::make_unique<L2rSorted>();
       ModelsInvocable(&L2rSorted::operator()<int>, Up, 0, 1, 2);
       NotInvocable(&L2rSorted::operator()<int>, Up);
       NotInvocable(&L2rSorted::operator()<int>, Up, 0);
       NotInvocable(&L2rSorted::operator()<int>, Up, 0, 1);
     }
     {
       auto Sp = std::make_shared<L2rSorted>();
       ModelsInvocable(&L2rSorted::operator()<int>, Sp, 0, 1, 2);
       NotInvocable(&L2rSorted::operator()<int>, Sp);
       NotInvocable(&L2rSorted::operator()<int>, Sp, 0);
       NotInvocable(&L2rSorted::operator()<int>, Sp, 0, 1);
     }
+    {
+      L2rSorted X;
+      auto Rw = std::reference_wrapper<L2rSorted>(X);
+      ModelsInvocable(&L2rSorted::operator()<int>, Rw, 0, 1, 2);
+      NotInvocable(&L2rSorted::operator()<int>, Rw, 0);
+    }
+  }
+  {
+    ModelsInvocable(Relation::Greater, 0, 0);
+    ModelsInvocable(Relation::Greater, 0, 0.0);
+    ModelsInvocable(Relation::MaybeRelation(), 0, Predicate::LambdaPredicate);
+    NotInvocable(Relation::MaybeRelation(), Predicate::LambdaPredicate, 0);
   }
   {
     auto G = std::mt19937_64(
         std::chrono::high_resolution_clock().now().time_since_epoch().count());
     auto D = std::uniform_int_distribution<>();
     ModelsInvocable(D, G);
   }
   return 0;
 }

libcxx/test/std/concepts/callable/predicate.compile.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>
+#include <functional>
+#include <memory>
+#include <random>
+#include <type_traits>
+
+#include "functions.h"
+
+// clang-format off
+template <class F, class... Args>
+requires std::predicate<F, Args...>
+constexpr void ModelsPredicate(F, Args&&...) noexcept {}
+
+template <class F, class... Args>
+requires(!std::predicate<F, Args...>)
+constexpr void NotPredicate(F, Args&&...) noexcept {}
+// clang-format on
+
+static_assert(!std::predicate<void>);
+static_assert(!std::predicate<void*>);
+static_assert(!std::predicate<int>);
+static_assert(!std::predicate<int&>);
+static_assert(!std::predicate<int&&>);
+
+int main(int, char**) {
+  {
+    using RegularInvocable::A;
+    A X;
+    ModelsPredicate(&A::F, X);
+    ModelsPredicate(&A::G, X, 0);
+
+    NotPredicate(&A::G, X);
+    NotPredicate(&A::G, 0);
+    NotPredicate(&A::H);
+    {
+      auto Sp = std::make_shared<A>();
+      ModelsPredicate(&A::I, Sp);
+      ModelsPredicate(&A::F, Sp);
+      ModelsPredicate(&A::G, Sp, 0);
+      NotPredicate(&A::H, Sp, 0);
+    }
+  }
+  {
+    using Predicate::L2rSorted;
+    L2rSorted Pred;
+    ModelsPredicate(Pred, 0, 0, 0);
+    NotPredicate(Pred, 0);
+    NotPredicate(Pred, 0, 1);
+
+    using Predicate::NotAPredicate;
+    NotPredicate(NotAPredicate());
+
+    using Predicate::L2rSortedWithBooleanTestable;
+    L2rSortedWithBooleanTestable L2rBT;
+    ModelsPredicate(&L2rSortedWithBooleanTestable::AlwaysTrue, L2rBT);
+
+    ModelsPredicate(Predicate::LambdaPredicate, 42, -0.0);
+    ModelsPredicate(Predicate::ReturnsConvertibleToBool);
+    NotPredicate(Predicate::ReturnsConvertibleToBool, -42);
+    NotPredicate(Predicate::ReturnsNotAPredicate);
+
+    {
+      auto Up = std::make_unique<L2rSortedWithBooleanTestable>();
+      ModelsPredicate(&L2rSortedWithBooleanTestable::AlwaysTrue, Up);
+      NotPredicate(&L2rSortedWithBooleanTestable::AlwaysTrue, Up, 0);
+    }
+    {
+      auto Rw = std::reference_wrapper<L2rSorted>(Pred);
+      ModelsPredicate(&L2rSorted::operator()<int>, Rw, 0, 1, 2);
+      NotPredicate(&L2rSorted::operator()<int>, Rw);
+      NotPredicate(&L2rSorted::operator()<int>, Rw, 0);
+      NotPredicate(&L2rSorted::operator()<int>, Rw, 0, 1);
+    }
+  }
+
+  ModelsPredicate(Relation::Greater, 0, 0);
+  ModelsPredicate(Relation::Greater, 0, 0.0);
+  ModelsPredicate(Relation::MaybeRelation(), 0, Predicate::LambdaPredicate);
+  NotPredicate(Relation::MaybeRelation(), Predicate::LambdaPredicate, 0);
+  return 0;
+}

libcxx/test/std/concepts/callable/regularinvocable.compile.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 T, class U>
+// template<class F, class... Args>
 // concept regular_invocable;
 
 #include <concepts>
 #include <memory>
 #include <random>
 #include <type_traits>
 
 #include "functions.h"
int main(int, char**) {
     }
     {
       auto Sp = std::make_shared<A>();
       ModelsRegularInvocable(&A::I, Sp);
       ModelsRegularInvocable(&A::F, Sp);
       ModelsRegularInvocable(&A::G, Sp, 0);
       NotRegularInvocable(&A::H, Sp, 0);
     }
+    {
+      A X;
+      auto Rw = std::reference_wrapper<A>(X);
+      ModelsRegularInvocable(&A::I, Rw);
+      ModelsRegularInvocable(&A::F, Rw);
+      ModelsRegularInvocable(&A::G, Rw, 0);
+      NotRegularInvocable(&A::H, Rw, 0);
+    }
   }
   {
     using namespace Predicate;
     {
       ModelsRegularInvocable(L2rSorted{}, 0, 1, 2);
       NotRegularInvocable(L2rSorted{});
       NotRegularInvocable(L2rSorted{}, 0);
       NotRegularInvocable(L2rSorted{}, 0, 1);
     }
     {
       auto Up = std::make_unique<L2rSorted>();
       ModelsRegularInvocable(&L2rSorted::operator()<int>, Up, 0, 1, 2);
       NotRegularInvocable(&L2rSorted::operator()<int>, Up);
       NotRegularInvocable(&L2rSorted::operator()<int>, Up, 0);
       NotRegularInvocable(&L2rSorted::operator()<int>, Up, 0, 1);
     }
     {
       auto Sp = std::make_shared<L2rSorted>();
       ModelsRegularInvocable(&L2rSorted::operator()<int>, Sp, 0, 1, 2);
       NotRegularInvocable(&L2rSorted::operator()<int>, Sp);
       NotRegularInvocable(&L2rSorted::operator()<int>, Sp, 0);
       NotRegularInvocable(&L2rSorted::operator()<int>, Sp, 0, 1);
     }
+    {
+      L2rSorted X;
+      auto Rw = std::reference_wrapper<L2rSorted>(X);
+      ModelsRegularInvocable(&L2rSorted::operator()<int>, Rw, 0, 1, 2);
+      NotRegularInvocable(&L2rSorted::operator()<int>, Rw, 0);
+    }
+  }
+  {
+    ModelsRegularInvocable(Relation::Greater, 0, 0);
+    ModelsRegularInvocable(Relation::Greater, 0, 0.0);
+    ModelsRegularInvocable(Relation::MaybeRelation(), 0,
+                           Predicate::LambdaPredicate);
+    NotRegularInvocable(Relation::MaybeRelation(), Predicate::LambdaPredicate,
+                        0);
   }
   // {
   // RNG doesn't model regular_invocable, left here for documentation
   //  auto G = std::mt19937_64(std::random_device()());
   //  auto D = std::uniform_int_distribution<>();
   //  models_invocable(D, G);
   // }
   return 0;
 }

libcxx/test/std/concepts/callable/relation.compile.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 T, class U>
+// concept relation;
+
+#include <concepts>
+#include <functional>
+#include <memory>
+#include <random>
+#include <type_traits>
+
+#include "functions.h"
+
+// clang-format off
+template <class F, class T, class U>
+requires std::relation<F, T, U>
+constexpr void ModelsRelation(F, T&&, U&&) noexcept {}
+
+template <class F, class T, class U>
+requires(!std::relation<F, T, U>)
+constexpr void NotRelation(F, T&&, U&&) noexcept {}
+// clang-format on
+
+static_assert(!std::relation<void, int, int>);
+static_assert(!std::relation<void*, void, int>);
+static_assert(!std::relation<const void*, void, int>);
+static_assert(!std::relation<int, int, int>);
+static_assert(!std::relation<const int, int, int>);
+static_assert(!std::relation<int&, bool, int>);
+static_assert(!std::relation<const int&, bool, int>);
+static_assert(!std::relation<int&&, double, void>);
+static_assert(!std::relation<const int&&, double, void>);
+static_assert(!std::relation<int[10], double, void>);
+
+int main(int, char**) {
+  {
+    using RegularInvocable::A;
+    NotRelation(&A::F, 0, 0);
+    NotRelation(&A::G, 0, 0);
+    NotRelation(RegularInvocable::F, 0, 0);
+    NotRelation(RegularInvocable::G, 0, 0);
+
+    {
+      auto Up = std::make_unique<A>();
+      NotRelation(&A::I, Up, 0);
+      NotRelation(&A::F, Up, 0);
+      NotRelation(&A::G, Up, 0);
+      NotRelation(&A::H, Up, 0);
+    }
+    {
+      auto Sp = std::make_shared<A>();
+      NotRelation(&A::I, Sp, 0);
+      NotRelation(&A::F, Sp, 0);
+      NotRelation(&A::G, Sp, 0);
+      NotRelation(&A::H, Sp, 0);
+    }
+    {
+      A X;
+      auto Rw = std::reference_wrapper<A>(X);
+      NotRelation(&A::I, Rw, 0);
+      NotRelation(&A::F, Rw, 0);
+      NotRelation(&A::G, Rw, 0);
+      NotRelation(&A::H, Rw, 0);
+    }
+  }
+
+  {
+    NotRelation(Predicate::L2rSorted(), 0, 0.0);
+    NotRelation(Predicate::NotAPredicate(), 0, 0);
+    ModelsRelation(Predicate::LambdaPredicate, 0, 1.0);
+  }
+  {
+    ModelsRelation(Relation::EqualTo, 0, 0);
+    ModelsRelation(Relation::Greater, 0, 0);
+    ModelsRelation(Relation::Greater, 0.0, 0);
+    ModelsRelation(Relation::MaybeRelation(), 0, 0);
+    ModelsRelation(Relation::MaybeRelation(), 0, 0.0);
+    ModelsRelation(Relation::MaybeRelation(), 0.0, 0);
+    NotRelation(Relation::MaybeRelation(), 0, Predicate::LambdaPredicate);
+    NotRelation(Relation::MaybeRelation(), Predicate::LambdaPredicate, 0);
+
+    ModelsRelation(Relation::Equivalent(), 0, 10L);
+    ModelsRelation(Relation::Equivalent(), 0, 1.0L);
+    ModelsRelation(Relation::Less(), 0, 10L);
+    ModelsRelation(Relation::Less(), 0, 1.0L);
+
+    const Relation::MaybeRelation StillARelation;
+    ModelsRelation(StillARelation, 0, 0);
+  }
+  return 0;
+}

libcxx/test/std/concepts/callable/strictweakorder.compile.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 T, class U>
+// concept strict_weak_order;
+
+#include <concepts>
+#include <functional>
+#include <memory>
+#include <random>
+#include <type_traits>
+
+#include "functions.h"
+
+// clang-format off
+template <class F, class T, class U>
+requires std::strict_weak_order<F, T, U>
+constexpr void ModelsStrictWeakOrder(F, T&&, U&&) noexcept {}
+
+template <class F, class T, class U>
+requires(!std::strict_weak_order<F, T, U>)
+constexpr void NotStrictWeakOrder(F, T&&, U&&) noexcept {}
+// clang-format on
+
+static_assert(!std::strict_weak_order<void, int, int>);
+static_assert(!std::strict_weak_order<void*, void, int>);
+static_assert(!std::strict_weak_order<const void*, void, int>);
+static_assert(!std::strict_weak_order<int, int, int>);
+static_assert(!std::strict_weak_order<const int, int, int>);
+static_assert(!std::strict_weak_order<int&, bool, int>);
+static_assert(!std::strict_weak_order<const int&, bool, int>);
+static_assert(!std::strict_weak_order<int&&, double, void>);
+static_assert(!std::strict_weak_order<const int&&, double, void>);
+static_assert(!std::strict_weak_order<int[10], double, void>);
+
+int main(int, char**) {
+  // The difference between `std::relation` and `std::strict_weak_order` is
+  // purely semantic. Tests that are commented out with /// satisfy
+  // `std::strict_weak_order`, but don't model the semantic requirements.
+  // They're kept here for informational purposes only.
+  {
+    using RegularInvocable::A;
+    NotStrictWeakOrder(&A::F, 0, 0);
+    NotStrictWeakOrder(&A::G, 0, 0);
+    NotStrictWeakOrder(RegularInvocable::F, 0, 0);
+    NotStrictWeakOrder(RegularInvocable::G, 0, 0);
+
+    {
+      auto Up = std::make_unique<A>();
+      NotStrictWeakOrder(&A::I, Up, 0);
+      NotStrictWeakOrder(&A::F, Up, 0);
+      NotStrictWeakOrder(&A::G, Up, 0);
+      NotStrictWeakOrder(&A::H, Up, 0);
+    }
+    {
+      auto Sp = std::make_shared<A>();
+      NotStrictWeakOrder(&A::I, Sp, 0);
+      NotStrictWeakOrder(&A::F, Sp, 0);
+      NotStrictWeakOrder(&A::G, Sp, 0);
+      NotStrictWeakOrder(&A::H, Sp, 0);
+    }
+    {
+      A X;
+      auto Rw = std::reference_wrapper<A>(X);
+      NotStrictWeakOrder(&A::I, Rw, 0);
+      NotStrictWeakOrder(&A::F, Rw, 0);
+      NotStrictWeakOrder(&A::G, Rw, 0);
+      NotStrictWeakOrder(&A::H, Rw, 0);
+    }
+  }
+
+  {
+      /// NotStrictWeakOrder(Predicate::L2rSorted(), 0, 0.0);
+      /// NotStrictWeakOrder(Predicate::NotAPredicate(), 0, 0);
+      /// ModelsStrictWeakOrder(Predicate::LambdaPredicate, 0, 1.0);
+  } {
+    /// ModelsStrictWeakOrder(Relation::EqualTo, 0, 0);
+    ModelsStrictWeakOrder(Relation::Greater, 0, 0);
+    ModelsStrictWeakOrder(Relation::Greater, 0.0, 0);
+    /// ModelsStrictWeakOrder(Relation::MaybeRelation(), 0, 0);
+    /// ModelsStrictWeakOrder(Relation::MaybeRelation(), 0, 0.0);
+    /// ModelsStrictWeakOrder(Relation::MaybeRelation(), 0.0, 0);
+    /// NotStrictWeakOrder(Relation::MaybeRelation(), 0, Predicate::LambdaPredicate);
+    /// NotStrictWeakOrder(Relation::MaybeRelation(), Predicate::LambdaPredicate, 0);
+
+    /// ModelsStrictWeakOrder(Relation::Equivalent(), 0, 10L);
+    /// ModelsStrictWeakOrder(Relation::Equivalent(), 0, 1.0L);
+    ModelsStrictWeakOrder(Relation::Less(), 0, 10L);
+    ModelsStrictWeakOrder(Relation::Less(), 0, 1.0L);
+
+    /// const Relation::MaybeRelation StillARelation;
+    /// ModelsStrictWeakOrder(StillARelation, 0, 0);
+  }
+  return 0;
+}

libcxx/test/std/concepts/lang/moveconstructible.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
-#ifndef TEST_STD_CONCEPTS_LAND_MOVECONSTRUCTIBLE_H
-#define TEST_STD_CONCEPTS_LAND_MOVECONSTRUCTIBLE_H
+#ifndef TEST_STD_CONCEPTS_LANG_MOVECONSTRUCTIBLE_H
+#define TEST_STD_CONCEPTS_LANG_MOVECONSTRUCTIBLE_H
 
 struct HasDefaultOps {};
 
 struct CustomMoveCtor {
   CustomMoveCtor(CustomMoveCtor&&) noexcept;
 };
 
 struct MoveOnly {

 class MemberRvalueReference {
 public:
   MemberRvalueReference(int&&);
 
 private:
   int&& X;
 };
 
-#endif // TEST_STD_CONCEPTS_LAND_MOVECONSTRUCTIBLE_H
+#endif // TEST_STD_CONCEPTS_LANG_MOVECONSTRUCTIBLE_H