Tidy code

Author: maneatingape

src/lib.rs

@@ -13,7 +13,9 @@
 macro_rules! library {
     ($year:tt $description:literal $($day:tt),*) => {
         #[doc = concat!("# ", $description)]
-        pub mod $year {$(pub mod $day;)*}
+        pub mod $year {
+            $(pub mod $day;)*
+        }
     }
 }
 

src/main.rs

@@ -1,38 +1,39 @@
 use aoc::util::ansi::*;
 use aoc::util::parse::*;
-use aoc::*;
 use std::env::args;
 use std::fs::read_to_string;
-use std::iter::empty;
 use std::time::{Duration, Instant};
 
 fn main() {
     // Parse command line options
-    let args: Vec<_> = args().collect();
-    let args: Vec<_> = args.iter().map(String::as_str).collect();
-    let mut iter = args.iter().flat_map(|arg| arg.iter_unsigned::<u32>());
+    let mut iter = args().flat_map(|arg| arg.as_str().iter_unsigned().collect::<Vec<u32>>());
     let (year, day) = (iter.next(), iter.next());
 
+    let solutions = [
+        year2015(),
+        year2016(),
+        year2017(),
+        year2018(),
+        year2019(),
+        year2020(),
+        year2021(),
+        year2022(),
+        year2023(),
+        year2024(),
+    ];
+
     // Filter solutions then pretty print output.
-    let (stars, duration) = empty()
-        .chain(year2015())
-        .chain(year2016())
-        .chain(year2017())
-        .chain(year2018())
-        .chain(year2019())
-        .chain(year2020())
-        .chain(year2021())
-        .chain(year2022())
-        .chain(year2023())
-        .chain(year2024())
-        .filter(|solution| year.is_none_or(|y| y == solution.year))
-        .filter(|solution| day.is_none_or(|d| d == solution.day))
+    let (stars, duration) = solutions
+        .into_iter()
+        .flatten()
+        .filter(|s| year.is_none_or(|y| y == s.year))
+        .filter(|s| day.is_none_or(|d| d == s.day))
         .fold((0, Duration::ZERO), |(stars, duration), Solution { year, day, wrapper }| {
             let path = format!("input/year{year}/day{day:02}.txt");
 
             if let Ok(data) = read_to_string(&path) {
                 let instant = Instant::now();
-                let (part1, part2) = wrapper(data);
+                let (part1, part2) = wrapper(&data);
                 let elapsed = instant.elapsed();
 
                 println!("{BOLD}{YELLOW}{year} Day {day}{RESET}");
@@ -50,16 +51,16 @@ fn main() {
         });
 
     // Optionally print totals.
-    if args.contains(&"--totals") {
-        println!("{BOLD}{YELLOW}⭐ {}{RESET}", stars);
+    if args().any(|arg| arg == "--totals") {
+        println!("{BOLD}{YELLOW}⭐ {stars}{RESET}");
         println!("{BOLD}{WHITE}🕓 {} ms{RESET}", duration.as_millis());
     }
 }
 
 struct Solution {
     year: u32,
     day: u32,
-    wrapper: fn(String) -> (String, String),
+    wrapper: fn(&str) -> (String, String),
 }
 
 macro_rules! run {
@@ -68,8 +69,8 @@ macro_rules! run {
             vec![$({
                 let year = stringify!($year).unsigned();
                 let day = stringify!($day).unsigned();
-                let wrapper = |data: String| {
-                    use $year::$day::*;
+                let wrapper = |data: &str| {
+                    use aoc::$year::$day::*;
 
                     let input = parse(&data);
                     let part1 = part1(&input);

src/util/bitset.rs

@@ -22,7 +22,6 @@ pub struct Bitset<T> {
 impl<T> Iterator for Bitset<T>
 where
     T: Integer<T>,
-    T: TryInto<usize>,
 {
     type Item = usize;
 
@@ -34,7 +33,6 @@ where
 
         let tz = self.t.trailing_zeros();
         self.t = self.t ^ (T::ONE << tz);
-
-        tz.try_into().ok()
+        Some(tz as usize)
     }
 }

src/util/grid.rs

@@ -60,12 +60,11 @@ impl Grid<u8> {
 impl<T: Copy + PartialEq> Grid<T> {
     #[inline]
     pub fn find(&self, needle: T) -> Option<Point> {
-        let to_point = |index| {
+        self.bytes.iter().position(|&h| h == needle).map(|index| {
             let x = (index as i32) % self.width;
             let y = (index as i32) / self.width;
             Point::new(x, y)
-        };
-        self.bytes.iter().position(|&h| h == needle).map(to_point)
+        })
     }
 }
 

src/util/integer.rs

@@ -14,15 +14,15 @@ pub trait Integer<T>:
     + Div<Output = T>
     + Mul<Output = T>
     + Rem<Output = T>
-    + Shl<Output = T>
-    + Shr<Output = T>
+    + Shl<u32, Output = T>
+    + Shr<u32, Output = T>
     + Sub<Output = T>
 {
     const ZERO: T;
     const ONE: T;
     const TEN: T;
 
-    fn trailing_zeros(self) -> T;
+    fn trailing_zeros(self) -> u32;
 }
 
 pub trait Unsigned<T>: Integer<T> {}
@@ -37,9 +37,8 @@ macro_rules! integer {
             const TEN: $t = 10;
 
             #[inline]
-            #[allow(trivial_numeric_casts)]
-            fn trailing_zeros(self) -> $t {
-                <$t>::trailing_zeros(self) as $t
+            fn trailing_zeros(self) -> u32 {
+                <$t>::trailing_zeros(self)
             }
         }
     )*)

src/util/math.rs

@@ -53,7 +53,7 @@ impl<T: Integer<T>> IntegerMathOps<T> for T {
                 c = (c * b) % m;
             }
             b = (b * b) % m;
-            e = e >> T::ONE;
+            e = e >> 1;
         }
 
         c

src/util/parse.rs

@@ -105,16 +105,15 @@ fn try_unsigned<T: Unsigned<T>>(bytes: &mut Bytes<'_>) -> Option<T> {
         }
     };
 
-    loop {
-        let Some(byte) = bytes.next() else { break Some(n) };
+    for byte in bytes {
         let digit = byte.to_decimal();
-
-        if digit < 10 {
-            n = T::TEN * n + T::from(digit);
-        } else {
-            break Some(n);
+        if digit >= 10 {
+            break;
         }
+        n = T::TEN * n + T::from(digit);
     }
+
+    Some(n)
 }
 
 fn try_signed<T: Signed<T>>(bytes: &mut Bytes<'_>) -> Option<T> {
@@ -130,16 +129,13 @@ fn try_signed<T: Signed<T>>(bytes: &mut Bytes<'_>) -> Option<T> {
         }
     };
 
-    loop {
-        let Some(byte) = bytes.next() else {
-            break Some(if negative { -n } else { n });
-        };
+    for byte in bytes {
         let digit = byte.to_decimal();
-
-        if digit < 10 {
-            n = T::TEN * n + T::from(digit);
-        } else {
-            break Some(if negative { -n } else { n });
+        if digit >= 10 {
+            break;
         }
+        n = T::TEN * n + T::from(digit);
     }
+
+    Some(if negative { -n } else { n })
 }

src/util/thread.rs

@@ -87,7 +87,7 @@ impl<'a, T> Iterator for ParIter<'a, T> {
 
                     (size > 0).then_some((other, current, size))
                 })
-                .max_by_key(|t| t.2);
+                .max_by_key(|&(_, _, size)| size);
 
             if let Some((other, current, size)) = available {
                 // Split the work items into two roughly equal piles.

src/year2016/day06.rs

@@ -18,9 +18,9 @@ pub fn parse(input: &str) -> Input {
             input.iter().skip(offset).step_by(stride).for_each(|&b| freq[to_index(b)] += 1);
 
             let (max, _) =
-                freq.iter().enumerate().filter(|(_, f)| **f > 0).max_by_key(|(_, f)| **f).unwrap();
+                freq.iter().enumerate().filter(|&(_, &f)| f > 0).max_by_key(|&(_, &f)| f).unwrap();
             let (min, _) =
-                freq.iter().enumerate().filter(|(_, f)| **f > 0).min_by_key(|(_, f)| **f).unwrap();
+                freq.iter().enumerate().filter(|&(_, &f)| f > 0).min_by_key(|&(_, &f)| f).unwrap();
 
             (to_char(max), to_char(min))
         })

src/year2017/day07.rs

@@ -60,7 +60,7 @@ pub fn parse(input: &str) -> Input<'_> {
     }
 
     // The root is the only node without a parent.
-    let part_one = indices.iter().find(|(_, v)| !nodes[**v].has_parent).unwrap().0;
+    let part_one = indices.iter().find(|&(_, &v)| !nodes[v].has_parent).unwrap().0;
     let mut part_two = 0;
 
     while let Some(index) = todo.pop_front() {