doc: fix typos

This commit fixes an amazing number of new typos that I introduced in
the regex 1.9 release.

The typos were found and fixed by the typos-cli tool.[1]

[1]: https://crates.io/crates/typos-cli

PR #1026

Author: jqnatividad

CHANGELOG.md

@@ -187,7 +187,7 @@ More specifically, any ASCII character except for `[0-9A-Za-z<>]` can now be
 escaped. Also, a new routine, `is_escapeable_character`, has been added to
 `regex-syntax` to query whether a character is escapeable or not.
 * [FEATURE #547](https://github.com/rust-lang/regex/issues/547):
-Add `Regex::captures_at`. This filles a hole in the API, but doesn't otherwise
+Add `Regex::captures_at`. This fills a hole in the API, but doesn't otherwise
 introduce any new expressive power.
 * [FEATURE #595](https://github.com/rust-lang/regex/issues/595):
 Capture group names are now Unicode-aware. They can now begin with either a `_`

regex-automata/src/dfa/automaton.rs

@@ -1074,7 +1074,7 @@ pub unsafe trait Automaton {
     ///     // encoding of any Unicode scalar value except for 'a', 'b' or 'c'.
     ///     // That translates to a much more complicated DFA, and also
     ///     // inhibits the 'accelerator' optimization that we are trying to
-    ///     // demostrate in this example.
+    ///     // demonstrate in this example.
     ///     .syntax(syntax::Config::new().unicode(false).utf8(false))
     ///     .build("[^abc]+a")?;
     ///

regex-automata/src/dfa/dense.rs

@@ -2109,7 +2109,7 @@ impl<T: AsRef<[u32]>> DFA<T> {
     /// let mut buf = vec![0; original_dfa.write_to_len()];
     /// // This is guaranteed to succeed, because the only serialization error
     /// // that can occur is when the provided buffer is too small. But
-    /// // write_to_len guarantees a correct sie.
+    /// // write_to_len guarantees a correct size.
     /// let written = original_dfa.write_to_native_endian(&mut buf).unwrap();
     /// // But this is not guaranteed to succeed! In particular,
     /// // deserialization requires proper alignment for &[u32], but our buffer
@@ -3336,7 +3336,7 @@ impl<'a> TransitionTable<&'a [u32]> {
     ///
     /// # Safety
     ///
-    /// This routine is not safe because it does not check the valdity of the
+    /// This routine is not safe because it does not check the validity of the
     /// transition table itself. In particular, the transition table can be
     /// quite large, so checking its validity can be somewhat expensive. An
     /// invalid transition table is not safe because other code may rely on the
@@ -3929,7 +3929,7 @@ impl<'a> StartTable<&'a [u32]> {
     ///
     /// # Safety
     ///
-    /// This routine is not safe because it does not check the valdity of the
+    /// This routine is not safe because it does not check the validity of the
     /// starting state IDs themselves. In particular, the number of starting
     /// IDs can be of variable length, so it's possible that checking their
     /// validity cannot be done in constant time. An invalid starting state

regex-automata/src/dfa/determinize.rs

@@ -539,7 +539,7 @@ impl<'a> Runner<'a> {
         }
         let state = builder.to_state();
         // States use reference counting internally, so we only need to count
-        // their memroy usage once.
+        // their memory usage once.
         self.memory_usage_state += state.memory_usage();
         self.builder_states.push(state.clone());
         self.cache.insert(state, id);

regex-automata/src/dfa/minimize.rs

@@ -152,7 +152,7 @@ impl<'a> Minimizer<'a> {
 
         // At this point, we now have a minimal partitioning of states, where
         // each partition is an equivalence class of DFA states. Now we need to
-        // use this partioning to update the DFA to only contain one state for
+        // use this partitioning to update the DFA to only contain one state for
         // each partition.
 
         // Create a map from DFA state ID to the representative ID of the

regex-automata/src/dfa/mod.rs

@@ -1,5 +1,5 @@
 /*!
-A module for building and searching with determinstic finite automata (DFAs).
+A module for building and searching with deterministic finite automata (DFAs).
 
 Like other modules in this crate, DFAs support a rich regex syntax with Unicode
 features. DFAs also have extensive options for configuring the best space vs
@@ -267,7 +267,7 @@ the regexes in this module are almost universally slow to compile, especially
 when they contain large Unicode character classes. For example, on my system,
 compiling `\w{50}` takes about 1 second and almost 15MB of memory! (Compiling
 a sparse regex takes about the same time but only uses about 1.2MB of
-memory.) Conversly, compiling the same regex without Unicode support, e.g.,
+memory.) Conversely, compiling the same regex without Unicode support, e.g.,
 `(?-u)\w{50}`, takes under 1 millisecond and about 15KB of memory. For this
 reason, you should only use Unicode character classes if you absolutely need
 them! (They are enabled by default though.)

regex-automata/src/dfa/regex.rs

@@ -590,7 +590,7 @@ impl<A: Automaton> Regex<A> {
 ///
 /// The type parameters are as follows:
 ///
-/// * `A` represents the type of the underyling DFA that implements the
+/// * `A` represents the type of the underlying DFA that implements the
 /// [`Automaton`] trait.
 ///
 /// The lifetime parameters are as follows:

regex-automata/src/hybrid/dfa.rs

@@ -32,7 +32,7 @@ use crate::{
     },
 };
 
-/// The mininum number of states that a lazy DFA's cache size must support.
+/// The minimum number of states that a lazy DFA's cache size must support.
 ///
 /// This is checked at time of construction to ensure that at least some small
 /// number of states can fit in the given capacity allotment. If we can't fit
@@ -2332,7 +2332,7 @@ impl<'i, 'c> Lazy<'i, 'c> {
                             "lazy DFA cache has been cleared {} times, \
                              which exceeds the limit of {}, \
                              AND its bytes searched per state is less \
-                             than the configured mininum of {}, \
+                             than the configured minimum of {}, \
                              therefore lazy DFA is giving up \
                              (bytes searched since cache clear = {}, \
                               number of states = {})",
@@ -2348,7 +2348,7 @@ impl<'i, 'c> Lazy<'i, 'c> {
                             "lazy DFA cache has been cleared {} times, \
                              which exceeds the limit of {}, \
                              AND its bytes searched per state is greater \
-                             than the configured mininum of {}, \
+                             than the configured minimum of {}, \
                              therefore lazy DFA is continuing! \
                              (bytes searched since cache clear = {}, \
                               number of states = {})",
@@ -2771,7 +2771,7 @@ enum StateSaver {
     /// is stored in 'Saved' since it may have changed.
     ToSave { id: LazyStateID, state: State },
     /// An ID that of a state that has been persisted through a lazy DFA
-    /// cache clearing. The ID recorded here corresonds to an ID that was
+    /// cache clearing. The ID recorded here corresponds to an ID that was
     /// once marked as ToSave. The IDs are likely not equivalent even though
     /// the states they point to are.
     Saved(LazyStateID),

regex-automata/src/hybrid/mod.rs

@@ -1,5 +1,5 @@
 /*!
-A module for building and searching with lazy determinstic finite automata
+A module for building and searching with lazy deterministic finite automata
 (DFAs).
 
 Like other modules in this crate, lazy DFAs support a rich regex syntax with

regex-automata/src/hybrid/search.rs

@@ -188,7 +188,7 @@ fn find_fwd_imp(
             // mentioned above was a pretty big pessimization in some other
             // cases. Namely, it resulted in too much ping-ponging into and out
             // of the loop, which resulted in nearly ~2x regressions in search
-            // time when compared to the originaly lazy DFA in the regex crate.
+            // time when compared to the originally lazy DFA in the regex crate.
             // So I've removed the second loop unrolling that targets the
             // self-transition case.
             let mut prev_sid = sid;