refactor: Fix typo of namespace in src code

Author: FrozenLemonTee

src/primitives/primitive.impl.cppm

@@ -3,13 +3,15 @@ module;
 
 export module mcpplibs.primitives.primitive.impl;
 
-// Import policy concept to constrain Policies parameter pack.
-export import mcpplibs.primitive.traits.policy;
+import mcpplibs.primitives.traits.policy;
+import mcpplibs.primitives.traits.underlying;
 
 export namespace mcpplibs::primitives {
 
 template <typename T, primitive::policy::policy_type... Policies>
 struct primitive {
+template <underlying_type T,
+          policy::policy_type... Policies>
   using value_type = T;
   using policies = std::tuple<Policies...>;
   constexpr explicit primitive(T v) noexcept : value(v) {}

src/primitives/primitive.traits.cppm

@@ -5,65 +5,61 @@ module;
 export module mcpplibs.primitives.primitive.traits;
 
 // Import the policy taxonomy so we can inspect policy::traits<>.
-export import mcpplibs.primitive.traits.policy;
+export import mcpplibs.primitives.traits.policy;
 
 // Public default policy aliases — these must be visible to internal details.
 export namespace mcpplibs::primitives {
-using default_value_policy = ::mcpplibs::primitive::policy::unchecked_value;
-using default_type_policy = ::mcpplibs::primitive::policy::transparent_type;
-using default_error_policy = ::mcpplibs::primitive::policy::throw_error;
-using default_concurrency_policy = ::mcpplibs::primitive::policy::single_thread;
+using default_value_policy = policy::unchecked_value;
+using default_type_policy = policy::transparent_type;
+using default_error_policy = policy::throw_error;
+using default_concurrency_policy = policy::single_thread;
 }
 
 // Internal implementation details — not exported.
 namespace mcpplibs::primitives::traits::details {
-using policy_category = ::mcpplibs::primitive::policy::category;
+using policy_category = policy::category;
 
-template <policy_category C,
-          ::mcpplibs::primitive::policy::policy_type... Policies>
+template <policy_category C, policy::policy_type... Policies>
 struct count_matching_impl;
 
 template <policy_category C> struct count_matching_impl<C> {
   static constexpr std::size_t value = 0;
 };
 
-template <policy_category C, ::mcpplibs::primitive::policy::policy_type First,
-          ::mcpplibs::primitive::policy::policy_type... Rest>
+template <policy_category C, policy::policy_type First,
+          policy::policy_type... Rest>
 struct count_matching_impl<C, First, Rest...> {
   static constexpr std::size_t rest = count_matching_impl<C, Rest...>::value;
   static constexpr bool is_match =
-      ::mcpplibs::primitive::policy::traits<First>::enabled &&
-      (::mcpplibs::primitive::policy::traits<First>::kind == C);
+      policy::traits<First>::enabled && policy::traits<First>::kind == C;
   static constexpr std::size_t value = rest + (is_match ? 1u : 0u);
 };
 
-template <policy_category C,
-          ::mcpplibs::primitive::policy::policy_type... Policies>
+template <policy_category C, policy::policy_type... Policies>
 constexpr std::size_t count_matching_v =
     count_matching_impl<C, Policies...>::value;
 
-template <policy_category C,
-          ::mcpplibs::primitive::policy::policy_type... Policies>
+template <policy_category C, policy::policy_type... Policies>
 struct find_first_impl;
 
 template <policy_category C> struct find_first_impl<C> {
   using type = void;
 };
 
-template <policy_category C, ::mcpplibs::primitive::policy::policy_type First,
-          ::mcpplibs::primitive::policy::policy_type... Rest>
+template <policy_category C, policy::policy_type First,
+          policy::policy_type... Rest>
 struct find_first_impl<C, First, Rest...> {
   static constexpr bool is_match =
-      ::mcpplibs::primitive::policy::traits<First>::enabled &&
-      (::mcpplibs::primitive::policy::traits<First>::kind == C);
+      policy::traits<First>::enabled &&
+      policy::traits<First>::kind == C;
   using type = std::conditional_t<is_match, First,
                                   typename find_first_impl<C, Rest...>::type>;
 };
 
-template <policy_category C, primitive::policy::policy_type... Policies>
+template <policy_category C, policy::policy_type... Policies>
 using find_first_t = find_first_impl<C, Policies...>::type;
 
-template <policy_category C, primitive::policy::policy_type... Policies>
+template <policy_category C, policy::policy_type... Policies>
 struct resolve_policy_impl {
   static_assert(count_matching_v<C, Policies...> <= 1,
                 "Multiple policies provided for the same category");
@@ -72,37 +68,35 @@ struct resolve_policy_impl {
   using type = std::conditional_t<
       std::is_same_v<found, void>,
       std::conditional_t<
-          C == policy_category::value, primitives::default_value_policy,
+          C == policy_category::value, default_value_policy,
           std::conditional_t<
-              C == policy_category::type, primitives::default_type_policy,
+              C == policy_category::type, default_type_policy,
               std::conditional_t<C == policy_category::error,
-                                 primitives::default_error_policy,
-                                 primitives::default_concurrency_policy>>>,
+                                 default_error_policy,
+                                 default_concurrency_policy>>>,
       found>;
 };
 
 template <policy_category C,
-          ::mcpplibs::primitive::policy::policy_type... Policies>
-using resolve_policy_t = typename resolve_policy_impl<C, Policies...>::type;
+          policy::policy_type... Policies>
+using resolve_policy_t = resolve_policy_impl<C, Policies...>::type;
 
 } // namespace mcpplibs::primitives::traits::details
 
 // Public API exported from this module.
 export namespace mcpplibs::primitives::traits {
-    using policy_category = ::mcpplibs::primitive::policy::category;
+    using policy_category = policy::category;
 
-    template <policy_category C,
-              ::mcpplibs::primitive::policy::policy_type... Policies>
-    using resolve_policy_t =
-        ::mcpplibs::primitives::traits::details::resolve_policy_t<C, Policies...>;
+    template <policy_category C, policy::policy_type... Policies>
+    using resolve_policy_t = details::resolve_policy_t<C, Policies...>;
 
     template <typename P> struct primitive_traits; // customization point for users
 
     // Forward-declare exported `primitive` (defined in impl module).
-    template <typename T, ::mcpplibs::primitive::policy::policy_type... Policies>
+    template <typename T, policy::policy_type... Policies>
     struct primitive;
 
-    template <typename T, ::mcpplibs::primitive::policy::policy_type... Policies>
+    template <typename T, policy::policy_type... Policies>
     struct primitive_traits<primitive<T, Policies...>> {
         using value_type = T;
         using policies = std::tuple<Policies...>;

src/traits/policy.cppm

@@ -1,11 +1,9 @@
 module;
 #include <type_traits>
 
-export module mcpplibs.primitive.traits.policy;
+export module mcpplibs.primitives.traits.policy;
 
-export namespace mcpplibs::primitive {
-
-namespace policy {
+export namespace mcpplibs::primitives::policy {
 
 enum class category { value, type, error, concurrency };
 
@@ -112,6 +110,4 @@ template <typename P>
 concept concurrency_policy =
     policy_type<P> && (traits<P>::kind == category::concurrency);
 
-} // namespace policy
-
-} // namespace mcpplibs::primitive
+} // namespace mcpplibs::primitives::policy

src/traits/traits.cppm

@@ -1,14 +1,14 @@
 module;
 
-export module mcpplibs.primitive.traits;
+export module mcpplibs.primitives.traits;
 
-export import mcpplibs.primitive.traits.underlying;
-export import mcpplibs.primitive.traits.policy;
+export import mcpplibs.primitives.traits.underlying;
+export import mcpplibs.primitives.traits.policy;
 
 // Expose default policy aliases from the primitives-facing traits module.
 export namespace mcpplibs::primitives {
-using default_value_policy = ::mcpplibs::primitive::policy::unchecked_value;
-using default_type_policy = ::mcpplibs::primitive::policy::transparent_type;
-using default_error_policy = ::mcpplibs::primitive::policy::throw_error;
-using default_concurrency_policy = ::mcpplibs::primitive::policy::single_thread;
+using default_value_policy = policy::unchecked_value;
+using default_type_policy = policy::transparent_type;
+using default_error_policy = policy::throw_error;
+using default_concurrency_policy = policy::single_thread;
 } // namespace mcpplibs::primitives

src/traits/underlying.cppm

@@ -2,9 +2,9 @@ module;
 #include <concepts>
 #include <type_traits>
 
-export module mcpplibs.primitive.traits.underlying;
+export module mcpplibs.primitives.traits.underlying;
 
-export namespace mcpplibs::primitive {
+export namespace mcpplibs::primitives {
 
 template <typename T>
 concept std_bool = std::same_as<std::remove_cv_t<T>, bool>;
@@ -70,9 +70,9 @@ template <std_underlying_type T> struct traits<T> {
 };
 } // namespace underlying
 
-} // namespace mcpplibs::primitive
+} // namespace mcpplibs::primitives
 
-namespace mcpplibs::primitive::underlying::details {
+namespace mcpplibs::primitives::underlying::details {
 
 template <typename T>
 concept enabled = traits<std::remove_cv_t<T>>::enabled;
@@ -125,9 +125,9 @@ concept has_consistent_category =
      category_of_std_underlying_type<
          typename traits<std::remove_cv_t<T>>::rep_type>());
 
-} // namespace mcpplibs::primitive::underlying::details
+} // namespace mcpplibs::primitives::underlying::details
 
-export namespace mcpplibs::primitive {
+export namespace mcpplibs::primitives {
 
 template <typename T>
 concept underlying_type =
@@ -136,4 +136,4 @@ concept underlying_type =
     underlying::details::has_std_rep_type<T> &&
     underlying::details::has_consistent_category<T>;
 
-} // namespace mcpplibs::primitive
+} // namespace mcpplibs::primitives