Jan/AoC
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: Fancier traits

Browse Source
This commit is contained in:
Jan-Bulthuis 2025-12-03 23:04:50 +01:00
parent 3740d93f81
commit 22fc3511b7
4 changed files with 116 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
aoc_2025/src/day1.rs
View File

@ -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");
}
}

18
aoc_2025/src/day2.rs
View File

@ -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");
}
}

93
aoc_2025/src/lib.rs
View File

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

34
aoc_2025/src/template.rs
View File

@ -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 parse(input: String) -> Parsed {
let mut input: &str = input.as_str();
String::new()
fn day() -> impl WinnowDay {
AoC::new(parse as _, part1 as _, part2 as _)
}
fn part1(input: &Parsed) -> String {
let res = 0;
format!("{res}")
type Parsed = ();
fn parse(input: &mut &str) -> Result<Parsed> {
"".map(|_| ()).parse_next(input)
}
fn part2(input: &Parsed) -> String {
let res = 0;
format!("{res}")
fn part1(input: Parsed) -> usize {
0
}
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"), "");
// }
}