diff --git a/include/iris/x4/core/detail/parse_alternative.hpp b/include/iris/x4/core/detail/parse_alternative.hpp
index 352330273..95d6e41f3 100644
--- a/include/iris/x4/core/detail/parse_alternative.hpp
+++ b/include/iris/x4/core/detail/parse_alternative.hpp
@@ -106,26 +106,6 @@ struct pass_non_variant_attribute
     }
 };
 
-// Unwrap single element sequences
-template<class Parser, X4Attribute Attr>
-    requires traits::is_size_one_sequence_v<Attr>
-struct pass_non_variant_attribute<Parser, Attr>
-{
-    using attr_type = typename std::remove_reference_t<
-        alloy::tuple_element_t<0, Attr>
-    >;
-    using pass = pass_parser_attribute<Parser, attr_type>;
-    using type = typename pass::type;
-
-    template<X4Attribute Attr_>
-    [[nodiscard]] static constexpr type
-    call(Attr_& attr)
-        noexcept(noexcept(pass::call(alloy::get<0>(attr))))
-    {
-        return pass::call(alloy::get<0>(attr));
-    }
-};
-
 template<class Parser, X4Attribute Attr>
     requires (!traits::is_variant_v<Attr>)
 struct pass_parser_attribute<Parser, Attr>
diff --git a/include/iris/x4/core/detail/parse_into_container.hpp b/include/iris/x4/core/detail/parse_into_container.hpp
index 8a40b2493..d36ecb322 100644
--- a/include/iris/x4/core/detail/parse_into_container.hpp
+++ b/include/iris/x4/core/detail/parse_into_container.hpp
@@ -87,11 +87,10 @@ struct parse_into_container_base_impl
 
     // ------------------------------------------------------
 
-    // Parser has attribute && it is NOT tuple-like
+    // Parser has attribute
     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>)
+            has_attribute_v<Parser>
     [[nodiscard]] static constexpr bool
     call(
         Parser const& parser, It& first, Se const& last,
@@ -99,23 +98,7 @@ struct parse_into_container_base_impl
     )
     {
         // 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));
+        return parse_into_container_base_impl::call_synthesize(parser, first, last, ctx, x4::unwrap_single_element_tuple_like(attr));
     }
 
     // Parser has no attribute (pass unused)
@@ -149,7 +132,7 @@ struct parse_into_container_impl<Parser>
                 It, Se, Context,
                 typename parser_traits<Parser>::attribute_type
             >::actual_type,
-            traits::container_value_t<Attr>
+            traits::container_value_t<traits::unwrap_single_element_tuple_like_t<Attr>>
         >>
     >;
 
@@ -205,22 +188,25 @@ template<
 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)))
+)  // TODO: add noexcept
 {
     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>) {
+    if constexpr (traits::is_variant_v<traits::unwrap_single_element_tuple_like_t<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, traits::build_container_t<attribute_type>>;
+        using substitute_type = traits::variant_find_substitute_t<
+            traits::unwrap_single_element_tuple_like_t<Attr>,
+            traits::build_container_t<attribute_type>
+        >;
 
         // instead of creating a temporary `substitute_type`, append directly into the emplaced alternative
-        auto& variant_alt = attr.template emplace<substitute_type>();
+        auto& variant_alt = x4::unwrap_single_element_tuple_like(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 eee6e0dcf..927e12ff1 100644
--- a/include/iris/x4/core/detail/parse_sequence.hpp
+++ b/include/iris/x4/core/detail/parse_sequence.hpp
@@ -49,19 +49,6 @@ struct pass_sequence_attribute_unused
     }
 };
 
-template<class Attr>
-struct pass_sequence_attribute_size_one_view
-{
-    using type = alloy::tuple_element_t<0, Attr>;
-
-    [[nodiscard]] static constexpr type
-    call(Attr& attribute)
-        noexcept(noexcept(alloy::get<0>(attribute)))
-    {
-        return alloy::get<0>(attribute);
-    }
-};
-
 template<class Attr>
 struct pass_through_sequence_attribute
 {
@@ -76,11 +63,8 @@ struct pass_through_sequence_attribute
 };
 
 template<class Parser, class Attr>
-struct pass_sequence_attribute : std::conditional_t<
-    traits::is_size_one_view_v<Attr>,
-    pass_sequence_attribute_size_one_view<Attr>,
-    pass_through_sequence_attribute<Attr>
->
+struct pass_sequence_attribute
+    : pass_through_sequence_attribute<Attr>
 {};
 
 template<class LParser, class RParser, class Attr>
@@ -126,21 +110,21 @@ struct partition_attribute
 
     using view = alloy::tuple_ref_t<Attr>;
     using splitted = alloy::tuple_split_t<view, l_size, r_size>;
-    using l_part = alloy::tuple_element_t<0, splitted>;
-    using r_part = alloy::tuple_element_t<1, splitted>;
+    using l_part = traits::unwrap_single_element_tuple_like_t<alloy::tuple_element_t<0, splitted>>;
+    using r_part = traits::unwrap_single_element_tuple_like_t<alloy::tuple_element_t<1, splitted>>;
     using l_pass = pass_sequence_attribute<LParser, l_part>;
     using r_pass = pass_sequence_attribute<RParser, r_part>;
 
     [[nodiscard]] static constexpr l_part left(Attr& s)
         // TODO: noexcept
     {
-        return alloy::get<0>(alloy::tuple_split<l_size, r_size>(alloy::tuple_ref(s)));
+        return x4::unwrap_single_element_tuple_like(alloy::get<0>(alloy::tuple_split<l_size, r_size>(alloy::tuple_ref(s))));
     }
 
     [[nodiscard]] static constexpr r_part right(Attr& s)
         // TODO: noexcept
     {
-        return alloy::get<1>(alloy::tuple_split<l_size, r_size>(alloy::tuple_ref(s)));
+        return x4::unwrap_single_element_tuple_like(alloy::get<1>(alloy::tuple_split<l_size, r_size>(alloy::tuple_ref(s))));
     }
 };
 
@@ -284,7 +268,7 @@ 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,
-        traits::container_value_t<Attr>
+        traits::container_value_t<traits::unwrap_single_element_tuple_like_t<Attr>>
     >;
 
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
diff --git a/include/iris/x4/core/move_to.hpp b/include/iris/x4/core/move_to.hpp
index 61c81534c..ce8908640 100644
--- a/include/iris/x4/core/move_to.hpp
+++ b/include/iris/x4/core/move_to.hpp
@@ -116,18 +116,7 @@ constexpr void move_to(It const&, Se const&, unused_type const&&) = delete; // t
 // Category specific --------------------------------------
 
 template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::plain_attr> Dest>
-    requires 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");
-    // TODO: preliminarily invoke static_assert to check if the assignment is valid
-    dest = std::forward_like<Source>(alloy::get<0>(std::forward<Source>(src)));
-}
-
-template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::plain_attr> Dest>
-    requires (!traits::is_size_one_sequence_v<Source>)
+    requires (!traits::is_single_element_tuple_like_v<Dest>)
 constexpr void
 move_to(Source&& src, Dest& dest)
     noexcept(std::is_nothrow_assignable_v<Dest&, Source&&>)
@@ -139,8 +128,8 @@ move_to(Source&& src, Dest& dest)
 
 template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::tuple_attr> Dest>
     requires
-        traits::is_same_size_sequence_v<Dest, Source> &&
-        (!traits::is_size_one_sequence_v<Dest>)
+        traits::is_same_size_tuple_like_v<Dest, std::remove_cvref_t<Source>> &&
+        (!traits::is_single_element_tuple_like_v<Dest>)
 constexpr void
 move_to(Source&& src, Dest& dest)
     noexcept(noexcept(alloy::tuple_assign(std::forward<Source>(src), dest)))
@@ -152,43 +141,40 @@ move_to(Source&& src, Dest& dest)
     alloy::tuple_assign(std::forward<Source>(src), dest);
 }
 
+// Source is single element tuple-like and Dest is variant which *can* holds Source directly
 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
+        (!traits::is_single_element_tuple_like_v<Dest>) &&
+        traits::is_single_element_tuple_like_v<std::remove_cvref_t<Source>> &&
+        traits::variant_has_substitute_v<Dest, std::remove_cvref_t<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>);
     dest = std::forward<Source>(src);
 }
 
+// Source is single element tuple-like and Dest is variant which *can not* holds Source directly
 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
+        (!traits::is_single_element_tuple_like_v<Dest>) &&
+        traits::is_single_element_tuple_like_v<std::remove_cvref_t<Source>> &&
+        (!traits::variant_has_substitute_v<Dest, std::remove_cvref_t<Source>>)
 constexpr void
-move_to(Source&& src, Dest& dest)
-    noexcept(noexcept(dest = std::forward_like<Source>(alloy::get<0>(std::forward<Source>(src)))))
+move_to(Source&& src, Dest& dest)  // TODO: add noexcept
 {
     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>>,
-        "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)));
 }
 
+// Source is *NOT* single element tuple-like and Dest is variant
 template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::variant_attr> Dest>
-    requires (!traits::is_size_one_sequence_v<Source>)
+    requires
+        (!traits::is_single_element_tuple_like_v<Dest>) &&
+        (!traits::is_single_element_tuple_like_v<std::remove_cvref_t<Source>>)
 constexpr void
 move_to(Source&& src, Dest& dest)
     noexcept(std::is_nothrow_assignable_v<Dest&, Source&&>)
@@ -199,6 +185,7 @@ move_to(Source&& src, Dest& dest)
 }
 
 template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::optional_attr> Dest>
+    requires (!traits::is_single_element_tuple_like_v<Dest>)
 constexpr void
 move_to(Source&& src, Dest& dest)
     noexcept(std::is_nothrow_assignable_v<Dest&, Source&&>)
@@ -214,6 +201,7 @@ template<class ContainerAttr>
 struct container_appender;
 
 template<std::forward_iterator It, std::sentinel_for<It> Se, traits::CategorizedAttr<traits::container_attr> Dest>
+    requires (!traits::is_single_element_tuple_like_v<Dest>)
 constexpr void
 move_to(It first, Se last, Dest& dest)
     // never noexcept, requires container insertion
@@ -243,21 +231,13 @@ 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));
 }
 
-template<std::forward_iterator It, std::sentinel_for<It> Se, traits::CategorizedAttr<traits::tuple_attr> Dest>
-    requires traits::is_size_one_sequence_v<Dest>
-constexpr void
-move_to(It first, Se last, Dest& dest)
-    noexcept(noexcept(x4::move_to(first, last, alloy::get<0>(dest))))
-{
-    x4::move_to(first, last, alloy::get<0>(dest));
-}
-
 // Move non-container `src` into container `dest`.
 // e.g. Source=std::string_view, Dest=std::string (used in `attr_parser`)
 template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::container_attr> Dest>
     requires
         (!traits::X4Container<Source>) &&
-        (!std::same_as<std::remove_const_t<Dest>, unused_container_type>)
+        (!std::same_as<std::remove_const_t<Dest>, unused_container_type>) &&
+        (!traits::is_single_element_tuple_like_v<Dest>)
 constexpr void
 move_to(Source&& src, Dest& dest)
     noexcept(std::is_nothrow_assignable_v<Dest&, Source&&>)
@@ -272,6 +252,7 @@ move_to(Source&& src, Dest& dest)
 }
 
 template<traits::X4Container Source, traits::CategorizedAttr<traits::container_attr> Dest>
+    requires (!traits::is_single_element_tuple_like_v<Dest>)
 constexpr void
 move_to(Source&& src, Dest& dest)
     // TODO: noexcept
@@ -285,12 +266,21 @@ move_to(Source&& src, Dest& dest)
     }
 }
 
-// Size-one tuple-like forwarding
-template<traits::NonUnusedAttr Source, traits::CategorizedAttr<traits::tuple_attr> Dest>
-    requires traits::is_size_one_sequence_v<Dest>
+// single element tuple-like forwarding
+
+template<std::forward_iterator It, std::sentinel_for<It> Se, traits::NonUnusedAttr Dest>
+    requires traits::is_single_element_tuple_like_v<Dest>
 constexpr void
-move_to(Source&& src, Dest& dest)
-    noexcept(noexcept(x4::move_to(std::forward<Source>(src), alloy::get<0>(dest))))
+move_to(It first, Se last, Dest& dest)
+    noexcept(noexcept(x4::move_to(first, last, alloy::get<0>(dest))))
+{
+    x4::move_to(first, last, alloy::get<0>(dest));
+}
+
+template<traits::NonUnusedAttr Source, traits::NonUnusedAttr Dest>
+    requires traits::is_single_element_tuple_like_v<Dest>
+constexpr void
+move_to(Source&& src, Dest& dest)  // TODO: add noexcept
 {
     static_assert(!std::same_as<std::remove_cvref_t<Source>, Dest>, "[BUG] This call should instead resolve to the overload handling identical types");
 
diff --git a/include/iris/x4/operator/alternative.hpp b/include/iris/x4/operator/alternative.hpp
index 84a1a323a..2e013bb05 100644
--- a/include/iris/x4/operator/alternative.hpp
+++ b/include/iris/x4/operator/alternative.hpp
@@ -31,7 +31,7 @@ namespace iris::x4 {
 template<class Left, class Right>
 struct alternative : binary_parser<Left, Right, alternative<Left, Right>>
 {
-    using attribute_type = traits::attribute_of_binary<iris::rvariant, alternative, Left, Right>::type;
+    using attribute_type = traits::attribute_of_binary<iris::rvariant, Left, Right>::type;
 
     using binary_parser<Left, Right, alternative>::binary_parser;
 
diff --git a/include/iris/x4/operator/sequence.hpp b/include/iris/x4/operator/sequence.hpp
index b2d95c11d..34dad71dd 100644
--- a/include/iris/x4/operator/sequence.hpp
+++ b/include/iris/x4/operator/sequence.hpp
@@ -31,7 +31,7 @@ namespace iris::x4 {
 template<class Left, class Right>
 struct sequence : binary_parser<Left, Right, sequence<Left, Right>>
 {
-    using attribute_type = traits::attribute_of_binary<alloy::tuple, x4::sequence, Left, Right>::type;
+    using attribute_type = traits::attribute_of_binary<alloy::tuple, Left, Right>::type;
 
     static constexpr std::size_t sequence_size =
         parser_traits<Left>::sequence_size + parser_traits<Right>::sequence_size;
diff --git a/include/iris/x4/rule.hpp b/include/iris/x4/rule.hpp
index 2f58af834..fb8ef1e3f 100644
--- a/include/iris/x4/rule.hpp
+++ b/include/iris/x4/rule.hpp
@@ -378,11 +378,6 @@ concept RuleAttrTransformable =
         RuleAttr
     >;
 
-template<class Exposed, class RuleAttr>
-concept RuleAttrCompatible =
-    std::same_as<std::remove_const_t<Exposed>, RuleAttr> ||
-    RuleAttrTransformable<Exposed, RuleAttr>;
-
 } // detail
 
 template<class RuleID, X4Attribute RuleAttr, bool ForceAttr>
@@ -415,7 +410,8 @@ struct rule : parser<rule<RuleID, RuleAttr, ForceAttr>>
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Exposed>
         requires
             (!std::same_as<std::remove_const_t<Exposed>, unused_type>) &&
-            detail::RuleAttrCompatible<Exposed, RuleAttr>
+            (!std::same_as<std::remove_const_t<Exposed>, RuleAttr>) &&
+            detail::RuleAttrTransformable<Exposed, RuleAttr>
     [[nodiscard]] constexpr bool
     parse(It& first, Se const& last, Context const& ctx, Exposed& exposed_attr) const
         // never noexcept; requires very complex implementation details
@@ -435,39 +431,52 @@ struct rule : parser<rule<RuleID, RuleAttr, ForceAttr>>
 
         using detail::parse_rule; // ADL
 
-        if constexpr (std::same_as<std::remove_const_t<Exposed>, RuleAttr>) {
-            return static_cast<bool>(parse_rule(detail::rule_id<RuleID>{}, first, last, rule_agnostic_ctx, exposed_attr));  // NOLINT(bugprone-non-zero-enum-to-bool-conversion)
-
-        } else {
-            static_assert(detail::RuleAttrTransformable<Exposed, RuleAttr>);
+        static_assert(detail::RuleAttrConvertibleWithoutNarrowing<Exposed, RuleAttr>);
 
-            // TODO: specialize `container_appender` case, do not create temporary
+        // TODO: specialize `container_appender` case, do not create temporary
 
-            RuleAttr rule_attr;
-            if (!static_cast<bool>(parse_rule(detail::rule_id<RuleID>{}, first, last, rule_agnostic_ctx, rule_attr))) {  // NOLINT(bugprone-non-zero-enum-to-bool-conversion)
-                return false;
-            }
+        RuleAttr rule_attr;
+        if (!static_cast<bool>(parse_rule(detail::rule_id<RuleID>{}, first, last, rule_agnostic_ctx, rule_attr))) {  // NOLINT(bugprone-non-zero-enum-to-bool-conversion)
+            return false;
+        }
 
-            if constexpr (is_ttp_specialization_of_v<std::remove_const_t<Exposed>, container_appender>) {
-                traits::append(
-                    exposed_attr.container,
-                    std::make_move_iterator(traits::begin(rule_attr)),
-                    std::make_move_iterator(traits::end(rule_attr))
-                );
-            } else {
-                static_assert(std::is_assignable_v<Exposed&, RuleAttr>);
-                exposed_attr = std::move(rule_attr);
-            }
-            return true;
+        if constexpr (is_ttp_specialization_of_v<std::remove_const_t<Exposed>, container_appender>) {
+            traits::append(
+                exposed_attr.container,
+                std::make_move_iterator(traits::begin(rule_attr)),
+                std::make_move_iterator(traits::end(rule_attr))
+            );
+        } else {
+            static_assert(std::is_assignable_v<Exposed&, RuleAttr>);
+            exposed_attr = std::move(rule_attr);
         }
+        return true;
+    }
+    
+    // rule's attribute type is the same as the exposed one
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Exposed>
+        requires
+            (!std::same_as<std::remove_const_t<Exposed>, unused_type>) &&
+            std::same_as<std::remove_const_t<Exposed>, RuleAttr>
+    [[nodiscard]] constexpr bool
+    parse(It& first, Se const& last, Context const& ctx, Exposed& exposed_attr) const
+        // never noexcept; requires very complex implementation details
+    {
+        static_assert(has_attribute, "A rule must have an attribute. Check your rule definition.");
+
+        // See the comment above
+        auto&& rule_agnostic_ctx = x4::remove_first_context<contexts::rule_var>(ctx);
+
+        using detail::parse_rule; // ADL
+        return static_cast<bool>(parse_rule(detail::rule_id<RuleID>{}, first, last, rule_agnostic_ctx, exposed_attr));  // NOLINT(bugprone-non-zero-enum-to-bool-conversion)
     }
 
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Exposed>
         requires
             (!std::same_as<std::remove_const_t<Exposed>, unused_type>) &&
-            (!detail::RuleAttrCompatible<Exposed, RuleAttr>) &&
-            detail::RuleAttrConvertible<Exposed, RuleAttr> &&
-            (!detail::RuleAttrConvertibleWithoutNarrowing<Exposed, RuleAttr>)
+            (!std::same_as<std::remove_const_t<Exposed>, RuleAttr>) &&
+            (!detail::RuleAttrTransformable<Exposed, RuleAttr>) &&
+            (detail::RuleAttrConvertible<Exposed, RuleAttr> && !detail::RuleAttrConvertibleWithoutNarrowing<Exposed, RuleAttr>)
     [[nodiscard]] constexpr bool
     parse(It&, Se const&, Context const&, Exposed&) const = delete; // Rule attribute needs narrowing conversion
 
diff --git a/include/iris/x4/string/detail/string_parse.hpp b/include/iris/x4/string/detail/string_parse.hpp
index 120a03ddd..64d78650c 100644
--- a/include/iris/x4/string/detail/string_parse.hpp
+++ b/include/iris/x4/string/detail/string_parse.hpp
@@ -30,9 +30,8 @@ string_parse(
     Attr& attr, CaseCompareFunc const& compare
 ) noexcept(std::same_as<std::remove_const_t<Attr>, unused_container_type>)
 {
-    using synthesized_value_type = traits::synthesized_value_t<Attr>;
-    static_assert(std::same_as<traits::attribute_category_t<synthesized_value_type>, traits::container_attr>);
-    using value_type = traits::container_value_t<synthesized_value_type>;
+    static_assert(std::same_as<traits::attribute_category_t<Attr>, traits::container_attr>);
+    using value_type = traits::container_value_t<traits::unwrap_single_element_tuple_like_t<Attr>>;
     static_assert(!traits::CharLike<value_type> || std::same_as<value_type, CharT>, "Mixing incompatible char types is not allowed");
 
     It it = first;
@@ -77,9 +76,8 @@ string_parse(
     It& first, Se const& last, Attr& attr
 ) noexcept(std::same_as<std::remove_const_t<Attr>, unused_container_type>)
 {
-    using synthesized_value_type = traits::synthesized_value_t<Attr>;
-    static_assert(std::same_as<traits::attribute_category_t<synthesized_value_type>, traits::container_attr>);
-    using value_type = traits::container_value_t<synthesized_value_type>;
+    static_assert(std::same_as<traits::attribute_category_t<Attr>, traits::container_attr>);
+    using value_type = traits::container_value_t<traits::unwrap_single_element_tuple_like_t<Attr>>;
     static_assert(!traits::CharLike<value_type> || std::same_as<value_type, CharT>, "Mixing incompatible char types is not allowed");
 
     auto uc_it = ucstr.begin();
diff --git a/include/iris/x4/traits/attribute_category.hpp b/include/iris/x4/traits/attribute_category.hpp
index 5032b1ff8..13da35c15 100644
--- a/include/iris/x4/traits/attribute_category.hpp
+++ b/include/iris/x4/traits/attribute_category.hpp
@@ -10,10 +10,11 @@
     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>
+#include <iris/x4/traits/subrange_traits.hpp>
+#include <iris/x4/traits/tuple_traits.hpp>
+#include <iris/x4/traits/variant_traits.hpp>
 
 #include <iris/alloy/traits.hpp>
 
@@ -88,12 +89,19 @@ concept NonUnusedAttr =
     !std::is_same_v<typename attribute_category<std::remove_cvref_t<T>>::type, unused_attr>;
 
 template<class T>
-    requires alloy::is_tuple_like_v<T>
+    requires alloy::is_tuple_like_v<T> && (!traits::is_single_element_tuple_like_v<T>)
 struct attribute_category<T>
 {
     using type = tuple_attr;
 };
 
+// attribute-category of single element tuple-like "fallthrough" into unwrapped attribute's one
+template<class T>
+    requires alloy::is_tuple_like_v<T> && traits::is_single_element_tuple_like_v<T>
+struct attribute_category<T>
+    : attribute_category<traits::unwrap_single_element_tuple_like_t<T>>
+{};
+
 template<class T>
     requires is_variant_v<std::remove_cvref_t<T>>
 struct attribute_category<T>
diff --git a/include/iris/x4/traits/attribute_of_binary.hpp b/include/iris/x4/traits/attribute_of_binary.hpp
index 0628e2429..6e7b4a109 100644
--- a/include/iris/x4/traits/attribute_of_binary.hpp
+++ b/include/iris/x4/traits/attribute_of_binary.hpp
@@ -16,81 +16,102 @@
 #include <iris/x4/core/unused.hpp>
 #include <iris/x4/core/parser_traits.hpp>
 
+#include <iris/type_traits.hpp>  // TODO: move iris::type_list to separate header
+
 #include <type_traits>
 
 namespace iris::x4::traits {
 
 namespace detail {
 
-template<class... Ts>
-struct type_sequence
-{
-    using type = type_sequence;
-
-    static constexpr std::size_t size = sizeof...(Ts);
-
-    template<class... Us>
-    using prepend = type_sequence<Us..., Ts...>;
+template<class TypeList, class... Us>
+struct append_to_type_list {};
 
-    template<class U>
-    using extend = U::template prepend<Ts...>;
+template<class TypeList, class... Us>
+using append_to_type_list_t = append_to_type_list<TypeList, Us...>::type; 
 
-    template<template<class...> class U>
-    using transfer_to = U<Ts...>;
+template<class... Ts>
+struct append_to_type_list<type_list<Ts...>>
+{
+    using type = type_list<Ts...>;
 };
 
-template<X4Attribute Attr>
-struct types_of_binary_init : type_sequence<Attr>
+template<class... Ts, class... Us>
+struct append_to_type_list<type_list<Ts...>, unused_type, Us...>
+    : append_to_type_list<type_list<Ts...>, Us...>
 {};
 
-template<>
-struct types_of_binary_init<unused_type> : type_sequence<>
+template<class... Ts, class U, class... Us>
+struct append_to_type_list<type_list<Ts...>, U, Us...>
+    : append_to_type_list<type_list<Ts..., U>, Us...>
 {};
 
-template<>
-struct types_of_binary_init<unused_type const> : type_sequence<>
+template<class... Ts, class... Us, class... Vs>
+struct append_to_type_list<type_list<Ts...>, type_list<Us...>, Vs...>
+    : append_to_type_list<append_to_type_list_t<type_list<Ts...>, Us...>, Vs...>
 {};
 
-template<template<class, class> class BinaryParserTT, class ParserT>
-struct get_types_of_binary
-    : types_of_binary_init<typename parser_traits<ParserT>::attribute_type> // TODO: unwrap
-{};
+template<template<class...> class TupleTT, class T>
+struct tuple_to_type_list;
 
-template<template<class, class> class BinaryParserTT, class Left, class Right>
-struct get_types_of_binary<BinaryParserTT, BinaryParserTT<Left, Right>>
-    : get_types_of_binary<BinaryParserTT, Left>::template extend<get_types_of_binary<BinaryParserTT, Right>>
-{};
+template<template<class...> class TupleTT, class T>
+using tuple_to_type_list_t = tuple_to_type_list<TupleTT, T>::type;
 
-template<template<class...> class AttrTT, class T, std::size_t = T::size>
-struct type_sequence_to_attribute
+template<template<class...> class TupleTT, class T>
+struct tuple_to_type_list
 {
-    using type = typename T::template transfer_to<AttrTT>;
+    using type = T;
 };
 
-template<template<class...> class AttrTT, class T>
-struct type_sequence_to_attribute<AttrTT, T, 1>
-    : T::template transfer_to<std::type_identity>
-{};
+template<template<class...> class TupleTT, class... Ts>
+struct tuple_to_type_list<TupleTT, TupleTT<Ts...>>
+{
+    using type = type_list<tuple_to_type_list_t<TupleTT, Ts>...>;
+};
+
+template<template<class...> class TupleTT, class T>
+using tuple_to_type_list_t = tuple_to_type_list<TupleTT, T>::type;
+
+template<template<class...> class TupleTT, class TypeList>
+struct type_list_to_tuple {};
 
-template<template<class...> class AttrTT, class T>
-struct type_sequence_to_attribute<AttrTT, T, 0>
+template<template<class...> class TupleTT>
+struct type_list_to_tuple<TupleTT, type_list<>>
 {
     using type = unused_type;
 };
 
+template<template<class...> class TupleTT, class T>
+struct type_list_to_tuple<TupleTT, type_list<T>>
+{
+    using type = T;
+};
+
+template<template<class...> class TupleTT, class T0, class T1, class... Ts>
+struct type_list_to_tuple<TupleTT, type_list<T0, T1, Ts...>>
+{
+    using type = TupleTT<T0, T1, Ts...>;
+};
+
+template<template<class...> class TupleTT, class TypeList>
+using type_list_to_tuple_t = type_list_to_tuple<TupleTT, TypeList>::type;
+
 } // detail
 
 template<
-    template<class...> class AttrTT,
-    template<class, class> class BinaryParserTT,
-    class Left, class Right
+    template<class...> class TupleTT,
+    class LeftParser, class RightParser
 >
 struct attribute_of_binary
 {
-    using type = detail::type_sequence_to_attribute<
-        AttrTT,
-        typename detail::get_types_of_binary<BinaryParserTT, BinaryParserTT<Left, Right>>::type
-    >::type;
+    using type = detail::type_list_to_tuple_t<
+        TupleTT,
+        detail::append_to_type_list_t<
+            type_list<>,
+            detail::tuple_to_type_list_t<TupleTT, typename parser_traits<LeftParser>::attribute_type>,
+            detail::tuple_to_type_list_t<TupleTT, typename parser_traits<RightParser>::attribute_type>
+        >
+    >;
 };
 
 } // iris::x4::traits
diff --git a/include/iris/x4/traits/container_traits.hpp b/include/iris/x4/traits/container_traits.hpp
index c5c9b28fc..157efc4a7 100644
--- a/include/iris/x4/traits/container_traits.hpp
+++ b/include/iris/x4/traits/container_traits.hpp
@@ -12,10 +12,9 @@
 =============================================================================*/
 
 #include <iris/config.hpp>
-#include <iris/x4/core/unused.hpp>
 
-#include <iris/alloy/traits.hpp>
-#include <iris/alloy/tuple.hpp>
+#include <iris/x4/core/unused.hpp>
+#include <iris/x4/traits/tuple_traits.hpp>
 
 #include <ranges>
 #include <iterator>
@@ -471,9 +470,6 @@ struct build_container
 template<class T>
 using build_container_t = typename build_container<T>::type;
 
-template<class T>
-struct build_container<alloy::tuple<T>> : build_container<T> {};
-
 template<>
 struct build_container<unused_type>
 {
diff --git a/include/iris/x4/traits/substitution.hpp b/include/iris/x4/traits/substitution.hpp
index 896e12fcf..91745f3cd 100644
--- a/include/iris/x4/traits/substitution.hpp
+++ b/include/iris/x4/traits/substitution.hpp
@@ -21,9 +21,6 @@
 
 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;
@@ -47,7 +44,7 @@ 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>
+    requires is_same_size_tuple_like_v<TTuple, UTuple>
 struct is_all_substitute_for_tuple<TTuple, UTuple> : is_all_substitute_for_tuple_impl<TTuple, UTuple> {};
 
 template<class T, X4Attribute Attr>
@@ -75,12 +72,6 @@ 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>
diff --git a/include/iris/x4/traits/tuple_traits.hpp b/include/iris/x4/traits/tuple_traits.hpp
index 5f7810621..f481d89c2 100644
--- a/include/iris/x4/traits/tuple_traits.hpp
+++ b/include/iris/x4/traits/tuple_traits.hpp
@@ -14,78 +14,85 @@
 
 #include <type_traits>
 
-namespace iris::x4::traits {
+namespace iris::x4 {
 
-template<class A, class B>
-struct has_same_size
-    : std::bool_constant<
-        alloy::tuple_size_v<std::remove_cvref_t<A>> ==
-        alloy::tuple_size_v<std::remove_cvref_t<B>>
-    >
-{};
+namespace traits {
 
 template<class A, class B>
-constexpr bool has_same_size_v = has_same_size<A, B>::value;
+struct is_same_size_tuple_like_impl {};
 
-template<class T, std::size_t N>
-struct has_size
-    : std::bool_constant<alloy::tuple_size_v<std::remove_cvref_t<T>> == N>
+template<class A, class B>
+  requires alloy::is_tuple_like_v<A> && alloy::is_tuple_like_v<B>
+struct is_same_size_tuple_like_impl<A, B>
+    : std::bool_constant<alloy::tuple_size_v<A> == alloy::tuple_size_v<B>>
 {};
 
-template<class T, std::size_t N>
-constexpr bool has_size_v = has_size<T, N>::value;
-
 template<class A, class B>
-struct is_same_size_sequence
+struct is_same_size_tuple_like
     : std::bool_constant<std::conjunction_v<
-        alloy::is_tuple_like<std::remove_cvref_t<A>>,
-        alloy::is_tuple_like<std::remove_cvref_t<B>>,
-        has_same_size<A, B>
+        alloy::is_tuple_like<A>,
+        alloy::is_tuple_like<B>,
+        is_same_size_tuple_like_impl<A, B>
     >>
 {};
 
 template<class A, class B>
-constexpr bool is_same_size_sequence_v = is_same_size_sequence<A, B>::value;
+constexpr bool is_same_size_tuple_like_v = is_same_size_tuple_like<A, B>::value;
 
-template<class Seq>
-struct is_size_one_sequence
-    : std::bool_constant<std::conjunction_v<
-        alloy::is_tuple_like<std::remove_cvref_t<Seq>>,
-        has_size<Seq, 1>
-    >>
-{};
+template<class T>
+struct is_single_element_tuple_like_impl {};
 
-template<class Seq>
-constexpr bool is_size_one_sequence_v = is_size_one_sequence<Seq>::value;
+template<class T>
+  requires alloy::is_tuple_like_v<T>
+struct is_single_element_tuple_like_impl<T>
+    : std::bool_constant<alloy::tuple_size_v<T> == 1>
+{};
 
-template<class View>
-struct is_size_one_view
+template<class T>
+struct is_single_element_tuple_like
     : std::bool_constant<std::conjunction_v<
-        alloy::is_tuple_like_view<std::remove_cvref_t<View>>,
-        has_size<View, 1>
+        alloy::is_tuple_like<T>,
+        is_single_element_tuple_like_impl<T>
     >>
 {};
 
-template<class View>
-constexpr bool is_size_one_view_v = is_size_one_view<View>::value;
+template<class T>
+constexpr bool is_single_element_tuple_like_v = is_single_element_tuple_like<T>::value;
+
+template<class T>
+struct unwrap_single_element_tuple_like;
 
+template<class T>
+using unwrap_single_element_tuple_like_t = unwrap_single_element_tuple_like<T>::type;
 
 template<class T>
-struct synthesized_value
+struct unwrap_single_element_tuple_like
 {
     using type = T;
 };
 
 template<class T>
-using synthesized_value_t = typename synthesized_value<T>::type;
+  requires is_single_element_tuple_like_v<T>
+struct unwrap_single_element_tuple_like<T>
+{
+    using type = alloy::tuple_element_t<0, T>;
+};
+
+} // triats
 
 template<class T>
-    requires is_size_one_sequence_v<std::remove_cvref_t<T>>
-struct synthesized_value<T>
+constexpr T&& unwrap_single_element_tuple_like(T&& t) noexcept
 {
-    using type = std::remove_cvref_t<alloy::tuple_element_t<0, T>>;
-};
+    return std::forward<T>(t);
+}
+
+template<class T>
+    requires traits::is_single_element_tuple_like_v<std::remove_cvref_t<T>>
+constexpr auto&& unwrap_single_element_tuple_like(T&& t)  // TODO: add noexcept
+{
+    return alloy::get<0>(std::forward<T>(t));
+}
 
-} // iris::x4::traits
+} // iris::x4
 
 #endif
diff --git a/include/iris/x4/traits/variant_traits.hpp b/include/iris/x4/traits/variant_traits.hpp
index 38615ee32..36650188b 100644
--- a/include/iris/x4/traits/variant_traits.hpp
+++ b/include/iris/x4/traits/variant_traits.hpp
@@ -115,7 +115,7 @@ struct variant_has_substitute<unused_type const, Attr>
 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>...>
+    : std::disjunction<is_substitute<Ts, Attr>...>
 {};
 
 } // iris::x4::traits
diff --git a/test/x4/CMakeLists.txt b/test/x4/CMakeLists.txt
index 47821e52d..4ce55f6c8 100644
--- a/test/x4/CMakeLists.txt
+++ b/test/x4/CMakeLists.txt
@@ -93,6 +93,7 @@ x4_define_tests(
     without
     x3_rule_problem
     alloy_wrong_substitute_test_case
+    single_element_tuple_like
 )
 
 x4_define_test(rule_separate_tu rule_separate_tu.cpp rule_separate_tu_grammar.cpp)
diff --git a/test/x4/single_element_tuple_like.cpp b/test/x4/single_element_tuple_like.cpp
new file mode 100644
index 000000000..64f34e9ba
--- /dev/null
+++ b/test/x4/single_element_tuple_like.cpp
@@ -0,0 +1,51 @@
+#include "iris_x4_test.hpp"
+
+#include <iris/x4.hpp>
+
+#include <iris/alloy/adapt.hpp>
+#include <iris/alloy/tuple.hpp>
+
+struct Ident {
+    std::string value;
+};
+
+struct Var {
+    Ident ident;
+};
+
+struct Decl {
+    Var var;
+};
+
+IRIS_ALLOY_ADAPT_STRUCT(Ident, value)
+IRIS_ALLOY_ADAPT_STRUCT(Var, ident)
+IRIS_ALLOY_ADAPT_STRUCT(Decl, var);
+
+using IdentRule = x4::rule<struct ident_tag, Ident>;
+using VarRule = x4::rule<struct var_tag, Var>;
+using DeclRule = x4::rule<struct decl_tag, Decl>;
+
+constexpr IdentRule ident;
+constexpr VarRule var;
+constexpr DeclRule decl;
+
+IRIS_X4_DECLARE(IdentRule);
+IRIS_X4_DECLARE(VarRule);
+IRIS_X4_DECLARE(DeclRule)
+
+constexpr auto ident_def = (+x4::char_ >> x4::eps);
+constexpr auto var_def = x4::lexeme[x4::lit('$') >> ident];
+constexpr auto decl_def = x4::skip(x4::space)[x4::lit("let") >> var];
+
+IRIS_X4_DEFINE(ident);
+IRIS_X4_DEFINE(var);
+IRIS_X4_DEFINE(decl);
+
+TEST_CASE("single element tuple like")
+{
+    {
+        Decl attr;
+        CHECK(parse("let $foo", decl, attr));
+        CHECK(attr.var.ident.value == "foo");
+    }
+}