refactor(01/2016): improve readability

Author: manhunto

src/solutions/year2016/day01.rs

@@ -1,6 +1,7 @@
 use crate::solutions::Solution;
 use crate::utils::direction::Direction;
 use crate::utils::point::Point;
+use crate::utils::rotation::Rotation;
 use crate::utils::vector::Vector;
 use std::collections::HashSet;
 
@@ -12,12 +13,7 @@ impl Solution for Day01 {
         let mut vector = Vector::new(start, Direction::North);
 
         self.parse(input.trim()).for_each(|(rotation, distance)| {
-            vector = match rotation {
-                RotationDirection::Right => vector.rotate_cw(),
-                RotationDirection::Left => vector.rotate_ccw(),
-            };
-
-            vector = vector.forward_with_length(distance);
+            vector = vector.rotate(rotation).forward_with_length(distance);
         });
 
         vector.position().manhattan_distance(&start).to_string()
@@ -31,38 +27,27 @@ impl Solution for Day01 {
         visited.insert(start);
 
         'outer: for (rotation, distance) in self.parse(input.trim()) {
-            vector = match rotation {
-                RotationDirection::Right => vector.rotate_cw(),
-                RotationDirection::Left => vector.rotate_ccw(),
-            };
+            vector = vector.rotate(rotation);
 
             for _ in 0..distance {
                 vector = vector.forward();
 
-                let position = vector.position();
-                if visited.contains(&position) {
+                if !visited.insert(vector.position()) {
                     break 'outer;
                 }
-
-                visited.insert(position);
             }
         }
 
         vector.position().manhattan_distance(&start).to_string()
     }
 }
 
-enum RotationDirection {
-    Right,
-    Left,
-}
-
 impl Day01 {
-    fn parse<'a>(&self, input: &'a str) -> impl Iterator<Item = (RotationDirection, isize)> + 'a {
+    fn parse<'a>(&self, input: &'a str) -> impl Iterator<Item = (Rotation, isize)> + 'a {
         input.split(", ").map(|instruction| {
             let rotation = match &instruction[0..1] {
-                "R" => RotationDirection::Right,
-                "L" => RotationDirection::Left,
+                "R" => Rotation::Clockwise,
+                "L" => Rotation::CounterClockwise,
                 _ => unreachable!(),
             };
 

src/utils/mod.rs

@@ -15,6 +15,7 @@ pub mod point;
 pub mod point3d;
 pub mod polygon;
 pub mod range;
+pub mod rotation;
 pub mod shoelace_formula;
 pub mod surface_range;
 pub mod traits;

src/utils/rotation.rs

@@ -0,0 +1,4 @@
+pub enum Rotation {
+    Clockwise,
+    CounterClockwise,
+}

src/utils/vector.rs

@@ -1,5 +1,6 @@
 use crate::utils::direction::Direction;
 use crate::utils::point::Point;
+use crate::utils::rotation::Rotation;
 use std::fmt::{Display, Formatter};
 
 #[derive(Debug, PartialEq, Eq, Clone, Hash, Copy, PartialOrd, Ord)]
@@ -21,33 +22,48 @@ impl Vector {
         self.facing
     }
 
+    #[inline]
     pub fn forward(&self) -> Self {
         Self::new(self.position.move_in(self.facing), self.facing)
     }
 
+    #[inline]
     pub fn forward_with_length(&self, length: isize) -> Self {
         Self::new(
             self.position.move_in_with_length(self.facing, length),
             self.facing,
         )
     }
 
+    #[inline]
     pub fn backward(&self) -> Self {
         Self::new(self.position.move_in(self.facing.opposite()), self.facing)
     }
 
-    pub fn rotate(&self, facing: Direction) -> Self {
+    #[inline]
+    pub fn rotate(&self, rotation: Rotation) -> Self {
+        match rotation {
+            Rotation::Clockwise => self.rotate_cw(),
+            Rotation::CounterClockwise => self.rotate_ccw(),
+        }
+    }
+
+    #[inline]
+    pub fn rotate_to_direction(&self, facing: Direction) -> Self {
         Self::new(self.position, facing)
     }
 
+    #[inline]
     pub fn rotate_cw(&self) -> Self {
         Self::new(self.position, self.facing.cw())
     }
 
+    #[inline]
     pub fn rotate_ccw(&self) -> Self {
         Self::new(self.position, self.facing.ccw())
     }
 
+    #[inline]
     pub fn opposite(&self) -> Self {
         Self::new(self.position, self.facing.opposite())
     }