Comment linting

Author: maneatingape

src/util/hash.rs

@@ -11,7 +11,7 @@ use std::ops::BitXor as _;
 /// Type alias for [`HashSet`] using [`FxHasher`].
 pub type FastSet<T> = HashSet<T, BuildFxHasher>;
 
-/// Convenience methods to contruct a [`FastSet`].
+/// Convenience methods to construct a [`FastSet`].
 pub trait FastSetBuilder<T> {
     fn new() -> Self;
     fn with_capacity(capacity: usize) -> Self;
@@ -37,7 +37,7 @@ impl<T: Eq + Hash> FastSetBuilder<T> for FastSet<T> {
 /// Type alias for [`HashMap`] using [`FxHasher`].
 pub type FastMap<K, V> = HashMap<K, V, BuildFxHasher>;
 
-/// Convenience methods to contruct a [`FastMap`].
+/// Convenience methods to construct a [`FastMap`].
 pub trait FastMapBuilder<K, V> {
     fn new() -> Self;
     fn with_capacity(capacity: usize) -> Self;
@@ -75,7 +75,7 @@ impl BuildHasher for BuildFxHasher {
 
 /// Simplified implementation, in particular running on a system with 64 bit `usize` is assumed.
 ///
-/// Checkout the [Firefox code](https://searchfox.org/mozilla-central/rev/633345116df55e2d37be9be6555aa739656c5a7d/mfbt/HashFunctions.h#109-153)
+/// Check out the [Firefox code](https://searchfox.org/mozilla-central/rev/633345116df55e2d37be9be6555aa739656c5a7d/mfbt/HashFunctions.h#109-153)
 /// for a full description.
 const K: u64 = 0x517cc1b727220a95;
 

src/util/iter.rs

@@ -2,7 +2,7 @@
 //! [`array_chunks`] method.
 //!
 //! Using Rust's const generics, concrete implementations are provided for sizes 2 to 12 to handle
-//! the most common situations. Once [`array_chunks`] is stablized then this module can be removed.
+//! the most common situations. Once [`array_chunks`] is stabilized then this module can be removed.
 //!
 //! [`array_chunks`]: std::iter::Iterator::array_chunks
 pub struct Chunk<I: Iterator, const N: usize> {

src/year2015/day13.rs

@@ -3,7 +3,7 @@
 //! This problem is very similar to [`Day 9`] and we solve it in almost exactly the same way by
 //! computing an adjacency matrix of happiness then permuting the order of the diners.
 //!
-//! For part one we reduce the permutatations from 8! = 40,320 permutations to 7! = 5,040
+//! For part one we reduce the permutations from 8! = 40,320 permutations to 7! = 5,040
 //! permutations by arbitrarily choosing one of the diners as the start.
 //!
 //! We solve part two at the same time by noticing that by inserting yourself between two diners

src/year2015/day18.rs

@@ -35,7 +35,7 @@
 //! 5. Apply the rules using only bitwise logic.
 //!
 //! Consider the binary representation of a 4 bit hex digit.
-//! * A cell stays on if it has 2 or 3 neigbours, binary `0010` or binary `0011`.
+//! * A cell stays on if it has 2 or 3 neighbors, binary `0010` or binary `0011`.
 //! * A cell turns on if it has exactly 3 neighbors, binary `0011`.
 //!
 //! If we `OR` the neighbor count with the current cell, either `0000` or `0001` then the

src/year2015/day24.rs

@@ -5,7 +5,7 @@
 //!
 //! Sorts the weights in ascending order, then tries combinations of increasing size until a
 //! match in found. This will be the answer since the package count is the smallest and the
-//! quantum entaglement will also be the lowest.
+//! quantum entanglement will also be the lowest.
 use crate::util::bitset::*;
 use crate::util::parse::*;
 

src/year2015/day25.rs

@@ -2,7 +2,7 @@
 //!
 //! There are two parts to solving this problem.
 //!
-//! The first is converting the row and column to an *zero based* index. Using the example of
+//! The first is converting the row and column to a *zero-based* index. Using the example of
 //! the 12th code at row 4 column 2:
 //!
 //! ```none
@@ -23,11 +23,11 @@
 //! Starting at the chosen number 12 and moving diagonally upwards to the right we intersect
 //! the top row at column `column + row - 1 = 2 + 4 - 1 = 5`. This gives the triangular number
 //! `5 * (5 + 1) / 2 = 15`. Then we count backward by `row` elements to get the one less
-//! zero based based index `15 - 4 = 11`.
+//! zero-based index `15 - 4 = 11`.
 //!
 //! The second part is realizing that the description of the code generation is
 //! [modular exponentiation](https://en.wikipedia.org/wiki/Modular_exponentiation). The exponent
-//! of the first code is zero, which is the reason for using a zero based index.
+//! of the first code is zero, which is the reason for using a zero-based index.
 use crate::util::iter::*;
 use crate::util::math::*;
 use crate::util::parse::*;

src/year2016/day16.rs

@@ -13,7 +13,7 @@
 //! We find the number of ones for a pattern of length `n` in `log(n)` complexity as follows:
 //! * Start with a known pattern `abcde` and let the reversed bit inverse of this pattern be
 //!   `EDCBA`.
-//! * Caculate the [prefix sum](https://en.wikipedia.org/wiki/Prefix_sum) of the known sequence.
+//! * Calculate the [prefix sum](https://en.wikipedia.org/wiki/Prefix_sum) of the known sequence.
 //! * If the requested length is within the known sequence (in this example from 0 to 5 inclusive)
 //!   then we're done, return the number of ones directly.
 //! * Else after one repetition this becomes `abcde0EDCBA`.

src/year2016/day19.rs

@@ -24,7 +24,7 @@
 //!
 //! ~~1~~ ~~2~~ 3 ~~4~~ 5
 //!
-//! We can represent this as a loop
+//! We can represent this as a loop:
 //!
 //! ```none
 //!    let mut n = <starting number of elves>
@@ -67,12 +67,12 @@
 //!
 //! `a b` => `a b c`
 //!
-//! Play passes to the left, in this case elf `a` must have eliminated an elf 2 steps away
+//! Play passes to the left, in this case elf `a` must have eliminated an elf 2 steps away:
 //!
 //! `a b c` => `a b d c`
 //!
 //! Play passes to the left, wrapping around to elf `c` that must have eliminated an elf 2 steps
-//! away
+//! away:
 //!
 //! `a b d c` => `a e b d c`
 //!

src/year2017/day18.rs

@@ -4,11 +4,11 @@
 //! Each input differs only in the number specified on line 10.
 //!
 //! The first section is only executed by program 0 and generates a pseudorandom sequence of
-//! 127 numbers between 0 and 9999. The programs then take turns implementing the innner loop of
-//! the [imfamous bubble sort](https://en.wikipedia.org/wiki/Bubble_sort) in descending order.
+//! 127 numbers between 0 and 9999. The programs then take turns implementing the inner loop of
+//! the [infamous bubble sort](https://en.wikipedia.org/wiki/Bubble_sort) in descending order.
 //!
 //! The partially sorted sequence is passed back and forth between each program until in final
-//! sorted order. Assembly code annotated with Rust pseduocode:
+//! sorted order. Assembly code annotated with Rust pseudocode:
 //!
 //! ```none
 //!     set i 31

src/year2017/day25.rs

@@ -96,7 +96,7 @@ pub fn part1(input: &Input) -> i32 {
         remaining -= steps;
         checksum += ones;
 
-        // Use a vector to simulate an empty tape. In practise the cursor doesn't move more than
+        // Use a vector to simulate an empty tape. In practice the cursor doesn't move more than
         // a few thousand steps in any direction, so this approach is as fast as a fixed size
         // array, but much more robust.
         if advance {