✨ Add formatting support for values from ct

Problem:
- `CX_VALUE` is fine, but sometimes you have a `std::integral_constant` already.

Solution:
- Add compile-time formatting support for such values wrapped in types.

Author: elbeno

include/stdx/ct_format.hpp

@@ -100,19 +100,30 @@ template <typename T>
 concept cx_value = requires { typename T::cx_value_t; } or
                    requires(T t) { ct_string_from_type(t); };
 
-CONSTEVAL auto arg_value(auto a) { return a; }
+template <typename T, T V>
+CONSTEVAL auto arg_value(std::integral_constant<T, V>) {
+    if constexpr (std::is_enum_v<T>) {
+        return enum_as_string<V>();
+    } else {
+        return V;
+    }
+}
 
 template <typename T> CONSTEVAL auto arg_value(type_identity<T>) {
     return type_as_string<T>();
 }
 
+template <ct_string S> CONSTEVAL auto arg_value(cts_t<S>) { return S; }
+
 CONSTEVAL auto arg_value(cx_value auto a) {
     if constexpr (requires { ct_string_from_type(a); }) {
         return ct_string_from_type(a);
     } else if constexpr (std::is_enum_v<decltype(a())>) {
         return enum_as_string<a()>();
-    } else {
+    } else if constexpr (requires { arg_value(a()); }) {
         return arg_value(a());
+    } else {
+        return a();
     }
 }
 
@@ -156,7 +167,7 @@ CONSTEVAL auto convert_output() {
 }
 
 template <ct_string Fmt, typename Arg> constexpr auto format1(Arg arg) {
-    if constexpr (cx_value<Arg>) {
+    if constexpr (requires { arg_value(arg); }) {
         return [&] {
             constexpr auto fmtstr = FMT_COMPILE(std::string_view{Fmt});
             constexpr auto a = arg_value(arg);

include/stdx/ct_string.hpp

@@ -114,7 +114,7 @@ operator+(ct_string<N> const &lhs,
     return ret;
 }
 
-template <stdx::ct_string S> struct cts_t {
+template <ct_string S> struct cts_t {
     constexpr static auto value = S;
 };
 

test/ct_format.cpp

@@ -34,7 +34,8 @@ TEST_CASE("format a static string", "[ct_format]") {
     static_assert(stdx::ct_format<"Hello">() == "Hello"_fmt_res);
 }
 
-TEST_CASE("format a compile-time stringish argument", "[ct_format]") {
+TEST_CASE("format a compile-time stringish argument (CX_VALUE)",
+          "[ct_format]") {
     using namespace std::string_view_literals;
     static_assert(stdx::ct_format<"Hello {}">(CX_VALUE("world"sv)) ==
                   "Hello world"_fmt_res);
@@ -44,16 +45,34 @@ TEST_CASE("format a compile-time stringish argument", "[ct_format]") {
                   "Hello world"_fmt_res);
 }
 
-TEST_CASE("format a compile-time integral argument", "[ct_format]") {
+TEST_CASE("format a compile-time stringish argument (ct)", "[ct_format]") {
+    using namespace std::string_view_literals;
+    static_assert(stdx::ct_format<"Hello {}">("world"_ctst) ==
+                  "Hello world"_fmt_res);
+    static_assert(stdx::ct_format<"Hello {}">(stdx::ct<"world">()) ==
+                  "Hello world"_fmt_res);
+}
+
+TEST_CASE("format a compile-time integral argument (CX_VALUE)", "[ct_format]") {
     static_assert(stdx::ct_format<"Hello {}">(CX_VALUE(42)) ==
                   "Hello 42"_fmt_res);
 }
 
-TEST_CASE("format a type argument", "[ct_format]") {
+TEST_CASE("format a compile-time integral argument (ct)", "[ct_format]") {
+    static_assert(stdx::ct_format<"Hello {}">(stdx::ct<42>()) ==
+                  "Hello 42"_fmt_res);
+}
+
+TEST_CASE("format a type argument (CX_VALUE)", "[ct_format]") {
     static_assert(stdx::ct_format<"Hello {}">(CX_VALUE(int)) ==
                   "Hello int"_fmt_res);
 }
 
+TEST_CASE("format a type argument (ct)", "[ct_format]") {
+    static_assert(stdx::ct_format<"Hello {}">(stdx::ct<int>()) ==
+                  "Hello int"_fmt_res);
+}
+
 TEST_CASE("format a compile-time argument with fmt spec", "[ct_format]") {
     static_assert(stdx::ct_format<"Hello {:*>#6x}">(CX_VALUE(42)) ==
                   "Hello **0x2a"_fmt_res);
@@ -63,11 +82,16 @@ namespace {
 enum struct E { A };
 }
 
-TEST_CASE("format a compile-time enum argument", "[ct_format]") {
+TEST_CASE("format a compile-time enum argument (CX_VALUE)", "[ct_format]") {
     static_assert(stdx::ct_format<"Hello {}">(CX_VALUE(E::A)) ==
                   "Hello A"_fmt_res);
 }
 
+TEST_CASE("format a compile-time enum argument (ct)", "[ct_format]") {
+    static_assert(stdx::ct_format<"Hello {}">(stdx::ct<E::A>()) ==
+                  "Hello A"_fmt_res);
+}
+
 TEST_CASE("format a runtime argument", "[ct_format]") {
     constexpr auto x = 17;
     constexpr auto expected =