fix some typos

PERFORMANCE.md

@@ -145,9 +145,9 @@ In general, these are ordered from fastest to slowest.
 `is_match` is fastest because it doesn't actually need to find the start or the
 end of the leftmost-first match. It can quit immediately after it knows there
 is a match. For example, given the regex `a+` and the haystack, `aaaaa`, the
-search will quit after examing the first byte.
+search will quit after examining the first byte.
 
-In constrast, `find` must return both the start and end location of the
+In contrast, `find` must return both the start and end location of the
 leftmost-first match. It can use the DFA matcher for this, but must run it
 forwards once to find the end of the match *and then run it backwards* to find
 the start of the match. The two scans and the cost of finding the real end of
@@ -196,7 +196,7 @@ a few examples of regexes that get literal prefixes detected:
 
 Literals in anchored regexes can also be used for detecting non-matches very
 quickly. For example, `^foo\w+` and `\w+foo$` may be able to detect a non-match
-just by examing the first (or last) three bytes of the haystack.
+just by examining the first (or last) three bytes of the haystack.
 
 ## Unicode word boundaries may prevent the DFA from being used
 

regex-syntax/src/ast/parse.rs

@@ -167,7 +167,7 @@ impl ParserBuilder {
     /// they should impose a limit on the length, in bytes, of the concrete
     /// pattern string. In particular, this is viable since this parser
     /// implementation will limit itself to heap space proportional to the
-    /// lenth of the pattern string.
+    /// length of the pattern string.
     ///
     /// Note that a nest limit of `0` will return a nest limit error for most
     /// patterns but not all. For example, a nest limit of `0` permits `a` but
@@ -236,7 +236,7 @@ pub struct Parser {
     /// supported.
     octal: bool,
     /// The initial setting for `ignore_whitespace` as provided by
-    /// Th`ParserBuilder`. is is used when reseting the parser's state.
+    /// `ParserBuilder`. It is used when resetting the parser's state.
     initial_ignore_whitespace: bool,
     /// Whether whitespace should be ignored. When enabled, comments are
     /// also permitted.
@@ -1023,7 +1023,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
     /// The given `kind` should correspond to the operator observed by the
     /// caller.
     ///
-    /// This assumes that the paser is currently positioned at the repetition
+    /// This assumes that the parser is currently positioned at the repetition
     /// operator and advances the parser to the first character after the
     /// operator. (Note that the operator may include a single additional `?`,
     /// which makes the operator ungreedy.)
@@ -1078,7 +1078,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
     /// corresponds to the {m,n} syntax, and does not include the ?, * or +
     /// operators.
     ///
-    /// This assumes that the paser is currently positioned at the opening `{`
+    /// This assumes that the parser is currently positioned at the opening `{`
     /// and advances the parser to the first character after the operator.
     /// (Note that the operator may include a single additional `?`, which
     /// makes the operator ungreedy.)

regex-syntax/src/parser.rs

@@ -45,7 +45,7 @@ impl ParserBuilder {
     /// they should impose a limit on the length, in bytes, of the concrete
     /// pattern string. In particular, this is viable since this parser
     /// implementation will limit itself to heap space proportional to the
-    /// lenth of the pattern string.
+    /// length of the pattern string.
     ///
     /// Note that a nest limit of `0` will return a nest limit error for most
     /// patterns but not all. For example, a nest limit of `0` permits `a` but

src/exec.rs

@@ -140,7 +140,7 @@ impl ExecBuilder {
     ///
     /// Note that when compiling 2 or more regular expressions, capture groups
     /// are completely unsupported. (This means both `find` and `captures`
-    /// wont work.)
+    /// won't work.)
     pub fn new_many<I, S>(res: I) -> Self
     where
         S: AsRef<str>,