Use anyhow to make try operator feasible in parse and part#.

2021/Cargo.lock

@@ -6,10 +6,17 @@ version = 3
 name = "advent2021"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "aoc-runner",
  "aoc-runner-derive",
 ]
 
+[[package]]
+name = "anyhow"
+version = "1.0.51"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b26702f315f53b6071259e15dd9d64528213b44d61de1ec926eca7715d62203"
+
 [[package]]
 name = "aoc-runner"
 version = "0.3.0"

2021/Cargo.toml

@@ -6,5 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+anyhow = "1.0.45"
 aoc-runner = "0.3.0"
 aoc-runner-derive = "0.3.0"

2021/src/day1.rs

@@ -73,36 +73,34 @@
 //!
 //! Consider sums of a three-measurement sliding window. How many sums are larger than the previous sum?
 
+use anyhow::Result;
 use aoc_runner_derive::{aoc, aoc_generator};
 
-/// Reads text file containing one integer per line, and parses them into `Vec<u32>`.  Any
-/// non-number will result in a panice.
+/// Reads text file containing one integer per line, and parses them into `Vec<u32>`.  
 #[aoc_generator(day1)]
-fn parse(input: &str) -> Vec<u32> {
-    input
-        .split("\n")
-        .map(|s| s.parse().expect("not a number"))
-        .collect()
+fn parse(input: &str) -> Result<Vec<u32>> {
+    input.split("\n").map(|s| Ok(s.parse()?)).collect()
 }
 
 #[aoc(day1, part1)]
-fn part1(depths: &[u32]) -> u32 {
-    depths
+fn part1(depths: &[u32]) -> Result<u32> {
+    Ok(depths
         .windows(2)
         .map(|s| if s[0] < s[1] { 1 } else { 0 })
-        .sum()
+        .sum())
 }
 
 #[aoc(day1, part2)]
-fn part2(depths: &[u32]) -> u32 {
+fn part2(depths: &[u32]) -> Result<u32> {
     let sums: Vec<u32> = depths.windows(3).map(|s| s.iter().sum()).collect();
-    sums.windows(2)
+    Ok(sums
+        .windows(2)
         .map(|s| if s[0] < s[1] { 1 } else { 0 })
-        .sum()
+        .sum())
 }
 
 #[test]
-fn test_part1() {
+fn test_part1() -> Result<()> {
     assert_eq!(
         part1(&parse(
             r#"199
@@ -115,13 +113,14 @@ fn test_part1() {
 269
 260
 263"#
-        )),
+        )?)?,
         7
     );
+    Ok(())
 }
 
 #[test]
-fn test_part2() {
+fn test_part2() -> Result<()> {
     assert_eq!(
         part2(&parse(
             r#"199
@@ -134,7 +133,8 @@ fn test_part2() {
 269
 260
 263"#
-        )),
+        )?)?,
         5
     );
+    Ok(())
 }

2021/src/day2.rs

@@ -52,49 +52,50 @@
 //!
 //! Using this new interpretation of the commands, calculate the horizontal position and depth you would have after following the planned course. What do you get if you multiply your final horizontal position by your final depth?
 
+use anyhow::Result;
 use aoc_runner_derive::{aoc, aoc_generator};
 
 #[aoc(day2, part1)]
-fn part1(input: &str) -> i32 {
+fn part1(input: &str) -> Result<i32> {
     let mut horizontal: i32 = 0;
     let mut depth: i32 = 0;
-    input.split("\n").for_each(|l| {
+    for l in input.split("\n") {
         let p: Vec<_> = l.split(" ").collect();
 
         match p[0] {
-            "forward" => horizontal += p[1].parse::<i32>().expect("forward"),
-            "up" => depth -= p[1].parse::<i32>().expect("up"),
-            "down" => depth += p[1].parse::<i32>().expect("down"),
+            "forward" => horizontal += p[1].parse::<i32>()?,
+            "up" => depth -= p[1].parse::<i32>()?,
+            "down" => depth += p[1].parse::<i32>()?,
             _ => panic!("unknown command {}", p[0]),
         }
-    });
-    horizontal * depth
+    }
+    Ok(horizontal * depth)
 }
 
 #[aoc(day2, part2)]
-fn part2(input: &str) -> i32 {
+fn part2(input: &str) -> Result<i32> {
     let mut horizontal: i32 = 0;
     let mut depth: i32 = 0;
     let mut aim: i32 = 0;
-    input.split("\n").for_each(|l| {
+    for l in input.split("\n") {
         let p: Vec<_> = l.split(" ").collect();
 
         match p[0] {
             "forward" => {
-                let v = p[1].parse::<i32>().expect("forward");
+                let v = p[1].parse::<i32>()?;
                 horizontal += v;
                 depth += v * aim;
             }
-            "up" => aim -= p[1].parse::<i32>().expect("up"),
-            "down" => aim += p[1].parse::<i32>().expect("down"),
+            "up" => aim -= p[1].parse::<i32>()?,
+            "down" => aim += p[1].parse::<i32>()?,
             _ => panic!("unknown command {}", p[0]),
         }
-    });
-    horizontal * depth
+    }
+    Ok(horizontal * depth)
 }
 
 #[test]
-fn test_part1() {
+fn test_part1() -> Result<()> {
     let input = r#"
 forward 5
 down 5
@@ -104,11 +105,12 @@ down 8
 forward 2
 "#
     .trim();
-    assert_eq!(part1(input), 150);
+    assert_eq!(part1(input)?, 150);
+    Ok(())
 }
 
 #[test]
-fn test_part2() {
+fn test_part2() -> Result<()> {
     let input = r#"
 forward 5
 down 5
@@ -118,5 +120,6 @@ down 8
 forward 2
 "#
     .trim();
-    assert_eq!(part2(input), 900);
+    assert_eq!(part2(input)?, 900);
+    Ok(())
 }

2021/src/template.rs

@@ -1,36 +1,42 @@
+use anyhow::Result;
 use aoc_runner_derive::{aoc, aoc_generator};
 
 #[aoc_generator(dayX)]
-fn parse(input: &str) -> Vec<u32> {
-    todo!("parse")
+fn parse(input: &str) -> Result<Vec<u32>> {
+    todo!("parse");
+    Ok(Vec::new())
 }
 
 #[aoc(dayX, part1)]
-fn part1(depths: &[u32]) -> u32 {
-    todo!("part1")
+fn part1(depths: &[u32]) -> Result<u32> {
+    todo!("part1");
+    Ok(())
 }
 
 /*
 #[aoc(dayX, part2)]
-fn part2(depths: &[u32]) -> u32 {
+fn part2(depths: &[u32]) -> Result<u32> {
     todo!("part2")
+    Ok(())
 }
 */
 
 #[test]
-fn test_part1() {
+fn test_part1() -> Result<()> {
     let input = r#"
 "#
     .trim();
-    assert_eq!(part1(&parse(input)), TODO);
+    assert_eq!(part1(&parse(input)?)?, TODO);
+    Ok(())
 }
 
 /*
 #[test]
-fn test_part2() {
+fn test_part2()->Result<()> {
     let input = r#"
 "#
     .trim();
-    assert_eq!(part2(&parse(input)), TODO);
+    assert_eq!(part2(&parse(input)?)?, TODO);
+Ok(())
 }
 */