refactor: introduce full Type Layer (meta) and complete Type Pattern DSL (type::is/in/not_in/from)

Author: sentomk

CMakeLists.txt

@@ -89,9 +89,12 @@ PTN_JOIN_HEADERS(PTN_HEADERS
   include/ptn/pattern/pattern_base.hpp
   include/ptn/pattern/pattern_traits.hpp
 
-  # Type Layer
+  # Type Pattern Layer
   include/ptn/pattern/type/type_of.hpp
   include/ptn/pattern/type/type.hpp
+
+  # Type Meta Layer
+  include/ptn/type/meta.hpp
 )
 
 # ========== Public interface target ==========

include/ptn/pattern/type/type.hpp

@@ -1,39 +1,130 @@
 #pragma once
 /**
- * @file type_tag.hpp
- * @brief Defines `type_tag<T>` / `type_c<T>` as both a type tag and
- *        a Patternia pattern (matches by static type).
+ * @file type.hpp
+ * @brief Static type-based patterns for Patternia.
  *
- * Part of Pattern Layer (namespace ptn::pattern::value)
+ * Provides the static Type Pattern DSL:
+ *   - type::is<T>        : match when subject's type is exactly T
+ *   - type::in<Ts...>    : match when subject's type is in Ts...
+ *   - type::not_in<Ts...>
+ *   - type::from<Tpl>    : match any specialization of template Tpl<...>
+ *
+ * Legacy:
+ *   - type_is<T> alias kept as compatibility wrapper → type::is<T>
+ *
+ * This file forms the Pattern Layer entry for type patterns.
  */
 
 #include <type_traits>
+#include <utility>
+
 #include "ptn/pattern/pattern_base.hpp"
 
 namespace ptn::pattern::type {
 
-  /**
-   * @brief Compile-time wrapper around a C++ type, and also a pattern
-   *        that matches when the subject's (decayed) type equals `T`.
-   */
+  //====================================================================
+  //  Internal helper: is specialization of template?
+  //====================================================================
+  namespace detail {
+
+    template <template <typename...> typename Tpl, typename T>
+    struct is_specialization_of : std::false_type {};
+
+    template <template <typename...> typename Tpl, typename... Args>
+    struct is_specialization_of<Tpl, Tpl<Args...>> : std::true_type {};
+
+  } // namespace detail
+
+  //====================================================================
+  //  type::is<T>  — static type equality
+  //====================================================================
+
   template <typename T>
-  struct type_tag : ptn::pattern::pattern_base<type_tag<T>> {
+  struct is_pattern : ptn::pattern::pattern_base<is_pattern<T>> {
 
     template <typename X>
     constexpr bool match(X &&) const noexcept {
-      return std::is_same_v<T, std::decay_t<X>>;
+      return std::is_same_v<std::decay_t<X>, T>;
+    }
+    template <typename X>
+    constexpr auto bind(X &&x) const noexcept {
+      return std::forward<X>(x);
     }
+  };
+
+  template <typename T>
+  inline constexpr is_pattern<T> is{};
 
+  //====================================================================
+  //  type::in<Ts...>  — membership
+  //====================================================================
+
+  template <typename... Ts>
+  struct in_pattern : ptn::pattern::pattern_base<in_pattern<Ts...>> {
+
+    template <typename X>
+    constexpr bool match(X &&) const noexcept {
+      using D = std::decay_t<X>;
+      return (std::is_same_v<D, Ts> || ...);
+    }
     template <typename X>
     constexpr auto bind(X &&x) const noexcept {
       return std::forward<X>(x);
     }
   };
 
-  /**
-   * @brief Shorthand constant for `type_tag<T>`.
-   */
+  template <typename... Ts>
+  inline constexpr in_pattern<Ts...> in{};
+
+  //====================================================================
+  //  type::not_in<Ts...>
+  //====================================================================
+
+  template <typename... Ts>
+  struct not_in_pattern : ptn::pattern::pattern_base<not_in_pattern<Ts...>> {
+
+    template <typename X>
+    constexpr bool match(X &&v) const noexcept {
+      return !in_pattern<Ts...>{}.match(std::forward<X>(v));
+    }
+    template <typename X>
+    constexpr auto bind(X &&x) const noexcept {
+      return std::forward<X>(x);
+    }
+  };
+
+  template <typename... Ts>
+  inline constexpr not_in_pattern<Ts...> not_in{};
+
+  //====================================================================
+  //  type::from<Tpl>  — match template family
+  //====================================================================
+
+  template <template <typename...> typename Tpl>
+  struct from_pattern : ptn::pattern::pattern_base<from_pattern<Tpl>> {
+
+    template <typename X>
+    constexpr bool match(X &&) const noexcept {
+      using D = std::decay_t<X>;
+      return detail::is_specialization_of<Tpl, D>::value;
+    }
+    template <typename X>
+    constexpr auto bind(X &&x) const noexcept {
+      return std::forward<X>(x);
+    }
+  };
+
+  template <template <typename...> typename Tpl>
+  inline constexpr from_pattern<Tpl> from{};
+
+  //====================================================================
+  //  Legacy compatibility
+  //====================================================================
+
+  template <typename T>
+  using type_tag = is_pattern<T>;
+
   template <typename T>
-  inline constexpr type_tag<T> type_is{};
+  inline constexpr auto type_is = is<T>;
 
 } // namespace ptn::pattern::type

include/ptn/patternia.hpp

@@ -74,6 +74,8 @@ namespace ptn {
 
   // ---- Export Type Layer (ONLY selected symbols) ----
 #if PTN_ENABLE_TYPE
+#include "ptn/pattern/type/type.hpp"
+  namespace type = ptn::pattern::type;
   using pattern::type::type_is;
   using pattern::type::type_of;
   using pattern::type::type_tag;