Refactor.

src/day1/mod.rs

@@ -27,15 +27,15 @@ fn process(lines: Vec::<String>) -> Result<u32, AdventError> {
     Ok(calibrations.iter().sum::<u32>())
 }
 
-pub fn one() -> Result<(), AdventError> {
+pub fn one() -> Result<u32, AdventError> {
     let lines: Vec<String> = read_into_vec::<String>(Path::new("resources/input1.txt"))?;
-    Ok(println!("{}", process(lines)?))
+    Ok(process(lines)?)
 }
 
 struct Mutation(usize, char);
 struct Pattern(&'static str, char);
 
-pub fn two() -> Result<(), AdventError> {
+pub fn two() -> Result<u32, AdventError> {
     let mut lines = read_into_vec(Path::new("resources/input1.txt"))?;
     
     let mut mutations = Vec::<Mutation>::new();
@@ -75,7 +75,7 @@ pub fn two() -> Result<(), AdventError> {
         
     }).collect();
 
-    Ok(println!("{}", process(new_lines)?))
+    Ok(process(new_lines)?)
 
 }
 

src/day2/mod.rs

@@ -78,7 +78,7 @@ struct Game {
 }
 
 
-pub fn one() -> Result<(), AdventError> {
+pub fn one() -> Result<u32, AdventError> {
     let games: Vec<Game> = read_into_vec(Path::new("resources/input2.txt"))?;
     let mut sum: u32 = 0;
 
@@ -100,10 +100,10 @@ pub fn one() -> Result<(), AdventError> {
         }
     }
 
-    Ok(println!("{}", sum))
+    Ok(sum)
 }
 
-pub fn two() -> Result<(), AdventError> {
+pub fn two() -> Result<u32, AdventError> {
     let games: Vec<Game> = read_into_vec(Path::new("resources/input2.txt"))?;
     let mut power: u32 = 0;
 
@@ -123,5 +123,5 @@ pub fn two() -> Result<(), AdventError> {
         power += max_nr_red * max_nr_green * max_nr_blue;
     }
 
-    Ok(println!("{}", power))
+    Ok(power)
 }

src/day3/mod.rs

@@ -179,7 +179,7 @@ fn filter_gears(rows: &mut Vec<RowInfo>) -> &mut Vec<RowInfo> {
     rows
 }
 
-pub fn one() -> Result<(), AdventError> {
+pub fn one() -> Result<u32, AdventError> {
     let rows = read_into_vec::<RowInfo>(Path::new("resources/input3.txt"))?;
     let mut sum: u32 = 0;
     for (i, row) in rows.iter().enumerate() {
@@ -196,11 +196,10 @@ pub fn one() -> Result<(), AdventError> {
             }
         }
     }
-    println!("{}", sum);
-    Ok(())
+    Ok(sum)
 }
 
-pub fn two() -> Result<(), AdventError> {
+pub fn two() -> Result<u32, AdventError> {
     let mut rows = read_into_vec::<RowInfo>(Path::new("resources/input3.txt"))?;
     rows = filter_gears(&mut rows).clone();
     let mut sum: u32 = 0;
@@ -229,7 +228,6 @@ pub fn two() -> Result<(), AdventError> {
             }
         }
     }
-    println!("{}", sum);
 
-    Ok(())
+    Ok(sum)
 }

src/day4/mod.rs

@@ -0,0 +1,26 @@
+use std::{collections::HashSet, path::Path, str::FromStr};
+
+use crate::input::{AdventError, read_into_vec};
+
+impl FromStr for ScratchGame {
+    type Err = AdventError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        todo!()
+    }
+}
+
+struct ScratchGame {
+    id: i32,
+    my_numbers: HashSet<i32>,
+    winning_numbers: HashSet<i32>
+}
+
+pub fn one() -> Result<u32, AdventError> {
+    let games = read_into_vec::<ScratchGame>(Path::new("resources/input4.txt"));
+    Ok(0)
+}
+
+pub fn two() -> Result<u32, AdventError> {
+    Ok(0)
+}

src/main.rs

@@ -1,16 +1,40 @@
 pub mod input;
 
-pub mod one;
-pub mod two;
-pub mod three;
+pub mod day1;
+pub mod day2;
+pub mod day3;
+pub mod day4;
+
+use std::{env};
 
 use input::AdventError;
 
 fn main() -> Result<(), AdventError> {
-    one::one()?;
-    one::two()?;
-    two::one()?;
-    two::two()?;
-    three::one()?;
-    Ok(three::two()?)
+    let days = vec![
+        (day1::one as fn() -> Result<u32, AdventError>, day1::two as fn() -> Result<u32, AdventError>),
+        (day2::one as fn() -> Result<u32, AdventError>, day2::two as fn() -> Result<u32, AdventError>),
+        (day3::one as fn() -> Result<u32, AdventError>, day3::two as fn() -> Result<u32, AdventError>),
+        (day4::one as fn() -> Result<u32, AdventError>, day4::two as fn() -> Result<u32, AdventError>),
+    ];
+
+    if env::args().len() != 3 {
+        Ok(days.into_iter().map(|(one, two)| {
+            let one_result = one()?;
+            let two_result = two()?;
+            Ok((one_result, two_result))
+        }).map(|r: Result<(u32, u32), AdventError>| {
+            match r {
+                Ok((res1, res2)) => println!("1: {} 2: {}", res1, res2),
+                Err(e) => println!("Error: {}", e.0)
+            };
+        }).fold((), |acc, _| { acc }))
+    } else {
+        let (one, two) = days[env::args().nth(1).ok_or(AdventError("Failed to parse day".into()))?.parse::<usize>()? - 1];
+        match env::args().nth(2).unwrap().parse::<usize>()? {
+            1 => Ok(println!("1: {}", one()?)),
+            2 => Ok(println!("2: {}", two()?)),
+            _ => return Err(AdventError("part must be either 1 or 2".into()))
+        }
+    }
+    
 }