✨ Add CT_WRAP

Problem:
- It is useful to have a macro that wraps a potentially-`constexpr`-usable value
  in `stdx::ct` when possible, to preserve its `constexpr` properties.

Solution:
- Add `CT_WRAP` that does this.

Notes:
- See intel/compile-time-init-build#743 for some parts
  of this in CIB; this part probably belongs in stdx.

Author: elbeno

include/stdx/ct_string.hpp

@@ -160,6 +160,8 @@ template <std::size_t N> struct ct_helper<ct_string<N>>;
 
 template <ct_string Value> CONSTEVAL auto ct() { return cts_t<Value>{}; }
 
+template <ct_string Value> constexpr auto is_ct_v<cts_t<Value>> = true;
+
 inline namespace literals {
 inline namespace ct_string_literals {
 template <ct_string S> CONSTEVAL_UDL auto operator""_cts() { return S; }

include/stdx/utility.hpp

@@ -209,6 +209,12 @@ template <detail::ct_helper Value> CONSTEVAL auto ct() {
 }
 template <typename T> CONSTEVAL auto ct() { return type_identity<T>{}; }
 
+template <typename> constexpr auto is_ct_v = false;
+template <typename T, T V>
+constexpr auto is_ct_v<std::integral_constant<T, V>> = true;
+template <typename T> constexpr auto is_ct_v<type_identity<T>> = true;
+template <typename T> constexpr auto is_ct_v<T const> = is_ct_v<T>;
+
 #endif
 } // namespace v1
 } // namespace stdx
@@ -244,5 +250,22 @@ template <typename T> CONSTEVAL auto ct() { return type_identity<T>{}; }
     }()
 #endif
 
+#if __cplusplus >= 202002L
+
+#define CT_WRAP(X)                                                             \
+    [&](auto f) {                                                              \
+        if constexpr (::stdx::is_ct_v<decltype(f())>) {                        \
+            return f();                                                        \
+        } else if constexpr (requires {                                        \
+                                 ::stdx::ct<[&]() constexpr { return X; }()>;  \
+                             }) {                                              \
+            return ::stdx::ct<[&]() constexpr { return X; }()>();              \
+        } else {                                                               \
+            return f();                                                        \
+        }                                                                      \
+    }([&] { return X; })
+
+#endif
+
 // NOLINTEND(cppcoreguidelines-macro-usage)
 // NOLINTEND(modernize-use-constraints)

test/ct_string.cpp

@@ -150,3 +150,30 @@ TEST_CASE("ct (ct_string)", "[ct_string]") {
     constexpr auto v2 = stdx::ct<"Hello"_cts>();
     STATIC_REQUIRE(v2 == "Hello"_ctst);
 }
+
+TEST_CASE("is_ct (ct_string)", "[ct_string]") {
+    using namespace stdx::ct_string_literals;
+    constexpr auto v1 = stdx::ct<"Hello">();
+    STATIC_REQUIRE(stdx::is_ct_v<decltype(v1)>);
+}
+
+TEST_CASE("CT_WRAP", "[ct_string]") {
+    using namespace stdx::ct_string_literals;
+    auto x1 = "hello"_cts;
+    STATIC_REQUIRE(std::is_same_v<decltype(CT_WRAP(x1)), stdx::ct_string<6>>);
+    CHECK(CT_WRAP(x1) == "hello"_cts);
+
+    auto x2 = "hello"_ctst;
+    STATIC_REQUIRE(std::is_same_v<decltype(CT_WRAP(x2)), stdx::cts_t<"hello">>);
+    STATIC_REQUIRE(CT_WRAP(x2) == "hello"_ctst);
+
+    constexpr static auto x3 = "hello"_cts;
+    STATIC_REQUIRE(std::is_same_v<decltype(CT_WRAP(x3)), stdx::cts_t<"hello">>);
+    STATIC_REQUIRE(CT_WRAP(x3) == "hello"_ctst);
+
+    []<stdx::ct_string X>() {
+        STATIC_REQUIRE(
+            std::is_same_v<decltype(CT_WRAP(X)), stdx::cts_t<"hello">>);
+        STATIC_REQUIRE(CT_WRAP(X) == "hello"_ctst);
+    }.template operator()<"hello">();
+}

test/utility.cpp

@@ -271,4 +271,38 @@ TEST_CASE("ct (type)", "[utility]") {
     STATIC_REQUIRE(std::is_same_v<decltype(v), stdx::type_identity<int> const>);
 }
 
+TEST_CASE("is_ct", "[utility]") {
+    constexpr auto x1 = stdx::ct<42>();
+    STATIC_REQUIRE(stdx::is_ct_v<decltype(x1)>);
+    constexpr auto x2 = stdx::ct<int>();
+    STATIC_REQUIRE(stdx::is_ct_v<decltype(x2)>);
+}
+
+TEST_CASE("CT_WRAP", "[utility]") {
+    auto x1 = 42;
+    STATIC_REQUIRE(std::is_same_v<decltype(CT_WRAP(x1)), int>);
+    CHECK(CT_WRAP(x1) == 42);
+
+    auto x2 = stdx::ct<42>();
+    STATIC_REQUIRE(
+        std::is_same_v<decltype(CT_WRAP(x2)), std::integral_constant<int, 42>>);
+    STATIC_REQUIRE(CT_WRAP(x2).value == 42);
+
+    auto const x3 = 42;
+    STATIC_REQUIRE(
+        std::is_same_v<decltype(CT_WRAP(x3)), std::integral_constant<int, 42>>);
+    STATIC_REQUIRE(CT_WRAP(x3).value == 42);
+
+    constexpr static auto x4 = 42;
+    STATIC_REQUIRE(
+        std::is_same_v<decltype(CT_WRAP(x4)), std::integral_constant<int, 42>>);
+    STATIC_REQUIRE(CT_WRAP(x4).value == 42);
+
+    []<auto X>() {
+        STATIC_REQUIRE(std::is_same_v<decltype(CT_WRAP(X)),
+                                      std::integral_constant<int, 42>>);
+        STATIC_REQUIRE(CT_WRAP(X).value == 42);
+    }.template operator()<42>();
+}
+
 #endif