clippy nursery 🍼 (almost)

Author: rene-d

2018/day1/day1.rs

@@ -7,8 +7,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle {
+    const fn new() -> Self {
+        Self {
             data: String::new(),
         }
     }

2018/day10/day10.rs

@@ -11,8 +11,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle {
+    const fn new() -> Self {
+        Self {
             pos: vec![],
             vel: vec![],
             message: String::new(),
@@ -113,7 +113,7 @@ impl Puzzle {
     }
 
     /// Solve part two.
-    fn part2(&self) -> u32 {
+    const fn part2(&self) -> u32 {
         self.seconds
     }
 }

2018/day11/day11.rs

@@ -5,8 +5,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle { serial_number: 0 }
+    const fn new() -> Self {
+        Self { serial_number: 0 }
     }
 
     /// Get the puzzle input.

2018/day12/day12.rs

@@ -8,8 +8,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle {
+    fn new() -> Self {
+        Self {
             state: String::new(),
             rules: HashSet::new(),
         }
@@ -23,14 +23,14 @@ impl Puzzle {
             if let Some(state) = line.strip_prefix("initial state: ") {
                 self.state = state.to_string();
             } else if let Some(from) = line.strip_suffix(" => #") {
-                self.rules.insert(Vec::from_iter(from.chars()));
+                self.rules.insert(from.chars().collect::<Vec<_>>());
             }
         }
     }
 
     /// Solve part one.
     fn part1(&self) -> i32 {
-        let mut state = Vec::from_iter(self.state.chars());
+        let mut state = self.state.chars().collect::<Vec<_>>();
 
         let mut pots = 0;
 
@@ -76,7 +76,7 @@ impl Puzzle {
 
     /// Solve part two.
     fn part2(&self) -> i64 {
-        let mut state = Vec::from_iter(self.state.chars());
+        let mut state = self.state.chars().collect::<Vec<_>>();
 
         let mut score = 0;
         let mut pots = 0;

2018/day13/day13.rs

@@ -32,8 +32,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle {
+    fn new() -> Self {
+        Self {
             verbose: false,
             grid: Grid::new(),
             carts: vec![],

2018/day14/day14.rs

@@ -48,7 +48,7 @@ fn appear(recipes: &str) -> usize {
 
     let score: Vec<u8> = recipes
         .chars()
-        .map(|c| c.to_digit(10).unwrap() as u8)
+        .map(|c| u8::try_from(c.to_digit(10).unwrap()).unwrap())
         .collect();
 
     let score = score.as_slice();
@@ -85,8 +85,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle {
+    const fn new() -> Self {
+        Self {
             recipes: String::new(),
         }
     }
@@ -95,7 +95,7 @@ impl Puzzle {
     fn configure(&mut self, path: &str) {
         let data = std::fs::read_to_string(path).unwrap();
 
-        self.recipes = data.trim().to_owned();
+        data.trim().clone_into(&mut self.recipes);
     }
 
     /// Solve part one.

2018/day15/day15.rs

@@ -100,9 +100,7 @@ fn next_pos(
         if target_adj.contains(&(x, y)) {
             min_path = min_path.min(steps);
             pos.push(e);
-        } else if !visited.contains(&(x, y)) {
-            visited.insert((x, y));
-
+        } else if visited.insert((x, y)) {
             q.extend(
                 adjacent(x, y)
                     .iter()
@@ -138,8 +136,8 @@ fn has_elves_and_goblins(units: &[Unit]) -> bool {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle {
+    fn new() -> Self {
+        Self {
             wall: HashSet::new(),
             units: vec![],
         }

2018/day16/day16.rs

@@ -40,8 +40,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle {
+    const fn new() -> Self {
+        Self {
             result1: 0,
             result2: 0,
         }
@@ -142,12 +142,12 @@ impl Puzzle {
     }
 
     /// Solve part one.
-    fn part1(&self) -> u32 {
+    const fn part1(&self) -> u32 {
         self.result1
     }
 
     /// Solve part two.
-    fn part2(&self) -> u32 {
+    const fn part2(&self) -> u32 {
         self.result2
     }
 }

2018/day17/day17.rs

@@ -21,17 +21,17 @@ struct Point {
 }
 
 impl Point {
-    fn go(&self, dir: &Dir) -> Self {
+    const fn go(&self, dir: &Dir) -> Self {
         match dir {
-            Dir::Right => Point {
+            Dir::Right => Self {
                 x: self.x + 1,
                 y: self.y,
             },
-            Dir::Left => Point {
+            Dir::Left => Self {
                 x: self.x - 1,
                 y: self.y,
             },
-            Dir::Down => Point {
+            Dir::Down => Self {
                 x: self.x,
                 y: self.y + 1,
             },
@@ -66,8 +66,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle {
+    fn new() -> Self {
+        Self {
             grid: HashMap::new(),
             ymin: 0,
             ymax: 0,
@@ -108,15 +108,15 @@ impl Puzzle {
 
         for y in 0..=self.ymax {
             for x in xmin..=xmax {
-                let c = match self.grid.get(&Point { x, y }) {
-                    Some(t) => match *t {
-                        CLAY => "\x1b[38;5;166m#\x1b[0m",
-                        SETTLE => "?",
-                        FLOW => "\x1b[94m|\x1b[0m",
-                        _ => "\x1b[96m~\x1b[0m",
-                    },
-                    _ => "\x1b[38;5;231m.\x1b[0m",
-                };
+                let c =
+                    self.grid
+                        .get(&Point { x, y })
+                        .map_or("\x1b[38;5;231m.\x1b[0m", |t| match *t {
+                            CLAY => "\x1b[38;5;166m#\x1b[0m",
+                            SETTLE => "?",
+                            FLOW => "\x1b[94m|\x1b[0m",
+                            _ => "\x1b[96m~\x1b[0m",
+                        });
                 print!("{c}");
             }
             println!();

2018/day18/day18.rs

@@ -88,8 +88,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle {
+    fn new() -> Self {
+        Self {
             area: grid![],
             n: 0,
         }