From bd3d583f4c87191491114a7cdbc6e1f2a1833e56 Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Tue, 4 Jun 2024 11:20:29 -0500
Subject: [PATCH 1/3] docs(comb): Shrink seq example

---
 src/macros/seq.rs  | 33 ---------------------------------
 src/macros/test.rs | 37 +++++++++++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 33 deletions(-)

diff --git a/src/macros/seq.rs b/src/macros/seq.rs
index 0ffe4f9a..06a1ac76 100644
--- a/src/macros/seq.rs
+++ b/src/macros/seq.rs
@@ -53,39 +53,6 @@
 ///         },
 ///     )),
 /// );
-///
-/// // Or parse into enum variants
-/// #[derive(Debug, PartialEq, Eq)]
-/// enum Expr {
-///     Add { lhs: u32, rhs: u32 },
-///     Mul(u32, u32),
-/// }
-///
-/// fn add(input: &mut &[u8]) -> PResult<Expr> {
-///     seq!{Expr::Add {
-///         lhs: dec_uint::<_, u32, ContextError>,
-///         _: b" + ",
-///         rhs: dec_uint::<_, u32, ContextError>,
-///     }}.parse_next(input)
-/// }
-///
-/// fn mul(input: &mut &[u8]) -> PResult<Expr> {
-///     seq!(Expr::Mul(
-///         dec_uint::<_, u32, ContextError>,
-///         _: b" * ",
-///         dec_uint::<_, u32, ContextError>,
-///    )).parse_next(input)
-/// }
-///
-/// assert_eq!(
-///     add.parse_peek(&b"1 + 2"[..]),
-///     Ok((&b""[..], Expr::Add { lhs: 1, rhs: 2 })),
-/// );
-///
-/// assert_eq!(
-///     mul.parse_peek(&b"3 * 4"[..]),
-///     Ok((&b""[..], Expr::Mul(3, 4))),
-/// );
 /// ```
 #[macro_export]
 #[doc(alias = "tuple")]
diff --git a/src/macros/test.rs b/src/macros/test.rs
index 17601bc3..ef50133f 100644
--- a/src/macros/test.rs
+++ b/src/macros/test.rs
@@ -187,6 +187,43 @@ fn seq_struct_no_trailing_comma_elided() {
     }
 }
 
+#[test]
+fn seq_enum_struct_variant() {
+    #[derive(Debug, PartialEq, Eq)]
+    enum Expr {
+        Add { lhs: u32, rhs: u32 },
+        Mul(u32, u32),
+    }
+
+    fn add(input: &mut &[u8]) -> PResult<Expr> {
+        seq! {Expr::Add {
+            lhs: dec_uint::<_, u32, _>,
+            _: b" + ",
+            rhs: dec_uint::<_, u32, _>,
+        }}
+        .parse_next(input)
+    }
+
+    fn mul(input: &mut &[u8]) -> PResult<Expr> {
+        seq!(Expr::Mul(
+             dec_uint::<_, u32, _>,
+             _: b" * ",
+             dec_uint::<_, u32, _>,
+        ))
+        .parse_next(input)
+    }
+
+    assert_eq!(
+        add.parse_peek(&b"1 + 2"[..]),
+        Ok((&b""[..], Expr::Add { lhs: 1, rhs: 2 })),
+    );
+
+    assert_eq!(
+        mul.parse_peek(&b"3 * 4"[..]),
+        Ok((&b""[..], Expr::Mul(3, 4))),
+    );
+}
+
 #[test]
 fn seq_tuple_struct_basics() {
     #[derive(Debug, PartialEq)]

From a761e542f0ecc0d8ace0bb5f795fead89e2802fd Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Tue, 4 Jun 2024 11:24:03 -0500
Subject: [PATCH 2/3] docs(comb): Be more explicit on seq behavior

Inspired by winnow-rs/winnow#534
---
 src/macros/seq.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/macros/seq.rs b/src/macros/seq.rs
index 06a1ac76..137b6001 100644
--- a/src/macros/seq.rs
+++ b/src/macros/seq.rs
@@ -1,5 +1,13 @@
 /// Initialize a struct or tuple out of a sequences of parsers
 ///
+/// Unlike normal struct initialization syntax:
+/// - `_` fields can exist to run a parser but ignore the result
+/// - Parse results for a field can later be referenced using the field name
+///
+/// Unlike normal tuple initialization syntax:
+/// - Struct-style initialization (`{ 0: _, 1: _}`) is not supported
+/// - `_: <parser>` fields can exist to run a parser but ignore the result
+///
 ///# Example
 ///
 /// ```

From acda2d8315b2e255effa187d6e394181bf8e7c68 Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Tue, 4 Jun 2024 11:27:13 -0500
Subject: [PATCH 3/3] fix(comb): Improve non-parser seq error messages

This only helps in the struct case.
---
 src/macros/seq.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/macros/seq.rs b/src/macros/seq.rs
index 137b6001..a9991c9d 100644
--- a/src/macros/seq.rs
+++ b/src/macros/seq.rs
@@ -74,7 +74,6 @@
 macro_rules! seq {
     ($($name: ident)::* { $($fields: tt)* }) => {
         $crate::combinator::trace(stringify!($($name)::*), move |input: &mut _| {
-            use $crate::Parser;
             $crate::seq_parse_struct_fields!(input; $($fields)*);
             #[allow(clippy::redundant_field_names)]
             Ok($crate::seq_init_struct_fields!( ($($fields)*); $($name)::*;))
@@ -82,7 +81,6 @@ macro_rules! seq {
     };
     ($($name: ident)::* ( $($elements: tt)* )) => {
         $crate::combinator::trace(stringify!($($name)::*), move |input: &mut _| {
-            use $crate::Parser;
             $crate::seq_parse_tuple_fields!( ($($elements)*) ; ).map(|t| {
                 $crate::seq_init_tuple_fields!(
                     ($($elements)*);
@@ -116,27 +114,27 @@ macro_rules! seq_parse_struct_fields {
         $input: ident;
         _ : $head_parser: expr, $($fields: tt)*
     ) => {
-        let _ = $head_parser.parse_next($input)?;
+        let _ = $crate::Parser::parse_next(&mut $head_parser, $input)?;
         $crate::seq_parse_struct_fields!($input; $($fields)*)
     };
     (
         $input: ident;
         _ : $head_parser: expr
     ) => {
-        let _ = $head_parser.parse_next($input)?;
+        let _ = $crate::Parser::parse_next(&mut $head_parser, $input)?;
     };
     (
         $input: ident;
         $head_field: ident : $head_parser: expr, $($fields: tt)*
     ) => {
-        let $head_field = $head_parser.parse_next($input)?;
+        let $head_field = $crate::Parser::parse_next(&mut $head_parser, $input)?;
         $crate::seq_parse_struct_fields!($input; $($fields)*)
     };
     (
         $input: ident;
         $head_field: ident : $head_parser: expr
     ) => {
-        let $head_field = $head_parser.parse_next($input)?;
+        let $head_field = $crate::Parser::parse_next(&mut $head_parser, $input)?;
     };
     (
         $input: expr;