Rewrite container parsing

include/iris/x4/auxiliary/attr.hpp

@@ -43,8 +43,6 @@ struct attr_parser : parser<attr_parser<T, HeldValueT>>
     using attribute_type = T;
     using held_value_type = HeldValueT;
 
-    static constexpr bool handles_container = traits::is_container_v<T>;
-
     template<class U>
         requires
             (!std::is_same_v<std::remove_cvref_t<U>, attr_parser>) &&
@@ -77,8 +75,6 @@ struct attr_parser<T, void> : parser<attr_parser<T, void>>
 
     using attribute_type = T;
 
-    static constexpr bool handles_container = traits::is_container_v<T>;
-
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4UnusedAttribute UnusedAttr>
     [[nodiscard]] static constexpr bool
     parse(It&, Se const&, Context const&, UnusedAttr const&) noexcept

include/iris/x4/core/action.hpp

@@ -27,8 +27,6 @@ namespace iris::x4 {
 
 namespace detail {
 
-struct raw_attribute_t;
-
 template<class Context, X4Attribute Attr>
 struct action_context;
 
@@ -207,17 +205,6 @@ struct action : proxy_parser<Subject, action<Subject, ActionF>>
         first = saved_first;
         return false;
     }
-
-    // attr==raw, action wants iterator_range (see raw.hpp)
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context>
-    [[nodiscard]] constexpr bool
-    parse_main(It& first, Se const& last, Context const& ctx, detail::raw_attribute_t&) const
-        noexcept(false) // construction of `subrange` is never noexcept as per the standard
-    {
-        // synthesize the attribute since one is not supplied
-        std::ranges::subrange<It, It> rng; // This must be It-It pair, NOT It-Se pair
-        return this->parse_main(first, last, ctx, rng);
-    }
 };
 
 template<X4Subject Subject, class Action>

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

@@ -67,7 +67,7 @@ template<class Parser, X4Attribute Attr>
 struct pass_parser_attribute
 {
     using attribute_type = parser_traits<Parser>::attribute_type;
-    using substitute_type = traits::variant_find_substitute_t<Attr, attribute_type>;
+    using substitute_type = traits::variant_find_holdable_type<Attr, attribute_type>::type;
 
     using type = std::conditional_t<
         std::same_as<Attr, substitute_type>,

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

@@ -16,213 +16,100 @@
 #include <iris/x4/core/container_appender.hpp>
 
 #include <iris/x4/traits/container_traits.hpp>
-#include <iris/x4/traits/substitution.hpp>
+#include <iris/x4/traits/tuple_traits.hpp>
+#include <iris/x4/traits/can_hold.hpp>
 
 #include <iris/alloy/tuple.hpp>
 
 #include <iterator>
 #include <type_traits>
 #include <utility>
 
-namespace iris::x4::detail {
-
-template<class Parser, class Container>
-struct parser_accepts_container
-    : traits::is_substitute<typename parser_traits<Parser>::attribute_type, Container>
-{};
-
-template<class Parser, class Container>
-constexpr bool parser_accepts_container_v = parser_accepts_container<Parser, Container>::value;
+namespace iris::x4 {
 
-template<class Parser>
-struct parse_into_container_base_impl
-{
-    // Parser has attribute (synthesize; Attribute is a container)
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
-        requires (!parser_accepts_container_v<Parser, unwrap_recursive_type<Attr>>)
-    [[nodiscard]] static constexpr bool
-    call_synthesize(
-        Parser const& parser, It& first, Se const& last,
-        Context const& ctx, Attr& attr
-    ) // never noexcept (requires container insertion)
-    {
-        static_assert(!std::same_as<std::remove_const_t<Attr>, unused_container_type>);
+template<class Subject>
+struct optional;
 
-        typename traits::container_value<unwrap_recursive_type<Attr>>::type val{}; // value-initialize
-
-        //static_assert(Parsable<Parser, It, Se, Context, value_type>);
-        if (!parser.parse(first, last, ctx, val)) return false;
-
-        // push the parsed value into our attribute
-        traits::push_back(unwrap_recursive(attr), std::move(val));
-        return true;
-    }
+} // iris::x4
 
-    // unused_container_type
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context>
-        requires (!parser_accepts_container_v<Parser, unused_container_type>)
-    [[nodiscard]] static constexpr bool
-    call_synthesize(
-        Parser const& parser, It& first, Se const& last,
-        Context const& ctx, unused_container_type const&
-    ) noexcept(is_nothrow_parsable_v<Parser, It, Se, Context, unused_type>)
-    {
-        //static_assert(Parsable<Parser, It, Se, Context, unused_type>);
-        return parser.parse(first, last, ctx, unused);
-    }
-
-    // Parser has attribute (synthesize; Attribute is a container)
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
-        requires parser_accepts_container_v<Parser, unwrap_recursive_type<Attr>>
-    [[nodiscard]] static constexpr bool
-    call_synthesize(
-        Parser const& parser, It& first, Se const& last,
-        Context const& ctx, Attr& attr
-    ) noexcept(is_nothrow_parsable_v<Parser, It, Se, Context, unwrap_recursive_type<Attr>>)
-    {
-        //static_assert(Parsable<Parser, It, Se, Context, unwrap_recursive_type<Attr>>);
-        return parser.parse(first, last, ctx, attr);
-    }
-
-    // ------------------------------------------------------
-
-    // Parser has attribute && it is NOT tuple-like
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
-        requires
-            has_attribute_v<Parser> &&
-            (!alloy::is_tuple_like_v<Attr>)
-    [[nodiscard]] static constexpr bool
-    call(
-        Parser const& parser, It& first, Se const& last,
-        Context const& ctx, Attr& attr
-    )
-    {
-        // TODO: reduce call stack while keeping maintainability
-        return parse_into_container_base_impl::call_synthesize(parser, first, last, ctx, attr);
-    }
+namespace iris::x4::detail {
 
-    // Parser has attribute && it is tuple-like
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
-        requires
-            has_attribute_v<Parser> &&
-            alloy::is_tuple_like_v<Attr>
-    [[nodiscard]] static constexpr bool
-    call(
-        Parser const& parser, It& first, Se const& last,
-        Context const& ctx, Attr& attr
-    ) noexcept(noexcept(parse_into_container_base_impl::call_synthesize(parser, first, last, ctx, alloy::get<0>(attr))))
-    {
-        static_assert(traits::has_size_v<Attr, 1>, "Expecting a single element tuple-like");
-        // TODO: reduce call stack while keeping maintainability
-        return parse_into_container_base_impl::call_synthesize(parser, first, last, ctx, alloy::get<0>(attr));
-    }
+// Determines whether `Parser` accepts "outer" Container as exposed attribute.
+// Returns `false` if parser's attribute type is same as "inner" type.
+template<class Parser, class Container>
+struct parser_accepts_container {};
 
-    // Parser has no attribute (pass unused)
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
-        requires (!has_attribute_v<Parser>)
-    [[nodiscard]] static constexpr bool
-    call(
-        Parser const& parser, It& first, Se const& last,
-        Context const& ctx, Attr& /* attr */
-    ) noexcept(is_nothrow_parsable_v<Parser, It, Se, Context, unused_container_type>)
-    {
-        // static_assert(Parsable<Parser, It, Se, Context, unused_container_type>);
-        return parser.parse(first, last, ctx, unused_container);
-    }
+template<class Parser, traits::X4Container Container>
+struct parser_accepts_container<Parser, Container>
+{
+    static constexpr bool value =
+        parser_traits<Parser>::template handles_container<Container> &&
+        (!std::same_as<typename parser_traits<Parser>::attribute_type, typename traits::container_value<Container>::type>);
 };
 
-template<class Parser>
-struct parse_into_container_impl : parse_into_container_base_impl<Parser> {};
-
+template<class Parser, class Container>
+inline constexpr bool parser_accepts_container_v = parser_accepts_container<Parser, Container>::value;
 
 template<class Parser>
-    requires Parser::handles_container
-struct parse_into_container_impl<Parser>
+struct parse_into_container_impl_default
 {
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
-    static constexpr bool pass_attibute_as_is = std::disjunction_v<
-        parser_accepts_container<Parser, Attr>,
-
-        std::negation<traits::is_substitute< // parser attribute is substitute for container value?
-            typename traits::pseudo_attribute<
-                It, Se, Context,
-                typename parser_traits<Parser>::attribute_type
-            >::actual_type,
-            typename traits::container_value<Attr>::type
-        >>
-    >;
-
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
-        requires (!pass_attibute_as_is<It, Se, Context, Attr>)
-    [[nodiscard]] static constexpr bool
-    call(
-        Parser const& parser, It& first, Se const& last,
-        Context const& ctx, Attr& attr
-    ) noexcept(noexcept(parse_into_container_base_impl<Parser>::call(
-        parser, first, last, ctx, attr
-    )))
-    {
-        return parse_into_container_base_impl<Parser>::call(
-            parser, first, last, ctx, attr
-        );
-    }
-
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context>
-        requires pass_attibute_as_is<It, Se, Context, unused_container_type>
-    [[nodiscard]] static constexpr bool
-    call(
-        Parser const& parser, It& first, Se const& last,
-        Context const& ctx, unused_container_type
-    ) noexcept(is_nothrow_parsable_v<Parser, It, Se, Context, unused_container_type>)
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4NonUnusedAttribute Attr>
+    static constexpr bool call(Parser const& parser, It& first, Se const& last, Context& ctx, Attr& attr)
     {
-        static_assert(Parsable<Parser, It, Se, Context, unused_container_type>);
-        return parser.parse(first, last, ctx, unused_container);
-    }
-
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
-        requires pass_attibute_as_is<It, Se, Context, Attr>
-    [[nodiscard]] static constexpr bool
-    call(
-        Parser const& parser, It& first, Se const& last,
-        Context const& ctx, Attr& attr
-    ) // never noexcept (requires container insertion)
-    {
-        static_assert(!std::same_as<std::remove_const_t<Attr>, unused_type>);
-        static_assert(!std::same_as<std::remove_const_t<Attr>, unused_container_type>);
-        static_assert(Parsable<Parser, It, Se, Context, Attr>);
-
-        auto&& appender = x4::make_container_appender(attr);
-        return parser.parse(first, last, ctx, appender);
+        using unwrapped_attribute_type = iris::unwrap_recursive_type<Attr>;
+        auto& unwrapped_attr = iris::unwrap_recursive(attr);
+
+        if constexpr (traits::is_container_v<unwrapped_attribute_type>) { // Attr is a container
+            if constexpr (parser_accepts_container_v<Parser, unwrapped_attribute_type>) { // parser accepts the container; make parser append directly
+                auto&& appender = x4::make_container_appender(unwrapped_attr);
+                return parser.parse(first, last, ctx, appender);
+            } else { // parser DOES NOT accept the container; parse into value type and append it
+                using value_type = traits::container_value<unwrapped_attribute_type>::type;
+                value_type value{}; // value-initialize
+                if (!parser.parse(first, last, ctx, value)) return false;
+                traits::push_back(unwrapped_attr, std::move(value));
+                return true;
+            }
+        } else {
+            if constexpr (traits::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 {
+                static_assert(false, "parse_into_container accepts a container, a variant of container or a single element tuple-like of container");
+                return false;
+            }
+        }
     }
 };
 
-template<
-    class Parser, std::forward_iterator It, std::sentinel_for<It> Se,
-    class Context, X4Attribute Attr
->
+// internal customization point
+template<class Parser>
+struct parse_into_container_impl
+    : parse_into_container_impl_default<Parser>
+{};
+
+template<class Parser, std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
 [[nodiscard]] constexpr bool
 parse_into_container(
     Parser const& parser, It& first, Se const& last,
     Context const& ctx, Attr& attr
-) noexcept(noexcept(parse_into_container_impl<Parser>::call(parser, first, last, ctx, attr)))
+) noexcept(X4UnusedAttribute<Attr> || !has_attribute_v<Parser>)
 {
-    static_assert(
-        !std::same_as<Attr, unused_type>,
-        "`unused_type` should not be passed to `parse_into_container`. Use `x4::assume_container(attr)`"
-    );
-
-    if constexpr (traits::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_substitute_t<Attr, typename traits::build_container<attribute_type>::type>;
-
-        // instead of creating a temporary `substitute_type`, append directly into the emplaced alternative
-        auto& variant_alt = attr.template emplace<substitute_type>();
-        return parse_into_container_impl<Parser>::call(parser, first, last, ctx, variant_alt);
+    if constexpr (X4UnusedAttribute<Attr> || !has_attribute_v<Parser>) { // handle unused types first
+        return parser.parse(first, last, ctx, unused);
     } else {
-        return parse_into_container_impl<Parser>::call(parser, first, last, ctx, attr);
+        if constexpr (traits::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;
+
+            // instead of creating a temporary `substitute_type`, append directly into the emplaced alternative
+            auto& variant_alt = attr.template emplace<substitute_type>();
+            return parse_into_container_impl<Parser>::call(parser, first, last, ctx, variant_alt);
+        } else {
+            return parse_into_container_impl<Parser>::call(parser, first, last, ctx, attr);
+        }
     }
 }