refactor(core): centralize traits, remove duplicates and fix tap collision between print and inspect

Author: GaspardKirira

include/vix/inspect/Inspect.hpp

@@ -49,6 +49,7 @@
 #include <utility>
 #include <variant>
 #include <vector>
+#include <vix/meta/traits.hpp>
 
 #if defined(__cpp_lib_expected) && __cpp_lib_expected >= 202202L
 #include <expected>
@@ -70,11 +71,11 @@ namespace vix
   struct inspect_options;
 
   /// @brief Primary inspector template — specialize to teach inspect about your type.
-  template <typename T, typename = void>
+  template <typename T, typename>
   struct inspector;
 
   /// @brief Field map template — specialize to register struct fields for reflection.
-  template <typename T, typename = void>
+  template <typename T, typename>
   struct field_map;
 
   namespace detail
@@ -166,346 +167,6 @@ namespace vix
 
   } // namespace demangle
 
-  namespace traits
-  {
-
-    // Streamable via operator<<
-    template <typename T, typename = void>
-    struct is_ostreamable : std::false_type
-    {
-    };
-    template <typename T>
-    struct is_ostreamable<T,
-                          std::void_t<decltype(std::declval<std::ostream &>() << std::declval<const T &>())>>
-        : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_ostreamable_v = is_ostreamable<T>::value;
-
-    // String-like (atomic, not iterable)
-    template <typename T>
-    struct is_string_like : std::false_type
-    {
-    };
-    template <>
-    struct is_string_like<std::string> : std::true_type
-    {
-    };
-    template <>
-    struct is_string_like<std::string_view> : std::true_type
-    {
-    };
-    template <>
-    struct is_string_like<const char *> : std::true_type
-    {
-    };
-    template <>
-    struct is_string_like<char *> : std::true_type
-    {
-    };
-    template <>
-    struct is_string_like<std::wstring> : std::true_type
-    {
-    };
-    template <>
-    struct is_string_like<std::wstring_view> : std::true_type
-    {
-    };
-    template <>
-    struct is_string_like<const wchar_t *> : std::true_type
-    {
-    };
-    template <std::size_t N>
-    struct is_string_like<char[N]> : std::true_type
-    {
-    };
-    template <std::size_t N>
-    struct is_string_like<const char[N]> : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_string_like_v = is_string_like<std::remove_cvref_t<T>>::value;
-
-    // Range (iterable, not string)
-    template <typename T, typename = void>
-    struct is_range : std::false_type
-    {
-    };
-    template <typename T>
-    struct is_range<T, std::void_t<
-                           decltype(std::begin(std::declval<const T &>())),
-                           decltype(std::end(std::declval<const T &>()))>>
-        : std::bool_constant<!is_string_like_v<T>>
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_range_v = is_range<T>::value;
-
-    // Map-like (key_type + mapped_type)
-    template <typename T, typename = void>
-    struct is_map_like : std::false_type
-    {
-    };
-    template <typename T>
-    struct is_map_like<T, std::void_t<typename T::key_type, typename T::mapped_type>>
-        : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_map_like_v = is_map_like<T>::value;
-
-    // Tuple-like
-    template <typename T, typename = void>
-    struct is_tuple_like : std::false_type
-    {
-    };
-    template <typename T>
-    struct is_tuple_like<T, std::void_t<decltype(std::tuple_size<T>::value)>>
-        : std::true_type
-    {
-    };
-    template <>
-    struct is_tuple_like<std::string> : std::false_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_tuple_like_v = is_tuple_like<std::remove_cvref_t<T>>::value;
-
-    // Pair
-    template <typename T>
-    struct is_pair : std::false_type
-    {
-    };
-    template <typename A, typename B>
-    struct is_pair<std::pair<A, B>> : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_pair_v = is_pair<std::remove_cvref_t<T>>::value;
-
-    // Smart pointers
-    template <typename T>
-    struct is_unique_ptr : std::false_type
-    {
-    };
-    template <typename T, typename D>
-    struct is_unique_ptr<std::unique_ptr<T, D>> : std::true_type
-    {
-    };
-    template <typename T>
-    struct is_shared_ptr : std::false_type
-    {
-    };
-    template <typename T>
-    struct is_shared_ptr<std::shared_ptr<T>> : std::true_type
-    {
-    };
-    template <typename T>
-    struct is_weak_ptr : std::false_type
-    {
-    };
-    template <typename T>
-    struct is_weak_ptr<std::weak_ptr<T>> : std::true_type
-    {
-    };
-
-    // Optional / variant / any
-    template <typename T>
-    struct is_optional : std::false_type
-    {
-    };
-    template <typename T>
-    struct is_optional<std::optional<T>> : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_optional_v = is_optional<std::remove_cvref_t<T>>::value;
-
-    template <typename T>
-    struct is_variant : std::false_type
-    {
-    };
-    template <typename... Ts>
-    struct is_variant<std::variant<Ts...>> : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_variant_v = is_variant<std::remove_cvref_t<T>>::value;
-
-    template <typename T>
-    inline constexpr bool is_any_v = std::is_same_v<std::remove_cvref_t<T>, std::any>;
-
-    // Chrono
-    template <typename T>
-    struct is_duration : std::false_type
-    {
-    };
-    template <typename Rep, typename Period>
-    struct is_duration<std::chrono::duration<Rep, Period>> : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_duration_v = is_duration<std::remove_cvref_t<T>>::value;
-
-    template <typename T>
-    struct is_time_point : std::false_type
-    {
-    };
-    template <typename C, typename D>
-    struct is_time_point<std::chrono::time_point<C, D>> : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_time_point_v = is_time_point<std::remove_cvref_t<T>>::value;
-
-    // Misc
-    template <typename T>
-    inline constexpr bool is_fs_path_v =
-        std::is_same_v<std::remove_cvref_t<T>, std::filesystem::path>;
-
-    template <typename T>
-    struct is_ref_wrapper : std::false_type
-    {
-    };
-    template <typename T>
-    struct is_ref_wrapper<std::reference_wrapper<T>> : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_ref_wrapper_v = is_ref_wrapper<std::remove_cvref_t<T>>::value;
-
-    template <typename T>
-    inline constexpr bool is_nullptr_v =
-        std::is_same_v<std::remove_cvref_t<T>, std::nullptr_t>;
-
-    template <typename T>
-    inline constexpr bool is_bool_v =
-        std::is_same_v<std::remove_cvref_t<T>, bool>;
-
-    template <typename T>
-    inline constexpr bool is_char_v =
-        std::is_same_v<std::remove_cvref_t<T>, char> ||
-        std::is_same_v<std::remove_cvref_t<T>, signed char> ||
-        std::is_same_v<std::remove_cvref_t<T>, unsigned char> ||
-        std::is_same_v<std::remove_cvref_t<T>, wchar_t> ||
-        std::is_same_v<std::remove_cvref_t<T>, char8_t> ||
-        std::is_same_v<std::remove_cvref_t<T>, char16_t> ||
-        std::is_same_v<std::remove_cvref_t<T>, char32_t>;
-
-    // Container adapters
-    template <typename T>
-    struct is_stack : std::false_type
-    {
-    };
-    template <typename T, typename C>
-    struct is_stack<std::stack<T, C>> : std::true_type
-    {
-    };
-    template <typename T>
-    struct is_queue : std::false_type
-    {
-    };
-    template <typename T, typename C>
-    struct is_queue<std::queue<T, C>> : std::true_type
-    {
-    };
-    template <typename T>
-    struct is_priority_queue : std::false_type
-    {
-    };
-    template <typename T, typename C, typename Cmp>
-    struct is_priority_queue<std::priority_queue<T, C, Cmp>> : std::true_type
-    {
-    };
-
-    // ADL vix_inspect detection
-    template <typename T, typename = void>
-    struct has_vix_inspect_hook : std::false_type
-    {
-    };
-    template <typename T>
-    struct has_vix_inspect_hook<T, std::void_t<
-                                       decltype(vix_inspect(std::declval<inspect_context &>(), std::declval<const T &>()))>>
-        : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool has_vix_inspect_hook_v =
-        has_vix_inspect_hook<std::remove_cvref_t<T>>::value;
-
-    // inspector<T> specialization detection
-    template <typename T, typename = void>
-    struct has_inspector_specialization : std::false_type
-    {
-    };
-    template <typename T>
-    struct has_inspector_specialization<T, std::void_t<
-                                               decltype(inspector<T>::inspect(
-                                                   std::declval<inspect_context &>(),
-                                                   std::declval<const T &>()))>>
-        : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool has_inspector_v =
-        has_inspector_specialization<std::remove_cvref_t<T>>::value;
-
-    // field_map detection
-    template <typename T, typename = void>
-    struct has_field_map : std::false_type
-    {
-    };
-    template <typename T>
-    struct has_field_map<T, std::void_t<decltype(field_map<T>::fields())>>
-        : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool has_field_map_v =
-        has_field_map<std::remove_cvref_t<T>>::value;
-
-#if VIX_HAS_EXPECTED
-    template <typename T>
-    struct is_expected : std::false_type
-    {
-    };
-    template <typename T, typename E>
-    struct is_expected<std::expected<T, E>> : std::true_type
-    {
-    };
-    template <typename T>
-    inline constexpr bool is_expected_v = is_expected<std::remove_cvref_t<T>>::value;
-#endif
-
-  } // namespace traits
-
-  namespace concepts
-  {
-
-    template <typename T>
-    concept Ostreamable = traits::is_ostreamable_v<T>;
-    template <typename T>
-    concept StringLike = traits::is_string_like_v<T>;
-    template <typename T>
-    concept Range = traits::is_range_v<T>;
-    template <typename T>
-    concept MapLike = traits::is_map_like_v<T>;
-    template <typename T>
-    concept TupleLike = traits::is_tuple_like_v<T> && !Range<T>;
-    template <typename T>
-    concept HasVixInspect = traits::has_vix_inspect_hook_v<T>;
-    template <typename T>
-    concept HasInspector = traits::has_inspector_v<T>;
-    template <typename T>
-    concept HasFieldMap = traits::has_field_map_v<T>;
-    template <typename T>
-    concept Duration = traits::is_duration_v<T>;
-    template <typename T>
-    concept TimePoint = traits::is_time_point_v<T>;
-
-  } // namespace concepts
-
   /**
    * @brief Complete set of compile-time and runtime metadata for a type T.
    *
@@ -2083,10 +1744,10 @@ namespace vix
    * @brief Inspect a value mid-expression and return it unchanged.
    *
    * @example
-   *   auto result = vix::tap(compute());  // prints and returns
+   *   auto result = vix::inspect_tap(compute());  // prints and returns
    */
   template <typename T>
-  const T &tap(const T &value, std::string_view label = "")
+  const T &inspect_tap(const T &value, std::string_view label = "")
   {
     auto &os = *default_options().out;
     if (!label.empty())