Talk about Day 15

Author: ochsnerd

src/day15.rs

@@ -6,22 +6,19 @@ use crate::{
 };
 
 pub fn solve(input: &str) -> (usize, usize) {
-    let (mut warehouse, movements) = parse(input);
-    let mut warehouse2 = warehouse.clone().into_part2();
-    (
-        part1(&mut warehouse, &movements),
-        part2(&mut warehouse2, &movements),
-    )
+    let (warehouse, movements) = parse(input);
+    let warehouse2 = warehouse.make_part2();
+    (part1(warehouse, &movements), part2(warehouse2, &movements))
 }
 
-fn part1(warehouse: &mut Warehouse, movements: &[Direction]) -> usize {
+fn part1(mut warehouse: Warehouse, movements: &[Direction]) -> usize {
     for &m in movements.into_iter() {
         warehouse.do_move(m)
     }
     warehouse.score()
 }
 
-fn part2(warehouse: &mut Warehouse2, movements: &[Direction]) -> usize {
+fn part2(mut warehouse: Warehouse2, movements: &[Direction]) -> usize {
     for &m in movements.into_iter() {
         warehouse.do_move(m)
     }
@@ -100,14 +97,14 @@ impl Warehouse {
             .sum()
     }
 
-    fn into_part2(self) -> Warehouse2 {
+    fn make_part2(&self) -> Warehouse2 {
         Warehouse2 {
             robot: self.robot.scaled_x(2),
             map: Grid::new(
                 (self.map.size.0 * 2, self.map.size.1),
                 self.map
                     .elements
-                    .into_iter()
+                    .iter()
                     .flat_map(|t| match t {
                         Thing::Wall => [Thing2::Wall, Thing2::Wall],
                         Thing::Box => [Thing2::BoxLeft, Thing2::BoxRight],
@@ -219,15 +216,13 @@ impl fmt::Display for Warehouse2 {
         write!(
             f,
             "{}",
-            self.map.display(
-                |i| if i == robot { Some('@') } else { None },
-                |t| match t {
-                    Thing2::Wall => '#',
-                    Thing2::BoxLeft => '[',
-                    Thing2::BoxRight => ']',
-                    Thing2::Floor => '.',
-                }
-            )
+            self.map.display(|t, i| match (t, i) {
+                (_, i) if i == robot => '@',
+                (Thing2::Wall, _) => '#',
+                (Thing2::BoxLeft, _) => '[',
+                (Thing2::BoxRight, _) => ']',
+                (Thing2::Floor, _) => '.',
+            })
         )?;
 
         Ok(())

src/grid.rs

@@ -126,12 +126,11 @@ impl<T> Grid<T> {
         dyadic(self.size, monadic)
     }
 
-    pub fn display<'a, O, M>(&'a self, overlay: O, mapping: M) -> GridDisplayer<'a, M, O, T>
+    pub fn display<'a, M>(&'a self, mapping: M) -> GridDisplayer<'a, M, T>
     where
-        O: Fn(Index) -> Option<char>,
-        M: Fn(&T) -> char,
+        M: Fn(&T, Index) -> char,
     {
-        GridDisplayer::new(mapping, overlay, &self)
+        GridDisplayer::new(mapping, &self)
     }
 }
 
@@ -163,40 +162,33 @@ impl<M: FnMut(char) -> Result<T, GridParseError>, T> GridParser<M> {
     }
 }
 
-pub struct GridDisplayer<'a, M, O, T> {
+pub struct GridDisplayer<'a, M, T> {
     mapping: M,
-    overlay: O,
     grid: &'a Grid<T>,
 }
 
-impl<'a, M, O, T> GridDisplayer<'a, M, O, T>
+impl<'a, M, T> GridDisplayer<'a, M, T>
 where
-    M: Fn(&T) -> char,
-    O: Fn(Index) -> Option<char>,
+    M: Fn(&T, Index) -> char,
 {
-    pub fn new(mapping: M, overlay: O, grid: &'a Grid<T>) -> Self {
-        Self {
-            mapping,
-            overlay,
-            grid,
-        }
+    pub fn new(mapping: M, grid: &'a Grid<T>) -> Self {
+        Self { mapping, grid }
     }
 }
 
-impl<'a, M, O, T> fmt::Display for GridDisplayer<'a, M, O, T>
+impl<'a, M, T> fmt::Display for GridDisplayer<'a, M, T>
 where
     // I would like to have this a FnMut (as it is Map),
     // but the fmt::Display-interface forbids that
-    M: Fn(&T) -> char,
-    O: Fn(Index) -> Option<char>,
+    M: Fn(&T, Index) -> char,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         for row in self.grid.iter_indices_by_rows().into_iter() {
             writeln!(
                 f,
                 "{}",
                 row.into_iter()
-                    .map(|i| ((self.overlay)(i)).unwrap_or_else(|| (self.mapping)(&self.grid[i])))
+                    .map(|i| (self.mapping)(&self.grid[i], i))
                     .collect::<String>()
             )?;
         }