feat: Fancier traits

aoc_2025/src/day1.rs

@@ -1,4 +1,4 @@
-use crate::AoC;
+use crate::{AoC, Day, SimpleDay, WinnowDay};
 use winnow::{
     Parser, Result,
     ascii::{digit1, multispace0},
@@ -11,7 +11,9 @@ enum Side {
     Right(i64),
 }
 
-const AOC: AoC<Parsed> = AoC::new(parse, part1, part2);
+fn day() -> impl SimpleDay {
+    AoC::new(parse as _, part1 as _, part2 as _)
+}
 
 fn parse(input: String) -> Parsed {
     let mut input: &str = input.as_str();
@@ -34,7 +36,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 {
@@ -49,7 +51,7 @@ 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 {
@@ -77,7 +79,7 @@ mod tests {
 
     #[test]
     fn part1_test() {
-        AOC.assert1(
+        day().assert1(
             "L68
 L30
 R48
@@ -94,12 +96,12 @@ L82",
 
     #[test]
     fn part1_solve() {
-        AOC.assert1(include_str!("../input/day1.txt"), "982");
+        day().assert1(include_str!("../input/day1.txt"), "982");
     }
 
     #[test]
     fn part2_test() {
-        AOC.assert2(
+        day().assert2(
             "L68
 L30
 R48
@@ -116,6 +118,6 @@ L82",
 
     #[test]
     fn part2_solve() {
-        AOC.assert2(include_str!("../input/day1.txt"), "6106");
+        day().assert2(include_str!("../input/day1.txt"), "6106");
     }
 }

aoc_2025/src/day2.rs

@@ -1,4 +1,4 @@
-use crate::AoC;
+use crate::{AoC, Day, SimpleDay, WinnowDay};
 use winnow::{
     Parser, Result,
     ascii::digit1,
@@ -7,7 +7,9 @@ use winnow::{
 
 type Parsed = Vec<(u64, u64)>;
 
-const AOC: AoC<Parsed> = AoC::new(parse, part1, part2);
+fn day() -> impl SimpleDay {
+    AoC::new(parse as _, part1 as _, part2 as _)
+}
 
 fn parse(input: String) -> Parsed {
     let mut input: &str = input.as_str();
@@ -20,7 +22,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)| {
@@ -36,7 +38,7 @@ fn part1(input: &Parsed) -> String {
     format!("{res}")
 }
 
-fn part2(input: &Parsed) -> String {
+fn part2(input: Parsed) -> String {
     let res = input
         .iter()
         .map(|(from, to)| {
@@ -60,7 +62,7 @@ mod tests {
 
     #[test]
     fn part1_test() {
-        AOC.assert1(
+        day().assert1(
             "11-22,95-115,998-1012,1188511880-1188511890,222220-222224,1698522-1698528,446443-446449,38593856-38593862,565653-565659,824824821-824824827,2121212118-2121212124",
             "1227775554",
         );
@@ -68,12 +70,12 @@ mod tests {
 
     #[test]
     fn part1_solve() {
-        AOC.assert1(include_str!("../input/day2.txt"), "12599655151");
+        day().assert1(include_str!("../input/day2.txt"), "12599655151");
     }
 
     #[test]
     fn part2_test() {
-        AOC.assert2(
+        day().assert2(
             "11-22,95-115,998-1012,1188511880-1188511890,222220-222224,1698522-1698528,446443-446449,38593856-38593862,565653-565659,824824821-824824827,2121212118-2121212124",
             "4174379265",
         );
@@ -81,6 +83,6 @@ mod tests {
 
     #[test]
     fn part2_solve() {
-        AOC.assert2(include_str!("../input/day2.txt"), "20942028255");
+        day().assert2(include_str!("../input/day2.txt"), "20942028255");
     }
 }

aoc_2025/src/lib.rs

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

aoc_2025/src/template.rs

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