Faster numeric parsing

Author: maneatingape

src/util/parse.rs

@@ -12,60 +12,145 @@
 //!
 //! [`iter_unsigned`]: ParseUnsigned::iter_unsigned
 //! [`iter_signed`]: ParseSigned::iter_signed
-use std::iter::{Filter, Map};
-use std::str::{FromStr, Split};
-
-/// Much shorter alias for the trait return type.
-type Wrapper<'a, T> = Map<Filter<Split<'a, fn(char) -> bool>, fn(&&str) -> bool>, fn(&str) -> T>;
-
-/// This convenience method does the same thing as `s.parse().unwrap()` but without the
-/// extra `<F as FromStr>::Err` type bound so that we can have shorter type signatures.
-pub fn from<T: FromStr>(s: &str) -> T {
-    match s.parse() {
-        Ok(t) => t,
-        Err(_) => panic!("Unable to parse \"{s}\""),
-    }
-}
+use std::marker::PhantomData;
+use std::ops::{Add, Neg, Shl};
+use std::str::Bytes;
+
+/// Traits allow us to keep type safety, restricting the possiblities to only integer types.
+pub trait Common: Copy + From<u8> + Add<Output = Self> + Shl<u8, Output = Self> {}
+impl Common for u8 {}
+impl Common for u16 {}
+impl Common for u32 {}
+impl Common for u64 {}
+impl Common for usize {}
+impl Common for i16 {}
+impl Common for i32 {}
+impl Common for i64 {}
 
-/// This trait allows us to keep type safety, restricting the possiblities to only
-/// `u32`, `u64` and `usize`.
-pub trait Unsigned: FromStr {}
+pub trait Unsigned: Common {}
 impl Unsigned for u8 {}
+impl Unsigned for u16 {}
 impl Unsigned for u32 {}
 impl Unsigned for u64 {}
 impl Unsigned for usize {}
 
-/// Rust closures have an unique type that only the compiler knows and that us mere
-/// mortals are not allowed to ascertain. Fortunately we can coerce the type to a known
-/// function signature by using intermediate variables.
-pub trait ParseUnsigned {
-    fn iter_unsigned<T: Unsigned>(&self) -> Wrapper<'_, T>;
+pub trait Signed: Common + Neg<Output = Self> {}
+impl Signed for i16 {}
+impl Signed for i32 {}
+impl Signed for i64 {}
+
+pub struct ParseUnsigned<'a, T> {
+    bytes: Bytes<'a>,
+    phantom: PhantomData<T>,
+}
+
+pub struct ParseSigned<'a, T> {
+    bytes: Bytes<'a>,
+    phantom: PhantomData<T>,
+}
+
+pub trait ParseOps {
+    fn unsigned<T: Unsigned>(&self) -> T;
+    fn signed<T: Signed>(&self) -> T;
+    fn iter_unsigned<T: Unsigned>(&self) -> ParseUnsigned<'_, T>;
+    fn iter_signed<T: Signed>(&self) -> ParseSigned<'_, T>;
 }
 
-impl ParseUnsigned for &str {
-    fn iter_unsigned<T: Unsigned>(&self) -> Wrapper<'_, T> {
-        let not_numeric: fn(char) -> bool = |c| !c.is_ascii_digit();
-        let not_empty: fn(&&str) -> bool = |s| !s.is_empty();
-        self.split(not_numeric).filter(not_empty).map(from)
+impl ParseOps for &str {
+    fn unsigned<T: Unsigned>(&self) -> T {
+        match try_unsigned(&mut self.bytes()) {
+            Some(t) => t,
+            None => panic!("Unable to parse \"{self}\""),
+        }
+    }
+
+    fn signed<T: Signed>(&self) -> T {
+        match try_signed(&mut self.bytes()) {
+            Some(t) => t,
+            None => panic!("Unable to parse \"{self}\""),
+        }
+    }
+
+    fn iter_unsigned<T: Unsigned>(&self) -> ParseUnsigned<'_, T> {
+        ParseUnsigned { bytes: self.bytes(), phantom: PhantomData }
+    }
+
+    fn iter_signed<T: Signed>(&self) -> ParseSigned<'_, T> {
+        ParseSigned { bytes: self.bytes(), phantom: PhantomData }
     }
 }
 
-/// This trait allows us to keep type safety, restricting the possiblities to only
-/// `i32` and `i64`.
-pub trait Signed: FromStr {}
-impl Signed for i32 {}
-impl Signed for i64 {}
+impl<T: Unsigned> Iterator for ParseUnsigned<'_, T> {
+    type Item = T;
 
-/// Essentially the same as `ParseUnsigned` but also considers the `-` character as part
-/// of a number.
-pub trait ParseSigned {
-    fn iter_signed<T: Signed>(&self) -> Wrapper<'_, T>;
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let (lower, upper) = self.bytes.size_hint();
+        (lower / 3, upper.map(|u| u / 3))
+    }
+
+    fn next(&mut self) -> Option<Self::Item> {
+        try_unsigned(&mut self.bytes)
+    }
+}
+
+impl<T: Signed> Iterator for ParseSigned<'_, T> {
+    type Item = T;
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let (lower, upper) = self.bytes.size_hint();
+        (lower / 3, upper.map(|u| u / 3))
+    }
+
+    fn next(&mut self) -> Option<Self::Item> {
+        try_signed(&mut self.bytes)
+    }
 }
 
-impl ParseSigned for &str {
-    fn iter_signed<T: Signed>(&self) -> Wrapper<'_, T> {
-        let not_numeric: fn(char) -> bool = |c| !c.is_ascii_digit() && c != '-';
-        let not_empty: fn(&&str) -> bool = |s| !s.is_empty();
-        self.split(not_numeric).filter(not_empty).map(from)
+fn try_unsigned<T: Unsigned>(bytes: &mut Bytes) -> Option<T> {
+    let mut n = loop {
+        let b = bytes.next()?;
+        let d = b.wrapping_sub(b'0');
+
+        if d < 10 {
+            break T::from(d);
+        }
+    };
+
+    loop {
+        let Some(b) = bytes.next() else { break Some(n) };
+        let d = b.wrapping_sub(b'0');
+
+        if d < 10 {
+            n = (n << 3) + (n << 1) + T::from(d);
+        } else {
+            break Some(n);
+        }
+    }
+}
+
+fn try_signed<T: Signed>(bytes: &mut Bytes) -> Option<T> {
+    let (mut n, negative) = loop {
+        let b = bytes.next()?;
+        let d = b.wrapping_sub(b'0');
+
+        if d == 253 {
+            break (T::from(0), true);
+        }
+        if d < 10 {
+            break (T::from(d), false);
+        }
+    };
+
+    loop {
+        let Some(b) = bytes.next() else {
+            break Some(if negative { -n } else { n });
+        };
+        let d = b.wrapping_sub(b'0');
+
+        if d < 10 {
+            n = (n << 3) + (n << 1) + T::from(d);
+        } else {
+            break Some(if negative { -n } else { n });
+        }
     }
 }

src/year2015/day07.rs

@@ -37,8 +37,8 @@ pub fn parse(input: &str) -> Result {
             match second {
                 "AND" => Gate::And(first, third),
                 "OR" => Gate::Or(first, third),
-                "LSHIFT" => Gate::LeftShift(first, from(third)),
-                "RSHIFT" => Gate::RightShift(first, from(third)),
+                "LSHIFT" => Gate::LeftShift(first, third.unsigned()),
+                "RSHIFT" => Gate::RightShift(first, third.unsigned()),
                 _ => unreachable!(),
             }
         };
@@ -67,7 +67,7 @@ fn signal<'a>(
     }
 
     let result = if key.chars().next().unwrap().is_ascii_digit() {
-        from(key)
+        key.unsigned()
     } else {
         match circuit[key] {
             Gate::Wire(w) => signal(w, circuit, cache),

src/year2015/day09.rs

@@ -43,7 +43,7 @@ pub fn parse(input: &str) -> Result {
     for [start, _, end, _, distance] in tokens.iter() {
         let start = indices[start];
         let end = indices[end];
-        let distance = from(distance);
+        let distance = distance.unsigned();
         distances[stride * start + end] = distance;
         distances[stride * end + start] = distance;
     }

src/year2020/day01.rs

@@ -16,7 +16,7 @@
 use crate::util::parse::*;
 
 pub fn parse(input: &str) -> Vec<usize> {
-    input.lines().map(from).collect()
+    input.lines().map(|line| line.unsigned()).collect()
 }
 
 pub fn part1(input: &[usize]) -> usize {

src/year2020/day02.rs

@@ -21,8 +21,8 @@ pub struct Rule<'a> {
 
 impl Rule<'_> {
     fn from([a, b, c, d]: [&str; 4]) -> Rule {
-        let start = from(a);
-        let end = from(b);
+        let start = a.unsigned();
+        let end = b.unsigned();
         let letter = c.as_bytes()[0];
         let password = d.as_bytes();
         Rule { start, end, letter, password }

src/year2020/day07.rs

@@ -43,7 +43,7 @@ pub fn parse(input: &str) -> Haversack {
 
         for (index, chunk) in tokens {
             let [amount, first_name, second_name, _] = chunk;
-            let amount = from(amount);
+            let amount = amount.unsigned();
             let next = indices[&[first_name, second_name]];
             bag[index] = Some(Rule { amount, next });
         }

src/year2020/day08.rs

@@ -22,10 +22,11 @@ pub enum Instruction {
 
 impl Instruction {
     fn from([a, b]: [&str; 2]) -> Instruction {
+        let amount = b.signed();
         match a {
-            "acc" => Instruction::Acc(from(b)),
-            "jmp" => Instruction::Jmp(from(b)),
-            "nop" => Instruction::Nop(from(b)),
+            "acc" => Instruction::Acc(amount),
+            "jmp" => Instruction::Jmp(amount),
+            "nop" => Instruction::Nop(amount),
             _ => unreachable!(),
         }
     }

src/year2020/day12.rs

@@ -9,7 +9,7 @@ use crate::util::point::*;
 type Command = (u8, i32);
 
 pub fn parse(input: &str) -> Vec<Command> {
-    input.lines().map(|line| (line.as_bytes()[0], from(&line[1..]))).collect()
+    input.lines().map(|line| (line.as_bytes()[0], (&line[1..]).signed())).collect()
 }
 
 pub fn part1(input: &[Command]) -> i32 {

src/year2020/day13.rs

@@ -17,12 +17,12 @@ pub struct Input {
 
 pub fn parse(input: &str) -> Input {
     let lines: Vec<_> = input.lines().collect();
-    let timestamp = from(lines[0]);
+    let timestamp = lines[0].unsigned();
     let buses: Vec<(usize, usize)> = lines[1]
         .split(',')
         .enumerate()
         .filter(|&(_, id)| id != "x")
-        .map(|(offset, id)| (offset, from(id)))
+        .map(|(offset, id)| (offset, id.unsigned()))
         .collect();
     Input { timestamp, buses }
 }

src/year2020/day14.rs

@@ -133,8 +133,8 @@ pub fn parse(input: &str) -> Vec<Instruction> {
             Instruction::mask(&line[7..])
         } else {
             let (address, value) = line[4..].split_once("] = ").unwrap();
-            let address = from(address);
-            let value = from(value);
+            let address = address.unsigned();
+            let value = value.unsigned();
             Instruction::Mem { address, value }
         };
         instructions.push(instruction);

src/year2020/day20.rs

@@ -71,7 +71,7 @@ impl Tile {
     ];
 
     fn from(chunk: &[&str]) -> Tile {
-        let id = from(&chunk[0][5..9]);
+        let id = (&chunk[0][5..9]).unsigned();
 
         let pixels: [[u8; 10]; 10] =
             std::array::from_fn(|i| chunk[i + 1].as_bytes().try_into().unwrap());

src/year2021/day01.rs

@@ -19,7 +19,7 @@
 use crate::util::parse::*;
 
 pub fn parse(input: &str) -> Vec<u32> {
-    input.lines().map(from).collect()
+    input.iter_unsigned().collect()
 }
 
 pub fn part1(input: &[u32]) -> usize {

src/year2021/day02.rs

@@ -16,11 +16,14 @@ pub enum Sub {
 }
 
 pub fn parse(input: &str) -> Vec<Sub> {
-    let helper = |[a, b]: [&str; 2]| match a {
-        "up" => Sub::Up(from(b)),
-        "down" => Sub::Down(from(b)),
-        "forward" => Sub::Forward(from(b)),
-        _ => unreachable!(),
+    let helper = |[a, b]: [&str; 2]| {
+        let amount = b.signed();
+        match a {
+            "up" => Sub::Up(amount),
+            "down" => Sub::Down(amount),
+            "forward" => Sub::Forward(amount),
+            _ => unreachable!(),
+        }
     };
     input.split_ascii_whitespace().chunk::<2>().map(helper).collect()
 }

src/year2021/day13.rs

@@ -34,8 +34,8 @@ pub fn parse(input: &str) -> Input {
     let folds: Vec<_> = suffix
         .lines()
         .map(|line| match line.split_once('=').unwrap() {
-            ("fold along x", x) => Fold::Horizontal(from(x)),
-            ("fold along y", y) => Fold::Vertical(from(y)),
+            ("fold along x", x) => Fold::Horizontal(x.signed()),
+            ("fold along y", y) => Fold::Vertical(y.signed()),
             _ => unreachable!(),
         })
         .collect();

src/year2021/day24.rs

@@ -28,7 +28,7 @@ pub fn parse(input: &str) -> Vec<Constraint> {
         .map(|chunk| {
             let helper = |i: usize| {
                 let token = chunk[i].split_ascii_whitespace().last().unwrap();
-                from(token)
+                token.signed()
             };
             if helper(4) == 1 {
                 Push(helper(15))

src/year2022/day01.rs

@@ -14,7 +14,7 @@ use crate::util::parse::*;
 /// Parse and group lines.
 pub fn parse(input: &str) -> Vec<u32> {
     let mut elves: Vec<u32> =
-        input.split("\n\n").map(|s| s.lines().map(from::<u32>).sum()).collect();
+        input.split("\n\n").map(|s| s.lines().map(|line| line.unsigned::<u32>()).sum()).collect();
     elves.sort_unstable();
     elves
 }

src/year2022/day07.rs

@@ -56,7 +56,7 @@ pub fn parse(input: &str) -> Vec<u32> {
         } else if token == "cd" {
             cd = true;
         } else if token.as_bytes()[0].is_ascii_digit() {
-            total += from::<u32>(token);
+            total += token.unsigned::<u32>();
         }
     }
 

src/year2022/day09.rs

@@ -26,7 +26,7 @@ pub fn parse(input: &str) -> Vec<Input> {
         .chunk::<2>()
         .map(|[d, n]| {
             let point = Point::from_string(d);
-            let amount = from(n);
+            let amount = n.unsigned();
             (point, amount)
         })
         .collect()

src/year2022/day10.rs

@@ -11,7 +11,7 @@ pub fn parse(input: &str) -> Vec<i32> {
         match token {
             "noop" => (),
             "addx" => (),
-            delta => x += from::<i32>(delta),
+            delta => x += delta.signed::<i32>(),
         }
         xs.push(x);
     }

src/year2022/day11.rs

@@ -65,8 +65,8 @@ pub fn parse(input: &str) -> Vec<Monkey> {
         let tokens: Vec<&str> = chunk[2].split(' ').rev().take(2).collect();
         let operation = match tokens[..] {
             ["old", _] => Operation::Square,
-            [y, "*"] => Operation::Multiply(from(y)),
-            [y, "+"] => Operation::Add(from(y)),
+            [y, "*"] => Operation::Multiply(y.unsigned()),
+            [y, "+"] => Operation::Add(y.unsigned()),
             _ => unreachable!(),
         };
         let test = chunk[3].iter_unsigned().next().unwrap();