unify the representation of lambda type

Author: 16bit-ykiko

README.md

@@ -56,9 +56,9 @@ It's the custom name, isn't it convenient? I have pre-defined some commonly used
 Considering that some terminals do not support color, or do not support `utf` characters, the display will appear garbled, so we provide options to turn off these functions
 ```cpp
 magic::VisualizeOption option;
-option.UTF8_SUPPORT = false;     // do not use utf8 characters
-option.COLORFUL_SUPPORT = false; // turn off color support
-option.FULL_NAME = true;        // use full name instead of custom alias
+option.utf_support = false;     // do not use utf8 characters
+option.color_support = false; // turn off color support
+option.full_name = true;        // use full name instead of custom alias
 std::cout << magic::visualize<std::string>(option) << std::endl;
 ```
 Output:

README.zh.md

@@ -55,9 +55,9 @@ struct magic::type_info<std::string>
 考虑到有的终端并不支持彩色，或者不支持`utf`字符，这样的话显示就出出现乱码，所以我们提供选项来关闭这些功能
 ```cpp
 magic::VisualizeOption option;
-option.UTF8_SUPPORT = false;     // 不使用utf8字符
-option.COLORFUL_SUPPORT = false; // 关闭彩色支持
-option.FULL_NAME = true;        // 使用全名而不是自定义的别名
+option.utf_support = false;     // 不使用utf8字符
+option.color_support = false; // 关闭彩色支持
+option.full_name = true;        // 使用全名而不是自定义的别名
 std::cout << magic::visualize<std::string>(option) << std::endl;
 ```
 

include/magic/field_count.h

@@ -1,12 +1,13 @@
 #ifndef MAGIC_CPP_FIELD_COUNT_H
 #define MAGIC_CPP_FIELD_COUNT_H
 
-#include <array>
-
-#define MAGIC_CPP_C_ARRAY_SUPPORT 0
+#define MAGIC_CPP_C_ARRAY_SUPPORT 1
 
+#include <array>
 namespace magic::details
 {
+    struct Any;
+
     struct Any
     {
         constexpr Any(int) {}
@@ -19,8 +20,12 @@ namespace magic::details
         requires std::is_move_constructible_v<T>
         operator T&&();
 
+        struct Empty
+        {
+        };
+
         template <typename T>
-        requires(!std::is_copy_constructible_v<T> && !std::is_move_constructible_v<T>)
+        requires(!std::is_copy_constructible_v<T> && !std::is_move_constructible_v<T> && !std::is_constructible_v<T, Empty>)
         operator T();
     };
 

include/magic/raw_name.h

@@ -22,7 +22,6 @@ namespace magic
         return start == std::string_view::npos ? name : std::string_view{name.data() + start + 1, name.size() - start - 1};
 #else
         static_assert(false, "Unsupported compiler");
-
 #endif
     }
 
@@ -42,7 +41,6 @@ namespace magic
         return start == std::string_view::npos ? name : std::string_view{name.data() + start + 1, name.size() - start - 1};
 #else
         static_assert(false, "Unsupported compiler");
-
 #endif
     }
 
@@ -62,7 +60,6 @@ namespace magic
         return start == std::string_view::npos ? name : std::string_view{name.data() + start + 1, name.size() - start - 1};
 #else
         static_assert(false, "Unsupported compiler");
-
 #endif
     }
 

include/magic/struct.h

@@ -10,23 +10,22 @@
 
 namespace magic::details
 {
-    // clang-format off
+
     template <typename T>
     constexpr auto field_types_of_impl(T object)
     {
         constexpr auto N = field_count_of<T>();
-        #include "generate/struct_bind_of_field_types.code"
+#include "generate/struct_bind_of_field_types.code"
     }
 
     template <std::size_t Index>
     constexpr auto&& field_of_impl(auto&& object)
     {
         using T = std::remove_cvref_t<decltype(object)>;
         constexpr auto N = field_count_of<T>();
-        #include "generate/struct_bind_of_field_access.code"
-      
+#include "generate/struct_bind_of_field_access.code"
     }
-    // clang-format on
+
 } // namespace magic::details
 
 namespace magic
@@ -82,9 +81,6 @@ namespace magic
         return field_names_of<T>()[Index];
     }
 
-    template <typename T>
-    constexpr std::string_view name_of();
-
     template <std::size_t N, typename T>
     struct Field
     {
@@ -98,7 +94,7 @@ namespace magic
 
         constexpr static std::string_view name() { return field_name_of<std::remove_cvref_t<T>>(N); }
 
-        constexpr static std::string_view type_name() { return name_of<type>(); }
+        constexpr static std::string_view type_name() { return raw_name_of<type>(); }
 
         constexpr static std::size_t index() { return N; }
 
@@ -110,6 +106,22 @@ namespace magic
         friend constexpr void foreach (Object&& object, auto&& functor);
     };
 
+    template <typename T>
+    concept FIELD = requires(T t) {
+        {
+            t.name()
+        } -> std::same_as<std::string_view>;
+        {
+            t.type_name()
+        } -> std::same_as<std::string_view>;
+        {
+            t.index()
+        } -> std::same_as<std::size_t>;
+        {
+            t.value()
+        };
+    };
+
     template <typename Object>
     constexpr void foreach (Object&& object, auto&& functor)
     {

include/magic/type_tree.h

@@ -153,14 +153,54 @@ namespace magic::details
         virtual TypeKind Kind() const override { return TypeKind::FUNCTION; }
     };
 
+    struct never_functor
+    {
+    };
+
+    struct always_functor
+    {
+        void operator()();
+    };
+
+    template <typename T>
+    struct is_functor_impl : always_functor, std::conditional_t<std::is_class_v<T>, T, never_functor>
+    {
+    };
+
+    template <typename T, typename U = void>
+    struct is_functor : std::true_type
+    {
+    };
+
+    template <typename T>
+    struct is_functor<T, std::void_t<decltype(&is_functor_impl<T>::operator())>> : std::false_type
+    {
+    };
+
+    template <typename T>
+    constexpr bool is_functor_v = is_functor<T>::value;
+
+    template <typename T>
+    constexpr bool is_lambda()
+    {
+        if constexpr (is_functor_v<T>)
+        {
+            constexpr auto name = raw_name_of<T>();
+            return name.find("lambda") != std::string_view::npos;
+        }
+        else
+        {
+            return false;
+        }
+    }
     template <typename T>
     Type* parse(bool is_full_name);
 
     template <auto Value>
     Type* parse_nttp(bool is_full_name)
     {
         NTTP* nttp = new NTTP{};
-        nttp->type = parse<decltype(Value)>(is_full_name);
+        nttp->type = parse<std::remove_cv_t<decltype(Value)>>(is_full_name);
         using Type = decltype(Value);
         if constexpr (std::is_enum_v<Type>)
         {
@@ -174,13 +214,26 @@ namespace magic::details
         {
             nttp->name = std::to_string(Value);
         }
+        else if constexpr (is_lambda<Type>())
+        {
+            nttp->name = "<lambda object>";
+        }
         else
         {
             nttp->name = raw_name_of<Value>();
         }
         return nttp;
     }
 
+    inline std::size_t lambda_id = 0;
+
+    template <typename T>
+    std::string resolve_lambda()
+    {
+        static std::size_t id = lambda_id++;
+        return "<lambda{" + std::to_string(id) + "}>";
+    }
+
     template <typename Tuple, std::size_t... Is>
     void parse_function_params(std::index_sequence<Is...>, std::vector<Type*>& parameters, bool is_full_name)
     {
@@ -309,7 +362,14 @@ namespace magic::details
         else
         {
             BasicType* basic_type = new BasicType{};
-            basic_type->name = raw_name_of<Primary>();
+            if constexpr (is_lambda<Primary>())
+            {
+                basic_type->name = resolve_lambda<Primary>();
+            }
+            else
+            {
+                basic_type->name = raw_name_of<Primary>();
+            }
             basic_type->is_const = is_const;
             basic_type->is_volatile = is_volatile;
             return basic_type;

include/magic/visualize.h

@@ -14,9 +14,9 @@ namespace magic
 {
     struct VisualizeOption
     {
-        bool UTF8_SUPPORT = true;
-        bool COLORFUL_SUPPORT = true;
-        bool FULL_NAME = false;
+        bool utf_support = true;
+        bool color_support = true;
+        bool full_name = false;
     };
 
     struct HighlightConfig
@@ -124,13 +124,13 @@ namespace magic::details
         std::string result;
         HighlightConfig config;
         DirectoryTreeSymbols symbols;
-        bool colorful_support;
+        bool color_support;
 
       public:
         VisualizationImpl(const VisualizeOption& option, const HighlightConfig& config)
-            : result(), config(config), colorful_support(option.COLORFUL_SUPPORT)
+            : result(), config(config), color_support(option.color_support)
         {
-            if (option.UTF8_SUPPORT)
+            if (option.utf_support)
             {
                 symbols = {"├── ", "│   ", "└── ", "    "};
             }
@@ -143,7 +143,7 @@ namespace magic::details
         template <typename T>
         std::string colorize(T&& text, std::uint32_t color)
         {
-            if (!colorful_support)
+            if (!color_support)
             {
                 return std::forward<T>(text);
             }
@@ -291,7 +291,7 @@ namespace magic
     std::string visualize(const VisualizeOption& option, const HighlightConfig& config)
     {
         std::string result;
-        Type* type = details::parse<T>(option.FULL_NAME);
+        Type* type = details::parse<T>(option.full_name);
         details::VisualizationImpl visualizationImpl{option, config};
         visualizationImpl.visualize(type, "", "", true);
         delete type;