Linting

Author: maneatingape

CONTRIBUTING.md

@@ -3,7 +3,7 @@
 I hope that you've enjoyed reading these solutions as much as I enjoyed writing them.
 They're pretty fast and clean...but can you make them even *faster and cleaner*?
 
-If you've made an improvement then please
+If you've made an improvement, then please
 [open a pull request](https://github.com/maneatingape/advent-of-code-rust/compare).
 Contributions are encouraged and valued. ❤️
 

src/util/grid.rs

@@ -18,8 +18,8 @@
 //!
 //! A convenience [`parse`] method creates a `Grid` directly from a 2 dimensional set of
 //! ASCII characters, a common occurrence in Advent of Code inputs. The [`same_size_with`] function
-//! creates a grid of the same size, that can be used for in BFS algorithms for tracking visited
-//! location or for tracking cost in Dijkstra.
+//! creates a grid of the same size that can be used in BFS algorithms for tracking visited
+//! locations or for tracking cost in Dijkstra.
 //!
 //! [`Point`]: crate::util::point
 //! [`parse`]: Grid::parse

src/util/math.rs

@@ -6,7 +6,7 @@
 //!
 //! * [Least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple)
 //!
-//! * [Modular exponentation](https://en.wikipedia.org/wiki/Modular_exponentiation).
+//! * [Modular exponentiation](https://en.wikipedia.org/wiki/Modular_exponentiation).
 //!   Calculates bᵉ mod m efficiently using
 //!   [exponentiation by squaring](https://en.wikipedia.org/wiki/Exponentiation_by_squaring).
 //!

src/util/parse.rs

@@ -8,8 +8,8 @@
 //! ```
 //!
 //! This module provides two [`&str`] extension methods [`iter_signed`] and [`iter_unsigned`]. The
-//! reason for the separate methods is that some Advent of Code inputs contains the `-` character
-//! as a delimeter and this would cause numbers to be incorrectly parsed as negative.
+//! reason for the separate methods is that some Advent of Code inputs contain the `-` character
+//! as a delimiter and this would cause numbers to be incorrectly parsed as negative.
 //!
 //! [`iter_unsigned`]: ParseOps::iter_unsigned
 //! [`iter_signed`]: ParseOps::iter_signed

src/util/thread.rs

@@ -1,6 +1,6 @@
 //! Utility methods to spawn a number of
 //! [scoped](https://doc.rust-lang.org/stable/std/thread/fn.scope.html)
-//! threads equals to the number of cores on the machine. Unlike normal threads, scoped threads
+//! threads equal to the number of cores on the machine. Unlike normal threads, scoped threads
 //! can borrow data from their environment.
 use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering::Relaxed};
 use std::thread::*;
@@ -31,7 +31,7 @@ where
 /// Spawns `n` scoped threads that each receive a
 /// [work stealing](https://en.wikipedia.org/wiki/Work_stealing) iterator.
 /// Work stealing is an efficient strategy that keeps each CPU core busy when some items take longer
-/// than other to process, used by popular libraries such as [rayon](https://github.com/rayon-rs/rayon).
+/// than others to process, used by popular libraries such as [rayon](https://github.com/rayon-rs/rayon).
 /// Processing at different rates also happens on many modern CPUs with
 /// [heterogeneous performance and efficiency cores](https://en.wikipedia.org/wiki/ARM_big.LITTLE).
 pub fn spawn_parallel_iterator<F, R, T>(items: &[T], f: F) -> Vec<R>

src/year2015/day23.rs

@@ -4,7 +4,7 @@
 //! [3n + 1 sequence](https://en.wikipedia.org/wiki/Collatz_conjecture)
 //! for one of two different numbers chosen depending on whether `a` is 0 or 1.
 //!
-//! The code fast enough to emulate directly without needing any understanding of what it's doing.
+//! The code is fast enough to emulate directly without needing any understanding of what it's doing.
 use crate::util::parse::*;
 
 pub enum Op {

src/year2016/day24.rs

@@ -9,7 +9,7 @@
 //! searches starting from each location.
 //!
 //! For speed we convert each location into an index, then store the distances between
-//! every pair of locations in an vec for fast lookup. Our utility [`permutations`] method uses
+//! every pair of locations in a vec for fast lookup. Our utility [`permutations`] method uses
 //! [Heap's algorithm](https://en.wikipedia.org/wiki/Heap%27s_algorithm) for efficiency,
 //! modifying the slice in place.
 //!

src/year2019/day16.rs

@@ -63,7 +63,7 @@
 //! We could compute the coefficient using the formula `nᵏ/k!` however this [grows rather large]
 //! and quickly will overflow even a `u128`.
 //!
-//! However we only need to coefficient modulo 10. [Lucas's theorem] allow us to computer binomial
+//! However we only need the coefficient modulo 10. [Lucas's theorem] allows us to compute binomial
 //! coefficients modulo some prime number. If we compute the coefficients modulo 2 and modulo 5
 //! then we can use the [Chinese remainder theorem] to find the result modulo 10.
 //!

src/year2019/day25.rs

@@ -244,7 +244,7 @@ fn drain_output(computer: &mut Computer) {
     while let State::Output(_) = computer.run() {}
 }
 
-// Convert an normal binary number to its Gray Code equivalent
+// Convert a normal binary number to its Gray Code equivalent.
 fn gray_code(n: u32) -> u32 {
     n ^ (n >> 1)
 }

src/year2020/day07.rs

@@ -1,7 +1,7 @@
 //! # Handy Haversacks
 //!
-//! A hashtable would be a natural data structure for this problem but is a little slow.
-//! To make things faster we implement the hashtable using an array and a combination of three
+//! A hash table would be a natural data structure for this problem but is a little slow.
+//! To make things faster we implement the hash table using an array and a combination of three
 //! [perfect hash functions](https://en.wikipedia.org/wiki/Perfect_hash_function) that map from
 //! each combination of bag descriptions to a unique index.
 //!