aoc_2025/src/day1.rs

@@ -1,4 +1,4 @@
-use crate::{AoC, SimpleDay};
+use crate::AoC;
 use winnow::{
     Parser, Result,
     ascii::{digit1, multispace0},
@@ -11,9 +11,7 @@ enum Side {
     Right(i64),
 }
 
-fn day() -> impl SimpleDay {
+const AOC: AoC<Parsed> = AoC::new(parse, part1, part2);
-    AoC::new(parse as _, part1 as _, part2 as _)
-}
 
 fn parse(input: String) -> Parsed {
     let mut input: &str = input.as_str();
@@ -36,7 +34,7 @@ fn parse_right(input: &mut &str) -> Result<Side> {
         .parse_next(input)
 }
 
-fn part1(input: Parsed) -> String {
+fn part1(input: &Parsed) -> String {
     let mut res = 0;
     let mut pos = 50i64;
     for change in input {
@@ -51,12 +49,12 @@ fn part1(input: Parsed) -> String {
     format!("{res}")
 }
 
-fn part2(input: Parsed) -> String {
+fn part2(input: &Parsed) -> String {
     let input = input
         .iter()
         .flat_map(|side| match side {
-            Side::Left(dx) => (0..*dx).map(|_| Side::Left(1)).collect::<Vec<Side>>(),
+            Side::Left(dx) => (0..*dx).map(|i| Side::Left(1)).collect::<Vec<Side>>(),
-            Side::Right(dx) => (0..*dx).map(|_| Side::Right(1)).collect::<Vec<Side>>(),
+            Side::Right(dx) => (0..*dx).map(|i| Side::Right(1)).collect::<Vec<Side>>(),
         })
         .collect::<Vec<Side>>();
     let mut res = 0;
@@ -75,13 +73,11 @@ fn part2(input: Parsed) -> String {
 
 #[cfg(test)]
 mod tests {
-    use crate::Day;
-
     use super::*;
 
     #[test]
     fn part1_test() {
-        day().assert1(
+        AOC.assert1(
             "L68
 L30
 R48
@@ -98,12 +94,12 @@ L82",
 
     #[test]
     fn part1_solve() {
-        day().assert1(include_str!("../input/day1.txt"), "982");
+        AOC.assert1(include_str!("../input/day1.txt"), "982");
     }
 
     #[test]
     fn part2_test() {
-        day().assert2(
+        AOC.assert2(
             "L68
 L30
 R48
@@ -120,6 +116,6 @@ L82",
 
     #[test]
     fn part2_solve() {
-        day().assert2(include_str!("../input/day1.txt"), "6106");
+        AOC.assert2(include_str!("../input/day1.txt"), "6106");
     }
 }

aoc_2025/src/day2.rs

@@ -1,4 +1,4 @@
-use crate::{AoC, SimpleDay};
+use crate::AoC;
 use winnow::{
     Parser, Result,
     ascii::digit1,
@@ -7,9 +7,7 @@ use winnow::{
 
 type Parsed = Vec<(u64, u64)>;
 
-fn day() -> impl SimpleDay {
+const AOC: AoC<Parsed> = AoC::new(parse, part1, part2);
-    AoC::new(parse as _, part1 as _, part2 as _)
-}
 
 fn parse(input: String) -> Parsed {
     let mut input: &str = input.as_str();
@@ -22,7 +20,7 @@ fn parse_range(input: &mut &str) -> Result<(u64, u64)> {
     separated_pair(digit1.parse_to(), "-", digit1.parse_to()).parse_next(input)
 }
 
-fn part1(input: Parsed) -> String {
+fn part1(input: &Parsed) -> String {
     let res = input
         .iter()
         .map(|(from, to)| {
@@ -38,13 +36,13 @@ fn part1(input: Parsed) -> String {
     format!("{res}")
 }
 
-fn part2(input: Parsed) -> String {
+fn part2(input: &Parsed) -> String {
     let res = input
         .iter()
         .map(|(from, to)| {
             (*from..=*to)
                 .filter(|i| {
-                    let n = i.ilog10() + 1;
+                    let n = (i.ilog10() + 1);
                     (1..=(n >> 1)).filter(|p| n % p == 0).any(|p| {
                         (1..(n / p))
                             .all(|s| i % 10u64.pow(p) == (i / 10u64.pow(p * s)) % 10u64.pow(p))
@@ -58,13 +56,11 @@ fn part2(input: Parsed) -> String {
 
 #[cfg(test)]
 mod tests {
-    use crate::Day;
-
     use super::*;
 
     #[test]
     fn part1_test() {
-        day().assert1(
+        AOC.assert1(
             "11-22,95-115,998-1012,1188511880-1188511890,222220-222224,1698522-1698528,446443-446449,38593856-38593862,565653-565659,824824821-824824827,2121212118-2121212124",
             "1227775554",
         );
@@ -72,12 +68,12 @@ mod tests {
 
     #[test]
     fn part1_solve() {
-        day().assert1(include_str!("../input/day2.txt"), "12599655151");
+        AOC.assert1(include_str!("../input/day2.txt"), "12599655151");
     }
 
     #[test]
     fn part2_test() {
-        day().assert2(
+        AOC.assert2(
             "11-22,95-115,998-1012,1188511880-1188511890,222220-222224,1698522-1698528,446443-446449,38593856-38593862,565653-565659,824824821-824824827,2121212118-2121212124",
             "4174379265",
         );
@@ -85,6 +81,6 @@ mod tests {
 
     #[test]
     fn part2_solve() {
-        day().assert2(include_str!("../input/day2.txt"), "20942028255");
+        AOC.assert2(include_str!("../input/day2.txt"), "20942028255");
     }
 }

aoc_2025/src/day3.rs

@@ -1,102 +0,0 @@
-use std::iter::Sum;
-
-use crate::{AoC, WinnowDay};
-use winnow::{
-    Parser, Result,
-    ascii::newline,
-    combinator::{repeat, terminated},
-    error::ContextError,
-    token::one_of,
-};
-
-fn day() -> impl WinnowDay {
-    AoC::new(parse as _, part1 as _, part2 as _)
-}
-
-fn parse(input: &mut &str) -> Result<Vec<Vec<usize>>> {
-    repeat(1.., parse_line).parse_next(input)
-}
-
-fn parse_line(input: &mut &str) -> Result<Vec<usize>, ContextError> {
-    terminated(
-        repeat(
-            1..,
-            one_of(('0'..='9',)).map(|c: char| c.to_string().parse::<usize>().unwrap()),
-        ),
-        newline,
-    )
-    .parse_next(input)
-}
-
-fn part1(input: Vec<Vec<usize>>) -> usize {
-    input.iter().map(joltage(2)).sum()
-}
-
-fn part2(input: Vec<Vec<usize>>) -> usize {
-    input.iter().map(joltage(12)).sum()
-}
-
-fn joltage<
-    'a,
-    B: IntoIterator<IntoIter = I> + Copy,
-    I: ExactSizeIterator<Item = &'a N>,
-    N: Sum<&'a N> + Into<usize> + From<usize> + Copy + Default + 'a,
->(
-    size: usize,
-) -> impl Fn(B) -> N {
-    move |line| {
-        (line.into_iter().len() - size..line.into_iter().len())
-            .fold((0, 0), |(start, val), end| {
-                line.into_iter()
-                    .enumerate()
-                    .skip(start)
-                    .take(end - start + 1)
-                    .map(|(i, v)| (i + 1, (*v).into() + val * 10))
-                    .reduce(|a, b| if a.1 >= b.1 { a } else { b })
-                    .unwrap()
-            })
-            .1
-            .into()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::Day;
-
-    use super::*;
-
-    #[test]
-    fn part1_test() {
-        day().assert1(
-            "987654321111111
-811111111111119
-234234234234278
-818181911112111
-",
-            "357",
-        );
-    }
-
-    #[test]
-    fn part1_solve() {
-        day().assert1(include_str!("../input/day3.txt"), "17343");
-    }
-
-    #[test]
-    fn part2_test() {
-        day().assert2(
-            "987654321111111
-811111111111119
-234234234234278
-818181911112111
-",
-            "3121910778619",
-        );
-    }
-
-    #[test]
-    fn part2_solve() {
-        day().assert2(include_str!("../input/day3.txt"), "172664333119298");
-    }
-}

aoc_2025/src/lib.rs

@@ -1,97 +1,36 @@
 #![allow(dead_code)]
+#![allow(unused)]
 
-use std::fmt::{Debug, Display};
-
-use winnow::Parser;
-
-mod day1;
 mod day2;
-mod day3;
 
-trait Day {
+struct AoC<T> {
-    fn assert1(&self, input: &str, output: &str);
+    parse: fn(String) -> T,
-    fn assert2(&self, input: &str, output: &str);
+    part1: fn(&T) -> String,
+    part2: fn(&T) -> String,
 }
 
-struct AoC<P, O1, O2> {
+impl<T> AoC<T> {
-    parse: P,
+    const fn new(parse: fn(String) -> T, part1: fn(&T) -> String, part2: fn(&T) -> String) -> Self {
-    part1: O1,
-    part2: O2,
-}
-
-impl<P, O1, O2> AoC<P, O1, O2> {
-    fn new(parse: P, part1: O1, part2: O2) -> Self {
         Self {
             parse,
             part1,
             part2,
         }
     }
-}
 
-trait SimpleDay: Day {}
-
-impl<P, O1, O2> SimpleDay for AoC<fn(String) -> P, fn(P) -> O1, fn(P) -> O2>
-where
-    O1: Display,
-    O2: Display,
-{
-}
-
-impl<P, O1, O2> Day for AoC<fn(String) -> P, fn(P) -> O1, fn(P) -> O2>
-where
-    O1: Display,
-    O2: Display,
-{
     fn assert1(&self, input: &str, output: &str) {
-        let parsed = (self.parse)(input.to_string());
+        let parsed = (self.parse)(input.into());
-        assert_eq!(format!("{}", (self.part1)(parsed)), output);
+        assert_eq!((self.part1)(&parsed), output);
     }
 
     fn assert2(&self, input: &str, output: &str) {
-        let parsed = (self.parse)(input.to_string());
+        let parsed = (self.parse)(input.into());
-        assert_eq!(format!("{}", (self.part2)(parsed)), output);
+        assert_eq!((self.part2)(&parsed), output);
-    }
-}
-
-trait WinnowDay: Day {}
-
-impl<O, E, O1, O2> WinnowDay
-    for AoC<for<'a, 'b> fn(&'a mut &'b str) -> Result<O, E>, fn(O) -> O1, fn(O) -> O2>
-where
-    E: Debug,
-    O1: Display,
-    O2: Display,
-{
-}
-
-fn as_parser<O, E>(
-    func: for<'a, 'b> fn(&'a mut &'b str) -> Result<O, E>,
-) -> impl for<'a> Parser<&'a str, O, E>
-where
-    E: Debug,
-{
-    func
-}
-
-impl<O, E, O1, O2> Day
-    for AoC<for<'a, 'b> fn(&'a mut &'b str) -> Result<O, E>, fn(O) -> O1, fn(O) -> O2>
-where
-    E: Debug,
-    O1: Display,
-    O2: Display,
-{
-    fn assert1(&self, input: &str, output: &str) {
-        let mut input = input;
-        let mut parser = as_parser(self.parse);
-        let parsed = parser.parse_next(&mut input).unwrap();
-        assert_eq!(format!("{}", (self.part1)(parsed)), output);
     }
 
-    fn assert2(&self, input: &str, output: &str) {
+    fn apply(&self, input: &str) {
-        let mut input = input;
+        let parsed = (self.parse)(input.into());
-        let mut parser = as_parser(self.parse);
+        println!("Part 1: {}", (self.part1)(&parsed));
-        let parsed = parser.parse_next(&mut input).unwrap();
+        println!("Part 2: {}", (self.part2)(&parsed));
-        assert_eq!(format!("{}", (self.part2)(parsed)), output);
     }
 }

aoc_2025/src/template.rs

@@ -1,48 +1,46 @@
+use crate::AoC;
 use winnow::{Parser, Result};
 
-use crate::{AoC, Day, SimpleDay, WinnowDay};
+type Parsed = String;
 
-fn day() -> impl WinnowDay {
+const AOC: AoC<Parsed> = AoC::new(parse, part1, part2);
-    AoC::new(parse as _, part1 as _, part2 as _)
+
+fn parse(input: String) -> Parsed {
+    let mut input: &str = input.as_str();
+    String::new()
 }
 
-type Parsed = ();
+fn part1(input: &Parsed) -> String {
-
+    let res = 0;
-fn parse(input: &mut &str) -> Result<Parsed> {
+    format!("{res}")
-    "".map(|_| ()).parse_next(input)
 }
 
-fn part1(input: Parsed) -> usize {
+fn part2(input: &Parsed) -> String {
-    0
+    let res = 0;
-}
+    format!("{res}")
-
-fn part2(input: Parsed) -> usize {
-    0
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::Day;
-
     use super::*;
 
     #[test]
     fn part1_test() {
-        day().assert1("", "");
+        AOC.assert1("", "");
     }
 
     #[test]
     fn part1_solve() {
-        day().assert1(include_str!("../input/day.txt"), "");
+        AOC.assert1(include_str!("../input/day1.txt"), "");
     }
 
     // #[test]
     // fn part2_test() {
-    //     day().assert2("", "");
+    //     AOC.assert2("", "");
     // }
 
     // #[test]
     // fn part2_solve() {
-    //     day().assert2(include_str!("../input/day.txt"), "");
+    //     AOC.assert2(include_str!("../input/day1.txt"), "");
     // }
 }