[libcxx-commits] [libcxx] c7ad020 - [libcxx] adds remaining callable concepts
Christopher Di Bella via libcxx-commits
libcxx-commits at lists.llvm.org
Wed Apr 7 09:15:37 PDT 2021
Author: Christopher Di Bella
Date: 2021-04-07T16:14:45Z
New Revision: c7ad02009934ecaea4e2f152ff784ee0d36029a0
URL: https://github.com/llvm/llvm-project/commit/c7ad02009934ecaea4e2f152ff784ee0d36029a0
DIFF: https://github.com/llvm/llvm-project/commit/c7ad02009934ecaea4e2f152ff784ee0d36029a0.diff
LOG: [libcxx] adds remaining callable concepts
* `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
Differential Revision: https://reviews.llvm.org/D96477
Added:
libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.pass.cpp
libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.pass.cpp
libcxx/test/std/concepts/concepts.callable/concept.predicate/predicate.pass.cpp
libcxx/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.pass.cpp
libcxx/test/std/concepts/concepts.callable/concept.relation/relation.pass.cpp
libcxx/test/std/concepts/concepts.callable/concept.relation/relation.subsumption.pass.cpp
libcxx/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.pass.cpp
libcxx/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.subsumption.pass.cpp
Modified:
Removed:
################################################################################
diff --git a/libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.pass.cpp b/libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.pass.cpp
new file mode 100644
index 0000000000000..f925eb5f75ed9
--- /dev/null
+++ b/libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.pass.cpp
@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// 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::relation<bool (S1::*)(S1*), S1*, S1*>);
+static_assert(std::relation<bool (S1::*)(S1&), S1&, S1&>);
+
+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; }
diff --git a/libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.pass.cpp b/libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.pass.cpp
new file mode 100644
index 0000000000000..0aad734fa654a
--- /dev/null
+++ b/libcxx/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.pass.cpp
@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// 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; }
diff --git a/libcxx/test/std/concepts/concepts.callable/concept.predicate/predicate.pass.cpp b/libcxx/test/std/concepts/concepts.callable/concept.predicate/predicate.pass.cpp
new file mode 100644
index 0000000000000..111f89cd16147
--- /dev/null
+++ b/libcxx/test/std/concepts/concepts.callable/concept.predicate/predicate.pass.cpp
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// 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; }
diff --git a/libcxx/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.pass.cpp b/libcxx/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.pass.cpp
new file mode 100644
index 0000000000000..86c79f008ad69
--- /dev/null
+++ b/libcxx/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.pass.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+// 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; }
diff --git a/libcxx/test/std/concepts/concepts.callable/concept.relation/relation.pass.cpp b/libcxx/test/std/concepts/concepts.callable/concept.relation/relation.pass.cpp
new file mode 100644
index 0000000000000..c7617fca9df0a
--- /dev/null
+++ b/libcxx/test/std/concepts/concepts.callable/concept.relation/relation.pass.cpp
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<bool (S1::*)(S1*), S1*, S1*>);
+static_assert(std::relation<bool (S1::*)(S1&), S1&, S1&>);
+
+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; }
diff --git a/libcxx/test/std/concepts/concepts.callable/concept.relation/relation.subsumption.pass.cpp b/libcxx/test/std/concepts/concepts.callable/concept.relation/relation.subsumption.pass.cpp
new file mode 100644
index 0000000000000..8568bd5f6ecf9
--- /dev/null
+++ b/libcxx/test/std/concepts/concepts.callable/concept.relation/relation.subsumption.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// 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; }
diff --git a/libcxx/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.pass.cpp b/libcxx/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.pass.cpp
new file mode 100644
index 0000000000000..437dcd2c870a0
--- /dev/null
+++ b/libcxx/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.pass.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<bool (S1::*)(S1*), S1*, S1*>);
+static_assert(std::strict_weak_order<bool (S1::*)(S1&), S1&, S1&>);
+
+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; }
diff --git a/libcxx/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.subsumption.pass.cpp b/libcxx/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.subsumption.pass.cpp
new file mode 100644
index 0000000000000..52a19f4f2d8d6
--- /dev/null
+++ b/libcxx/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.subsumption.pass.cpp
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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; }
More information about the libcxx-commits
mailing list