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/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/year2020/day24.rs

@@ -10,8 +10,8 @@
 //! a "pull" model where we check the surrounding neighbors of each tile, to a "push" model
 //! where we update the neighbors of each black tile instead.
 //!
-//! The SIMD alterative approach is much faster, processing 32 lanes at a time. As a further
-//! optimisation we skip rows and columns that the active state hasn't reached. The approach
+//! The SIMD alternative approach is much faster, processing 32 lanes at a time. As a further
+//! optimization we skip rows and columns that the active state hasn't reached. The approach
 //! is very similar to [`day 11`].
 //!
 //! [`day 17`]: crate::year2020::day17

src/year2023/day23.rs

@@ -63,7 +63,7 @@
 //! A row by row dynamic programming approach from top to bottom finds these paths. For each row
 //! we calculate all possible next rows. Interestingly it turns out that there are only 76 possible
 //! different rows. Then at each y coordinate we **deduplicate** rows to find the maximum value.
-//! This is the most important optimisation as it means that each row is at most 76 elements
+//! This is the most important optimization as it means that each row is at most 76 elements
 //! instead of growing exponentially (76², 76³, ...)
 //!
 //! ## Example paths