diff --git a/include/iris/x4/auxiliary/attr.hpp b/include/iris/x4/auxiliary/attr.hpp
index 62e6f63db..03dbb06b5 100644
--- a/include/iris/x4/auxiliary/attr.hpp
+++ b/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
diff --git a/include/iris/x4/core/action.hpp b/include/iris/x4/core/action.hpp
index fba6c57ab..d0a3195f9 100644
--- a/include/iris/x4/core/action.hpp
+++ b/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>
diff --git a/include/iris/x4/core/action_context.hpp b/include/iris/x4/core/action_context.hpp
index 972497620..33cefcc81 100644
--- a/include/iris/x4/core/action_context.hpp
+++ b/include/iris/x4/core/action_context.hpp
@@ -80,13 +80,6 @@ struct _as_var_fn
     static void operator()(Context const&&) = delete; // dangling
 };
 
-struct _where_fn
-{
-    template<class Context>
-    static constexpr void
-    operator()(Context const&) = delete; // `_where` is obsolete. Use `raw[...]` directive.
-};
-
 struct _attr_fn
 {
     template<class Context>
@@ -112,7 +105,6 @@ inline namespace cpos {
 inline constexpr detail::_rule_var_fn _val{};
 
 [[maybe_unused]] inline constexpr detail::_as_var_fn _as_var{};
-[[maybe_unused]] inline constexpr detail::_where_fn _where{}; // obsolete
 [[maybe_unused]] inline constexpr detail::_attr_fn _attr{};
 
 } // cpos
diff --git a/include/iris/x4/core/detail/parse_alternative.hpp b/include/iris/x4/core/detail/parse_alternative.hpp
index 7162d07ec..5176df180 100644
--- a/include/iris/x4/core/detail/parse_alternative.hpp
+++ b/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>,
diff --git a/include/iris/x4/core/detail/parse_into_container.hpp b/include/iris/x4/core/detail/parse_into_container.hpp
index 2593828b7..2b37abb06 100644
--- a/include/iris/x4/core/detail/parse_into_container.hpp
+++ b/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/substitution.hpp>
+#include <iris/x4/traits/tuple_traits.hpp>
 
 #include <iris/alloy/tuple.hpp>
 
@@ -24,205 +24,114 @@
 #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;
-
-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>);
-
-        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;
+namespace iris::x4 {
 
-        // push the parsed value into our attribute
-        traits::push_back(unwrap_recursive(attr), std::move(val));
-        return true;
-    }
+template<class Subject>
+struct optional;
 
-    // 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);
-    }
+} // iris::x4
 
-    // 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);
-    }
-
-    // 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));
-    }
+namespace iris::x4::detail {
 
-    // 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
+{
+    static constexpr bool value =
+        parser_traits<Parser>::template handles_container<Container> &&
+        !requires (Container& c, typename parser_traits<Parser>::attribute_type&& v) {
+            traits::push_back(c, std::move(v));
+        };
 };
 
-template<class Parser>
-struct parse_into_container_impl : parse_into_container_base_impl<Parser> {};
-
+template<class Parser, traits::X4Container Container>
+    requires traits::is_variant_v<typename parser_traits<Parser>::attribute_type>
+struct parser_accepts_container<Parser, Container>
+{
+    using alternative_type = traits::variant_find_holdable_type<
+        typename parser_traits<Parser>::attribute_type,
+        Container
+    >::type;
+
+    static constexpr bool value =
+        parser_traits<Parser>::template handles_container<Container> &&
+        !requires (Container& c, alternative_type&& v) {
+            traits::push_back(c, std::move(v));
+        };
+};
 
 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
-    )))
+    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)
+        // never noexcept (requires container insertion)
     {
-        return parse_into_container_base_impl<Parser>::call(
-            parser, first, last, ctx, attr
-        );
+        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<Parser, unwrapped_attribute_type>::value) {
+                // `Parser` accepts the exact `Container`; let parser append directly
+                auto&& appender = x4::make_container_appender(unwrapped_attr);
+                return parser.parse(first, last, ctx, appender);
+
+            } else {
+                // `Parser` DOES NOT accept the exact `Container`; parse into `value_type` and append it.
+                typename traits::container_value<unwrapped_attribute_type>::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 {
+                //attr = nullptr;
+                static_assert(false, "[BUG] parse_into_container accepts a container, a variant of container or a single element tuple-like of container");
+                return false;
+            }
+        }
     }
+};
 
-    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>)
-    {
-        static_assert(Parsable<Parser, It, Se, Context, unused_container_type>);
-        return parser.parse(first, last, ctx, unused_container);
-    }
+// internal customization point
+template<class Parser>
+struct parse_into_container_impl
+    : parse_into_container_impl_default<Parser>
+{};
 
-    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>);
+template<class Parser, class It, class Se, class Context, class Attr>
+struct parse_into_container_noexcept : std::false_type {};
 
-        auto&& appender = x4::make_container_appender(attr);
-        return parser.parse(first, last, ctx, appender);
-    }
-};
+template<class Parser, class It, class Se, class Context, class Attr>
+    requires X4UnusedAttribute<Attr> || (!has_attribute_v<Parser>)
+struct parse_into_container_noexcept<Parser, It, Se, Context, Attr> : is_nothrow_parsable<Parser, It, Se, Context, unused_type> {};
 
-template<
-    class Parser, std::forward_iterator It, std::sentinel_for<It> Se,
-    class Context, X4Attribute Attr
->
+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(parse_into_container_noexcept<Parser, It, Se, Context, Attr>::value)
 {
-    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);
+        }
     }
 }
 
diff --git a/include/iris/x4/core/detail/parse_sequence.hpp b/include/iris/x4/core/detail/parse_sequence.hpp
index 61242686f..6c534f0dd 100644
--- a/include/iris/x4/core/detail/parse_sequence.hpp
+++ b/include/iris/x4/core/detail/parse_sequence.hpp
@@ -18,7 +18,7 @@
 #include <iris/x4/traits/attribute_category.hpp>
 #include <iris/x4/traits/container_traits.hpp>
 #include <iris/x4/traits/tuple_traits.hpp>
-#include <iris/x4/traits/substitution.hpp>
+#include <iris/x4/traits/can_hold.hpp>
 
 #include <iris/alloy/tuple.hpp>
 #include <iris/alloy/utility.hpp>
@@ -97,15 +97,14 @@ struct pass_sequence_attribute<Parser, Attr>
 {};
 
 template<class LParser, class RParser, class Attr>
-struct partition_attribute
-{
-    using attr_category = traits::attribute_category_t<Attr>;
-
-    static_assert(
-        std::same_as<traits::tuple_attr, attr_category>,
-        "The parser expects tuple-like attribute type"
-    );
+struct partition_attribute {};
 
+template<class LParser, class RParser, traits::CategorizedAttr<traits::tuple_attr> Attr>
+    requires
+        has_attribute_v<LParser> &&
+        has_attribute_v<RParser>
+struct partition_attribute<LParser, RParser, Attr>
+{
     static constexpr std::size_t l_size = parser_traits<LParser>::sequence_size;
     static constexpr std::size_t r_size = parser_traits<RParser>::sequence_size;
 
@@ -243,7 +242,7 @@ template<class Parser, std::forward_iterator It, std::sentinel_for<It> Se, class
 parse_sequence_impl(Parser const& parser, It& first, Se const& last, Context const& ctx, Attr& attr)
     noexcept(is_nothrow_parsable_v<Parser, It, Se, Context, Attr>)
 {
-    static_assert(Parsable<Parser, It, Se, Context, Attr>);
+    // static_assert(Parsable<Parser, It, Se, Context, Attr>);
     return parser.parse(first, last, ctx, attr);
 }
 
@@ -281,49 +280,27 @@ parse_sequence(Parser const& parser, It& first, Se const& last, Context const& c
 template<class Left, class Right>
 struct parse_into_container_impl<sequence<Left, Right>>
 {
-    template<X4Attribute Attr>
-    static constexpr bool is_container_substitute = traits::is_substitute_v<
-        typename sequence<Left, Right>::attribute_type,
-        typename traits::container_value<Attr>::type
-    >;
-
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
-        requires is_container_substitute<Attr>
-    [[nodiscard]] static constexpr bool
-    call(
-        sequence<Left, Right> const& parser, It& first, Se const& last,
-        Context const& ctx, Attr& attr
-    ) noexcept(noexcept(parse_into_container_base_impl<sequence<Left, Right>>::call(
-        parser, first, last, ctx, attr
-    )))
-    {
-        return parse_into_container_base_impl<sequence<Left, Right>>::call(
-            parser, first, last, ctx, attr
-        );
-    }
-
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
-        requires (!is_container_substitute<Attr>)
     [[nodiscard]] static constexpr bool
     call(
         sequence<Left, Right> const& parser, It& first, Se const& last,
         Context const& ctx, Attr& attr
     ) // never noexcept (requires container insertion)
     {
-        static_assert(
-            std::same_as<traits::attribute_category_t<Attr>, traits::container_attr> ||
-            std::same_as<traits::attribute_category_t<Attr>, traits::unused_attr>
-        );
-
-        if constexpr (
-            std::same_as<std::remove_const_t<Attr>, unused_type> ||
-            std::same_as<std::remove_const_t<Attr>, unused_container_type>
-        ) {
-            return detail::parse_sequence(parser, first, last, ctx, x4::assume_container(attr));
-
+        if constexpr (traits::is_container_v<Attr>) {
+            constexpr bool sequence_attribute_can_directly_hold_value_type = traits::can_hold<
+                typename sequence<Left, Right>::attribute_type,
+                typename traits::container_value<Attr>::type
+            >::value;
+            if constexpr (sequence_attribute_can_directly_hold_value_type) {
+                return parse_into_container_impl_default<sequence<Left, Right>>::call(parser, first, last, ctx, attr);
+
+            } else {
+                auto&& appender = x4::make_container_appender(x4::assume_container(attr));
+                return detail::parse_sequence(parser, first, last, ctx, appender);
+            }
         } else {
-            auto&& appender = x4::make_container_appender(x4::assume_container(attr));
-            return detail::parse_sequence(parser, first, last, ctx, appender);
+            return parse_into_container_impl_default<sequence<Left, Right>>::call(parser, first, last, ctx, attr);
         }
     }
 };
diff --git a/include/iris/x4/core/list_like_parser.hpp b/include/iris/x4/core/list_like_parser.hpp
new file mode 100644
index 000000000..aad76b3fc
--- /dev/null
+++ b/include/iris/x4/core/list_like_parser.hpp
@@ -0,0 +1,140 @@
+#ifndef IRIS_X4_CORE_LIST_LIKE_PARSER_HPP
+#define IRIS_X4_CORE_LIST_LIKE_PARSER_HPP
+
+#include <iris/config.hpp>
+
+#include <iris/x4/traits/tuple_traits.hpp>
+#include <iris/x4/traits/variant_traits.hpp>
+
+#include <iris/x4/core/detail/parse_into_container.hpp> // export
+#include <iris/x4/core/parser.hpp> // export
+#include <iris/x4/core/attribute.hpp>
+#include <iris/x4/core/container_appender.hpp>
+
+#include <iris/rvariant/rvariant.hpp>
+#include <iris/rvariant/variant_helper.hpp>
+
+#include <iris/alloy/tuple.hpp>
+#include <iris/alloy/traits.hpp>
+
+#include <type_traits>
+
+namespace iris::x4 {
+
+namespace list_like_parser {
+
+namespace detail {
+
+template<X4NonUnusedAttribute ParserAttr, X4NonUnusedAttribute ExposedAttr>
+    // non-variant `ExposedAttr`
+struct unwrap_container_candidate
+{
+    using type = traits::synthesized_value<
+        unwrap_recursive_type<
+            typename unwrap_container_appender<ExposedAttr>::type
+        >
+    >::type;
+};
+
+template<X4NonUnusedAttribute ParserAttr, X4NonUnusedAttribute ExposedVariant>
+    requires traits::is_variant_v<unwrap_recursive_type<ExposedVariant>>
+struct unwrap_container_candidate<ParserAttr, ExposedVariant>
+{
+    using type = traits::variant_find_holdable_type<
+        unwrap_recursive_type<ExposedVariant>, ParserAttr
+    >::type;
+};
+
+template<X4NonUnusedAttribute ParserAttr, X4NonUnusedAttribute ExposedAttr>
+struct chunk_buffer_impl
+{
+    using type = unwrap_container_candidate<ParserAttr, ExposedAttr>::type;
+    static_assert(traits::X4Container<typename unwrap_container_candidate<ParserAttr, ExposedAttr>::type>);
+};
+
+template<class T>
+[[nodiscard]] constexpr auto&& unwrap_single_element(T&& value) noexcept
+{
+    return std::forward<T>(value);
+}
+
+template<class T>
+    requires traits::is_size_one_sequence_v<std::remove_cvref_t<T>>
+[[nodiscard]] constexpr auto&& unwrap_single_element(T&& value) noexcept
+{
+    return std::forward_like<T>(alloy::get<0>(std::forward<T>(value)));
+}
+
+template<class T>
+struct unwrap_single_element_plain
+{
+    using type = std::remove_cvref_t<T>;
+};
+
+template<class T>
+    requires traits::is_size_one_sequence_v<std::remove_cvref_t<T>>
+struct unwrap_single_element_plain<T>
+{
+    using type = std::remove_cvref_t<alloy::tuple_element_t<0, T>>;
+};
+
+} // detail
+
+
+template<X4NonUnusedAttribute ParserAttr, X4NonUnusedAttribute ExposedAttr>
+using chunk_buffer = detail::chunk_buffer_impl<ParserAttr, ExposedAttr>::type;
+
+
+template<X4NonUnusedAttribute ParserAttr, X4NonUnusedAttribute ExposedAttr>
+[[nodiscard]] constexpr auto& get_container(ExposedAttr& attr)
+{
+    using unwrapped_attr_type = detail::unwrap_single_element_plain<
+        unwrap_recursive_type<ExposedAttr>
+    >::type;
+    auto& unwrapped_attr = detail::unwrap_single_element(iris::unwrap_recursive(attr));
+
+    if constexpr (traits::is_variant_v<unwrapped_attr_type>) {
+        using container_alternative = traits::variant_find_holdable_type<
+            unwrapped_attr_type, ParserAttr
+        >::type;
+
+        if (iris::holds_alternative<container_alternative>(unwrapped_attr)) {
+            return iris::unsafe_get<container_alternative>(unwrapped_attr);
+        } else {
+            return unwrapped_attr.template emplace<container_alternative>();
+        }
+
+    } else {
+        return unwrapped_attr;
+    }
+}
+
+
+template<traits::X4Container ChunkBuf, traits::X4Container ExposedAttr>
+constexpr void successful_merge_into(ChunkBuf& chunk_buf, ExposedAttr& container_attr)
+{
+    traits::append(
+        container_attr,
+        std::make_move_iterator(traits::begin(chunk_buf)),
+        std::make_move_iterator(traits::end(chunk_buf))
+    );
+    traits::clear(chunk_buf);
+}
+
+template<traits::X4Container ChunkBuf, traits::X4Container ExposedAttr>
+    requires traits::is_variant_v<typename detail::unwrap_single_element_plain<ExposedAttr>::type>
+constexpr void successful_merge_into(ChunkBuf& chunk_buf, ExposedAttr& container_attr)
+{
+    traits::append(
+        container_attr,
+        std::make_move_iterator(traits::begin(chunk_buf)),
+        std::make_move_iterator(traits::end(chunk_buf))
+    );
+    traits::clear(chunk_buf);
+}
+
+} // list_like_parser
+
+} // iris::x4
+
+#endif
diff --git a/include/iris/x4/core/move_to.hpp b/include/iris/x4/core/move_to.hpp
index c87d7f8f4..24612e6c1 100644
--- a/include/iris/x4/core/move_to.hpp
+++ b/include/iris/x4/core/move_to.hpp
@@ -153,49 +153,35 @@ move_to(Source&& src, Dest& dest)
 }
 
 template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::variant_attr> Dest>
-    requires traits::is_size_one_sequence_v<Source> && traits::variant_has_substitute_v<Dest, Source>
+    requires std::is_assignable_v<Dest&, Source&&>
 constexpr void
 move_to(Source&& src, Dest& dest)
     noexcept(std::is_nothrow_assignable_v<Dest&, Source&&>)
 {
     static_assert(!std::same_as<std::remove_cvref_t<Source>, Dest>, "[BUG] This call should instead resolve to the overload handling identical types");
 
-    // dest is a variant, src is a single element tuple-like that the variant
-    // *can* directly hold.
-    static_assert(std::is_assignable_v<Dest&, Source>);
+    // e.g. Dest is `iris::rvariant<int>` and Source is `int`
+    // e.g. Dest is `iris::rvariant<alloy::tuple<int>>` and Source is `alloy::tuple<int>`
     dest = std::forward<Source>(src);
 }
 
 template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::variant_attr> Dest>
-    requires traits::is_size_one_sequence_v<Source> && (!traits::variant_has_substitute_v<Dest, Source>)
+    requires (!std::is_assignable_v<Dest&, Source&&>) && traits::is_size_one_sequence_v<Source>
 constexpr void
 move_to(Source&& src, Dest& dest)
     noexcept(noexcept(dest = std::forward_like<Source>(alloy::get<0>(std::forward<Source>(src)))))
 {
     static_assert(!std::same_as<std::remove_cvref_t<Source>, Dest>, "[BUG] This call should instead resolve to the overload handling identical types");
 
-    // dest is a variant, src is a single element tuple-like that the variant
-    // cannot directly hold. We'll try to unwrap the single element tuple-like.
-
-    // Make sure that the Dest variant can really hold Source
     static_assert(
-        traits::variant_has_substitute_v<Dest, alloy::tuple_element_t<0, Source>>,
+        std::is_assignable_v<Dest&, decltype(std::forward_like<Source>(alloy::get<0>(std::forward<Source>(src))))>,
         "Error! The destination variant (Dest) cannot hold the source type (Source)"
     );
 
-    // TODO: preliminarily invoke static_assert to check if the assignment is valid
-    dest = std::forward_like<Source>(alloy::get<0>(std::forward<Source>(src)));
-}
+    // forward_like is *required*, since when Source is `alloy::tuple<int&>` `alloy::get<0>(std::forward<Source>(src))` returns `int&` whereas we want `int&&` instead
 
-template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::variant_attr> Dest>
-    requires (!traits::is_size_one_sequence_v<Source>)
-constexpr void
-move_to(Source&& src, Dest& dest)
-    noexcept(std::is_nothrow_assignable_v<Dest&, Source&&>)
-{
-    static_assert(!std::same_as<std::remove_cvref_t<Source>, Dest>, "[BUG] This call should instead resolve to the overload handling identical types");
-    static_assert(std::is_assignable_v<Dest&, Source>);
-    dest = std::forward<Source>(src);
+    // e.g. Dest is `iris::rvariant<int>` and Source is `alloy::tuple<int>`
+    dest = std::forward_like<Source>(alloy::get<0>(std::forward<Source>(src)));
 }
 
 template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::optional_attr> Dest>
@@ -221,26 +207,17 @@ move_to(It first, Se last, Dest& dest)
     static_assert(!std::same_as<std::remove_const_t<Dest>, unused_type>);
     static_assert(!std::same_as<std::remove_const_t<Dest>, unused_container_type>);
 
-    // Be careful, this may result in converting surprisingly incompatible types,
-    // for example, `std::vector<int>` and `std::set<int>`. Such types must be
-    // handled *before* invoking `move_to`.
-
-    if constexpr (is_ttp_specialization_of_v<std::remove_const_t<Dest>, container_appender>) {
-        traits::append(dest, first, last);
-
-    } else {
+    if constexpr (!is_ttp_specialization_of_v<Dest, container_appender>) {
         if (!traits::is_empty(dest)) {
             traits::clear(dest);
         }
-        traits::append(dest, first, last); // try to reuse underlying memory buffer
     }
-}
 
-template<std::forward_iterator It, std::sentinel_for<It> Se, std::ranges::subrange_kind Kind>
-constexpr void
-move_to(It first, Se last, std::ranges::subrange<It, Se, Kind>& rng)
-{
-    rng = std::ranges::subrange<It, Se, Kind>(std::move(first), std::move(last));
+    // Be careful, this may result in converting surprisingly incompatible types,
+    // for example, `std::vector<int>` and `std::set<int>`. Such types must be
+    // handled *before* invoking `move_to`.
+
+    traits::append(dest, first, last); // try to reuse underlying memory buffer
 }
 
 template<std::forward_iterator It, std::sentinel_for<It> Se, traits::CategorizedAttr<traits::tuple_attr> Dest>
@@ -278,10 +255,14 @@ move_to(Source&& src, Dest& dest)
 {
     static_assert(!std::same_as<std::remove_cvref_t<Source>, Dest>, "[BUG] This call should instead resolve to the overload handling identical types");
 
-    if constexpr (std::is_rvalue_reference_v<Source&&>) {
-        x4::move_to(std::make_move_iterator(std::ranges::begin(src)), std::make_move_iterator(std::ranges::end(src)), dest);
+    if constexpr (std::same_as<std::remove_cvref_t<Source>, typename traits::container_value<Dest>::type>) {
+        traits::push_back(dest, std::forward<Source>(src));
     } else {
-        x4::move_to(std::ranges::begin(src), std::ranges::end(src), dest);
+        if constexpr (std::is_rvalue_reference_v<Source&&>) {
+            x4::move_to(std::make_move_iterator(std::ranges::begin(src)), std::make_move_iterator(std::ranges::end(src)), dest);
+        } else {
+            x4::move_to(std::ranges::begin(src), std::ranges::end(src), dest);
+        }
     }
 }
 
diff --git a/include/iris/x4/core/parser.hpp b/include/iris/x4/core/parser.hpp
index 7cd67f132..efdcbf68c 100644
--- a/include/iris/x4/core/parser.hpp
+++ b/include/iris/x4/core/parser.hpp
@@ -46,7 +46,6 @@ struct parser : private detail::parser_base
     static_assert(!std::is_reference_v<Derived>);
     using derived_type = Derived;
 
-    static constexpr bool handles_container = false;
     static constexpr bool has_action = false;
     static constexpr bool need_rcontext = false;
 
@@ -117,9 +116,11 @@ struct proxy_parser : unary_parser<Subject, Derived>
     using attribute_type = parser_traits<Subject>::attribute_type;
 
     static constexpr bool has_attribute = x4::has_attribute_v<Subject>;
-    static constexpr bool handles_container = Subject::handles_container;
     static constexpr std::size_t sequence_size = parser_traits<Subject>::sequence_size;
 
+    template<class Container>
+    static constexpr bool handles_container = parser_traits<Subject>::template handles_container<Container>;
+
     using unary_parser<Subject, Derived>::unary_parser;
 };
 
diff --git a/include/iris/x4/core/parser_traits.hpp b/include/iris/x4/core/parser_traits.hpp
index b5f98abdc..acb25898f 100644
--- a/include/iris/x4/core/parser_traits.hpp
+++ b/include/iris/x4/core/parser_traits.hpp
@@ -1,4 +1,4 @@
-#ifndef IRIS_ZZ_X4_CORE_PARSER_TRAITS_HPP
+#ifndef IRIS_ZZ_X4_CORE_PARSER_TRAITS_HPP
 #define IRIS_ZZ_X4_CORE_PARSER_TRAITS_HPP
 
 /*=============================================================================
@@ -11,6 +11,8 @@
 
 #include <iris/config.hpp>
 
+#include <iris/x4/traits/can_hold.hpp>
+
 #include <type_traits>
 
 #include <cstddef>
@@ -41,6 +43,23 @@ struct get_attribute_type<Parser>
     using type = Parser::attribute_type;
 };
 
+template<class Parser, class Container>
+struct get_handles_container
+{
+    static constexpr bool value = traits::can_hold<
+        typename get_attribute_type<Parser>::type,
+        Container
+    >::value;
+};
+
+template<class Parser, class Container>
+    requires
+        requires { Parser::template handles_container<Container>; }
+struct get_handles_container<Parser, Container>
+{
+    static constexpr bool value = Parser::template handles_container<Container>;
+};
+
 } // detail
 
 
@@ -112,7 +131,9 @@ struct parser_traits
 
     static constexpr std::size_t sequence_size = detail::get_sequence_size<Parser>::value;
 
-    static constexpr bool handles_container = Parser::handles_container;
+    template<class Container>
+    static constexpr bool handles_container = detail::get_handles_container<Parser, Container>::value;
+
     static constexpr bool has_action = Parser::has_action;
     static constexpr bool need_rcontext = Parser::need_rcontext;
 };
diff --git a/include/iris/x4/directive.hpp b/include/iris/x4/directive.hpp
index 20fe1595c..898383ef1 100644
--- a/include/iris/x4/directive.hpp
+++ b/include/iris/x4/directive.hpp
@@ -18,7 +18,6 @@
 #include <iris/x4/directive/no_case.hpp>
 #include <iris/x4/directive/no_skip.hpp>
 #include <iris/x4/directive/omit.hpp>
-#include <iris/x4/directive/raw.hpp>
 #include <iris/x4/directive/repeat.hpp>
 #include <iris/x4/directive/seek.hpp>
 #include <iris/x4/directive/skip.hpp>
diff --git a/include/iris/x4/directive/as.hpp b/include/iris/x4/directive/as.hpp
index a61d946f4..c4f2c4a6c 100644
--- a/include/iris/x4/directive/as.hpp
+++ b/include/iris/x4/directive/as.hpp
@@ -1,4 +1,4 @@
-#ifndef IRIS_ZZ_X4_DIRECTIVE_AS_HPP
+#ifndef IRIS_ZZ_X4_DIRECTIVE_AS_HPP
 #define IRIS_ZZ_X4_DIRECTIVE_AS_HPP
 
 /*=============================================================================
@@ -54,6 +54,11 @@ struct as_directive : unary_parser<Subject, as_directive<T, Subject>>
     static constexpr bool has_attribute = !std::same_as<T, unused_type>;
     static constexpr bool has_action = false; // Explicitly re-enable attribute detection in `x4::rule`
 
+    // `as_directive` should NOT inherit underlying parser's `handles_container`
+    // because `as_directive` is an atomic parser. The default implementation of
+    // `parser_traits<as_directive<...>>::handles_container` must transparently
+    // handle this case.
+
 private:
     static constexpr bool need_as_var = Subject::has_action;
 
@@ -119,12 +124,12 @@ struct as_directive : unary_parser<Subject, as_directive<T, Subject>>
         return true;
     }
 
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4NonUnusedAttribute OuterAttr>
-        requires
-            (!std::same_as<std::remove_const_t<OuterAttr>, T>) &&
-            (!X4Movable<T, OuterAttr>)
-    constexpr void
-    parse(It&, Se const&, Context const&, OuterAttr&) const = delete; // `T` is not movable to the exposed attribute
+    //template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4NonUnusedAttribute OuterAttr>
+    //    requires
+    //        (!std::same_as<std::remove_const_t<OuterAttr>, T>) &&
+    //        (!X4Movable<T, OuterAttr>)
+    //constexpr void
+    //parse(It&, Se const&, Context const&, OuterAttr&) const = delete; // `T` is not movable to the exposed attribute
 };
 
 namespace detail {
diff --git a/include/iris/x4/directive/raw.hpp b/include/iris/x4/directive/raw.hpp
deleted file mode 100644
index 00a27f987..000000000
--- a/include/iris/x4/directive/raw.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-#ifndef IRIS_ZZ_X4_DIRECTIVE_RAW_HPP
-#define IRIS_ZZ_X4_DIRECTIVE_RAW_HPP
-
-/*=============================================================================
-    Copyright (c) 2014 Joel de Guzman
-    Copyright (c) 2025 Nana Sakisaka
-    Copyright (c) 2026 The Iris Project Contributors
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-=============================================================================*/
-
-#include <iris/x4/core/skip_over.hpp>
-#include <iris/x4/core/parser.hpp>
-#include <iris/x4/core/move_to.hpp>
-
-#include <ranges>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-
-namespace iris::x4 {
-
-namespace detail {
-
-// Pseudo attribute type indicating that the parser wants the
-// iterator range pointing to the [first, last) matching characters from
-// the input iterators.
-struct raw_attribute_t {};
-
-} // detail
-
-template<class Subject>
-struct raw_directive : unary_parser<Subject, raw_directive<Subject>>
-{
-    using attribute_type = detail::raw_attribute_t;
-
-    static constexpr bool handles_container = true;
-
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4NonUnusedAttribute Attr>
-    [[nodiscard]] constexpr bool
-    parse(It& first, Se const& last, Context const& ctx, Attr& attr) const
-        // never noexcept; construction of `std::ranges::subrange` is never noexcept
-    {
-        static_assert(Parsable<Subject, It, Se, Context, unused_type>);
-
-        x4::skip_over(first, last, ctx);
-        It local_it = first;
-        if (!this->subject.parse(local_it, last, ctx, unused)) return false;
-
-        x4::move_to(first, local_it, attr);
-        first = local_it;
-        return true;
-    }
-
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4UnusedAttribute UnusedAttr>
-    [[nodiscard]] constexpr bool
-    parse(It& first, Se const& last, Context const& ctx, UnusedAttr const&) const
-        noexcept(is_nothrow_parsable_v<Subject, It, Se, Context, unused_type>)
-    {
-        return this->subject.parse(first, last, ctx, unused);
-    }
-};
-
-namespace detail {
-
-struct raw_gen
-{
-    template<X4Subject Subject>
-    [[nodiscard]] constexpr raw_directive<as_parser_plain_t<Subject>>
-    operator[](Subject&& subject) const
-        noexcept(is_parser_nothrow_constructible_v<raw_directive<as_parser_plain_t<Subject>>, Subject>)
-    {
-        return {as_parser(std::forward<Subject>(subject))};
-    }
-};
-
-} // detail
-
-namespace parsers::directive {
-
-[[maybe_unused]] inline constexpr detail::raw_gen raw{};
-
-} // parsers::directive
-
-using parsers::directive::raw;
-
-} // iris::x4
-
-namespace iris::x4::traits {
-
-template<std::forward_iterator It, std::sentinel_for<It> Se, class Context>
-struct pseudo_attribute<It, Se, Context, x4::detail::raw_attribute_t>
-{
-    using actual_type = std::ranges::subrange<It, Se>;
-
-    [[nodiscard]] static constexpr actual_type
-    make_actual_type(It& first, Se const& last, Context const&, x4::detail::raw_attribute_t)
-    {
-        return {first, last};
-    }
-};
-
-} // iris::x4::traits
-
-#endif
diff --git a/include/iris/x4/directive/repeat.hpp b/include/iris/x4/directive/repeat.hpp
index 5bf43d63d..e5cff7659 100644
--- a/include/iris/x4/directive/repeat.hpp
+++ b/include/iris/x4/directive/repeat.hpp
@@ -13,8 +13,8 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
-#include <iris/x4/core/parser.hpp>
-#include <iris/x4/operator/kleene.hpp>
+#include <iris/x4/core/list_like_parser.hpp>
+#include <iris/x4/core/unused.hpp>
 #include <iris/x4/core/expectation.hpp>
 
 #include <iterator>
@@ -39,7 +39,7 @@ struct exact_count // handles repeat(exact)[p]
     [[nodiscard]] constexpr bool got_max(T i) const noexcept { return i >= exact_value; }
     [[nodiscard]] constexpr bool got_min(T i) const noexcept { return i >= exact_value; }
 
-    T exact_value;
+    T exact_value{};
 };
 
 template<std::integral T>
@@ -49,8 +49,8 @@ struct finite_count // handles repeat(min, max)[p]
     [[nodiscard]] constexpr bool got_max(T i) const noexcept { return i >= max_value; }
     [[nodiscard]] constexpr bool got_min(T i) const noexcept { return i >= min_value; }
 
-    T min_value;
-    T max_value;
+    T min_value{};
+    T max_value{};
 };
 
 template<std::integral T>
@@ -60,7 +60,7 @@ struct infinite_count // handles repeat(min, inf)[p]
     [[nodiscard]] constexpr bool got_max(T /*i*/) const noexcept { return false; }
     [[nodiscard]] constexpr bool got_min(T i) const noexcept { return i >= min_value; }
 
-    T min_value;
+    T min_value{};
 };
 
 template<class Bounds>
@@ -87,9 +87,13 @@ template<class Subject, detail::RepeatBounds Bounds>
 struct repeat_directive : proxy_parser<Subject, repeat_directive<Subject, Bounds>>
 {
     using base_type = proxy_parser<Subject, repeat_directive>;
-    using attribute_type = traits::build_container<typename parser_traits<Subject>::attribute_type>::type;
+    using attribute_type = traits::default_container<typename parser_traits<Subject>::attribute_type>::type;
 
-    static constexpr bool handles_container = true;
+    template<class Container>
+    static constexpr bool handles_container = std::disjunction_v<
+        traits::can_hold<typename parser_traits<Subject>::attribute_type, Container>,
+        traits::can_hold<typename parser_traits<Subject>::attribute_type, typename traits::container_value<Container>::type>
+    >;
 
     template<class SubjectT, detail::RepeatBounds BoundsT>
         requires std::is_constructible_v<base_type, SubjectT> && std::is_constructible_v<Bounds, BoundsT>
@@ -99,15 +103,55 @@ struct repeat_directive : proxy_parser<Subject, repeat_directive<Subject, Bounds
         , bounds_(std::forward<BoundsT>(bounds))
     {}
 
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4NonUnusedAttribute Attr>
     [[nodiscard]] constexpr bool
     parse(It& first, Se const& last, Context const& ctx, Attr& attr) const
-        // never noexcept (requires container insertion)
+        // never noexcept; requires container insertion
+    {
+        auto& container_attr = list_like_parser::get_container<attribute_type, Attr>(attr);
+        list_like_parser::chunk_buffer<attribute_type, Attr> chunk_buf;
+
+        It local_it = first;
+        typename Bounds::value_type i{};
+        for (; !bounds_.got_min(i); ++i) {
+            if (detail::parse_into_container(this->subject, local_it, last, ctx, chunk_buf)) {
+                // We can't merge here; it will lead to partial status
+            } else {
+                return false;
+            }
+        }
+        list_like_parser::successful_merge_into(chunk_buf, container_attr);
+
+        first = local_it;
+        // parse some more up to the maximum specified
+        for (; !bounds_.got_max(i); ++i) {
+            if (detail::parse_into_container(this->subject, first, last, ctx, chunk_buf)) {
+                list_like_parser::successful_merge_into(chunk_buf, container_attr);
+            } else {
+                break;
+            }
+        }
+
+        if constexpr (has_context_v<Context, contexts::expectation_failure>) {
+            return !x4::has_expectation_failure(ctx);
+        } else {
+            return true;
+        }
+    }
+
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4UnusedAttribute UnusedAttr>
+    [[nodiscard]] constexpr bool
+    parse(It& first, Se const& last, Context const& ctx, UnusedAttr& unused_attr) const
+        noexcept(
+            noexcept(detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(unused_attr))) &&
+            std::is_nothrow_copy_assignable_v<It> &&
+            is_nothrow_parsable_v<Subject, It, Se, Context, unused_type>
+        )
     {
         It local_it = first;
         typename Bounds::value_type i{};
         for (; !bounds_.got_min(i); ++i) {
-            if (!detail::parse_into_container(this->subject, local_it, last, ctx, x4::assume_container(attr))) {
+            if (!detail::parse_into_container(this->subject, local_it, last, ctx, x4::assume_container(unused_attr))) {
                 return false;
             }
         }
@@ -115,7 +159,7 @@ struct repeat_directive : proxy_parser<Subject, repeat_directive<Subject, Bounds
         first = local_it;
         // parse some more up to the maximum specified
         for (; !bounds_.got_max(i); ++i) {
-            if (!detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(attr))) {
+            if (!detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(unused_attr))) {
                 break;
             }
         }
@@ -136,12 +180,7 @@ namespace detail {
 struct repeat_gen
 {
     template<X4Subject Subject>
-    [[nodiscard, deprecated("`repeat[p]` has the exact same meaning as `*p`. Use `*p` instead.")]]
-    constexpr auto operator[](Subject&& subject) const
-        noexcept(noexcept(*as_parser(std::forward<Subject>(subject))))
-    {
-        return *as_parser(std::forward<Subject>(subject));
-    }
+    constexpr void operator[](Subject&& subject) = delete; // `repeat[p]` has the exact same meaning as `*p`. Use `*p` instead.
 
     template<RepeatBounds Bounds>
     struct [[nodiscard]] repeat_gen_impl
diff --git a/include/iris/x4/operator/difference.hpp b/include/iris/x4/operator/difference.hpp
index 4d42381f0..5a1387010 100644
--- a/include/iris/x4/operator/difference.hpp
+++ b/include/iris/x4/operator/difference.hpp
@@ -25,8 +25,6 @@ struct difference : binary_parser<Left, Right, difference<Left, Right>>
 {
     using attribute_type = parser_traits<Left>::attribute_type;
 
-    static constexpr bool handles_container = Left::handles_container;
-
     using binary_parser<Left, Right, difference>::binary_parser;
 
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
diff --git a/include/iris/x4/operator/kleene.hpp b/include/iris/x4/operator/kleene.hpp
index 0289ce968..12c00e9da 100644
--- a/include/iris/x4/operator/kleene.hpp
+++ b/include/iris/x4/operator/kleene.hpp
@@ -12,13 +12,10 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 
-#include <iris/x4/core/parser.hpp>
-#include <iris/x4/core/detail/parse_into_container.hpp>
+#include <iris/x4/core/list_like_parser.hpp>
 #include <iris/x4/core/unused.hpp>
 #include <iris/x4/core/expectation.hpp>
 
-#include <iris/x4/traits/container_traits.hpp>
-
 #include <iterator>
 #include <type_traits>
 #include <utility>
@@ -28,16 +25,39 @@ namespace iris::x4 {
 template<class Subject>
 struct kleene : unary_parser<Subject, kleene<Subject>>
 {
-    using attribute_type = traits::build_container<typename parser_traits<Subject>::attribute_type>::type;
+    using attribute_type = traits::default_container<typename parser_traits<Subject>::attribute_type>::type;
 
-    static constexpr bool handles_container = true;
+    template<class Container>
+    static constexpr bool handles_container = std::disjunction_v<
+        std::bool_constant<parser_traits<Subject>::template handles_container<Container>>,
+        traits::can_hold<typename parser_traits<Subject>::attribute_type, typename traits::container_value<Container>::type>
+    >;
 
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4NonUnusedAttribute Attr>
     [[nodiscard]] constexpr bool
     parse(It& first, Se const& last, Context const& ctx, Attr& attr) const
-        noexcept(noexcept(detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(attr))))
+        // never noexcept; requires container insertion
+    {
+        auto& container_attr = list_like_parser::get_container<attribute_type, Attr>(attr);
+        list_like_parser::chunk_buffer<attribute_type, Attr> chunk_buf;
+
+        while (detail::parse_into_container(this->subject, first, last, ctx, chunk_buf)) {
+            list_like_parser::successful_merge_into(chunk_buf, container_attr);
+        }
+
+        if constexpr (has_context_v<Context, contexts::expectation_failure>) {
+            return !x4::has_expectation_failure(ctx);
+        } else {
+            return true;
+        }
+    }
+
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4UnusedAttribute UnusedAttr>
+    [[nodiscard]] constexpr bool
+    parse(It& first, Se const& last, Context const& ctx, UnusedAttr& unused_attr) const
+        noexcept(noexcept(detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(unused_attr))))
     {
-        while (detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(attr)))
+        while (detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(unused_attr)))
             /* loop */;
 
         if constexpr (has_context_v<Context, contexts::expectation_failure>) {
diff --git a/include/iris/x4/operator/list.hpp b/include/iris/x4/operator/list.hpp
index c6d9039b9..465f527dd 100644
--- a/include/iris/x4/operator/list.hpp
+++ b/include/iris/x4/operator/list.hpp
@@ -12,12 +12,9 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 
-#include <iris/x4/core/parser.hpp>
-#include <iris/x4/core/detail/parse_into_container.hpp>
-#include <iris/x4/core/expectation.hpp>
+#include <iris/x4/core/list_like_parser.hpp>
 #include <iris/x4/core/unused.hpp>
-
-#include <iris/x4/traits/container_traits.hpp>
+#include <iris/x4/core/expectation.hpp>
 
 #include <iterator>
 #include <type_traits>
@@ -28,30 +25,65 @@ namespace iris::x4 {
 template<class Left, class Right>
 struct list : binary_parser<Left, Right, list<Left, Right>>
 {
-    using attribute_type = traits::build_container<typename parser_traits<Left>::attribute_type>::type;
+    using attribute_type = traits::default_container<typename parser_traits<Left>::attribute_type>::type;
 
-    static constexpr bool handles_container = true;
+    template<class Container>
+    static constexpr bool handles_container = std::disjunction_v<
+        std::bool_constant<parser_traits<Left>::template handles_container<Container>>,
+        traits::can_hold<typename parser_traits<Left>::attribute_type, typename traits::container_value<Container>::type>
+    >;
 
     using binary_parser<Left, Right, list>::binary_parser;
 
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4NonUnusedAttribute Attr>
     [[nodiscard]] constexpr bool
     parse(It& first, Se const& last, Context const& ctx, Attr& attr) const
+        // never noexcept; requires container insertion
+    {
+        auto& container_attr = list_like_parser::get_container<attribute_type, Attr>(attr);
+        list_like_parser::chunk_buffer<attribute_type, Attr> chunk_buf;
+
+        // In order to succeed, we need to match at least one element
+        if (detail::parse_into_container(this->left, first, last, ctx, chunk_buf)) {
+            list_like_parser::successful_merge_into(chunk_buf, container_attr);
+        } else {
+            return false;
+        }
+
+        It last_parse_it = first;
+        while (
+            this->right.parse(last_parse_it, last, ctx, unused) &&
+            detail::parse_into_container(this->left, last_parse_it, last, ctx, chunk_buf)
+        ) {
+            list_like_parser::successful_merge_into(chunk_buf, container_attr);
+            first = last_parse_it;
+        }
+
+        if constexpr (has_context_v<Context, contexts::expectation_failure>) {
+            return !x4::has_expectation_failure(ctx);
+        } else {
+            return true;
+        }
+    }
+
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4UnusedAttribute UnusedAttr>
+    [[nodiscard]] constexpr bool
+    parse(It& first, Se const& last, Context const& ctx, UnusedAttr& unused_attr) const
         noexcept(
-            noexcept(detail::parse_into_container(this->left, first, last, ctx, x4::assume_container(attr))) &&
+            noexcept(detail::parse_into_container(this->left, first, last, ctx, x4::assume_container(unused_attr))) &&
             std::is_nothrow_copy_assignable_v<It> &&
             is_nothrow_parsable_v<Right, It, Se, Context, unused_type>
         )
     {
         // In order to succeed we need to match at least one element
-        if (!detail::parse_into_container(this->left, first, last, ctx, x4::assume_container(attr))) {
+        if (!detail::parse_into_container(this->left, first, last, ctx, x4::assume_container(unused_attr))) {
             return false;
         }
 
         It last_parse_it = first;
         while (
             this->right.parse(last_parse_it, last, ctx, unused) &&
-            detail::parse_into_container(this->left, last_parse_it, last, ctx, x4::assume_container(attr))
+            detail::parse_into_container(this->left, last_parse_it, last, ctx, x4::assume_container(unused_attr))
         ) {
             // TODO: can we reduce this copy assignment?
             first = last_parse_it;
diff --git a/include/iris/x4/operator/optional.hpp b/include/iris/x4/operator/optional.hpp
index 498b30f87..cc820f58d 100644
--- a/include/iris/x4/operator/optional.hpp
+++ b/include/iris/x4/operator/optional.hpp
@@ -32,7 +32,11 @@ struct optional : unary_parser<Subject, optional<Subject>>
 {
     using attribute_type = traits::build_optional<typename parser_traits<Subject>::attribute_type>::type;
 
-    static constexpr bool handles_container = true;
+    template<class Container>
+    static constexpr bool handles_container = std::disjunction_v<
+        std::bool_constant<parser_traits<Subject>::template handles_container<Container>>,
+        traits::can_hold<typename parser_traits<Subject>::attribute_type, typename traits::container_value<Container>::type>
+    >;
 
     // catch-all overload
     template<
diff --git a/include/iris/x4/operator/plus.hpp b/include/iris/x4/operator/plus.hpp
index 4b16ca713..e2c4a4099 100644
--- a/include/iris/x4/operator/plus.hpp
+++ b/include/iris/x4/operator/plus.hpp
@@ -12,12 +12,9 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 
-#include <iris/x4/core/parser.hpp>
+#include <iris/x4/core/list_like_parser.hpp>
 #include <iris/x4/core/unused.hpp>
 #include <iris/x4/core/expectation.hpp>
-#include <iris/x4/core/detail/parse_into_container.hpp>
-
-#include <iris/x4/traits/container_traits.hpp>
 
 #include <iterator>
 #include <type_traits>
@@ -28,20 +25,49 @@ namespace iris::x4 {
 template<class Subject>
 struct plus : unary_parser<Subject, plus<Subject>>
 {
-    using attribute_type = traits::build_container<typename parser_traits<Subject>::attribute_type>::type;
+    using attribute_type = traits::default_container<typename parser_traits<Subject>::attribute_type>::type;
 
-    static constexpr bool handles_container = true;
+    template<class Container>
+    static constexpr bool handles_container = std::disjunction_v<
+        std::bool_constant<parser_traits<Subject>::template handles_container<Container>>,
+        traits::can_hold<typename parser_traits<Subject>::attribute_type, typename traits::container_value<Container>::type>
+    >;
 
-    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4NonUnusedAttribute Attr>
     [[nodiscard]] constexpr bool
     parse(It& first, Se const& last, Context const& ctx, Attr& attr) const
-        noexcept(noexcept(detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(attr))))
+        // never noexcept; requires container insertion
+    {
+        auto& container_attr = list_like_parser::get_container<attribute_type, Attr>(attr);
+        list_like_parser::chunk_buffer<attribute_type, Attr> chunk_buf;
+
+        if (detail::parse_into_container(this->subject, first, last, ctx, chunk_buf)) {
+            list_like_parser::successful_merge_into(chunk_buf, container_attr);
+        } else {
+            return false;
+        }
+
+        while (detail::parse_into_container(this->subject, first, last, ctx, chunk_buf)) {
+            list_like_parser::successful_merge_into(chunk_buf, container_attr);
+        }
+
+        if constexpr (has_context_v<Context, contexts::expectation_failure>) {
+            return !x4::has_expectation_failure(ctx);
+        } else {
+            return true;
+        }
+    }
+
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4UnusedAttribute UnusedAttr>
+    [[nodiscard]] constexpr bool
+    parse(It& first, Se const& last, Context const& ctx, UnusedAttr& unused_attr) const
+        noexcept(noexcept(detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(unused_attr))))
     {
-        if (!detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(attr))) {
+        if (!detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(unused_attr))) {
             return false;
         }
 
-        while (detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(attr)))
+        while (detail::parse_into_container(this->subject, first, last, ctx, x4::assume_container(unused_attr)))
             /* loop */;
 
         if constexpr (has_context_v<Context, contexts::expectation_failure>) {
diff --git a/include/iris/x4/operator/sequence.hpp b/include/iris/x4/operator/sequence.hpp
index 67109b1a9..ac4ce5786 100644
--- a/include/iris/x4/operator/sequence.hpp
+++ b/include/iris/x4/operator/sequence.hpp
@@ -11,11 +11,13 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 
+#include <iris/x4/core/detail/parse_sequence.hpp>
 #include <iris/x4/core/expectation.hpp>
 #include <iris/x4/core/parser.hpp>
-#include <iris/x4/core/detail/parse_sequence.hpp>
+#include <iris/x4/core/move_to.hpp>
 
 #include <iris/x4/traits/attribute_of_binary.hpp>
+#include <iris/x4/traits/container_traits.hpp>
 
 #include <iris/x4/directive/expect.hpp>
 
@@ -28,6 +30,50 @@
 
 namespace iris::x4 {
 
+namespace detail {
+
+template<traits::X4Container Container, class Elem>
+struct container_can_hold_element : std::is_same<Container, Elem>
+{};
+
+template<traits::X4Container Container, class Elem>
+    requires
+        (!std::same_as<Container, Elem>) &&
+        (!traits::X4Container<Elem>) &&
+        requires (Container& c, Elem&& elem) {
+            traits::push_back(c, std::move(elem));
+        }
+struct container_can_hold_element<Container, Elem>
+    : std::true_type
+{};
+
+template<traits::X4Container Container, class ContainerElem>
+    requires
+        (!std::same_as<Container, ContainerElem>) &&
+        traits::X4Container<ContainerElem> &&
+        requires (Container& c, ContainerElem&& container_elem) {
+            x4::move_to(
+                std::make_move_iterator(traits::begin(container_elem)),
+                std::make_move_iterator(traits::end(container_elem)),
+                c
+            );
+        }
+struct container_can_hold_element<Container, ContainerElem>
+    : std::true_type
+{};
+
+template<traits::X4Container Container, class SequenceAttr_Maybe_Unwrapped>
+struct container_can_hold_sequence : container_can_hold_element<Container, SequenceAttr_Maybe_Unwrapped>
+{};
+
+template<traits::X4Container Container, class... Ts>
+struct container_can_hold_sequence<Container, alloy::tuple<Ts...>>
+    // this should not delegate to `container_can_hold_sequence`; we don't want recursive expansion here.
+    : std::conjunction<container_can_hold_element<Container, Ts>...>
+{};
+
+} // detail
+
 template<class Left, class Right>
 struct sequence : binary_parser<Left, Right, sequence<Left, Right>>
 {
@@ -36,6 +82,14 @@ struct sequence : binary_parser<Left, Right, sequence<Left, Right>>
     static constexpr std::size_t sequence_size =
         parser_traits<Left>::sequence_size + parser_traits<Right>::sequence_size;
 
+    template<traits::X4Container Container>
+    static constexpr bool handles_container =
+        (
+            parser_traits<Left>::template handles_container<Container> &&
+            parser_traits<Right>::template handles_container<Container>
+        ) ||
+        detail::container_can_hold_sequence<Container, attribute_type>::value;
+
     using binary_parser<Left, Right, sequence>::binary_parser;
 
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4UnusedAttribute UnusedAttr>
diff --git a/include/iris/x4/rule.hpp b/include/iris/x4/rule.hpp
index b2c22fc06..406ceb4e2 100644
--- a/include/iris/x4/rule.hpp
+++ b/include/iris/x4/rule.hpp
@@ -312,7 +312,6 @@ struct rule_definition : parser<rule_definition<RuleID, RHS, RuleDefAttr, ForceA
     using attribute_type = RuleDefAttr;
 
     static constexpr bool has_attribute = !std::is_same_v<std::remove_const_t<RuleDefAttr>, unused_type>;
-    static constexpr bool handles_container = traits::is_container_v<std::remove_const_t<RuleDefAttr>>;
     static constexpr bool force_attribute = ForceAttr;
 
     template<class RHS_T>
@@ -396,7 +395,6 @@ struct rule : parser<rule<RuleID, RuleAttr, ForceAttr>>
     using attribute_type = RuleAttr;
 
     static constexpr bool has_attribute = !std::is_same_v<std::remove_const_t<RuleAttr>, unused_type>;
-    static constexpr bool handles_container = traits::is_container_v<std::remove_const_t<RuleAttr>>;
     static constexpr bool force_attribute = ForceAttr;
 
     std::string_view name = "unnamed";
diff --git a/include/iris/x4/string/literal_string.hpp b/include/iris/x4/string/literal_string.hpp
index 848e5ed7a..14bc1bf79 100644
--- a/include/iris/x4/string/literal_string.hpp
+++ b/include/iris/x4/string/literal_string.hpp
@@ -42,7 +42,6 @@ struct literal_string : parser<literal_string<String, Encoding, Attr>>
     static_assert(!std::is_same_v<Attr, unused_container_type>, "`literal_string` with `unused_container_type` is not supported");
 
     static constexpr bool has_attribute = !std::is_same_v<Attr, unused_type>;
-    static constexpr bool handles_container = has_attribute;
 
     template<class T, class... Rest>
         requires
diff --git a/include/iris/x4/symbols.hpp b/include/iris/x4/symbols.hpp
index d5a3e4b85..ab325d5af 100644
--- a/include/iris/x4/symbols.hpp
+++ b/include/iris/x4/symbols.hpp
@@ -62,7 +62,6 @@ struct symbols_parser_impl : parser<Derived>
     using attribute_type = value_type;
 
     static constexpr bool has_attribute = !std::is_same_v<attribute_type, unused_type>;
-    static constexpr bool handles_container = traits::is_container_v<attribute_type>;
 
     constexpr symbols_parser_impl(std::string_view name = "symbols")
         requires(IsShared)
diff --git a/include/iris/x4/traits/attribute_category.hpp b/include/iris/x4/traits/attribute_category.hpp
index aac482c69..10049137c 100644
--- a/include/iris/x4/traits/attribute_category.hpp
+++ b/include/iris/x4/traits/attribute_category.hpp
@@ -10,7 +10,6 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 
-#include <iris/x4/traits/subrange_traits.hpp>
 #include <iris/x4/traits/variant_traits.hpp>
 #include <iris/x4/traits/container_traits.hpp>
 #include <iris/x4/traits/optional_traits.hpp>
@@ -34,7 +33,6 @@ struct container_attr {};
 struct tuple_attr {};
 struct variant_attr {};
 struct optional_attr {};
-struct subrange_attr {};
 
 template<class T>
 struct attribute_category
@@ -108,13 +106,6 @@ struct attribute_category<T>
     using type = optional_attr;
 };
 
-template<class T>
-    requires is_subrange_v<std::remove_cvref_t<T>>
-struct attribute_category<T>
-{
-    using type = subrange_attr;
-};
-
 template<class T>
     requires traits::is_container_v<std::remove_cvref_t<T>>
 struct attribute_category<T>
diff --git a/include/iris/x4/traits/can_hold.hpp b/include/iris/x4/traits/can_hold.hpp
new file mode 100644
index 000000000..469046c7f
--- /dev/null
+++ b/include/iris/x4/traits/can_hold.hpp
@@ -0,0 +1,114 @@
+#ifndef IRIS_X4_TRAITS_CAN_HOLD_HPP
+#define IRIS_X4_TRAITS_CAN_HOLD_HPP
+
+/*=============================================================================
+    Copyright (c) 2001-2014 Joel de Guzman
+    Copyright (c) 2025 Nana Sakisaka
+    Copyright (c) 2026 The Iris Project Contributors
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    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/traits/tuple_traits.hpp>
+
+#include <iris/x4/core/attribute.hpp>
+
+#include <iris/alloy/traits.hpp>
+
+#include <optional>
+#include <type_traits>
+
+namespace iris::x4::traits {
+
+template<class T, class U>
+struct can_hold;
+
+template<class T>
+struct is_variant;
+
+namespace detail {
+
+template<class TTuple, class UTuple, class IndexSeq = std::make_index_sequence<alloy::tuple_size_v<TTuple>>>
+struct is_all_substitute_for_tuple_impl {};
+
+template<class TTuple, class UTuple, std::size_t... Is>
+struct is_all_substitute_for_tuple_impl<TTuple, UTuple, std::index_sequence<Is...>>
+    : std::conjunction<can_hold<alloy::tuple_element_t<Is, TTuple>, alloy::tuple_element_t<Is, UTuple>>...> {};
+
+template<class TTuple, class UTuple>
+struct is_all_substitute_for_tuple : std::false_type {};
+
+template<class TTuple, class UTuple>
+    requires is_same_size_sequence_v<TTuple, UTuple>
+struct is_all_substitute_for_tuple<TTuple, UTuple> : is_all_substitute_for_tuple_impl<TTuple, UTuple> {};
+
+template<class T, class U>
+struct value_type_can_hold
+    : can_hold<typename container_value<T>::type, typename container_value<U>::type>
+{};
+
+// This "implementation" exists for short-circuiting `can_hold` for certain trivial combinations
+template<class T, class U>
+struct can_hold_impl : std::false_type {};
+
+template<class T, class U>
+    requires
+        alloy::is_tuple_like_v<T> &&
+        alloy::is_tuple_like_v<U>
+struct can_hold_impl<T, U>
+    : detail::is_all_substitute_for_tuple<T, U>
+{};
+
+template<class T, class U>
+    requires
+        is_container_v<T> &&
+        is_container_v<U>
+struct can_hold_impl<T, U>
+    : detail::value_type_can_hold<T, U>
+{};
+
+template<class T, class U>
+    requires is_variant<T>::value && X4UnusedAttribute<U>
+struct can_hold_impl<T, U>
+    : std::false_type
+{};
+
+template<class T, class U>
+    requires (!is_variant<T>::value) && X4UnusedAttribute<U>
+struct can_hold_impl<T, U>
+    : std::false_type
+{};
+
+template<class T, class U>
+    requires is_variant<T>::value && (!X4UnusedAttribute<U>)
+struct can_hold_impl<T, U>
+    : std::is_assignable<T&, U>
+{};
+
+template<class T, class U>
+struct can_hold_impl<std::optional<T>, std::optional<U>>
+    : can_hold<T, U>
+{};
+
+} // detail
+
+template<class T, class U>
+struct can_hold
+    : detail::can_hold_impl<T, U>
+{
+    static_assert(X4Attribute<T>);
+    static_assert(X4Attribute<U>);
+};
+
+template<class T>
+struct can_hold<T, T>
+    : std::true_type
+{
+    static_assert(X4Attribute<T>);
+};
+
+} // iris::x4::traits
+
+#endif
diff --git a/include/iris/x4/traits/container_traits.hpp b/include/iris/x4/traits/container_traits.hpp
index b48db67e7..bf17a1233 100644
--- a/include/iris/x4/traits/container_traits.hpp
+++ b/include/iris/x4/traits/container_traits.hpp
@@ -17,6 +17,7 @@
 #include <iris/alloy/traits.hpp>
 #include <iris/alloy/tuple.hpp>
 
+#include <concepts>
 #include <ranges>
 #include <iterator>
 #include <vector>
@@ -80,7 +81,11 @@ struct remove_value_const<std::pair<F, S>>
 
 // Customization point
 template<class Container>
-struct container_value
+struct container_value {};
+
+template<class Container>
+    requires requires { typename Container::value_type; }
+struct container_value<Container>
     : detail::remove_value_const<typename Container::value_type>
 {};
 
@@ -137,8 +142,8 @@ struct push_back_fn
     template<class Container>
     static constexpr void operator()(Container&, unused_type const&) noexcept
     {
-        static_assert(!std::is_same_v<std::remove_const_t<Container>, unused_type>);
-        static_assert(!std::is_same_v<std::remove_const_t<Container>, unused_container_type>);
+        static_assert(!std::same_as<std::remove_const_t<Container>, unused_type>);
+        static_assert(!std::same_as<std::remove_const_t<Container>, unused_container_type>);
     }
 
     template<class Container, class T>
@@ -170,8 +175,8 @@ struct push_back_fn
     static constexpr void operator()(Container& c, T&& val)
         noexcept(noexcept(push_back_container<Container>::call(c, std::forward<T>(val))))
     {
-        static_assert(!std::is_same_v<std::remove_const_t<Container>, unused_type>);
-        static_assert(!std::is_same_v<std::remove_const_t<Container>, unused_container_type>);
+        static_assert(!std::same_as<std::remove_const_t<Container>, unused_type>);
+        static_assert(!std::same_as<std::remove_const_t<Container>, unused_container_type>);
         push_back_container<Container>::call(c, std::forward<T>(val));
     }
 };
@@ -208,6 +213,9 @@ struct append_fn
     static constexpr void operator()(Container& c, It first, Se last)
         noexcept(noexcept(c.insert(first, last)))
     {
+        // appending incompatible type into a container can result in unexpected behavior
+        // e.g. appending `int` into `vector<vector<int>>` compiles, but gets resolved into `vector<int>::vector(size_t)`
+        static_assert(std::constructible_from<typename traits::container_value<Container>::type, std::iter_value_t<It>>);
         c.insert(first, last);
     }
 
@@ -221,6 +229,9 @@ struct append_fn
     static constexpr void operator()(Container& c, It first, Se last)
         noexcept(noexcept(c.insert(std::ranges::end(c), first, last)))
     {
+        // appending incompatible type into a container can result in unexpected behavior
+        // e.g. appending `int` into `vector<vector<int>>` compiles, but gets resolved into `vector<int>::vector(size_t)`
+        static_assert(std::constructible_from<typename traits::container_value<Container>::type, std::iter_value_t<It>>);
         c.insert(std::ranges::end(c), first, last);
     }
 
@@ -229,8 +240,12 @@ struct append_fn
     static constexpr void operator()(Container& c, It first, Se last)
         noexcept(noexcept(append_container<Container>::call(c, first, last)))
     {
-        static_assert(!std::is_same_v<std::remove_const_t<Container>, unused_type>);
-        static_assert(!std::is_same_v<std::remove_const_t<Container>, unused_container_type>);
+        static_assert(!std::same_as<std::remove_const_t<Container>, unused_type>);
+        static_assert(!std::same_as<std::remove_const_t<Container>, unused_container_type>);
+
+        // appending incompatible type into a container can result in unexpected behavior
+        // e.g. appending `int` into `vector<vector<int>>` compiles, but gets resolved into `vector<int>::vector(size_t)`
+        static_assert(std::constructible_from<typename traits::container_value<Container>::type, std::iter_value_t<It>>);
         append_container<Container>::call(c, first, last);
     }
 };
@@ -308,8 +323,8 @@ struct is_empty_fn
     [[nodiscard]] static constexpr bool
     operator()(Container const& c) noexcept
     {
-        static_assert(!std::is_same_v<Container, unused_type>);
-        static_assert(!std::is_same_v<Container, unused_container_type>);
+        static_assert(!std::same_as<Container, unused_type>);
+        static_assert(!std::same_as<Container, unused_container_type>);
         return std::ranges::empty(c);
     }
 
@@ -321,8 +336,8 @@ struct is_empty_fn
     operator()(Container const& c)
         noexcept(noexcept(is_empty_container<Container>::call(c)))
     {
-        static_assert(!std::is_same_v<Container, unused_type>);
-        static_assert(!std::is_same_v<Container, unused_container_type>);
+        static_assert(!std::same_as<Container, unused_type>);
+        static_assert(!std::same_as<Container, unused_container_type>);
         return is_empty_container<Container>::call(c);
     }
 };
@@ -438,13 +453,13 @@ template<class T>
         std::default_initializable<T> &&
 
         requires(T& c) {
-            typename T::value_type; // required
+            typename container_value<T>::type;
             traits::begin(c);
             requires std::forward_iterator<decltype(traits::begin(c))>;
             traits::end(c);
             requires std::sentinel_for<decltype(traits::end(c)), decltype(traits::begin(c))>;
             traits::is_empty(c);
-            traits::push_back(c, std::declval<typename T::value_type>());
+            traits::push_back(c, std::declval<typename container_value<T>::type>());
             traits::append(
                 c,
                 std::declval<decltype(std::make_move_iterator(traits::begin(c)))>(),
@@ -468,52 +483,52 @@ concept X4Container = is_container_v<std::remove_cvref_t<T>>;
 
 // Customization point
 template<class T>
-struct build_container
+struct default_container
 {
     using type = std::vector<T>;
 };
 
 template<class T>
-struct build_container<alloy::tuple<T>> : build_container<T> {};
+struct default_container<alloy::tuple<T>> : default_container<T> {};
 
 template<>
-struct build_container<unused_type>
+struct default_container<unused_type>
 {
     using type = unused_container_type;
 };
 
 template<>
-struct build_container<unused_container_type>
+struct default_container<unused_container_type>
 {
     using type = unused_container_type;
 };
 
 template<>
-struct build_container<char>
+struct default_container<char>
 {
     using type = std::basic_string<char>;
 };
 
 template<>
-struct build_container<wchar_t>
+struct default_container<wchar_t>
 {
     using type = std::basic_string<wchar_t>;
 };
 
 template<>
-struct build_container<char8_t>
+struct default_container<char8_t>
 {
     using type = std::basic_string<char8_t>;
 };
 
 template<>
-struct build_container<char16_t>
+struct default_container<char16_t>
 {
     using type = std::basic_string<char16_t>;
 };
 
 template<>
-struct build_container<char32_t>
+struct default_container<char32_t>
 {
     using type = std::basic_string<char32_t>;
 };
diff --git a/include/iris/x4/traits/subrange_traits.hpp b/include/iris/x4/traits/subrange_traits.hpp
deleted file mode 100644
index 70422b1f7..000000000
--- a/include/iris/x4/traits/subrange_traits.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef IRIS_ZZ_X4_TRAITS_SUBRANGE_TRAITS_HPP
-#define IRIS_ZZ_X4_TRAITS_SUBRANGE_TRAITS_HPP
-
-/*=============================================================================
-    Copyright (c) 2001-2014 Joel de Guzman
-    Copyright (c) 2025 Nana Sakisaka
-    Copyright (c) 2026 The Iris Project Contributors
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-=============================================================================*/
-
-#include <iterator>
-#include <ranges>
-#include <type_traits>
-
-namespace iris::x4::traits {
-
-template<class T>
-struct is_subrange : std::false_type {};
-
-template<class T>
-constexpr bool is_subrange_v = is_subrange<T>::value;
-
-template<std::input_or_output_iterator It, std::sentinel_for<It> Se, std::ranges::subrange_kind Kind>
-struct is_subrange<std::ranges::subrange<It, Se, Kind>> : std::true_type {};
-
-} // iris::x4::traits
-
-#endif
diff --git a/include/iris/x4/traits/substitution.hpp b/include/iris/x4/traits/substitution.hpp
deleted file mode 100644
index f675231ea..000000000
--- a/include/iris/x4/traits/substitution.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#ifndef IRIS_ZZ_X4_TRAITS_SUBSTITUTION_HPP
-#define IRIS_ZZ_X4_TRAITS_SUBSTITUTION_HPP
-
-/*=============================================================================
-    Copyright (c) 2001-2014 Joel de Guzman
-    Copyright (c) 2025 Nana Sakisaka
-    Copyright (c) 2026 The Iris Project Contributors
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-=============================================================================*/
-
-#include <iris/x4/core/attribute.hpp>
-#include <iris/x4/traits/container_traits.hpp>
-#include <iris/x4/traits/tuple_traits.hpp>
-
-#include <iris/alloy/traits.hpp>
-
-#include <optional>
-#include <type_traits>
-
-namespace iris::x4::traits {
-
-template<class T>
-struct is_variant;
-
-// Find out if T can be a (strong) substitute for Attribute
-template<class T, X4Attribute Attr>
-struct is_substitute;
-
-template<class T, X4Attribute Attr>
-constexpr bool is_substitute_v = is_substitute<T, Attr>::value;
-
-template<class Variant, X4Attribute Attr>
-struct variant_has_substitute;
-
-namespace detail {
-
-template<class TTuple, class UTuple, class IndexSeq = std::make_index_sequence<alloy::tuple_size_v<TTuple>>>
-struct is_all_substitute_for_tuple_impl {};
-
-template<class TTuple, class UTuple, std::size_t... Is>
-struct is_all_substitute_for_tuple_impl<TTuple, UTuple, std::index_sequence<Is...>>
-    : std::conjunction<is_substitute<alloy::tuple_element_t<Is, TTuple>, alloy::tuple_element_t<Is, UTuple>>...> {};
-
-template<class TTuple, class UTuple>
-struct is_all_substitute_for_tuple : std::false_type {};
-
-template<class TTuple, class UTuple>
-    requires is_same_size_sequence_v<TTuple, UTuple>
-struct is_all_substitute_for_tuple<TTuple, UTuple> : is_all_substitute_for_tuple_impl<TTuple, UTuple> {};
-
-template<class T, X4Attribute Attr>
-struct value_type_is_substitute
-    : is_substitute<typename container_value<T>::type, typename container_value<Attr>::type>
-{};
-
-template<class T, X4Attribute Attr>
-struct is_substitute_impl : std::false_type {};
-
-template<class T, X4Attribute Attr>
-    requires std::conjunction_v<
-        alloy::is_tuple_like<T>,
-        alloy::is_tuple_like<Attr>
-    >
-struct is_substitute_impl<T, Attr>
-    : is_all_substitute_for_tuple<T, Attr>
-{};
-
-template<class T, X4Attribute Attr>
-    requires
-        is_container_v<std::remove_const_t<T>> &&
-        is_container_v<std::remove_const_t<Attr>>
-struct is_substitute_impl<T, Attr>
-    : value_type_is_substitute<T, Attr>
-{};
-
-template<class T, X4Attribute Attr>
-    requires is_variant<std::remove_const_t<Attr>>::value
-struct is_substitute_impl<T, Attr>
-    : variant_has_substitute<Attr, T>
-{};
-
-} // detail
-
-template<class T, X4Attribute Attr>
-struct is_substitute
-    : std::disjunction<
-          std::is_same<T, Attr>,
-          detail::is_substitute_impl<T, Attr>
-    >
-{};
-
-template<class T, X4UnusedAttribute Attr>
-struct is_substitute<T, Attr>
-    : std::false_type
-{};
-
-// for reference T
-template<class T, X4Attribute Attr>
-struct is_substitute<T&, Attr>
-    : is_substitute<T, Attr>
-{};
-
-// for reference Attribute
-template<class T, X4Attribute Attr>
-struct is_substitute<T, Attr&>
-    : is_substitute<T, Attr>
-{};
-
-template<class T, X4Attribute Attr>
-struct is_substitute<std::optional<T>, std::optional<Attr>>
-    : is_substitute<T, Attr>
-{};
-
-} // iris::x4::traits
-
-#endif
diff --git a/include/iris/x4/traits/variant_traits.hpp b/include/iris/x4/traits/variant_traits.hpp
index 34203ab6f..f3fdc5415 100644
--- a/include/iris/x4/traits/variant_traits.hpp
+++ b/include/iris/x4/traits/variant_traits.hpp
@@ -12,10 +12,11 @@
 
 #include <iris/x4/core/unused.hpp>
 
-#include <iris/x4/traits/substitution.hpp>
+#include <iris/x4/traits/can_hold.hpp>
 
 #include <iris/rvariant/variant_helper.hpp>
 
+#include <concepts>
 #include <type_traits>
 
 namespace iris::x4::traits {
@@ -34,20 +35,40 @@ struct is_variant<iris::rvariant<Ts...>> : std::true_type {};
 
 namespace detail {
 
-template<class Attr, class... Ts>
-struct variant_find_substitute_impl;
+template<class T, class... Ts>
+struct any_of_unwrapped_exactly_same;
 
-template<class Attr>
-struct variant_find_substitute_impl<Attr>
+template<class T>
+struct any_of_unwrapped_exactly_same<T>
+    : std::false_type
+{};
+
+template<class T, class First, class... Rest>
+    requires std::same_as<T, iris::unwrap_recursive_type<First>>
+struct any_of_unwrapped_exactly_same<T, First, Rest...>
+    : std::true_type
+{};
+
+template<class T, class First, class... Rest>
+    requires (!std::same_as<T, iris::unwrap_recursive_type<First>>)
+struct any_of_unwrapped_exactly_same<T, First, Rest...>
+    : any_of_unwrapped_exactly_same<T, Rest...>
+{};
+
+template<class T, class... Ts>
+struct variant_find_holdable_type_impl;
+
+template<class T>
+struct variant_find_holdable_type_impl<T>
 {
-    using type = Attr;
+    using type = T;
 };
 
-template<class Attr, class First, class... Rest>
-struct variant_find_substitute_impl<Attr, First, Rest...>
+template<class T, class First, class... Rest>
+struct variant_find_holdable_type_impl<T, First, Rest...>
 {
     using type = std::conditional_t<
-        is_substitute_v<Attr, iris::unwrap_recursive_type<First>>,
+        can_hold<iris::unwrap_recursive_type<First>, T>::value,
 
         // Given some type `T`, when both `T` and `recursive_wrapper<T>` is seen
         // during attribute resolution, X4 should ideally materialize the latter
@@ -60,63 +81,36 @@ struct variant_find_substitute_impl<Attr, First, Rest...>
         //
         First, // no need to unwrap due to the reason described above
 
-        typename variant_find_substitute_impl<Attr, Rest...>::type
+        typename variant_find_holdable_type_impl<T, Rest...>::type
     >;
 };
 
 } // detail
 
 
-template<class Variant, X4Attribute Attr>
-struct variant_find_substitute;
+template<class Variant, class T>
+struct variant_find_holdable_type;
 
-template<class Variant, X4Attribute Attr>
-using variant_find_substitute_t = typename variant_find_substitute<Variant, Attr>::type;
-
-template<X4Attribute Attr>
-struct variant_find_substitute<Attr, Attr>
+template<class Variant>
+struct variant_find_holdable_type<Variant, Variant>
 {
-    using type = Attr;
+    static_assert(is_variant_v<Variant>);
+    using type = Variant;
 };
 
-// Recursively find the first type from the variant that can be a substitute for `Attr`.
-// If none is found, returns `Attr`.
-template<X4Attribute Attr, class... Ts>
-    requires (!std::same_as<iris::rvariant<Ts...>, Attr>)
-struct variant_find_substitute<iris::rvariant<Ts...>, Attr>
+template<class... Ts, class T>
+    requires (!std::same_as<iris::rvariant<Ts...>, T>) && detail::any_of_unwrapped_exactly_same<T, Ts...>::value
+struct variant_find_holdable_type<iris::rvariant<Ts...>, T>
 {
-    using type = typename detail::variant_find_substitute_impl<Attr, Ts...>::type;
+    using type = T;
 };
 
-
-template<class Variant, X4Attribute Attr>
-struct variant_has_substitute;
-
-template<class Variant, X4Attribute Attr>
-constexpr bool variant_has_substitute_v = variant_has_substitute<Variant, Attr>::value;
-
-template<X4Attribute Attr>
-struct variant_has_substitute<Attr, Attr>
-    : std::true_type
-{};
-
-template<X4Attribute Attr>
-struct variant_has_substitute<unused_type, Attr>
-    : std::true_type
-{};
-
-template<X4Attribute Attr>
-struct variant_has_substitute<unused_type const, Attr>
-    : std::true_type
-{};
-
-// Recursively find the first type from the variant that can be a substitute for `T`.
-// Returns boolean value whether it was found.
-template<X4Attribute Attr, class... Ts>
-    requires (!std::same_as<iris::rvariant<Ts...>, Attr>)
-struct variant_has_substitute<iris::rvariant<Ts...>, Attr>
-    : std::disjunction<is_substitute<Attr, Ts>...>
-{};
+template<class... Ts, class T>
+    requires (!std::same_as<iris::rvariant<Ts...>, T>) && (!detail::any_of_unwrapped_exactly_same<T, Ts...>::value)
+struct variant_find_holdable_type<iris::rvariant<Ts...>, T>
+{
+    using type = typename detail::variant_find_holdable_type_impl<T, Ts...>::type;
+};
 
 } // iris::x4::traits
 
diff --git a/modules/iris b/modules/iris
index cec583eed..fe9e3a14d 160000
--- a/modules/iris
+++ b/modules/iris
@@ -1 +1 @@
-Subproject commit cec583eed7ab2fb70e7ef6aa52ab840bc03e92ca
+Subproject commit fe9e3a14dd412910b5a6dd6f14590bb6ced68ddc
diff --git a/test/x4/CMakeLists.txt b/test/x4/CMakeLists.txt
index 9ef0da995..ab7fdac55 100644
--- a/test/x4/CMakeLists.txt
+++ b/test/x4/CMakeLists.txt
@@ -44,7 +44,6 @@ x4_define_tests(
     and_predicate
     as
     attr
-    attribute
     attribute_type_check
     bool
     char
@@ -66,14 +65,15 @@ x4_define_tests(
     list
     lit
     matches
+    move_to
     not_predicate
     no_case
     no_skip
     omit
     optional
     parser
+    partial_success
     plus
-    raw
     real1
     real2
     real3
@@ -86,6 +86,7 @@ x4_define_tests(
     seek
     sequence
     skip
+    substitution
     symbols1
     symbols2
     symbols3
diff --git a/test/x4/alternative.cpp b/test/x4/alternative.cpp
index 5b4adf757..6c1ea50a5 100644
--- a/test/x4/alternative.cpp
+++ b/test/x4/alternative.cpp
@@ -233,7 +233,7 @@ TEST_CASE("alternative")
         using attribute_type = x4::parser_traits<Parser>::attribute_type;
         STATIC_CHECK(std::same_as<attribute_type, std::vector<bool>>);
 
-        using substitute_type = x4::traits::variant_find_substitute_t<Attr, attribute_type>;
+        using substitute_type = x4::traits::variant_find_holdable_type<Attr, attribute_type>::type;
         STATIC_CHECK(std::same_as<substitute_type, std::vector<bool>>);
 
         Attr var;
@@ -247,7 +247,7 @@ TEST_CASE("alternative")
         using attribute_type = x4::parser_traits<Parser>::attribute_type;
         STATIC_CHECK(std::same_as<attribute_type, std::string>);
 
-        using substitute_type = x4::traits::variant_find_substitute_t<Attr, attribute_type>;
+        using substitute_type = x4::traits::variant_find_holdable_type<Attr, attribute_type>::type;
         STATIC_CHECK(std::same_as<substitute_type, std::string>);
 
         Attr var;
diff --git a/test/x4/attr.cpp b/test/x4/attr.cpp
index bba786535..e85d21a7c 100644
--- a/test/x4/attr.cpp
+++ b/test/x4/attr.cpp
@@ -142,11 +142,35 @@ TEST_CASE("attr")
         REQUIRE(parse("s", "s" >> attr(std::string("123")), s));
         CHECK(s == "123");
     }
+
+    // container of container
+
+    // vector<vector<int>>
+    {
+        std::vector<std::vector<int>> vecs;
+        std::vector<int> vec{1, 2, 3};
+        x4::move_to(std::move(vec), vecs);
+        CHECK(vecs == std::vector<std::vector<int>>{std::vector{1, 2, 3}});
+    }
+    {
+        std::vector<std::vector<int>> vecs;
+        REQUIRE(parse("", attr(std::vector<int>{1, 2, 3}) >> attr(std::vector<int>{4, 5, 6}), vecs));
+        CHECK(vecs == std::vector{std::vector{1, 2, 3}, std::vector{4, 5, 6}});
+    }
+
+    // vector<string>
+    {
+        std::vector<std::string> strs;
+        std::string str = "abc";
+        x4::move_to(std::move(str), strs);
+        CHECK(strs == std::vector{std::string("abc")});
+    }
     {
         std::vector<std::string> strs;
         REQUIRE(parse("", attr(std::string("123")) >> attr(std::string("456")), strs));
         CHECK(strs == std::vector<std::string>{"123", "456"});
     }
+
     {
         std::string s;
         REQUIRE(parse("", attr(std::string("123")) >> attr(std::string("456")), s));
diff --git a/test/x4/attribute.cpp b/test/x4/attribute.cpp
deleted file mode 100644
index 2dee8dbd9..000000000
--- a/test/x4/attribute.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2025 Nana Sakisaka
-    Copyright (c) 2026 The Iris Project Contributors
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-=============================================================================*/
-
-#include "iris_x4_test.hpp"
-
-#include <iris/x4/auxiliary/attr.hpp>
-#include <iris/x4/auxiliary/eps.hpp>
-#include <iris/x4/char/char.hpp>
-#include <iris/x4/char/char_class.hpp>
-#include <iris/x4/string/string.hpp>
-#include <iris/x4/numeric/int.hpp>
-#include <iris/x4/directive/omit.hpp>
-#include <iris/x4/operator/sequence.hpp>
-#include <iris/x4/operator/alternative.hpp>
-
-#include <iris/alloy/adapted/std_pair.hpp>
-
-#include <iostream>
-#include <vector>
-#include <string>
-#include <utility>
-
-// NOLINTBEGIN(readability-container-size-empty)
-
-namespace {
-
-struct strong_int
-{
-    int value = 0;
-    int assigned_count = 0;
-
-    strong_int() = default;
-    strong_int(strong_int const&) = default;
-    strong_int(strong_int&&) noexcept = default;
-
-    explicit strong_int(int value) : value(value) {}
-
-    strong_int& operator=(strong_int const& other)
-    {
-        value = other.value;
-        ++assigned_count;
-        return *this;
-    }
-
-    strong_int& operator=(strong_int&& other) noexcept
-    {
-        value = other.value;
-        ++assigned_count;
-        return *this;
-    }
-
-    strong_int& operator=(int new_value)
-    {
-        value = new_value;
-        ++assigned_count;
-        return *this;
-    }
-
-    bool operator==(strong_int const& other) const
-    {
-        return value == other.value;
-    }
-
-    friend std::ostream& operator<<(std::ostream& os, strong_int const& si)
-    {
-        return os << si.value;
-    }
-};
-
-} // anonymous
-
-TEST_CASE("attribute_alternative_hold")
-{
-    using x4::attr;
-    using x4::eps;
-    using x4::omit;
-    using x4::int_;
-
-    using x4::string;
-    using x4::lit;
-    using x4::standard::char_;
-    using x4::standard::space;
-
-    // Sanity checks
-    {
-        int i = -1;
-        REQUIRE(parse("", attr(42), i));
-        CHECK(i == 42);
-    }
-    {
-        std::string str;
-        REQUIRE(parse("", attr("foo"), str));
-        CHECK(str == "foo");
-    }
-    {
-        std::string str;
-        REQUIRE(parse("foo", string("foo"), str));
-        CHECK(str == "foo");
-    }
-
-    // Non-string container attribute
-    // Related to: https://github.com/boostorg/spirit/issues/378
-    {
-        static_assert(x4::traits::CategorizedAttr<std::vector<int>, x4::traits::container_attr>);
-        static_assert(x4::traits::X4Container<std::vector<int>>);
-        static_assert(x4::traits::is_container_v<std::vector<int>>);
-
-        {
-            std::vector<int> ints;
-            REQUIRE(parse("1 2", eps(false) | attr(98) >> attr(99), ints).is_partial_match());
-            CHECK(ints == std::vector<int>{98, 99});
-        }
-        {
-            std::vector<int> ints;
-            REQUIRE(parse("1 2", int_ >> int_ >> eps(false) | attr(98) >> attr(99), space, ints).is_partial_match());
-            // If we don't properly "hold" the value on the failed branch of
-            // `x4::alternative`, we would see {1, 2, 98, 99} here.
-            CHECK(ints == std::vector<int>{98, 99});
-        }
-        // Failed parse should not modify the exposed attribute
-        {
-            std::vector<int> ints;
-            REQUIRE(!parse("1 2", int_ >> int_ >> eps(false) | attr(98) >> attr(99) >> eps(false), space, ints));
-            // Wrong implementation yields {1, 2, 98, 99} or {98, 99}
-            CHECK(ints == std::vector<int>{});
-        }
-        {
-            std::vector<int> ints;
-            REQUIRE(parse("1 2", attr(std::vector<int>{3, 4}) >> eps(false) | attr(98) >> attr(99), space, ints).is_partial_match());
-            // Wrong implementation yields {3, 4, 98, 99}
-            CHECK(ints == std::vector<int>{98, 99});
-        }
-    }
-
-    // String container attribute
-    // Intended for testing `detail::string_parse`
-    {
-        static_assert(x4::traits::CategorizedAttr<std::string, x4::traits::container_attr>);
-        static_assert(x4::traits::X4Container<std::string>);
-        static_assert(x4::traits::is_container_v<std::string>);
-
-        {
-            std::string str;
-            REQUIRE(parse("foodie", "fox" | string("foodie"), str));
-            CHECK(str == "foodie");
-        }
-        {
-            constexpr auto fox = char_('f') >> char_('o') >> char_('x');
-
-            std::string str;
-            REQUIRE(parse("foodie", fox | string("foodie"), str));
-            // If we don't properly "hold" the value on the failed branch of
-            // `x4::alternative`, we would see "fofoodie" here.
-            CHECK(str == "foodie");
-        }
-        {
-            constexpr auto foo = char_('f') >> char_('o') >> char_('o');
-
-            std::string str;
-            REQUIRE(parse("foodie", foo >> eps(false) | string("foodie"), str));
-            // Wrong implementation yields "foofoodie"
-            CHECK(str == "foodie");
-        }
-        {
-            std::string str;
-            REQUIRE(parse("foodie", attr("bookworm") >> eps(false) | string("foodie"), str));
-            // Wrong implementation yields "bookwormfoodie"
-            CHECK(str == "foodie");
-        }
-        // Failed parse should not modify the exposed attribute
-        {
-            std::string str;
-            REQUIRE(!parse("foodie", attr("bookworm") >> eps(false) | string("foodie") >> eps(false), str));
-            // Wrong implementation yields "bookwormfoodie" or "foodie"
-            CHECK(str == "");
-        }
-
-        {
-            std::string str;
-            REQUIRE(parse("foodie", string("food") >> "fan" | string("foodie"), str));
-            // Wrong implementation yields "foodfoodie"
-            CHECK(str == "foodie");
-        }
-    }
-
-    // Plain attribute
-    {
-        static_assert(x4::traits::CategorizedAttr<strong_int, x4::traits::plain_attr>);
-        static_assert(!x4::traits::X4Container<strong_int>);
-        static_assert(!x4::traits::is_container_v<strong_int>);
-
-        {
-            strong_int si;
-            REQUIRE(parse("1", int_ | attr(strong_int{9}), si));
-            CHECK(si == strong_int{1});
-            CHECK(si.assigned_count == 1);
-        }
-        {
-            strong_int si;
-            REQUIRE(parse("1", int_ >> eps(false) | int_, si));
-            CHECK(si == strong_int{1});
-            // Wrong implementation yields 2, because `x4::alternative` wrongly mutates the exposed variable
-            CHECK(si.assigned_count == 1);
-        }
-    }
-
-    // Tuple attribute
-    {
-        using pair_int = std::pair<int, int>;
-
-        static_assert(x4::traits::CategorizedAttr<pair_int, x4::traits::tuple_attr>);
-        static_assert(!x4::traits::X4Container<pair_int>);
-        static_assert(!x4::traits::is_container_v<pair_int>);
-
-        {
-            pair_int pi;
-            REQUIRE(parse("1 2", int_ >> int_ | attr(pair_int{98, 99}), space, pi));
-            CHECK(pi == pair_int{1, 2});
-        }
-        {
-            pair_int pi;
-            REQUIRE(parse("1 2",
-                int_ >> int_ >> eps(false) | attr(pair_int{98, 99}) >> omit[int_ >> int_],
-                space, pi
-            ));
-            CHECK(pi == pair_int{98, 99});
-        }
-    }
-}
-
-// NOLINTEND(readability-container-size-empty)
diff --git a/test/x4/container_support.cpp b/test/x4/container_support.cpp
index 0722b7425..e7efada1a 100644
--- a/test/x4/container_support.cpp
+++ b/test/x4/container_support.cpp
@@ -13,6 +13,7 @@
 #include <iris/x4/rule.hpp>
 #include <iris/x4/char/char.hpp>
 #include <iris/x4/char/char_class.hpp>
+#include <iris/x4/directive/as.hpp>
 #include <iris/x4/directive/lexeme.hpp>
 #include <iris/x4/operator/sequence.hpp>
 #include <iris/x4/operator/list.hpp>
@@ -33,57 +34,22 @@
 
 namespace x4 = iris::x4;
 
-// check if we did not break user defined specializations
-namespace check_substitute {
-
-template<class T> struct foo {};
-template<class T> struct bar { using type = T; };
-template<class T> struct is_bar : std::false_type {};
-template<class T> struct is_bar<bar<T>> : std::true_type {};
-
-} // check_substitute
-
-namespace iris::x4::traits {
-
-using namespace check_substitute;
-
-template<class T, X4Attribute U>
-struct is_substitute<foo<T>, foo<U>>
-    : is_substitute<T, U>
-{};
-
-template<class T, X4Attribute U>
-    requires is_bar<T>::value && is_bar<U>::value
-struct is_substitute<T, U>
-    : is_substitute<typename T::type, typename U::type>
-{};
-
-} // iris::x4::traits
-
-namespace check_substitute {
-
-using x4::traits::is_substitute_v;
-static_assert( is_substitute_v<foo<int>, foo<int>>);
-static_assert(!is_substitute_v<foo<int>, foo<long>>);
-static_assert( is_substitute_v<bar<int>, bar<int>>);
-static_assert(!is_substitute_v<bar<int>, bar<long>>);
-
-} // check_substitute
-
-namespace {
-
 constexpr x4::rule<class pair_rule, std::pair<std::string, std::string>> pair_rule("pair");
 constexpr x4::rule<class string_rule, std::string> string_rule("string");
 
-constexpr auto pair_rule_def = string_rule >> x4::lit('=') >> string_rule;
 constexpr auto string_rule_def = x4::lexeme[*x4::standard::alnum];
+constexpr auto pair_rule_def = string_rule >> x4::lit('=') >> string_rule;
 
-IRIS_X4_DEFINE(pair_rule)
 IRIS_X4_DEFINE(string_rule)
+IRIS_X4_DEFINE(pair_rule)
+
+constexpr auto as_string_parser = x4::as<std::string>(x4::lexeme[*x4::standard::alnum]);
+constexpr auto as_pair_parser = x4::as<std::pair<std::string, std::string>>(as_string_parser >> x4::lit('=') >> as_string_parser);
 
 template<class Container>
 void test_map_support()
 {
+    // rule version
     {
         constexpr auto rule = pair_rule % x4::lit(',');
         Container actual;
@@ -103,11 +69,33 @@ void test_map_support()
         Container container;
         CHECK(parse("k1=v1,k2=v2,k2=v3", cic_rule, container));
     }
+
+    // as version
+    {
+        constexpr auto rule = as_pair_parser % x4::lit(',');
+        Container actual;
+        REQUIRE(parse("k1=v1,k2=v2,k2=v3", rule, actual));
+        CHECK(actual.size() == 2);
+        CHECK(actual == Container{{"k1", "v1"}, {"k2", "v2"}});
+    }
+    {
+        // test sequences parsing into containers
+        constexpr auto seq_rule = as_pair_parser >> ',' >> as_pair_parser >> ',' >> as_pair_parser;
+        Container container;
+        CHECK(parse("k1=v1,k2=v2,k2=v3", seq_rule, container));
+    }
+    {
+        // test parsing container into container
+        constexpr auto cic_rule = as_pair_parser >> +(',' >> as_pair_parser);
+        Container container;
+        CHECK(parse("k1=v1,k2=v2,k2=v3", cic_rule, container));
+    }
 }
 
 template<class Container>
 void test_multimap_support()
 {
+    // rule version
     {
         constexpr auto rule = pair_rule % x4::lit(',');
         Container actual;
@@ -127,11 +115,33 @@ void test_multimap_support()
         Container container;
         CHECK(parse("k1=v1,k2=v2,k2=v3", cic_rule, container));
     }
+
+    // as version
+    {
+        constexpr auto rule = as_pair_parser % x4::lit(',');
+        Container actual;
+        REQUIRE(parse("k1=v1,k2=v2,k2=v3", rule, actual));
+        CHECK(actual.size() == 3);
+        CHECK(actual == Container{ {"k1", "v1"}, {"k2", "v2"}, {"k2", "v3"} });
+    }
+    {
+        // test sequences parsing into containers
+        constexpr auto seq_rule = as_pair_parser >> ',' >> as_pair_parser >> ',' >> as_pair_parser;
+        Container container;
+        CHECK(parse("k1=v1,k2=v2,k2=v3", seq_rule, container));
+    }
+    {
+        // test parsing container into container
+        constexpr auto cic_rule = as_pair_parser >> +(',' >> as_pair_parser);
+        Container container;
+        CHECK(parse("k1=v1,k2=v2,k2=v3", cic_rule, container));
+    }
 }
 
 template<class Container>
 void test_sequence_support()
 {
+    // rule version
     {
         constexpr auto rule = string_rule % x4::lit(',');
         Container actual;
@@ -151,11 +161,33 @@ void test_sequence_support()
         Container container;
         CHECK(parse("e1,e2,e2", cic_rule, container));
     }
+
+    // as version
+    {
+        constexpr auto rule = as_string_parser % x4::lit(',');
+        Container actual;
+        REQUIRE(parse("e1,e2,e2", rule, actual));
+        CHECK(actual.size() == 3);
+        CHECK(actual == Container{ "e1", "e2", "e2" });
+    }
+    {
+        // test sequences parsing into containers
+        constexpr auto seq_rule = as_string_parser >> ',' >> as_string_parser >> ',' >> as_string_parser;
+        Container container;
+        CHECK(parse("e1,e2,e2", seq_rule, container));
+    }
+    {
+        // test parsing container into container
+        constexpr auto cic_rule = as_string_parser >> +(',' >> as_string_parser);
+        Container container;
+        CHECK(parse("e1,e2,e2", cic_rule, container));
+    }
 }
 
 template<class Container>
 void test_set_support()
 {
+    // rule version
     {
         constexpr auto rule = string_rule % x4::lit(',');
         Container actual;
@@ -175,11 +207,33 @@ void test_set_support()
         Container container;
         CHECK(parse("e1,e2,e2", cic_rule, container));
     }
+
+    // as version
+    {
+        constexpr auto rule = as_string_parser % x4::lit(',');
+        Container actual;
+        REQUIRE(parse("e1,e2,e2", rule, actual));
+        CHECK(actual.size() == 2);
+        CHECK(actual == Container{ "e1", "e2" });
+    }
+    {
+        // test sequences parsing into containers
+        constexpr auto seq_rule = as_string_parser >> ',' >> as_string_parser >> ',' >> as_string_parser;
+        Container container;
+        CHECK(parse("e1,e2,e2", seq_rule, container));
+    }
+    {
+        // test parsing container into container
+        constexpr auto cic_rule = as_string_parser >> +(',' >> as_string_parser);
+        Container container;
+        CHECK(parse("e1,e2,e2", cic_rule, container));
+    }
 }
 
 template<class Container>
 void test_multiset_support()
 {
+    // rule version
     {
         constexpr auto rule = string_rule % x4::lit(',');
         Container actual;
@@ -199,11 +253,33 @@ void test_multiset_support()
         Container container;
         CHECK(parse("e1,e2,e2", cic_rule, container));
     }
+
+    // as version
+    {
+        constexpr auto rule = as_string_parser % x4::lit(',');
+        Container actual;
+        REQUIRE(parse("e1,e2,e2", rule, actual));
+        CHECK(actual.size() == 3);
+        CHECK(actual == Container{"e1", "e2", "e2"});
+    }
+    {
+        // test sequences parsing into containers
+        constexpr auto seq_rule = as_string_parser >> ',' >> as_string_parser >> ',' >> as_string_parser;
+        Container container;
+        CHECK(parse("e1,e2,e2", seq_rule, container));
+    }
+    {
+        // test parsing container into container
+        constexpr auto cic_rule = as_string_parser >> +(',' >> as_string_parser);
+        Container container;
+        CHECK(parse("e1,e2,e2", cic_rule, container));
+    }
 }
 
 template<class Container>
 void test_string_support()
 {
+    // rule version
     {
         constexpr auto rule = string_rule % x4::lit(',');
         Container container;
@@ -223,9 +299,28 @@ void test_string_support()
         Container container;
         CHECK(parse("e1,e2,e2", cic_rule, container));
     }
-}
 
-} // anonymous
+    // as version
+    {
+        constexpr auto rule = as_string_parser % x4::lit(',');
+        Container container;
+        REQUIRE(parse("e1,e2,e2", rule, container));
+        CHECK(container.size() == 6);
+        CHECK(container == Container{"e1e2e2"});
+    }
+    {
+        // test sequences parsing into containers
+        constexpr auto seq_rule = as_string_parser >> ',' >> as_string_parser >> ',' >> as_string_parser;
+        Container container;
+        CHECK(parse("e1,e2,e2", seq_rule, container));
+    }
+    {
+        // test parsing container into container
+        constexpr auto cic_rule = as_string_parser >> +(',' >> as_string_parser);
+        Container container;
+        CHECK(parse("e1,e2,e2", cic_rule, container));
+    }
+}
 
 TEST_CASE("container_support")
 {
@@ -276,25 +371,25 @@ TEST_CASE("container_support")
     STATIC_CHECK(is_container_v<x4::container_appender<std::unordered_multiset<int>>>);
     STATIC_CHECK(is_associative_v<x4::container_appender<std::unordered_multiset<int>>>);
 
-    STATIC_CHECK(is_container_v<std::map<int,int>>);
-    STATIC_CHECK(is_associative_v<std::map<int,int>>);
-    STATIC_CHECK(is_container_v<x4::container_appender<std::map<int,int>>>);
-    STATIC_CHECK(is_associative_v<x4::container_appender<std::map<int,int>>>);
+    STATIC_CHECK(is_container_v<std::map<int, int>>);
+    STATIC_CHECK(is_associative_v<std::map<int, int>>);
+    STATIC_CHECK(is_container_v<x4::container_appender<std::map<int, int>>>);
+    STATIC_CHECK(is_associative_v<x4::container_appender<std::map<int, int>>>);
 
-    STATIC_CHECK(is_container_v<std::unordered_map<int,int>>);
-    STATIC_CHECK(is_associative_v<std::unordered_map<int,int>>);
-    STATIC_CHECK(is_container_v<x4::container_appender<std::unordered_map<int,int>>>);
-    STATIC_CHECK(is_associative_v<x4::container_appender<std::unordered_map<int,int>>>);
+    STATIC_CHECK(is_container_v<std::unordered_map<int, int>>);
+    STATIC_CHECK(is_associative_v<std::unordered_map<int, int>>);
+    STATIC_CHECK(is_container_v<x4::container_appender<std::unordered_map<int, int>>>);
+    STATIC_CHECK(is_associative_v<x4::container_appender<std::unordered_map<int, int>>>);
 
-    STATIC_CHECK(is_container_v<std::multimap<int,int>>);
-    STATIC_CHECK(is_associative_v<std::multimap<int,int>>);
-    STATIC_CHECK(is_container_v<x4::container_appender<std::multimap<int,int>>>);
-    STATIC_CHECK(is_associative_v<x4::container_appender<std::multimap<int,int>>>);
+    STATIC_CHECK(is_container_v<std::multimap<int, int>>);
+    STATIC_CHECK(is_associative_v<std::multimap<int, int>>);
+    STATIC_CHECK(is_container_v<x4::container_appender<std::multimap<int, int>>>);
+    STATIC_CHECK(is_associative_v<x4::container_appender<std::multimap<int, int>>>);
 
-    STATIC_CHECK(is_container_v<std::unordered_multimap<int,int>>);
-    STATIC_CHECK(is_associative_v<std::unordered_multimap<int,int>>);
-    STATIC_CHECK(is_container_v<x4::container_appender<std::unordered_multimap<int,int>>>);
-    STATIC_CHECK(is_associative_v<x4::container_appender<std::unordered_multimap<int,int>>>);
+    STATIC_CHECK(is_container_v<std::unordered_multimap<int, int>>);
+    STATIC_CHECK(is_associative_v<std::unordered_multimap<int, int>>);
+    STATIC_CHECK(is_container_v<x4::container_appender<std::unordered_multimap<int, int>>>);
+    STATIC_CHECK(is_associative_v<x4::container_appender<std::unordered_multimap<int, int>>>);
 
     // ------------------------------------------------------------------
 
@@ -310,9 +405,9 @@ TEST_CASE("container_support")
     test_multiset_support<std::multiset<std::string>>();
     test_multiset_support<std::unordered_multiset<std::string>>();
 
-    test_map_support<std::map<std::string,std::string>>();
-    test_map_support<std::unordered_map<std::string,std::string>>();
+    test_map_support<std::map<std::string, std::string>>();
+    test_map_support<std::unordered_map<std::string, std::string>>();
 
-    test_multimap_support<std::multimap<std::string,std::string>>();
-    test_multimap_support<std::unordered_multimap<std::string,std::string>>();
+    test_multimap_support<std::multimap<std::string, std::string>>();
+    test_multimap_support<std::unordered_multimap<std::string, std::string>>();
 }
diff --git a/test/x4/expect.cpp b/test/x4/expect.cpp
index 86fe5b483..4d6d04d72 100644
--- a/test/x4/expect.cpp
+++ b/test/x4/expect.cpp
@@ -33,7 +33,6 @@
 #include <iris/x4/directive/no_case.hpp>
 #include <iris/x4/directive/no_skip.hpp>
 #include <iris/x4/directive/omit.hpp>
-#include <iris/x4/directive/raw.hpp>
 #include <iris/x4/directive/repeat.hpp>
 #include <iris/x4/directive/seek.hpp>
 #include <iris/x4/directive/skip.hpp>
@@ -152,7 +151,6 @@ TEST_CASE("expectation_failure_context_uninstantiated_in_expect_less_parse")
     using x4::no_case;
     using x4::no_skip;
     using x4::omit;
-    using x4::raw;
     using x4::repeat;
     using x4::seek;
     using x4::skip;
@@ -216,7 +214,6 @@ TEST_CASE("expectation_failure_context_uninstantiated_in_expect_less_parse")
     (void)no_skip[int_ >> int_].parse(first, last, unused, dummy_ints);
 
     (void)omit[eps].parse(first, last, unused, unused);
-    (void)raw[eps].parse(first, last, unused, unused);
     (void)repeat(1)[eps].parse(first, last, unused, unused);
     (void)seek[eps].parse(first, last, unused, unused);
     (void)skip(space)[eps].parse(first, last, unused, unused);
@@ -252,7 +249,7 @@ TEST_CASE("expectation_failure_context_uninstantiated_in_expect_less_parse")
     (void)(-(int_ >> int_)).parse(first, last, unused, dummy_optional_ints);
 
     (void)(+eps(false)).parse(first, last, unused, unused);
-    (void)(+int_).parse(first, last, unused, dummy_int);
+    (void)(+int_).parse(first, last, unused, dummy_ints);
 
     (void)(eps >> eps).parse(first, last, unused, unused);
     (void)(int_ >> int_).parse(first, last, unused, dummy_ints);
@@ -292,7 +289,6 @@ TEST_CASE("expect")
     using x4::no_case;
     using x4::no_skip;
     using x4::omit;
-    using x4::raw;
     using x4::skip;
     using x4::seek;
     using x4::repeat;
@@ -660,15 +656,6 @@ TEST_CASE("expect")
         });
     }
 
-    // raw
-    {
-        X4_TEST_SUCCESS_PASS("ab", raw[lit('a') > 'b']);
-        X4_TEST_FAILURE("ab", raw[lit('a') > 'c'], {
-            CHECK(which == "'c'"sv);
-            CHECK(where == "b"sv);
-        });
-    }
-
     // repeat
     {
         X4_TEST_SUCCESS_PASS("ababac", repeat(1, 3)[lit('a') >> 'b'] >> "ac" | +alpha);
diff --git a/test/x4/iris_x4_test.hpp b/test/x4/iris_x4_test.hpp
index d5bbb77a2..5b7a38981 100644
--- a/test/x4/iris_x4_test.hpp
+++ b/test/x4/iris_x4_test.hpp
@@ -174,6 +174,19 @@ constexpr synth_parser<T> synth{};
 
 constexpr synth_parser<move_only> synth_move_only{};
 
+template<class T>
+struct custom_container
+{
+    using value_type = T;
+    T* begin() { return nullptr; }
+    T* end() { return nullptr; }
+    bool empty() const { return true; }
+    void clear() {}
+    void push_back(T const&) {}
+    template<class It, class Se>
+    void insert(T*, It, Se) {}
+};
+
 } // x4_test
 
 using x4_test::parse;
diff --git a/test/x4/iterator.cpp b/test/x4/iterator.cpp
index 16070ee10..14f9dc8d6 100644
--- a/test/x4/iterator.cpp
+++ b/test/x4/iterator.cpp
@@ -30,7 +30,6 @@
 #include <iris/x4/directive/no_case.hpp>
 #include <iris/x4/directive/no_skip.hpp>
 #include <iris/x4/directive/omit.hpp>
-#include <iris/x4/directive/raw.hpp>
 #include <iris/x4/directive/repeat.hpp>
 #include <iris/x4/directive/seek.hpp>
 #include <iris/x4/directive/skip.hpp>
@@ -290,7 +289,6 @@ TEST_CASE("rollback on failed parse (directive)")
     using x4::no_case;
     using x4::no_skip;
     using x4::omit;
-    using x4::raw;
     using x4::repeat;
     using x4::seek;
     using x4::skip;
@@ -465,34 +463,6 @@ TEST_CASE("rollback on failed parse (directive)")
         CHECK(dummy_int == -1); // `omit` never yields an attribute
     }
 
-    {
-        constexpr auto input = "foo"sv;
-        auto first = input.begin();
-        std::ranges::subrange<It> dummy_subrange{input.end(), input.end()};
-        REQUIRE_FALSE(raw[eps(false)].parse(first, input.end(), unused, dummy_subrange));
-        CHECK(first == input.begin());
-        CHECK(dummy_subrange.begin() == input.end());
-        CHECK(dummy_subrange.end() == input.end());
-    }
-    {
-        constexpr auto input = "foo"sv;
-        auto first = input.begin();
-        std::ranges::subrange<It> dummy_subrange{input.end(), input.end()};
-        REQUIRE_FALSE(raw[int_].parse(first, input.end(), unused, dummy_subrange));
-        CHECK(first == input.begin());
-        CHECK(dummy_subrange.begin() == input.end());
-        CHECK(dummy_subrange.end() == input.end());
-    }
-    {
-        constexpr auto input = "42"sv;
-        auto first = input.begin();
-        std::ranges::subrange<It> dummy_subrange{input.end(), input.end()};
-        REQUIRE_FALSE(raw[int_ >> eps(false)].parse(first, input.end(), unused, dummy_subrange));
-        CHECK(first == input.begin());
-        CHECK(dummy_subrange.begin() == input.end());
-        CHECK(dummy_subrange.end() == input.end());
-    }
-
     {
         constexpr auto input = "foo"sv;
         auto first = input.begin();
@@ -513,7 +483,7 @@ TEST_CASE("rollback on failed parse (directive)")
         std::vector<bool> dummy_bools;
         REQUIRE_FALSE(repeat(1)[true_ >> true_].parse(first, input.end(), unused, dummy_bools));
         CHECK(first == input.begin());
-        CHECK(dummy_bools == std::vector<bool>{true}); // sequence parser has side effect
+        CHECK(dummy_bools == std::vector<bool>{});
     }
     {
         constexpr auto input = "true123"sv;
@@ -521,7 +491,7 @@ TEST_CASE("rollback on failed parse (directive)")
         std::vector<bool> dummy_bools;
         REQUIRE_FALSE(repeat(2)[true_].parse(first, input.end(), unused, dummy_bools));
         CHECK(first == input.begin());
-        CHECK(dummy_bools == std::vector<bool>{true}); // sequence parser has side effect
+        CHECK(dummy_bools == std::vector<bool>{});
     }
 
     {
@@ -912,7 +882,6 @@ TEST_CASE("rollback on failed parse (rule)")
 
 TEST_CASE("transform iterator")
 {
-    using x4::raw;
     using x4::eps;
     using x4::eoi;
     using x4::standard::upper;
@@ -931,13 +900,6 @@ TEST_CASE("transform iterator")
         CHECK("ABCDE" == str);
     }
 
-    {
-        std::ranges::subrange<std::ranges::iterator_t<range_type>> str;
-
-        REQUIRE(parse(std::ranges::begin(rng), std::ranges::end(rng), raw[+upper >> eoi], str));
-        CHECK(std::ranges::equal(std::string("ABCDE"), str));
-    }
-
     CHECK(parse(std::ranges::begin(rng), std::ranges::end(rng), (repeat(6)[upper] | repeat(5)[upper]) >> eoi));
 }
 
diff --git a/test/x4/kleene.cpp b/test/x4/kleene.cpp
index 789244748..693868dad 100644
--- a/test/x4/kleene.cpp
+++ b/test/x4/kleene.cpp
@@ -19,27 +19,6 @@
 #include <string>
 #include <vector>
 
-struct x_attr {};
-
-namespace iris::x4::traits {
-
-template<>
-struct container_value<x_attr>
-{
-    using type = char; // value type of container
-};
-
-template<>
-struct push_back_container<x_attr>
-{
-    static constexpr void call(x_attr& /*c*/, char /*val*/) noexcept
-    {
-        // push back value type into container
-    }
-};
-
-} // x4::traits
-
 TEST_CASE("kleene")
 {
     using x4::char_;
@@ -131,7 +110,7 @@ TEST_CASE("kleene")
     }
 
     {
-        x_attr x;
+        x4_test::custom_container<char> x;
         (void)parse("abcde", *char_, x);
     }
 
diff --git a/test/x4/move_to.cpp b/test/x4/move_to.cpp
new file mode 100644
index 000000000..b7f168bde
--- /dev/null
+++ b/test/x4/move_to.cpp
@@ -0,0 +1,58 @@
+#include "iris_x4_test.hpp"
+
+#include <iris/x4/core/move_to.hpp>
+
+#include <iris/alloy/tuple.hpp>
+#include <iris/alloy/adapt.hpp>
+#include <iris/rvariant/rvariant.hpp>
+#include <iris/rvariant/rvariant_io.hpp>
+
+#include <vector>
+
+struct X {};
+struct Y {};
+struct Z {};
+
+struct Xs
+{
+    std::vector<X> xs;
+};
+IRIS_ALLOY_ADAPT_STRUCT(Xs, xs);
+
+using XYZ = iris::rvariant<X, Y, Z, Xs>;
+
+
+TEST_CASE("move_to")
+{
+    // TODO: add more test
+
+    // Currently not permitted by design, but may be changed in the future
+    // if legitimate rationale is discovered
+    {
+        //XYZ xyz;
+        //xyz = std::vector<X>{};
+        static_assert(!std::is_assignable_v<XYZ&, std::vector<X>>);
+        STATIC_CHECK(!x4::X4Movable<std::vector<X>, XYZ>);
+    }
+
+    // tuple contains reference
+    {
+        int n = 0;
+        alloy::tuple<int&> ref_tuple{ n };
+        x4::move_to(42, ref_tuple);
+        CHECK(n == 42);
+    }
+    {
+        int n = 42;
+        alloy::tuple<int&> ref_tuple{ n };
+        alloy::tuple<int> dest{ 0 };
+        x4::move_to(std::move(ref_tuple), dest);
+        CHECK(alloy::get<0>(dest) == 42);
+    }
+    {
+        x4_test::move_only mo;
+        alloy::tuple<x4_test::move_only&> ref_tuple{ mo };
+        alloy::tuple<x4_test::move_only> dest;
+        x4::move_to(std::move(ref_tuple), dest); // move "far" ownership
+    }
+}
diff --git a/test/x4/partial_success.cpp b/test/x4/partial_success.cpp
new file mode 100644
index 000000000..9219b6284
--- /dev/null
+++ b/test/x4/partial_success.cpp
@@ -0,0 +1,446 @@
+/*=============================================================================
+    Copyright (c) 2025 Nana Sakisaka
+    Copyright (c) 2026 The Iris Project Contributors
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+
+#include "iris_x4_test.hpp"
+
+#include <iris/x4/auxiliary/attr.hpp>
+#include <iris/x4/auxiliary/eps.hpp>
+#include <iris/x4/char/char.hpp>
+#include <iris/x4/char/char_class.hpp>
+#include <iris/x4/string/string.hpp>
+#include <iris/x4/numeric/int.hpp>
+#include <iris/x4/directive/omit.hpp>
+#include <iris/x4/operator/sequence.hpp>
+#include <iris/x4/operator/alternative.hpp>
+
+#include <iris/alloy/adapted/std_pair.hpp>
+
+// list-like
+#include <iris/x4/operator/kleene.hpp>
+#include <iris/x4/operator/plus.hpp>
+#include <iris/x4/operator/list.hpp>
+#include <iris/x4/directive/repeat.hpp>
+
+#include <concepts>
+#include <ostream>
+#include <vector>
+#include <string>
+#include <utility>
+
+// NOLINTBEGIN(readability-container-size-empty)
+
+using namespace std::string_view_literals;
+
+struct strong_int
+{
+    int value = 0;
+    int assigned_count = 0;
+
+    strong_int() = default;
+    strong_int(strong_int const&) = default;
+    strong_int(strong_int&&) noexcept = default;
+
+    explicit strong_int(int value) : value(value) {}
+
+    strong_int& operator=(strong_int const& other)
+    {
+        value = other.value;
+        ++assigned_count;
+        return *this;
+    }
+
+    strong_int& operator=(strong_int&& other) noexcept
+    {
+        value = other.value;
+        ++assigned_count;
+        return *this;
+    }
+
+    strong_int& operator=(int new_value)
+    {
+        value = new_value;
+        ++assigned_count;
+        return *this;
+    }
+
+    bool operator==(strong_int const& other) const
+    {
+        return value == other.value;
+    }
+
+    friend std::ostream& operator<<(std::ostream& os, strong_int const& si)
+    {
+        return os << si.value;
+    }
+};
+
+TEST_CASE("partial success (alternative)")
+{
+    using x4::attr;
+    using x4::eps;
+    using x4::omit;
+    using x4::int_;
+
+    using x4::string;
+    using x4::lit;
+    using x4::standard::char_;
+    using x4::standard::space;
+
+    // Sanity checks
+    {
+        int i = -1;
+        REQUIRE(parse("", attr(42), i));
+        CHECK(i == 42);
+    }
+    {
+        std::string str;
+        REQUIRE(parse("", attr("foo"), str));
+        CHECK(str == "foo");
+    }
+    {
+        std::string str;
+        REQUIRE(parse("foo", string("foo"), str));
+        CHECK(str == "foo");
+    }
+
+    // Non-string container attribute
+    // Related to: https://github.com/boostorg/spirit/issues/378
+    {
+        static_assert(x4::traits::CategorizedAttr<std::vector<int>, x4::traits::container_attr>);
+        static_assert(x4::traits::X4Container<std::vector<int>>);
+        static_assert(x4::traits::is_container_v<std::vector<int>>);
+
+        {
+            std::vector<int> ints;
+            REQUIRE(parse("1 2", eps(false) | attr(98) >> attr(99), ints).is_partial_match());
+            CHECK(ints == std::vector<int>{98, 99});
+        }
+        {
+            std::vector<int> ints;
+            REQUIRE(parse("1 2", int_ >> int_ >> eps(false) | attr(98) >> attr(99), space, ints).is_partial_match());
+            // If we don't properly "hold" the value on the failed branch of
+            // `x4::alternative`, we would see {1, 2, 98, 99} here.
+            CHECK(ints == std::vector<int>{98, 99});
+        }
+        // Failed parse should not modify the exposed attribute
+        {
+            std::vector<int> ints;
+            REQUIRE(!parse("1 2", int_ >> int_ >> eps(false) | attr(98) >> attr(99) >> eps(false), space, ints));
+            // Wrong implementation yields {1, 2, 98, 99} or {98, 99}
+            CHECK(ints == std::vector<int>{});
+        }
+        {
+            std::vector<int> ints;
+            REQUIRE(parse("1 2", attr(std::vector<int>{3, 4}) >> eps(false) | attr(98) >> attr(99), space, ints).is_partial_match());
+            // Wrong implementation yields {3, 4, 98, 99}
+            CHECK(ints == std::vector<int>{98, 99});
+        }
+    }
+
+    // String container attribute
+    // Intended for testing `detail::string_parse`
+    {
+        static_assert(x4::traits::CategorizedAttr<std::string, x4::traits::container_attr>);
+        static_assert(x4::traits::X4Container<std::string>);
+        static_assert(x4::traits::is_container_v<std::string>);
+
+        {
+            std::string str;
+            REQUIRE(parse("foodie", "fox" | string("foodie"), str));
+            CHECK(str == "foodie");
+        }
+        {
+            constexpr auto fox = char_('f') >> char_('o') >> char_('x');
+
+            std::string str;
+            REQUIRE(parse("foodie", fox | string("foodie"), str));
+            // If we don't properly "hold" the value on the failed branch of
+            // `x4::alternative`, we would see "fofoodie" here.
+            CHECK(str == "foodie");
+        }
+        {
+            constexpr auto foo = char_('f') >> char_('o') >> char_('o');
+
+            std::string str;
+            REQUIRE(parse("foodie", foo >> eps(false) | string("foodie"), str));
+            // Wrong implementation yields "foofoodie"
+            CHECK(str == "foodie");
+        }
+        {
+            std::string str;
+            REQUIRE(parse("foodie", attr("bookworm") >> eps(false) | string("foodie"), str));
+            // Wrong implementation yields "bookwormfoodie"
+            CHECK(str == "foodie");
+        }
+        // Failed parse should not modify the exposed attribute
+        {
+            std::string str;
+            REQUIRE(!parse("foodie", attr("bookworm") >> eps(false) | string("foodie") >> eps(false), str));
+            // Wrong implementation yields "bookwormfoodie" or "foodie"
+            CHECK(str == "");
+        }
+
+        {
+            std::string str;
+            REQUIRE(parse("foodie", string("food") >> "fan" | string("foodie"), str));
+            // Wrong implementation yields "foodfoodie"
+            CHECK(str == "foodie");
+        }
+    }
+
+    // Plain attribute
+    {
+        static_assert(x4::traits::CategorizedAttr<strong_int, x4::traits::plain_attr>);
+        static_assert(!x4::traits::X4Container<strong_int>);
+        static_assert(!x4::traits::is_container_v<strong_int>);
+
+        {
+            strong_int si;
+            REQUIRE(parse("1", int_ | attr(strong_int{9}), si));
+            CHECK(si == strong_int{1});
+            CHECK(si.assigned_count == 1);
+        }
+        {
+            strong_int si;
+            REQUIRE(parse("1", int_ >> eps(false) | int_, si));
+            CHECK(si == strong_int{1});
+            // Wrong implementation yields 2, because `x4::alternative` wrongly mutates the exposed variable
+            CHECK(si.assigned_count == 1);
+        }
+    }
+
+    // Tuple attribute
+    {
+        using pair_int = std::pair<int, int>;
+
+        static_assert(x4::traits::CategorizedAttr<pair_int, x4::traits::tuple_attr>);
+        static_assert(!x4::traits::X4Container<pair_int>);
+        static_assert(!x4::traits::is_container_v<pair_int>);
+
+        {
+            pair_int pi;
+            REQUIRE(parse("1 2", int_ >> int_ | attr(pair_int{98, 99}), space, pi));
+            CHECK(pi == pair_int{1, 2});
+        }
+        {
+            pair_int pi;
+            REQUIRE(parse("1 2",
+                int_ >> int_ >> eps(false) | attr(pair_int{98, 99}) >> omit[int_ >> int_],
+                space, pi
+            ));
+            CHECK(pi == pair_int{98, 99});
+        }
+    }
+}
+
+TEST_CASE("partial success (list-like)")
+{
+    using x4::char_encoding::standard;
+
+    using x4::standard::char_;
+    using x4::standard::string;
+    using x4::standard::lit;
+    using x4::repeat;
+
+    constexpr auto a = char_('a');
+    constexpr auto b = char_('b');
+    constexpr auto c = char_('c');
+    constexpr auto OO = string("OO");
+
+    constexpr auto abc = a >> b >> c;   // tuple<char, char, char>
+    constexpr auto aOOc = a >> OO >> c; // tuple<char, string, char>
+
+    // abc ----------------------------------------------
+    {
+        using Subject = x4::sequence<
+            x4::sequence<
+                x4::literal_char<standard>,
+                x4::literal_char<standard>
+            >,
+            x4::literal_char<standard>
+        >;
+        static_assert(std::same_as<std::remove_const_t<decltype(abc)>, Subject>);
+        STATIC_CHECK(std::same_as<Subject::attribute_type, alloy::tuple<char, char, char>>);
+        STATIC_CHECK(x4::detail::container_can_hold_sequence<std::string, alloy::tuple<char, char, char>>::value);
+
+        using Container = std::string;
+
+        STATIC_CHECK(x4::parser_traits<Subject>::template handles_container<Container>);
+        STATIC_CHECK(x4::parser_traits<x4::kleene<Subject>>::template handles_container<Container>);
+        STATIC_CHECK(x4::parser_traits<x4::plus<Subject>>::template handles_container<Container>);
+        STATIC_CHECK(x4::parser_traits<x4::list<Subject, x4::literal_char<standard, unused_type>>>::template handles_container<Container>);
+    }
+
+    // kleene
+    {
+        std::string abcs;
+        REQUIRE(parse("abcabx", *abc >> "abx", abcs));
+        CHECK(abcs == "abc"sv); // wrong implementation yields "abcab"
+    }
+    {
+        std::string abcs;
+        REQUIRE(parse("abcabcabx", *abc >> "abx", abcs));
+        CHECK(abcs == "abcabc"sv); // wrong implementation yields "abcabcab"
+    }
+
+    // plus
+    {
+        std::string abcs;
+        REQUIRE(parse("abcabx", +abc >> "abx", abcs));
+        CHECK(abcs == "abc"sv); // wrong implementation yields "abcab"
+    }
+    {
+        std::string abcs;
+        REQUIRE(parse("abcabcabx", +abc >> "abx", abcs));
+        CHECK(abcs == "abcabc"sv); // wrong implementation yields "abcabcab"
+    }
+
+    // list
+    {
+        std::string abcs;
+        REQUIRE(parse("abc,abx", abc % ',' >> ",abx", abcs));
+        CHECK(abcs == "abc"sv); // wrong implementation yields "abcab"
+    }
+    {
+        std::string abcs;
+        REQUIRE(parse("abc,abc,abx", abc % ',' >> ",abx", abcs));
+        CHECK(abcs == "abcabc"sv); // wrong implementation yields "abcabcab"
+    }
+
+    // repeat [exact]
+    {
+        std::string abcs;
+        REQUIRE(!parse("abcabx", repeat(2)[abc], abcs));
+        CHECK(abcs == ""sv); // wrong implementation yields "abc"
+    }
+    {
+        std::string abcs;
+        REQUIRE(!parse("abcabcabx", repeat(3)[abc], abcs));
+        CHECK(abcs == ""sv); // wrong implementation yields "abcabc"
+    }
+
+    // repeat [min, max]
+    {
+        std::string abcs;
+        REQUIRE(parse("abcabx", repeat(0, 2)[abc] >> "abx", abcs));
+        CHECK(abcs == "abc"sv); // wrong implementation yields "abcab"
+    }
+    {
+        std::string abcs;
+        REQUIRE(parse("abcabcabx", repeat(0, 3)[abc] >> "abx", abcs));
+        CHECK(abcs == "abcabc"sv); // wrong implementation yields "abcabcab"
+    }
+
+    // repeat [min, inf]
+    {
+        std::string abcs;
+        REQUIRE(parse("abcabx", repeat(0, x4::repeat_inf)[abc] >> "abx", abcs));
+        CHECK(abcs == "abc"sv); // wrong implementation yields "abcab"
+    }
+    {
+        std::string abcs;
+        REQUIRE(parse("abcabcabx", repeat(0, x4::repeat_inf)[abc] >> "abx", abcs));
+        CHECK(abcs == "abcabc"sv); // wrong implementation yields "abcabcab"
+    }
+
+
+    // aXXc ----------------------------------------------
+    {
+        using Subject = x4::sequence<
+            x4::sequence<
+                x4::literal_char<standard>,
+                x4::literal_string<std::string_view, standard>
+            >,
+            x4::literal_char<standard>
+        >;
+        static_assert(std::same_as<std::remove_const_t<decltype(aOOc)>, Subject>);
+        STATIC_CHECK(std::same_as<Subject::attribute_type, alloy::tuple<char, std::string, char>>);
+        STATIC_CHECK(x4::detail::container_can_hold_sequence<std::string, alloy::tuple<char, std::string, char>>::value);
+
+        using Container = std::string;
+
+        STATIC_CHECK(x4::parser_traits<Subject>::template handles_container<Container>);
+        STATIC_CHECK(x4::parser_traits<x4::kleene<Subject>>::template handles_container<Container>);
+        STATIC_CHECK(x4::parser_traits<x4::plus<Subject>>::template handles_container<Container>);
+        STATIC_CHECK(x4::parser_traits<x4::list<Subject, x4::literal_char<standard, unused_type>>>::template handles_container<Container>);
+    }
+
+    // kleene
+    {
+        std::string aOOcs;
+        REQUIRE(parse("aOOcaOOx", *aOOc >> "aOOx", aOOcs));
+        CHECK(aOOcs == "aOOc"sv); // wrong implementation yields "aOOcab"
+    }
+    {
+        std::string aOOcs;
+        REQUIRE(parse("aOOcaOOcaOOx", *aOOc >> "aOOx", aOOcs));
+        CHECK(aOOcs == "aOOcaOOc"sv); // wrong implementation yields "aOOcaOOcab"
+    }
+
+    // plus
+    {
+        std::string aOOcs;
+        REQUIRE(parse("aOOcaOOx", +aOOc >> "aOOx", aOOcs));
+        CHECK(aOOcs == "aOOc"sv); // wrong implementation yields "aOOcab"
+    }
+    {
+        std::string aOOcs;
+        REQUIRE(parse("aOOcaOOcaOOx", +aOOc >> "aOOx", aOOcs));
+        CHECK(aOOcs == "aOOcaOOc"sv); // wrong implementation yields "aOOcaOOcab"
+    }
+
+    // list
+    {
+        std::string aOOcs;
+        REQUIRE(parse("aOOc,aOOx", aOOc % ',' >> ",aOOx", aOOcs));
+        CHECK(aOOcs == "aOOc"sv); // wrong implementation yields "aOOcab"
+    }
+    {
+        std::string aOOcs;
+        REQUIRE(parse("aOOc,aOOc,aOOx", aOOc % ',' >> ",aOOx", aOOcs));
+        CHECK(aOOcs == "aOOcaOOc"sv); // wrong implementation yields "aOOcaOOcab"
+    }
+
+    // repeat [exact]
+    {
+        std::string aOOcs;
+        REQUIRE(!parse("aOOcaOOx", repeat(2)[aOOc], aOOcs));
+        CHECK(aOOcs == ""sv); // wrong implementation yields "aOOc"
+    }
+    {
+        std::string aOOcs;
+        REQUIRE(!parse("aOOcaOOcaOOx", repeat(3)[aOOc], aOOcs));
+        CHECK(aOOcs == ""sv); // wrong implementation yields "aOOcaOOc"
+    }
+
+    // repeat [min, max]
+    {
+        std::string aOOcs;
+        REQUIRE(parse("aOOcaOOx", repeat(0, 2)[aOOc] >> "aOOx", aOOcs));
+        CHECK(aOOcs == "aOOc"sv); // wrong implementation yields "aOOcab"
+    }
+    {
+        std::string aOOcs;
+        REQUIRE(parse("aOOcaOOcaOOx", repeat(0, 3)[aOOc] >> "aOOx", aOOcs));
+        CHECK(aOOcs == "aOOcaOOc"sv); // wrong implementation yields "aOOcaOOcab"
+    }
+
+    // repeat [min, inf]
+    {
+        std::string aOOcs;
+        REQUIRE(parse("aOOcaOOx", repeat(0, x4::repeat_inf)[aOOc] >> "aOOx", aOOcs));
+        CHECK(aOOcs == "aOOc"sv); // wrong implementation yields "aOOcab"
+    }
+    {
+        std::string aOOcs;
+        REQUIRE(parse("aOOcaOOcaOOx", repeat(0, x4::repeat_inf)[aOOc] >> "aOOx", aOOcs));
+        CHECK(aOOcs == "aOOcaOOc"sv); // wrong implementation yields "aOOcaOOcab"
+    }
+}
+
+// NOLINTEND(readability-container-size-empty)
diff --git a/test/x4/plus.cpp b/test/x4/plus.cpp
index d51da684e..55ece085f 100644
--- a/test/x4/plus.cpp
+++ b/test/x4/plus.cpp
@@ -23,27 +23,6 @@
 #include <string>
 #include <vector>
 
-struct x_attr {};
-
-namespace iris::x4::traits {
-
-template<>
-struct container_value<x_attr>
-{
-    using type = char; // value type of container
-};
-
-template<>
-struct push_back_container<x_attr>
-{
-    static constexpr void call(x_attr& /*c*/, char /*val*/) noexcept
-    {
-        // push back value type into container
-    }
-};
-
-} // x4::traits
-
 TEST_CASE("plus")
 {
     using x4::char_;
@@ -129,7 +108,7 @@ TEST_CASE("plus")
 
     // attribute customization
     {
-        x_attr x;
+        x4_test::custom_container<char> x;
         (void)parse("abcde", +char_, x);
     }
 
diff --git a/test/x4/raw.cpp b/test/x4/raw.cpp
deleted file mode 100644
index d7e7a08ac..000000000
--- a/test/x4/raw.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2014 Joel de Guzman
-    Copyright (c) 2025 Nana Sakisaka
-    Copyright (c) 2026 The Iris Project Contributors
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-=============================================================================*/
-
-#include "iris_x4_test.hpp"
-
-#include <iris/x4/rule.hpp>
-#include <iris/x4/auxiliary/eps.hpp>
-#include <iris/x4/char/char.hpp>
-#include <iris/x4/char/char_class.hpp>
-#include <iris/x4/directive/raw.hpp>
-#include <iris/x4/numeric/int.hpp>
-#include <iris/x4/operator/sequence.hpp>
-#include <iris/x4/operator/kleene.hpp>
-#include <iris/x4/operator/plus.hpp>
-#include <iris/x4/operator/alternative.hpp>
-
-#include <iris/rvariant.hpp>
-
-#include <iris/alloy/adapted/std_pair.hpp>
-
-#include <ranges>
-#include <string>
-
-namespace {
-
-using x4::rule;
-
-rule<class direct_rule, int> direct_rule = "direct_rule";
-rule<class indirect_rule, int> indirect_rule = "indirect_rule";
-
-auto const direct_rule_def = x4::int_;
-auto const indirect_rule_def = direct_rule;
-
-IRIS_X4_DEFINE(direct_rule)
-IRIS_X4_DEFINE(indirect_rule)
-
-} // anonymous
-
-TEST_CASE("raw")
-{
-    using namespace x4::standard;
-    using x4::raw;
-    using x4::eps;
-    using x4::lit;
-    using x4::_attr;
-    using x4::int_;
-    using x4::char_;
-
-    IRIS_X4_ASSERT_CONSTEXPR_CTORS(raw['x']);
-
-    {
-        std::ranges::subrange<std::string_view::const_iterator> range;
-        REQUIRE(parse("spirit_test_123", raw[alpha >> *(alnum | '_')], range));
-        CHECK(std::string(range.begin(), range.end()) == "spirit_test_123");
-    }
-    {
-        std::ranges::subrange<std::string_view::const_iterator> range;
-        REQUIRE(parse("  spirit", raw[*alpha], space, range));
-        CHECK(std::string(range.begin(), range.end()) == "spirit");
-    }
-
-    {
-        std::string str;
-        REQUIRE(parse("spirit_test_123", raw[alpha >> *(alnum | '_')], str));
-        CHECK(str == "spirit_test_123");
-    }
-    {
-        std::string str;
-        REQUIRE(parse("x123", alpha >> raw[+alnum], str));
-        CHECK(str == "x123");
-    }
-
-    {
-        std::ranges::subrange<std::string_view::const_iterator> range;
-        CHECK(parse("x", raw[alpha]));
-        CHECK(parse("x", raw[alpha], range));
-        CHECK(parse("x", raw[alpha] >> eps, range));
-    }
-
-    {
-        std::ranges::subrange<std::string_view::const_iterator> range;
-        REQUIRE(parse("x", raw[alpha][ ([&](auto&& ctx){ range = _attr(ctx); }) ]));
-        REQUIRE(range.size() == 1);
-        CHECK(*range.begin() == 'x');
-    }
-
-    {
-        std::ranges::subrange<std::string_view::const_iterator> range;
-        CHECK(parse("x123x", lit('x') >> raw[+digit] >> lit('x')));
-        CHECK(parse("x123x", lit('x') >> raw[+digit] >> lit('x'), range));
-        CHECK(std::string(range.begin(), range.end()) == "123");
-    }
-
-    {
-        using range = std::ranges::subrange<std::string_view::const_iterator>;
-        iris::rvariant<int, range> attr;
-
-        REQUIRE(parse("test", (int_ | raw[*char_]), attr));
-        auto const& rng = iris::get<range>(attr);
-        CHECK(std::string(rng.begin(), rng.end()) == "test");
-    }
-
-    {
-        std::vector<std::ranges::subrange<std::string_view::const_iterator>> attr;
-        REQUIRE(parse("123abcd", raw[int_] >> raw[*char_], attr));
-        CHECK(attr.size() == 2);
-        CHECK(std::string(attr[0].begin(), attr[0].end()) == "123");
-        CHECK(std::string(attr[1].begin(), attr[1].end()) == "abcd");
-    }
-
-    {
-        std::pair<int, std::ranges::subrange<std::string_view::const_iterator>> attr;
-        REQUIRE(parse("123abcd", int_ >> raw[*char_], attr));
-        CHECK(attr.first == 123);
-        CHECK(std::string(attr.second.begin(), attr.second.end()) == "abcd");
-    }
-
-    {
-        // test with simple rule
-        std::ranges::subrange<std::string_view::const_iterator> range;
-        REQUIRE(parse("123", raw[direct_rule], range));
-        CHECK(std::string(range.begin(), range.end()) == "123");
-    }
-
-    {
-        // test with complex rule
-        std::ranges::subrange<std::string_view::const_iterator> range;
-        REQUIRE(parse("123", raw[indirect_rule], range));
-        CHECK(std::string(range.begin(), range.end()) == "123");
-    }
-}
diff --git a/test/x4/rule3.cpp b/test/x4/rule3.cpp
index 7ad893611..128b2d2ea 100644
--- a/test/x4/rule3.cpp
+++ b/test/x4/rule3.cpp
@@ -52,8 +52,8 @@ namespace check_recursive {
 struct node_array;
 
 using node_t = iris::rvariant<
-   int,
-   iris::recursive_wrapper<node_array>
+    int,
+    iris::recursive_wrapper<node_array>
 >;
 
 struct node_array : std::vector<node_t>
@@ -158,6 +158,7 @@ TEST_CASE("rule3")
 
     {
         using namespace check_recursive;
+
         node_t v;
         REQUIRE(parse("[4,2]", grammar, v));
         CHECK((node_t{node_array{{4}, {2}}} == v));
diff --git a/test/x4/rule4.cpp b/test/x4/rule4.cpp
index 840a9a60f..4824331fa 100644
--- a/test/x4/rule4.cpp
+++ b/test/x4/rule4.cpp
@@ -11,7 +11,9 @@
 
 #include <iris/x4/rule.hpp>
 #include <iris/x4/char/char.hpp>
+#include <iris/x4/char/negated_char.hpp>
 #include <iris/x4/numeric/int.hpp>
+#include <iris/x4/operator/kleene.hpp>
 #include <iris/x4/operator/not_predicate.hpp>
 #include <iris/x4/operator/plus.hpp>
 #include <iris/x4/operator/sequence.hpp>
diff --git a/test/x4/sequence.cpp b/test/x4/sequence.cpp
index fc3628a70..b92d6cb0a 100644
--- a/test/x4/sequence.cpp
+++ b/test/x4/sequence.cpp
@@ -15,6 +15,7 @@
 #include <iris/x4/char/char.hpp>
 #include <iris/x4/char/negated_char.hpp>
 #include <iris/x4/char/char_class.hpp>
+#include <iris/x4/directive/as.hpp>
 #include <iris/x4/directive/no_case.hpp>
 #include <iris/x4/directive/omit.hpp>
 #include <iris/x4/numeric/int.hpp>
@@ -52,6 +53,7 @@ TEST_CASE("sequence")
     using x4::rule;
     using x4::_attr;
     using x4::eps;
+    using x4::as;
 
     IRIS_X4_ASSERT_CONSTEXPR_CTORS(char_ >> char_);
 
@@ -129,13 +131,27 @@ TEST_CASE("sequence")
         // unwrap it). It's odd that the RHS (r) does not really have a
         // single element tuple, so the original comment is not accurate.
 
-        using attr_type = alloy::tuple<char, int>;
-        attr_type tpl;
+        // rule version
+        {
+            using attr_type = alloy::tuple<char, int>;
+            attr_type tpl;
+
+            auto r = rule<struct r_id, attr_type>{} = char_ >> ',' >> int_;
+
+            REQUIRE(parse("test:x,1", "test:" >> r, tpl));
+            CHECK((tpl == attr_type('x', 1)));
+        }
 
-        auto r = rule<class r_id, attr_type>{} = char_ >> ',' >> int_;
+        // as version
+        {
+            using attr_type = alloy::tuple<char, int>;
+            attr_type tpl;
+
+            auto r = as<attr_type>(char_ >> ',' >> int_);
 
-        REQUIRE(parse("test:x,1", "test:" >> r, tpl));
-        CHECK((tpl == attr_type('x', 1)));
+            REQUIRE(parse("test:x,1", "test:" >> r, tpl));
+            CHECK((tpl == attr_type('x', 1)));
+        }
     }
 
     {
@@ -143,13 +159,27 @@ TEST_CASE("sequence")
         // has a single element tuple as its attribute. This is a correction
         // of the test above.
 
-        using attr_type = alloy::tuple<int>;
-        attr_type tpl;
+        // rule version
+        {
+            using attr_type = alloy::tuple<int>;
+            attr_type tpl;
+
+            auto r = rule<struct r_id, attr_type>{} = int_;
+
+            REQUIRE(parse("test:1", "test:" >> r, tpl));
+            CHECK((tpl == attr_type(1)));
+        }
+
+        // as version
+        {
+            using attr_type = alloy::tuple<int>;
+            attr_type tpl;
 
-        auto r = rule<class r_id, attr_type>{} = int_;
+            auto r = as<attr_type>(int_);
 
-        REQUIRE(parse("test:1", "test:" >> r, tpl));
-        CHECK((tpl == attr_type(1)));
+            REQUIRE(parse("test:1", "test:" >> r, tpl));
+            CHECK((tpl == attr_type(1)));
+        }
     }
 
     // unused means we don't care about the attribute
@@ -262,16 +292,33 @@ TEST_CASE("sequence")
     }
 
     {
-        std::vector<std::string> v;
+        // rule version
+        {
+            std::vector<std::string> v;
 
-        auto e = rule<class e_id, std::string>{} = *~char_(',');
-        auto l = rule<class l_id, std::vector<std::string>>{} = e >> *(',' >> e);
+            auto e = rule<struct e_id, std::string>{} = *~char_(',');
+            auto l = rule<struct l_id, std::vector<std::string>>{} = e >> *(',' >> e);
 
-        REQUIRE(parse("abc1,abc2,abc3", l, v));
-        REQUIRE(v.size() == 3);
-        CHECK(v[0] == "abc1");
-        CHECK(v[1] == "abc2");
-        CHECK(v[2] == "abc3");
+            REQUIRE(parse("abc1,abc2,abc3", l, v));
+            REQUIRE(v.size() == 3);
+            CHECK(v[0] == "abc1");
+            CHECK(v[1] == "abc2");
+            CHECK(v[2] == "abc3");
+        }
+
+        // as version
+        {
+            std::vector<std::string> v;
+
+            auto e = as<std::string>(*~char_(','));
+            auto l = as<std::vector<std::string>>(e >> *(',' >> e));
+
+            REQUIRE(parse("abc1,abc2,abc3", l, v));
+            REQUIRE(v.size() == 3);
+            CHECK(v[0] == "abc1");
+            CHECK(v[1] == "abc2");
+            CHECK(v[2] == "abc3");
+        }
     }
 
     // do the same with a plain string object
@@ -282,12 +329,25 @@ TEST_CASE("sequence")
     }
 
     {
-        std::string s;
-        auto e = rule<class e_id, std::string>{} = *~char_(',');
-        auto l = rule<class l_id, std::string>{} = e >> *(',' >> e);
+        // rule version
+        {
+            std::string s;
+            auto e = rule<struct e_id, std::string>{} = *~char_(',');
+            auto l = rule<struct l_id, std::string>{} = e >> *(',' >> e);
+
+            REQUIRE(parse("abc1,abc2,abc3", l, s));
+            CHECK(s == "abc1abc2abc3");
+        }
+
+        // as version
+        {
+            std::string s;
+            auto e = as<std::string>(*~char_(','));
+            auto l = as<std::string>(e >> *(',' >> e));
 
-        REQUIRE(parse("abc1,abc2,abc3", l, s));
-        CHECK(s == "abc1abc2abc3");
+            REQUIRE(parse("abc1,abc2,abc3", l, s));
+            CHECK(s == "abc1abc2abc3");
+        }
     }
 
     {
diff --git a/test/x4/substitution.cpp b/test/x4/substitution.cpp
new file mode 100644
index 000000000..5d8d24aac
--- /dev/null
+++ b/test/x4/substitution.cpp
@@ -0,0 +1,30 @@
+#include "iris_x4_test.hpp"
+
+#include <iris/x4/core/move_to.hpp>
+
+#include <iris/x4/traits/can_hold.hpp>
+#include <iris/x4/traits/variant_traits.hpp>
+
+#include <iris/rvariant.hpp>
+
+template<class T, class U>
+inline constexpr bool can_hold_v = x4::traits::can_hold<T, U>::value;
+
+TEST_CASE("can_hold")
+{
+    // identical types
+    STATIC_CHECK(can_hold_v<int, int>);
+    STATIC_CHECK(can_hold_v<std::vector<int>, std::vector<int>>);
+    STATIC_CHECK(can_hold_v<alloy::tuple<int>, alloy::tuple<int>>);
+    STATIC_CHECK(can_hold_v<iris::rvariant<int>, iris::rvariant<int>>);
+
+    // `iris::rvariant<int, double>` is "broader" than `int`
+    STATIC_CHECK( can_hold_v<iris::rvariant<int, double>, int>);
+    STATIC_CHECK(!can_hold_v<int, iris::rvariant<int, double>>);
+
+    // container types
+    STATIC_CHECK(can_hold_v<std::vector<iris::rvariant<int, double>>, std::vector<int>>);
+
+    // tuple-like types
+    STATIC_CHECK(can_hold_v<alloy::tuple<iris::rvariant<int, double>>, alloy::tuple<int>>);
+}