Don't parse trailing separator in parser.repeat(_arrayvec)

Author: ictrobot

crates/utils/src/array.rs

@@ -39,6 +39,38 @@ impl<T, const N: usize> ArrayVec<T, N> {
         }
     }
 
+    /// Creates a new `ArrayVec`, copying initial data from the provided slice.
+    ///
+    /// # Examples
+    /// ```
+    /// # use utils::array::ArrayVec;
+    /// let mut vec: ArrayVec<i32, 5> = ArrayVec::<i32, 5>::from_slice(&[1, 2, 3]).unwrap();
+    /// assert_eq!(vec.len(), 3);
+    /// assert_eq!(vec.pop(), Some(3));
+    /// assert_eq!(vec.pop(), Some(2));
+    /// assert_eq!(vec.pop(), Some(1));
+    /// assert_eq!(vec.pop(), None);
+    ///
+    /// assert_eq!(ArrayVec::<i32, 5>::from_slice(&[1, 2, 3, 4, 5, 6]), None);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn from_slice(slice: &[T]) -> Option<Self>
+    where
+        T: Copy + Default,
+    {
+        if slice.len() > N {
+            None
+        } else {
+            let mut data = [T::default(); N];
+            data[..slice.len()].copy_from_slice(slice);
+            Some(Self {
+                len: slice.len(),
+                data,
+            })
+        }
+    }
+
     /// Adds an element to the end of the vector.
     ///
     /// Returns [`Err`] containing the provided value if the vector is already full.

crates/utils/src/parser/base.rs

@@ -226,10 +226,18 @@ pub trait Parser<'i>: Sized {
     ///
     /// # Examples
     /// ```
-    /// # use utils::parser::{self, Parser};
+    /// # use utils::array::ArrayVec;
+    /// use utils::parser::{self, Parser};
     /// let parser = parser::u32()
-    ///     .repeat_arrayvec(",", 3);
-    /// assert_eq!(parser.parse(b"12,34,56,78"), Ok(([12, 34, 56, 78].into(), &b""[..])));
+    ///     .repeat_arrayvec::<5, _>(",", 3);
+    /// assert_eq!(
+    ///     parser.parse(b"12,34,56,78"),
+    ///     Ok((ArrayVec::from_slice(&[12, 34, 56, 78]).unwrap(), &b""[..]))
+    /// );
+    /// assert_eq!(
+    ///     parser.parse(b"12,34,56,abc"),
+    ///     Ok((ArrayVec::from_slice(&[12, 34, 56]).unwrap(), &b",abc"[..]))
+    /// );
     /// assert!(parser.parse(b"12,34").is_err());
     /// ```
     #[inline]
@@ -260,6 +268,7 @@ pub trait Parser<'i>: Sized {
     /// let parser = parser::u32()
     ///     .repeat(",", 3);
     /// assert_eq!(parser.parse(b"12,34,56,78"), Ok((vec![12, 34, 56, 78], &b""[..])));
+    /// assert_eq!(parser.parse(b"12,34,56,abc"), Ok((vec![12, 34, 56], &b",abc"[..])));
     /// assert!(parser.parse(b"12,34").is_err());
     /// ```
     #[inline]

crates/utils/src/parser/combinator.rs

@@ -113,6 +113,7 @@ impl<'i, const N: usize, P: Parser<'i, Output: Copy + Default>, S: Parser<'i>> P
     fn parse(&self, mut input: &'i [u8]) -> ParseResult<'i, Self::Output> {
         let mut output = ArrayVec::new();
 
+        let mut input_before_sep = input;
         let err = loop {
             let (v, remaining) = match self.parser.parse(input) {
                 Ok(v) => v,
@@ -125,16 +126,16 @@ impl<'i, const N: usize, P: Parser<'i, Output: Copy + Default>, S: Parser<'i>> P
             if output.push(v).is_err() {
                 return Err((ParseError::ExpectedLessItems(N), input));
             }
-            input = remaining;
+            input_before_sep = remaining;
 
-            match self.separator.parse(input) {
+            match self.separator.parse(remaining) {
                 Ok((_, remaining)) => input = remaining,
                 Err(err) => break err,
             }
         };
 
         if output.len() >= self.min_elements {
-            Ok((output, input))
+            Ok((output, input_before_sep))
         } else {
             Err(err)
         }
@@ -152,6 +153,7 @@ impl<'i, P: Parser<'i>, S: Parser<'i>> RepeatVec<P, S> {
     fn helper(&self, mut input: &'i [u8], consume_all: bool) -> ParseResult<'i, Vec<P::Output>> {
         let mut output = Vec::new();
 
+        let mut input_before_sep = input;
         let err = loop {
             let (v, remaining) = match self.parser.parse(input) {
                 Ok(v) => v,
@@ -168,20 +170,20 @@ impl<'i, P: Parser<'i>, S: Parser<'i>> RepeatVec<P, S> {
             }
 
             output.push(v);
-            input = remaining;
+            input_before_sep = remaining;
 
-            match self.separator.parse(input) {
+            match self.separator.parse(remaining) {
                 Ok((_, remaining)) => input = remaining,
                 Err(err) => break err,
             }
         };
 
-        if (consume_all && !input.is_empty()) || output.len() < self.min_elements {
+        if (consume_all && !input_before_sep.is_empty()) || output.len() < self.min_elements {
             // Return the last parsing error if this parser should consume the entire input and it
             // hasn't, or if the minimum number of elements isn't met.
             Err(err)
         } else {
-            Ok((output, input))
+            Ok((output, input_before_sep))
         }
     }
 }

crates/year2024/src/day05.rs

@@ -23,6 +23,7 @@ impl Day05 {
         let updates_parser = num.repeat(b',', 1).repeat(parser::eol(), 1);
 
         let (rule_list, updates) = rules_parser
+            .with_eol()
             .with_eol()
             .then(updates_parser)
             .parse_complete(input)?;