Tidy code

Author: maneatingape

Cargo.toml

@@ -246,7 +246,7 @@ ref_as_ptr = "warn"
 ref_binding_to_reference = "warn"
 ref_option = "warn"
 ref_option_ref = "warn"
-ref_patterns = "allow"
+ref_patterns = "warn"
 renamed_function_params = "warn"
 rest_pat_in_fully_bound_structs = "warn"
 return_and_then = "allow"

src/util/iter.rs

@@ -32,10 +32,8 @@ macro_rules! iterator {
 
             #[inline]
             fn next(&mut self) -> Option<Self::Item> {
-                Some([$({
-                    let $var = self.iter.next()?;
-                    $var
-                }),+])
+                $(let $var = self.iter.next()?;)+
+                Some([$($var),+])
             }
         }
     };

src/util/thread.rs

@@ -2,6 +2,7 @@
 //! [scoped](https://doc.rust-lang.org/stable/std/thread/fn.scope.html)
 //! threads equal to the number of cores on the machine. Unlike normal threads, scoped threads
 //! can borrow data from their environment.
+use std::iter::repeat_with;
 use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering::Relaxed};
 use std::thread::*;
 
@@ -17,13 +18,7 @@ where
     R: Send,
 {
     scope(|scope| {
-        let mut handles = Vec::new();
-
-        for _ in 0..threads() {
-            let handle = scope.spawn(f);
-            handles.push(handle);
-        }
-
+        let handles: Vec<_> = repeat_with(|| scope.spawn(f)).take(threads()).collect();
         handles.into_iter().flat_map(ScopedJoinHandle::join).collect()
     })
 }
@@ -54,13 +49,8 @@ where
     let workers = workers.as_slice();
 
     scope(|scope| {
-        let mut handles = Vec::new();
-
-        for id in 0..threads {
-            let handle = scope.spawn(move || f(ParIter { id, items, workers }));
-            handles.push(handle);
-        }
-
+        let handles: Vec<_> =
+            (0..threads).map(|id| scope.spawn(move || f(ParIter { id, items, workers }))).collect();
         handles.into_iter().flat_map(ScopedJoinHandle::join).collect()
     })
 }

src/year2016/day19.rs

@@ -91,15 +91,9 @@ pub fn parse(input: &str) -> u32 {
 }
 
 pub fn part1(input: &u32) -> u32 {
-    let mut elf = *input;
-
-    elf *= 2;
-    // Remove highest 1 bit.
-    elf -= 1 << elf.ilog2();
-    // Elves use 1-based indexing.
-    elf += 1;
-
-    elf
+    let n = *input * 2;
+    // Remove highest 1 bit, then add 1 for one-based indexing.
+    n - (1 << n.ilog2()) + 1
 }
 
 pub fn part2(input: &u32) -> u32 {

src/year2017/day20.rs

@@ -24,8 +24,8 @@ struct Vector {
 
 impl Vector {
     #[inline]
-    fn new(cs: [i32; 3]) -> Self {
-        Vector { x: cs[0], y: cs[1], z: cs[2] }
+    fn new([x, y, z]: [i32; 3]) -> Self {
+        Vector { x, y, z }
     }
 
     #[inline]
@@ -72,11 +72,11 @@ pub fn parse(input: &str) -> Vec<Particle> {
         .chunk::<3>()
         .chunk::<3>()
         .enumerate()
-        .map(|(id, cs)| Particle {
+        .map(|(id, [p, v, a])| Particle {
             id,
-            position: Vector::new(cs[0]),
-            velocity: Vector::new(cs[1]),
-            acceleration: Vector::new(cs[2]),
+            position: Vector::new(p),
+            velocity: Vector::new(v),
+            acceleration: Vector::new(a),
         })
         .collect()
 }

src/year2018/day04.rs

@@ -31,17 +31,17 @@ pub fn parse(input: &str) -> Input {
 
 /// Find the guard with the greatest total minutes asleep.
 pub fn part1(input: &Input) -> usize {
-    choose(input, |(_, m)| m.iter().sum())
+    choose(input, |m| m.iter().sum())
 }
 
 /// Find the guard with the highest single minute asleep.
 pub fn part2(input: &Input) -> usize {
-    choose(input, |(_, m)| *m.iter().max().unwrap())
+    choose(input, |m| *m.iter().max().unwrap())
 }
 
-fn choose(input: &Input, strategy: fn(&(&usize, &[u32; 60])) -> u32) -> usize {
+fn choose(input: &Input, strategy: impl Fn(&[u32; 60]) -> u32) -> usize {
     // Find the guard using a specific strategy.
-    let (id, minutes) = input.iter().max_by_key(strategy).unwrap();
+    let (id, minutes) = input.iter().max_by_key(|(_, m)| strategy(m)).unwrap();
     // Find the minute spent asleep the most.
     let (minute, _) = minutes.iter().enumerate().max_by_key(|&(_, &m)| m).unwrap();
     // Return the result.

src/year2018/day22.rs

@@ -109,8 +109,8 @@ pub fn part1(input: &Input) -> i32 {
 
 /// A* search for the shortest path to the target.
 pub fn part2(input: &Input) -> i32 {
-    let &Input { height, width, cave: ref erosion } = input;
-    let target = Point::new(width, height);
+    let erosion = &input.cave;
+    let target = Point::new(input.width, input.height);
 
     // Initialize bucket queue with pre-allocated capacity to reduce reallocations needed.
     let mut base = 0;
@@ -122,8 +122,8 @@ pub fn part2(input: &Input) -> i32 {
     // we implicitly disallow it during the A* search as the time to reach the square will
     // always be greater than zero.
     let mut cave = Grid::new(erosion.width, erosion.height, [i32::MAX; 3]);
-    for (i, level) in erosion.bytes.iter().enumerate() {
-        cave.bytes[i][*level as usize] = 0;
+    for (i, &level) in erosion.bytes.iter().enumerate() {
+        cave.bytes[i][level as usize] = 0;
     }
 
     // Start at origin with the torch equipped.

src/year2019/day02.rs

@@ -14,10 +14,9 @@ type Input = [i32; 3];
 
 pub fn parse(input: &str) -> Input {
     let code: Vec<_> = input.iter_unsigned().collect();
-
-    let c = check(&code, 0, 0) as i32;
-    let a = check(&code, 1, 0) as i32;
-    let b = check(&code, 0, 1) as i32;
+    let a = check(&code, 1, 0);
+    let b = check(&code, 0, 1);
+    let c = check(&code, 0, 0);
 
     [a - c, b - c, c]
 }
@@ -35,22 +34,18 @@ pub fn part2([a, b, c]: &Input) -> i32 {
         .unwrap()
 }
 
-fn check(input: &[usize], first: usize, second: usize) -> usize {
-    let mut code = input.to_vec();
+fn check(code: &[usize], first: usize, second: usize) -> i32 {
+    let mut pc = 0;
+    let code = &mut code.to_vec()[..];
+
     code[1] = first;
     code[2] = second;
 
-    execute(&mut code)
-}
-
-fn execute(code: &mut [usize]) -> usize {
-    let mut pc = 0;
-
     loop {
         match code[pc] {
             1 => code[code[pc + 3]] = code[code[pc + 1]] + code[code[pc + 2]],
             2 => code[code[pc + 3]] = code[code[pc + 1]] * code[code[pc + 2]],
-            _ => break code[0],
+            _ => break code[0] as i32,
         }
         pc += 4;
     }

src/year2019/day12.rs

@@ -45,29 +45,20 @@ pub fn part2(input: &Input) -> usize {
     let [mut a, mut b, mut c] = [0, 0, 0];
     let mut count = 0;
 
-    while a * b * c == 0 {
-        count += 1;
-
-        if a == 0 {
-            x = step(x);
-            if stopped(x) {
-                a = count;
-            }
-        }
-
-        if b == 0 {
-            y = step(y);
-            if stopped(y) {
-                b = count;
+    let update = |axis: &mut Axis, period: &mut usize, count: usize| {
+        if *period == 0 {
+            *axis = step(*axis);
+            if stopped(*axis) {
+                *period = count;
             }
         }
+    };
 
-        if c == 0 {
-            z = step(z);
-            if stopped(z) {
-                c = count;
-            }
-        }
+    while a * b * c == 0 {
+        count += 1;
+        update(&mut x, &mut a, count);
+        update(&mut y, &mut b, count);
+        update(&mut z, &mut c, count);
     }
 
     // a, b and c are the half period, so multiply by 2 to get final result.

src/year2019/day14.rs

@@ -34,6 +34,11 @@ pub fn parse(input: &str) -> Vec<Reaction> {
     indices.insert("FUEL", 0);
     indices.insert("ORE", 1);
 
+    let mut lookup = |s| {
+        let size = indices.len();
+        *indices.entry(s).or_insert(size)
+    };
+
     for line in lines {
         let mut tokens = line
             .split(|c: char| !c.is_ascii_alphanumeric())
@@ -43,18 +48,15 @@ pub fn parse(input: &str) -> Vec<Reaction> {
 
         // Assigns other indices in the arbitrary order that chemicals are encountered.
         let [kind, amount] = tokens.next().unwrap();
-        let size = indices.len();
-        let chemical = *indices.entry(kind).or_insert(size);
+        let chemical = lookup(kind);
 
         let reaction = &mut reactions[chemical];
         reaction.amount = amount.unsigned();
         reaction.chemical = chemical;
 
         for [kind, amount] in tokens {
-            let amount = amount.unsigned();
-            let size = indices.len();
-            let chemical = *indices.entry(kind).or_insert(size);
-            reaction.ingredients.push(Ingredient { amount, chemical });
+            let chemical = lookup(kind);
+            reaction.ingredients.push(Ingredient { amount: amount.unsigned(), chemical });
         }
     }