Use enumerate combinator

2022/src/common.rs

@@ -1,6 +1,7 @@
 //! Common helper utilities to all days
 
 use anyhow::Result;
+use nom::combinator::map;
 use nom::error::ErrorKind;
 use nom::error::ParseError;
 use nom::Finish;
@@ -93,6 +94,17 @@ where
     }
 }
 
+/// Add an index to repeated successful invocations of the embedded parser.
+pub fn enumerate<I, O, E>(f: impl Parser<I, O, E>) -> impl FnMut(I) -> IResult<I, (usize, O), E> {
+    let mut index = 0usize;
+
+    map(f, move |v| {
+        let res = (index, v);
+        index += 1;
+        res
+    })
+}
+
 /// Return the minimum and maximum of two unordered variables
 pub fn minmax<T>(a: T, b: T) -> (T, T)
 where

2022/src/day05.rs

@@ -16,17 +16,16 @@ use nom::sequence::terminated;
 use nom::sequence::tuple;
 use nom::IResult;
 
+use crate::common::enumerate;
 use crate::common::parse_input;
 
 type Move = (usize, usize, usize);
 type OwnedStacks = Vec<Vec<u8>>;
 
 fn parse_row<'a>(input: &'a [u8], stacks: &mut OwnedStacks) -> IResult<&'a [u8], ()> {
-    let mut index = 0usize;
-
     // Forgive me for this crime
     fold_many1(
-        terminated(
+        enumerate(terminated(
             alt((
                 // Parse a delimited value into a Some(content)
                 map(delimited(tag("["), take(1usize), tag("]")), |v: &[u8]| {
@@ -36,9 +35,9 @@ fn parse_row<'a>(input: &'a [u8], stacks: &mut OwnedStacks) -> IResult<&'a [u8],
                 map(tag("   "), |_| None),
             )),
             opt(tag(" ")),
-        ),
+        )),
         || (),
-        move |_, c| {
+        move |_, (index, c)| {
             if let Some(b) = c {
                 if stacks.len() <= index {
                     stacks.resize_with(index + 1, Vec::new);
@@ -46,8 +45,6 @@ fn parse_row<'a>(input: &'a [u8], stacks: &mut OwnedStacks) -> IResult<&'a [u8],
 
                 stacks[index].push(b)
             }
-
-            index += 1;
         },
     )(input)
 }