Move core traits to core/traits/

include/iris/x4/attribute/value.hpp

@@ -12,11 +12,11 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
+#include <iris/x4/traits/container_traits.hpp>
+#include <iris/x4/core/traits/char_traits.hpp>
+
 #include <iris/x4/core/parser.hpp>
 #include <iris/x4/core/move_to.hpp>
-#include <iris/x4/core/char_traits.hpp>
-
-#include <iris/x4/traits/container_traits.hpp>
 
 #include <string>
 #include <string_view>
@@ -93,7 +93,7 @@ struct fixed_value_parser<T, void> : parser<fixed_value_parser<T, void>>
     }
 
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4NonUnusedAttribute ContainerAttr>
-        requires traits::CategorizedAttr<ContainerAttr, traits::container_attr>
+        requires CategorizedAttr<ContainerAttr, container_tag>
     [[nodiscard]] static constexpr bool
     parse(It&, Se const&, Context const&, ContainerAttr& exposed_attr) noexcept
     {
@@ -102,7 +102,7 @@ struct fixed_value_parser<T, void> : parser<fixed_value_parser<T, void>>
     }
 
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4NonUnusedAttribute Attr>
-        requires (!traits::CategorizedAttr<Attr, traits::container_attr>)
+        requires (!CategorizedAttr<Attr, container_tag>)
     [[nodiscard]] static constexpr bool
     parse(It&, Se const&, Context const&, Attr& exposed_attr)
         noexcept(noexcept(exposed_attr = Attr{}))

include/iris/x4/char/char.hpp

@@ -13,14 +13,14 @@
 #include <iris/x4/char_string_literal.hpp> // IWYU pragma: export
 #include <iris/x4/char/any_char.hpp> // IWYU pragma: export
 
-#include <iris/x4/traits/char_encoding_traits.hpp>
+#include <iris/x4/core/traits/char_encoding_traits.hpp>
 
 namespace iris::x4 {
 
 namespace detail {
 
 template<class CharT>
-struct any_char_fn : any_char<traits::char_encoding_for<CharT>>
+struct any_char_fn : any_char<char_encoding_for<CharT>>
 {};
 
 } // detail

include/iris/x4/char/char_class.hpp

@@ -11,16 +11,14 @@
 ==============================================================================*/
 
 #include <iris/x4/core/skip_over.hpp>
-#include <iris/x4/core/char_traits.hpp>
+#include <iris/x4/core/traits/char_encoding_traits.hpp>
 
 #include <iris/x4/char/char_parser.hpp>
 #include <iris/x4/char/char_class_tags.hpp>
 #include <iris/x4/char/detail/cast_char.hpp>
 
 #include <iris/x4/string/case_compare.hpp>
 
-#include <iris/x4/traits/char_encoding_traits.hpp>
-
 #include <iris/x4/char_encoding/standard.hpp>
 
 #ifndef IRIS_X4_NO_STANDARD_WIDE
@@ -186,7 +184,7 @@ constexpr void builtin_skip_over(It& first, Se const& last) noexcept
     using CharT = std::remove_cvref_t<std::iter_value_t<It>>;
     static_assert(CharLike<CharT>);
 
-    using Encoding = traits::char_encoding_for<CharT>;
+    using Encoding = char_encoding_for<CharT>;
     using Parser = char_class_parser<Encoding, CharClassTag>;
 
     while (first != last && Parser::test(static_cast<Encoding::classify_type>(*first))) {

include/iris/x4/char/char_parser.hpp

@@ -13,7 +13,8 @@
 #include <iris/x4/core/parser.hpp>
 #include <iris/x4/core/skip_over.hpp>
 #include <iris/x4/core/move_to.hpp>
-#include <iris/x4/core/char_traits.hpp>
+
+#include <iris/x4/core/traits/char_traits.hpp>
 
 #include <concepts>
 #include <iterator>

include/iris/x4/char/char_set.hpp

@@ -13,7 +13,8 @@
 #include <iris/x4/char/char_parser.hpp>
 #include <iris/x4/char/detail/basic_chset.hpp>
 #include <iris/x4/string/case_compare.hpp>
-#include <iris/x4/core/char_traits.hpp>
+
+#include <iris/x4/core/traits/char_traits.hpp>
 
 #include <iris/unicode/string.hpp>
 

include/iris/x4/char_string_literal.hpp

@@ -11,9 +11,9 @@
 #include <iris/x4/char/literal_char.hpp>
 #include <iris/x4/string/literal_string.hpp>
 
+#include <iris/x4/core/traits/char_encoding_traits.hpp>
 #include <iris/x4/core/unused.hpp>
 #include <iris/x4/core/parser.hpp>
-#include <iris/x4/traits/char_encoding_traits.hpp>
 
 #include <iris/bits/specialization_of.hpp>
 
@@ -41,7 +41,7 @@ struct char_parser_fn
 {
     template<CharLike CharT>
     [[nodiscard]] static constexpr literal_char<
-        traits::char_encoding_for<CharT>,
+        char_encoding_for<CharT>,
         typename AttrSelectorTT<CharT>::type
     >
     operator()(CharT ch) noexcept
@@ -55,7 +55,7 @@ struct char_array_parser_fn
 {
     template<CharLike CharT>
     [[nodiscard]] static constexpr literal_char<
-        traits::char_encoding_for<CharT>,
+        char_encoding_for<CharT>,
         typename AttrSelectorTT<CharT>::type
     >
     operator()(CharT const (&str)[2]) noexcept
@@ -66,7 +66,7 @@ struct char_array_parser_fn
     template<CharLike CharT, std::size_t N>
     [[nodiscard]] static constexpr literal_string<
         std::array<CharT, N - 1>,
-        traits::char_encoding_for<CharT>,
+        char_encoding_for<CharT>,
         typename AttrSelectorTT<std::basic_string<CharT>>::type
     >
     operator()(CharT const (&str)[N]) noexcept
@@ -80,7 +80,7 @@ struct char_array_parser_fn
     template<CharLike CharT, std::size_t N>
     [[nodiscard]] static constexpr literal_string<
         std::basic_string_view<CharT>,
-        traits::char_encoding_for<CharT>,
+        char_encoding_for<CharT>,
         typename AttrSelectorTT<std::basic_string<CharT>>::type
     >
     operator()(CharT const (&str)[N]) noexcept
@@ -97,22 +97,22 @@ struct char_array_parser_fn<true, attribute_identity_switcher>
     template<CharLike CharT>
     [[nodiscard]] static constexpr literal_string<
         std::array<CharT, 1>,
-        traits::char_encoding_for<CharT>,
+        char_encoding_for<CharT>,
         std::basic_string<CharT>
     >
     operator()(CharT const (&str)[2]) noexcept
     {
         return literal_string<
             std::array<CharT, 1>,
-            traits::char_encoding_for<CharT>,
+            char_encoding_for<CharT>,
             std::basic_string<CharT>
         >{std::array{str[0]}};
     }
 
     template<CharLike CharT, std::size_t N>
     [[nodiscard]] static constexpr literal_string<
         std::array<CharT, N - 1>,
-        traits::char_encoding_for<CharT>,
+        char_encoding_for<CharT>,
         std::basic_string<CharT>
     >
     operator()(CharT const (&str)[N]) noexcept
@@ -126,7 +126,7 @@ struct char_array_parser_fn<true, attribute_identity_switcher>
     template<CharLike CharT, std::size_t N>
     [[nodiscard]] static constexpr literal_string<
         std::basic_string_view<CharT>,
-        traits::char_encoding_for<CharT>,
+        char_encoding_for<CharT>,
         std::basic_string<CharT>
     >
     operator()(CharT const (&str)[N]) noexcept
@@ -143,7 +143,7 @@ struct char_array_parser_fn<true, attribute_identity_switcher>
 //    template<CharLike CharT>
 //    [[nodiscard]] static constexpr literal_string<
 //        std::basic_string_view<CharT>,
-//        traits::char_encoding_for<CharT>,
+//        char_encoding_for<CharT>,
 //        typename AttrSelectorTT<std::basic_string<CharT>>::type
 //    >
 //    operator()(CharT const* s) noexcept
@@ -159,14 +159,14 @@ struct string_parser_fn
         requires is_ttp_specialization_of_v<std::remove_cvref_t<StringLikeT>, std::basic_string>
     [[nodiscard]] static constexpr literal_string<
         std::basic_string<char_type_for<StringLikeT>>,
-        traits::char_encoding_for<char_type_for<StringLikeT>>,
+        char_encoding_for<char_type_for<StringLikeT>>,
         typename AttrSelectorTT<std::basic_string<char_type_for<StringLikeT>>>::type
     >
     operator()(StringLikeT&& str)
         noexcept(std::is_nothrow_constructible_v<
             literal_string<
                 std::basic_string<char_type_for<StringLikeT>>,
-                traits::char_encoding_for<char_type_for<StringLikeT>>,
+                char_encoding_for<char_type_for<StringLikeT>>,
                 typename AttrSelectorTT<std::basic_string<char_type_for<StringLikeT>>>::type
             >,
             StringLikeT
@@ -183,14 +183,14 @@ struct string_view_parser_fn
         requires is_ttp_specialization_of_v<std::remove_cvref_t<StringLikeT>, std::basic_string_view>
     [[nodiscard]] static constexpr literal_string<
         std::basic_string_view<char_type_for<StringLikeT>>,
-        traits::char_encoding_for<char_type_for<StringLikeT>>,
+        char_encoding_for<char_type_for<StringLikeT>>,
         typename AttrSelectorTT<std::basic_string<char_type_for<StringLikeT>>>::type
     >
     operator()(StringLikeT&& str)
         noexcept(std::is_nothrow_constructible_v<
             literal_string<
                 std::basic_string_view<char_type_for<StringLikeT>>,
-                traits::char_encoding_for<char_type_for<StringLikeT>>,
+                char_encoding_for<char_type_for<StringLikeT>>,
                 typename AttrSelectorTT<std::basic_string<char_type_for<StringLikeT>>>::type
             >,
             StringLikeT

include/iris/x4/core/container_appender.hpp

@@ -1,4 +1,4 @@
-#ifndef IRIS_ZZ_X4_CORE_CONTAINER_APPENDER_HPP
+#ifndef IRIS_ZZ_X4_CORE_CONTAINER_APPENDER_HPP
 #define IRIS_ZZ_X4_CORE_CONTAINER_APPENDER_HPP
 
 /*=============================================================================
@@ -9,11 +9,12 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 
-#include <iris/config.hpp>
-#include <iris/type_traits.hpp>
+#include <iris/config.hpp> // IWYU pragma: keep
 
 #include <iris/x4/traits/container_traits.hpp>
-#include <iris/x4/traits/transform_attribute.hpp>
+#include <iris/x4/core/traits/transform_attribute.hpp>
+
+#include <iris/type_traits.hpp>
 
 #include <iterator>
 #include <type_traits>
@@ -141,19 +142,6 @@ make_container_appender(ContainerAttr& appender) noexcept
     return appender;
 }
 
-namespace traits {
-
-template<class ContainerAttr>
-struct append_container<container_appender<ContainerAttr>>
-{
-    template<std::forward_iterator It, std::sentinel_for<It> Se>
-    static constexpr void call(container_appender<ContainerAttr>& appender, It first, Se last)
-        noexcept(noexcept(traits::append(appender.container, std::move(first), std::move(last))))
-    {
-        traits::append(appender.container, std::move(first), std::move(last));
-    }
-};
-
 template<class Transformed>
 struct transform_attribute<Transformed, container_appender<Transformed>>
 {
@@ -170,6 +158,19 @@ struct transform_attribute<Transformed, container_appender<Transformed>>
     }
 };
 
+namespace traits {
+
+template<class ContainerAttr>
+struct append_container<container_appender<ContainerAttr>>
+{
+    template<std::forward_iterator It, std::sentinel_for<It> Se>
+    static constexpr void call(container_appender<ContainerAttr>& appender, It first, Se last)
+        noexcept(noexcept(traits::append(appender.container, std::move(first), std::move(last))))
+    {
+        traits::append(appender.container, std::move(first), std::move(last));
+    }
+};
+
 } // traits
 
 } // iris::x4

include/iris/x4/core/detail/parse_alternative.hpp

@@ -12,19 +12,18 @@
 
 #include <iris/config.hpp> // IWYU pragma: keep
 
+#include <iris/x4/traits/attribute_traits.hpp>
+#include <iris/x4/traits/container_traits.hpp>
+#include <iris/x4/core/traits/tuple_traits.hpp>
+#include <iris/x4/core/traits/variant_traits.hpp>
+
+#include <iris/x4/core/detail/parse_into_container.hpp>
 #include <iris/x4/core/expectation.hpp>
 #include <iris/x4/core/move_to.hpp>
 #include <iris/x4/core/nary_parser.hpp>
 #include <iris/x4/core/parser_traits.hpp>
 #include <iris/x4/core/unused.hpp>
-
-#include <iris/x4/traits/tuple_traits.hpp>
-#include <iris/x4/traits/variant_traits.hpp>
-#include <iris/x4/traits/container_traits.hpp>
-#include <iris/x4/traits/attribute_traits.hpp>
-
 #include <iris/x4/core/parser.hpp>
-#include <iris/x4/core/detail/parse_into_container.hpp>
 
 #include <iris/alloy/tuple.hpp> // IWYU pragma: keep
 
@@ -72,7 +71,7 @@ template<class Parser, X4Attribute Attr>
 struct pass_parser_attribute
 {
     using attribute_type = parser_traits<Parser>::attribute_type;
-    using substitute_type = traits::variant_find_holdable_type<Attr, attribute_type>::type;
+    using substitute_type = variant_find_holdable_type<Attr, attribute_type>::type;
 
     using type = std::conditional_t<
         std::same_as<Attr, substitute_type>,
@@ -113,7 +112,7 @@ struct pass_non_variant_attribute
 
 // Unwrap single element sequences
 template<class Parser, X4Attribute Attr>
-    requires traits::is_size_one_sequence_v<Attr>
+    requires tuple_is_size_one_sequence_v<Attr>
 struct pass_non_variant_attribute<Parser, Attr>
 {
     using attr_type = std::remove_reference_t<
@@ -132,7 +131,7 @@ struct pass_non_variant_attribute<Parser, Attr>
 };
 
 template<class Parser, X4Attribute Attr>
-    requires (!traits::is_variant_v<Attr>)
+    requires (!is_variant_v<Attr>)
 struct pass_parser_attribute<Parser, Attr>
     : pass_non_variant_attribute<Parser, Attr>
 {};
@@ -342,7 +341,7 @@ struct parse_into_container_impl<alternative<Ps...>>
         return parse_alternative_all<Ps...>::call(
             std::index_sequence_for<Ps...>{},
             [&]<std::size_t I>(auto& container_attr) {
-                if constexpr (traits::is_variant_v<typename traits::container_value<ExposedAttr>::type>) {
+                if constexpr (is_variant_v<typename traits::container_value<ExposedAttr>::type>) {
                     return detail::parse_into_container(alternative_helper{nary::get<I>(parser.elems)}, first, last, ctx, container_attr);
                 } else {
                     return detail::parse_into_container(nary::get<I>(parser.elems), first, last, ctx, container_attr);

include/iris/x4/core/detail/parse_into_container.hpp

@@ -16,7 +16,7 @@
 #include <iris/x4/core/container_appender.hpp>
 
 #include <iris/x4/traits/container_traits.hpp>
-#include <iris/x4/traits/tuple_traits.hpp>
+#include <iris/x4/core/traits/tuple_traits.hpp>
 
 #include <iris/alloy/tuple.hpp>
 
@@ -44,10 +44,10 @@ struct parser_accepts_container
 };
 
 template<class Parser, traits::X4Container Container>
-    requires traits::is_variant_v<typename parser_traits<Parser>::attribute_type>
+    requires is_variant_v<typename parser_traits<Parser>::attribute_type>
 struct parser_accepts_container<Parser, Container>
 {
-    using alternative_type = traits::variant_find_holdable_type<
+    using alternative_type = variant_find_holdable_type<
         typename parser_traits<Parser>::attribute_type,
         Container
     >::type;
@@ -83,7 +83,7 @@ struct parse_into_container_impl_default
             }
 
         } else {
-            if constexpr (traits::is_size_one_sequence_v<unwrapped_attribute_type>) {
+            if constexpr (tuple_is_size_one_sequence_v<unwrapped_attribute_type>) {
                 // attribute is single element tuple-like; unwrap and try again
                 return parse_into_container_impl_default<Parser>::call(parser, first, last, ctx, alloy::get<0>(unwrapped_attr));
             } else {
@@ -110,16 +110,16 @@ parse_into_container(Parser const& parser, It& first, Se const& last, Context co
     } else if constexpr (is_recursive_wrapper_v<Attr>) {
         return detail::parse_into_container(parser, first, last, ctx, *attr);
 
-    } else if constexpr (traits::is_size_one_sequence_v<Attr>) {
+    } else if constexpr (tuple_is_size_one_sequence_v<Attr>) {
         // A tuple-like holding a single container; parse into that container
         return detail::parse_into_container(parser, first, last, ctx, alloy::get<0>(attr));
 
-    } else if constexpr (traits::is_variant_v<Attr>) {
+    } else if constexpr (is_variant_v<Attr>) {
          // e.g. `char` when the caller is `+char_`
         using attribute_type = parser_traits<Parser>::attribute_type;
 
         // e.g. `std::string` when the attribute_type is `char`
-        using substitute_type = traits::variant_find_holdable_type<Attr, typename traits::default_container<attribute_type>::type>::type;
+        using substitute_type = variant_find_holdable_type<Attr, typename traits::default_container<attribute_type>::type>::type;
 
         // instead of creating a temporary `substitute_type`, append directly into the emplaced alternative
         auto& variant_alt = attr.template emplace<substitute_type>();