2017 day 11

Also optimize parsing of literals and lists with separators which take the vast majority of the time for this solution

Author: ictrobot

crates/utils/src/parser/base.rs

@@ -3,8 +3,8 @@ use crate::parser::combinator::{
     Map, MapResult, Optional, Or, RepeatN, RepeatVec, WithPrefix, WithSuffix,
 };
 use crate::parser::error::WithErrorMsg;
-use crate::parser::simple::Eol;
-use crate::parser::then::Then2;
+use crate::parser::simple::{Constant, Eol};
+use crate::parser::then::{Then2, Unimplemented};
 use crate::parser::ParseError;
 
 /// [`Result`] type returned by [`Parser::parse`].
@@ -182,42 +182,18 @@ pub trait Parser: Sized {
     /// If the number of items is constant and known in advance, prefer [`repeat_n`](Self::repeat_n)
     /// as it avoids allocating.
     ///
-    /// See also [`repeat_min`](Self::repeat_min), which ensures at least N items are parsed.
-    ///
-    /// # Examples
-    /// ```
-    /// # use utils::parser::{self, Parser};
-    /// assert_eq!(
-    ///     parser::u32()
-    ///         .with_suffix(",".optional())
-    ///         .repeat()
-    ///         .parse(b"12,34,56,78"),
-    ///     Ok((vec![12, 34, 56, 78], &b""[..]))
-    /// );
-    /// ```
-    fn repeat(self) -> RepeatVec<Self> {
-        RepeatVec {
-            parser: self,
-            min_elements: 0,
-        }
-    }
-
-    /// Repeat this parser at least N times, returning a [`Vec`].
-    ///
-    /// See also [`repeat`](Self::repeat).
-    ///
     /// # Examples
     /// ```
     /// # use utils::parser::{self, Parser};
     /// let parser = parser::u32()
-    ///     .with_suffix(",".optional())
-    ///     .repeat_min(3);
+    ///     .repeat(",", 3);
     /// assert_eq!(parser.parse(b"12,34,56,78"), Ok((vec![12, 34, 56, 78], &b""[..])));
     /// assert!(parser.parse(b"12,34").is_err());
     /// ```
-    fn repeat_min(self, min_elements: usize) -> RepeatVec<Self> {
+    fn repeat<S: Parser>(self, separator: S, min_elements: usize) -> RepeatVec<Self, S> {
         RepeatVec {
             parser: self,
+            separator,
             min_elements,
         }
     }
@@ -287,8 +263,25 @@ pub trait Parser: Sized {
         }
     }
 
+    /// Apply this parser once, checking the provided input is fully consumed.
+    ///
+    /// # Examples
+    /// ```
+    /// # use utils::parser::{self, Parser};
+    /// assert_eq!(parser::u32().parse_complete("1234").unwrap(), 1234);
+    /// assert!(parser::u32().parse_complete("1234abc").is_err());
+    /// ```
+    fn parse_complete<'i>(&self, input: &'i str) -> Result<Self::Output<'i>, InputError> {
+        match self.parse(input.as_bytes()).map_with_input(input)? {
+            (v, []) => Ok(v),
+            (_, remaining) => Err(InputError::new(input, remaining, "expected end of input")),
+        }
+    }
+
     /// Apply this parser repeatedly until the provided input is fully consumed.
     ///
+    /// Equivalent to `parser.repeat(parser::noop(), 0).parse_complete(input)`.
+    ///
     /// # Examples
     /// ```
     /// # use utils::parser::{self, Parser};
@@ -306,20 +299,9 @@ pub trait Parser: Sized {
     /// );
     /// ```
     fn parse_all<'i>(&self, input: &'i str) -> Result<Vec<Self::Output<'i>>, InputError> {
-        let mut results = Vec::new();
-        let mut remaining = input.as_bytes();
-        while !remaining.is_empty() {
-            let (v, new_remaining) = self.parse(remaining).map_with_input(input)?;
-
-            if results.is_empty() {
-                let length = remaining.len() - new_remaining.len();
-                results.reserve(2 + ((remaining.len() / length) * 6 / 5));
-            }
-
-            remaining = new_remaining;
-            results.push(v);
-        }
-        Ok(results)
+        ParserRef(self)
+            .repeat(Constant(()), 0)
+            .parse_complete(input)
     }
 
     /// Similar to [`parse_all`](Self::parse_all) but expects a newline after each item.
@@ -342,44 +324,26 @@ pub trait Parser: Sized {
     /// );
     /// ```
     fn parse_lines<'i>(&self, input: &'i str) -> Result<Vec<Self::Output<'i>>, InputError> {
-        // Can't use WithSuffix as it consumes the input parser
-        struct LineParser<'a, P>(&'a P);
-        impl<'a, P: Parser> Parser for LineParser<'a, P> {
-            type Output<'i> = P::Output<'i>;
-            type Then<T: Parser> = Then2<Self, T>;
+        ParserRef(self)
+            .with_suffix(Eol())
+            .repeat(Constant(()), 0)
+            .parse_complete(input)
+    }
+}
 
-            #[inline]
-            fn parse<'i>(&self, input: &'i [u8]) -> ParseResult<'i, Self::Output<'i>> {
-                match self.0.parse(input) {
-                    Ok((v, remaining)) => match Eol().parse(remaining) {
-                        Ok(((), remaining)) => Ok((v, remaining)),
-                        Err(e) => Err(e),
-                    },
-                    Err(e) => Err(e),
-                }
-            }
+// Workaround to allow using methods which consume a parser in methods which take references.
+struct ParserRef<'a, P>(&'a P);
+impl<'a, P: Parser> Parser for ParserRef<'a, P> {
+    type Output<'i> = P::Output<'i>;
+    type Then<T: Parser> = Unimplemented;
 
-            fn then<T: Parser>(self, _: T) -> Self::Then<T> {
-                unreachable!();
-            }
-        }
-
-        LineParser(self).parse_all(input)
+    #[inline]
+    fn parse<'i>(&self, input: &'i [u8]) -> ParseResult<'i, Self::Output<'i>> {
+        self.0.parse(input)
     }
 
-    /// Apply this parser once, checking the provided input is fully consumed.
-    ///
-    /// # Examples
-    /// ```
-    /// # use utils::parser::{self, Parser};
-    /// assert_eq!(parser::u32().parse_complete("1234").unwrap(), 1234);
-    /// assert!(parser::u32().parse_complete("1234abc").is_err());
-    /// ```
-    fn parse_complete<'i>(&self, input: &'i str) -> Result<Self::Output<'i>, InputError> {
-        match self.parse(input.as_bytes()).map_with_input(input)? {
-            (v, []) => Ok(v),
-            (_, remaining) => Err(InputError::new(input, remaining, "expected end of input")),
-        }
+    fn then<T: Parser>(self, _: T) -> Self::Then<T> {
+        unreachable!();
     }
 }
 

crates/utils/src/parser/combinator.rs

@@ -1,3 +1,4 @@
+use crate::input::{InputError, MapWithInputExt};
 use crate::parser::then::Then2;
 use crate::parser::{ParseError, ParseResult, Parser};
 
@@ -102,31 +103,67 @@ impl<const N: usize, P: for<'i> Parser<Output<'i>: Copy + Default>> Parser for R
 }
 
 #[derive(Copy, Clone)]
-pub struct RepeatVec<P> {
+pub struct RepeatVec<P, S> {
     pub(super) parser: P,
+    pub(super) separator: S,
     pub(super) min_elements: usize,
 }
-impl<P: Parser> Parser for RepeatVec<P> {
-    type Output<'i> = Vec<P::Output<'i>>;
-    type Then<T: Parser> = Then2<Self, T>;
-
+impl<P: Parser, S: Parser> RepeatVec<P, S> {
     #[inline]
-    fn parse<'i>(&self, mut input: &'i [u8]) -> ParseResult<'i, Self::Output<'i>> {
+    fn helper<'i>(
+        &self,
+        mut input: &'i [u8],
+        consume_all: bool,
+    ) -> ParseResult<'i, Vec<P::Output<'i>>> {
         let mut output = Vec::new();
+
         while let Ok((v, remaining)) = self.parser.parse(input) {
+            let consumed = input.len() - remaining.len();
+            assert!(consumed > 0, "parsing item consumed no input");
+
+            // When parsing the complete input, after parsing the first item use the proportion of
+            // consumed bytes for one item to reserve capacity for the output vec
+            if consume_all && output.is_empty() {
+                output.reserve(((remaining.len() / consumed) * 7 / 5) + 2);
+            }
+
             output.push(v);
-            input = remaining;
+
+            if let Ok((_, remaining)) = self.separator.parse(remaining) {
+                input = remaining;
+            } else {
+                input = remaining;
+                break;
+            }
         }
+
         if output.len() >= self.min_elements {
             Ok((output, input))
         } else {
             Err((ParseError::ExpectedMatches(self.min_elements), input))
         }
     }
+}
+impl<P: Parser, S: Parser> Parser for RepeatVec<P, S> {
+    type Output<'i> = Vec<P::Output<'i>>;
+    type Then<T: Parser> = Then2<Self, T>;
+
+    #[inline]
+    fn parse<'i>(&self, input: &'i [u8]) -> ParseResult<'i, Self::Output<'i>> {
+        self.helper(input, false)
+    }
 
     fn then<T: Parser>(self, next: T) -> Self::Then<T> {
         Then2::new(self, next)
     }
+
+    // Override the default implementation to set consume_all to true
+    fn parse_complete<'i>(&self, input: &'i str) -> Result<Self::Output<'i>, InputError> {
+        match self.helper(input.as_bytes(), true).map_with_input(input)? {
+            (v, []) => Ok(v),
+            (_, remaining) => Err(InputError::new(input, remaining, "expected end of input")),
+        }
+    }
 }
 
 #[derive(Copy, Clone)]

crates/utils/src/parser/macros.rs

@@ -0,0 +1,57 @@
+/// Parse one or more string literals, mapping the results.
+///
+/// This is a replacement for
+/// [`parser::one_of`](crate::parser::one_of())`(("a".map(|_| Enum::A), "b".map(|_| Enum::b)))`
+/// which produces more optimized assembly and is easier to read and write.
+///
+/// The string patterns are matched in the order provided, so strings should be ordered by length.
+///
+/// Using this makes [2017 day 11](../../year2017/struct.Day11.html), which parses a sequence of
+/// literals separated by commas, over 2x faster.
+///
+/// # Examples
+/// ```
+/// # use utils::parser::{Parser, self};
+///
+/// #[derive(Debug, PartialEq)]
+/// enum Example {
+///     A,
+///     B,
+///     C,
+/// }
+///
+/// let parser = parser::literal_map!(
+///     "A" | "a" => Example::A,
+///     "B" => Example::B,
+///     "C" => Example::C,
+/// );
+/// assert_eq!(parser.parse(b"A"), Ok((Example::A, &b""[..])));
+/// assert_eq!(parser.parse(b"a"), Ok((Example::A, &b""[..])));
+/// assert_eq!(parser.parse(b"B"), Ok((Example::B, &b""[..])));
+/// assert_eq!(parser.parse(b"C"), Ok((Example::C, &b""[..])));
+/// assert!(parser.parse(b"D").is_err());
+/// ```
+#[macro_export]
+macro_rules! parser_literal_map {
+    (
+        $($($l:literal)|+ => $e:expr),+$(,)?
+    ) => {{
+        fn coerce_to_parser<F: Fn(&[u8]) -> $crate::parser::ParseResult<'_, O>, O>(f: F) -> F { f }
+
+        coerce_to_parser(|input| {
+            $($(
+                if input.len() >= const { $l.len() } && const { $l.as_bytes() } == &input[..const { $l.len() }] {
+                    return Ok((($e), &input[const { $l.len() }..]));
+                }
+            )+)*
+
+            Err(($crate::parser_literal_map!(@error $($($l)+)+), input))
+        })
+    }};
+    (@error $first:literal $($l:literal)+) => {
+        $crate::parser::ParseError::Custom(concat!("expected one of '", $first, "'", $(", '", $l, "'",)+))
+    };
+    (@error $first:literal) => {
+        $crate::parser::ParseError::ExpectedLiteral($first)
+    };
+}

crates/utils/src/parser/mod.rs

@@ -3,6 +3,7 @@
 mod base;
 mod combinator;
 mod error;
+mod macros;
 mod number;
 mod one_of;
 mod simple;
@@ -12,4 +13,6 @@ pub use base::*;
 pub use error::ParseError;
 pub use number::{i128, i16, i32, i64, i8, number_range, u128, u16, u32, u64, u8};
 pub use one_of::one_of;
-pub use simple::{byte, byte_range, constant, eol, take_while, take_while1};
+pub use simple::{byte, byte_range, constant, eol, noop, take_while, take_while1};
+
+pub use crate::parser_literal_map as literal_map;

crates/utils/src/parser/one_of.rs

@@ -70,6 +70,8 @@ impl<L: ParserList> Parser for OneOf<L> {
 /// Similar to [`Parser::or`], each parser will be tried in order until one succeeds. If no parsers
 /// succeed, the error from the parser furthest into the input is returned.
 ///
+/// Prefer [`parser::literal_map`](super::literal_map) if all the parsers are string literals.
+///
 /// # Examples
 /// ```
 /// # use utils::input::InputError;

crates/utils/src/parser/simple.rs

@@ -91,7 +91,7 @@ pub fn byte_range(range: RangeInclusive<u8>) -> ByteRange {
 }
 
 #[derive(Copy, Clone)]
-pub struct Constant<V: Copy>(V);
+pub struct Constant<V: Copy>(pub(super) V);
 impl<V: Copy> Parser for Constant<V> {
     type Output<'i> = V;
     type Then<T: Parser> = Then2<Self, T>;
@@ -121,6 +121,24 @@ pub fn constant<T: Copy>(v: T) -> Constant<T> {
     Constant(v)
 }
 
+/// Parser that consumes no input and always succeeds, returning [`()`](unit).
+///
+/// # Examples
+/// ```
+/// # use utils::parser::{self, Parser};
+/// assert_eq!(
+///     parser::noop().parse(b"abc"),
+///     Ok(((), &b"abc"[..]))
+/// );
+/// ```
+#[must_use]
+pub fn noop() -> Constant<()> {
+    const {
+        assert!(size_of::<Constant<()>>() == 0);
+    }
+    Constant(())
+}
+
 #[derive(Copy, Clone)]
 pub struct Eol();
 impl Parser for Eol {

crates/year2015/src/day06.rs

@@ -35,11 +35,11 @@ enum Action {
 
 impl Day06 {
     pub fn new(input: &str, _: InputType) -> Result<Self, InputError> {
-        let mut instructions = parser::one_of((
-            "turn off ".map(|_| Action::TurnOff),
-            "turn on ".map(|_| Action::TurnOn),
-            "toggle ".map(|_| Action::Toggle),
-        ))
+        let mut instructions = parser::literal_map!(
+            "turn off " => Action::TurnOff,
+            "turn on " => Action::TurnOn,
+            "toggle " => Action::Toggle,
+        )
         .then(parser::u16())
         .then(parser::u16().with_prefix(b','))
         .then(parser::u16().with_prefix(" through "))

crates/year2015/src/day23.rs

@@ -24,7 +24,7 @@ enum Instruction {
 
 impl Day23 {
     pub fn new(input: &str, _: InputType) -> Result<Self, InputError> {
-        let register = b'a'.map(|_| Register::A).or(b'b'.map(|_| Register::B));
+        let register = parser::literal_map!("a" => Register::A, "b" => Register::B);
 
         Ok(Self {
             instructions: parser::one_of((