From 676f97eafc095843d51c2fdee803319064c15959 Mon Sep 17 00:00:00 2001
From: Denis Yaroshevskiy <dyaroshev@meta.com>
Date: Fri, 2 Aug 2024 04:03:55 -0700
Subject: [PATCH] folly concepts #1 (#2249)

Summary:
Pull Request resolved: https://github.com/facebook/folly/pull/2249

We have a need for some common concepts that are used in many places.

This is a proposal, please let me know what you think.

Differential Revision: D59396081
---
 folly/Traits.h                 | 34 ++++++++++++++++++++++++++++-
 folly/test/PortabilityTest.cpp |  4 ----
 folly/test/TraitsTest.cpp      | 40 ++++++++++++++++++++++++++++++++++
 3 files changed, 73 insertions(+), 5 deletions(-)

diff --git a/folly/Traits.h b/folly/Traits.h
index 3c6b86e1301..c1d550a823f 100644
--- a/folly/Traits.h
+++ b/folly/Traits.h
@@ -159,13 +159,17 @@ struct is_bounded_array : std::bool_constant<is_bounded_array_v<T>> {};
 
 /// is_instantiation_of_v
 /// is_instantiation_of
+/// instantiated_from
+/// uncvref_instantiated_from
 ///
 /// A trait variable and type to check if a given type is an instantiation of a
-/// class template.
+/// class template. And corresponding concepts.
 ///
 /// Note that this only works with type template parameters. It does not work
 /// with non-type template parameters, template template parameters, or alias
 /// templates.
+///
+/// NOTE: there is also `instantiation_of` concept
 template <template <typename...> class, typename>
 inline constexpr bool is_instantiation_of_v = false;
 template <template <typename...> class C, typename... T>
@@ -174,6 +178,17 @@ template <template <typename...> class C, typename... T>
 struct is_instantiation_of
     : std::bool_constant<is_instantiation_of_v<C, T...>> {};
 
+#if defined(__cpp_concepts)
+
+template <typename T, template <typename...> class Templ>
+concept instantiated_from = is_instantiation_of_v<Templ, T>;
+
+template <typename T, template <typename...> class Templ>
+concept uncvref_instantiated_from =
+    is_instantiation_of_v<Templ, std::remove_cvref_t<T>>;
+
+#endif
+
 /// member_pointer_traits
 ///
 /// For a member-pointer, reveals its constituent member-type and object-type.
@@ -301,6 +316,23 @@ struct like {
   using type = like_t<Src, Dst>;
 };
 
+#if defined(__cpp_concepts)
+
+/**
+ *  Concept to check that a type is same as a given type,
+ *  when stripping qualifiers and refernces.
+ *  Especially useful for perfect forwarding of a specific type.
+ *
+ *  Example:
+ *  ```
+ *    void foo(folly::uncvref_same_as<std::vector<int>> auto&& vec);
+ *  ```
+ */
+template <typename Ref, typename To>
+concept uncvref_same_as = std::is_same_v<std::remove_cvref_t<Ref>, To>;
+
+#endif
+
 /**
  *  type_t
  *
diff --git a/folly/test/PortabilityTest.cpp b/folly/test/PortabilityTest.cpp
index 2a8c17c70de..7e152108e74 100644
--- a/folly/test/PortabilityTest.cpp
+++ b/folly/test/PortabilityTest.cpp
@@ -51,7 +51,3 @@ TEST(Portability, Final) {
   EXPECT_EQ(3, fooBase(p.get()));
   EXPECT_EQ(3, fooDerived(p.get()));
 }
-
-#if __has_include(<range>)
-static_assert(std::ranges::random_access_range<std::vector<int>>);
-#endif
diff --git a/folly/test/TraitsTest.cpp b/folly/test/TraitsTest.cpp
index 3b6f395ddb3..6e435664cc9 100644
--- a/folly/test/TraitsTest.cpp
+++ b/folly/test/TraitsTest.cpp
@@ -532,6 +532,27 @@ TEST(Traits, like) {
            value));
 }
 
+#if defined(__cpp_concepts)
+TEST(Traits, UncvrefSameAs) {
+  static_assert(folly::uncvref_same_as<std::vector<int>, std::vector<int>>);
+  static_assert(folly::uncvref_same_as<std::vector<int>&, std::vector<int>>);
+  static_assert(
+      folly::uncvref_same_as<const std::vector<int>&, std::vector<int>>);
+  static_assert(folly::uncvref_same_as<std::vector<int>&&, std::vector<int>>);
+
+  constexpr auto refersToExample =
+      [](folly::uncvref_same_as<std::vector<int>> auto&&) {};
+
+  static_assert(std::invocable<decltype(refersToExample), std::vector<int>>);
+  static_assert(
+      std::invocable<decltype(refersToExample), const std::vector<int>&>);
+  static_assert(std::invocable<decltype(refersToExample), std::vector<int>&&>);
+
+  static_assert(
+      !std::invocable<decltype(refersToExample), std::vector<char>&&>);
+}
+#endif
+
 TEST(Traits, isUnboundedArrayV) {
   EXPECT_FALSE((folly::is_unbounded_array_v<void>));
   EXPECT_FALSE((folly::is_unbounded_array_v<int>));
@@ -556,6 +577,25 @@ TEST(Traits, isInstantiationOf) {
   EXPECT_FALSE((is_instantiation_of<A, B>::value));
 }
 
+#if defined(__cpp_concepts)
+TEST(Traits, InstantiationOf) {
+  static_assert(folly::instantiated_from<A<int>, A>);
+  static_assert(!folly::instantiated_from<A<int>&, A>);
+  static_assert(!folly::instantiated_from<A<int>, std::vector>);
+
+  static_assert(folly::uncvref_instantiated_from<A<int>, A>);
+  static_assert(folly::uncvref_instantiated_from<A<int>&, A>);
+  static_assert(!folly::uncvref_instantiated_from<A<int>&, std::vector>);
+
+  auto example = [](folly::uncvref_instantiated_from<std::vector> auto&&) {};
+
+  static_assert(std::invocable<decltype(example), std::vector<int>&&>);
+  static_assert(std::invocable<decltype(example), std::vector<int>&>);
+  static_assert(std::invocable<decltype(example), const std::vector<int>&>);
+  static_assert(std::invocable<decltype(example), std::vector<int>>);
+}
+#endif
+
 TEST(Traits, member_pointer_traits_data) {
   struct o {};
   using d = float;