Add parser.with_consumed()

Author: ictrobot

crates/utils/src/parser/base.rs

@@ -1,6 +1,7 @@
 use crate::input::{InputError, MapWithInputExt};
 use crate::parser::combinator::{
-    Map, MapResult, Optional, Or, RepeatArrayVec, RepeatN, RepeatVec, WithPrefix, WithSuffix,
+    Map, MapResult, Optional, Or, RepeatArrayVec, RepeatN, RepeatVec, WithConsumed, WithPrefix,
+    WithSuffix,
 };
 use crate::parser::error::{ParseError, WithErrorMsg};
 use crate::parser::iterator::{ParserIterator, ParserMatchesIterator};
@@ -233,6 +234,23 @@ pub trait Parser: Sized {
         }
     }
 
+    /// Return the output of this parser as well as the bytes consumed.
+    ///
+    /// This can be used to map any errors that occur while processing the parsed input back to the
+    /// problematic item's position in the input.
+    ///
+    /// # Examples
+    /// ```
+    /// # use utils::parser::{self, Parser};
+    /// assert_eq!(
+    ///     parser::u32().with_consumed().parse(b"012,345,678"),
+    ///     Ok(((12, &b"012"[..]), &b",345,678"[..]))
+    /// );
+    /// ```
+    fn with_consumed(self) -> WithConsumed<Self> {
+        WithConsumed { parser: self }
+    }
+
     /// Parse a prefix (normally a string literal) before this parser.
     ///
     /// The result of the prefix parser is discarded.

crates/utils/src/parser/combinator.rs

@@ -239,6 +239,23 @@ impl<A: Parser, B: for<'i> Parser<Output<'i> = A::Output<'i>>> Parser for Or<A,
     }
 }
 
+#[derive(Copy, Clone)]
+pub struct WithConsumed<P> {
+    pub(super) parser: P,
+}
+impl<P: Parser> Parser for WithConsumed<P> {
+    type Output<'i> = (P::Output<'i>, &'i [u8]);
+    type Then<T: Parser> = Then2<Self, T>;
+
+    #[inline]
+    fn parse<'i>(&self, input: &'i [u8]) -> ParseResult<'i, Self::Output<'i>> {
+        match self.parser.parse(input) {
+            Ok((v, remaining)) => Ok(((v, &input[..input.len() - remaining.len()]), remaining)),
+            Err(e) => Err(e),
+        }
+    }
+}
+
 #[derive(Copy, Clone)]
 pub struct WithPrefix<A, B> {
     pub(super) parser: A,

crates/year2024/src/day18.rs

@@ -35,15 +35,16 @@ impl Day18 {
         for item in parser::number_range(0..=max_coord)
             .then(parser::number_range(0..=max_coord).with_prefix(b','))
             .map(|(x, y)| Point2D { x, y })
+            .with_consumed()
             .with_suffix(parser::eol())
             .parse_iterator(input)
         {
-            let pos = item?;
+            let (pos, line) = item?;
             if blocked_at[(pos.y + 1) * size + (pos.x + 1)] == u16::MAX {
                 blocked_at[(pos.y + 1) * size + (pos.x + 1)] = fallen;
                 fallen += 1;
             } else {
-                return Err(InputError::new(input, 0, "duplicate position in input"));
+                return Err(InputError::new(input, line, "duplicate position in input"));
             }
         }
 

crates/year2024/src/day24.rs

@@ -40,17 +40,18 @@ impl Day24 {
             .then(parser::byte_range(b'0'..=b'9'))
             .with_suffix(": ")
             .then(parser::byte_range(b'0'..=b'1'))
+            .with_consumed()
             .with_suffix(parser::eol())
             .parse_iterator(initial_str)
         {
-            let (wire, b) = item?;
+            let ((wire, b), line) = item?;
             let n = ((wire.1 - b'0') * 10 + (wire.2 - b'0')) as usize;
 
             if (wire.0, n) != next {
                 if next.0 == b'x' && wire == (b'y', b'0', b'0') {
                     input_bits = next.1;
                 } else {
-                    return Err(InputError::new(input, 0, "unexpected initial value"));
+                    return Err(InputError::new(input, line, "unexpected initial value"));
                 }
             }
 

crates/year2024/src/day25.rs

@@ -9,24 +9,25 @@ pub struct Day25 {
 
 impl Day25 {
     pub fn new(input: &str, _: InputType) -> Result<Self, InputError> {
-        let mut locks = Vec::new();
-        let mut keys = Vec::new();
+        let mut locks = Vec::with_capacity(250);
+        let mut keys = Vec::with_capacity(250);
 
         for item in parser::one_of((b'.'.map(|_| false), b'#'.map(|_| true)))
             .repeat_n::<5, _>(parser::noop())
             .repeat_n::<7, _>(parser::eol())
+            .with_consumed()
             .with_suffix(parser::eol().then(parser::eol()))
             .parse_iterator(input)
         {
-            let grid = item?;
+            let (grid, grid_str) = item?;
 
             let top = grid[0][0];
             let bottom = grid[6][0];
             if top == bottom
                 || grid[0][1..].iter().any(|&x| x != top)
                 || grid[6][1..].iter().any(|&x| x != bottom)
             {
-                return Err(InputError::new(input, 0, "expected lock or key"));
+                return Err(InputError::new(input, grid_str, "expected lock or key"));
             }
 
             let mut mask = 0u32;