@grain/stdlib 0.5.12 → 0.6.0

package/regex.gr

@@ -1,9 +1,11 @@
 /**
- * @module Regex: Regular Expressions.
- * @example import Regex from "regex"
+ * Regular Expressions.
+ *
+ * @example from "regex" include Regex
  *
  * @since 0.4.3
  */
+module Regex
 
 /*
  This library provides support for regular expressions in Grain.
@@ -11,15 +13,15 @@
  which is licensed under Apache 2.0. Racket's regular expression
  engine is itself inspired by the Spencer engine, as found in Tcl.
  */
-import Array from "array"
-import Char from "char"
-import List from "list"
-import Map from "map"
-import Option from "option"
-import Result from "result"
-import String from "string"
-import Float32 from "float32"
-import { min, max } from "number"
+from "array" include Array
+from "char" include Char
+from "list" include List
+from "map" include Map
+from "option" include Option
+from "result" include Result
+from "string" include String
+from "number" include Number
+use Number.{ min, max }
 
 /*
 
@@ -61,11 +63,7 @@ let makeRegExParserConfig = () => {
   }
 }
 
-let configWithCaseSensitive =
-  (
-    config: RegExParserConfig,
-    caseSensitive: Bool,
-  ) => {
+let configWithCaseSensitive = (config: RegExParserConfig, caseSensitive: Bool) => {
   {
     isPerlRegExp: config.isPerlRegExp,
     caseSensitive,
@@ -170,12 +168,12 @@ let eat = (buf: RegExBuf, char: Char) => {
         parseErr(
           buf,
           "Expected character '" ++
-          Char.toString(char) ++
-          ", but found character '" ++
-          Char.toString(ret) ++
-          "'",
+            Char.toString(char) ++
+            ", but found character '" ++
+            Char.toString(ret) ++
+            "'",
           0
-        )
+        ),
       )
     }
   }
@@ -241,14 +239,13 @@ let rec rangeAdd = (rng: CharRange, v: CharRangeElt) => {
     _ when rangeContains(rng, v) => rng,
     _ => rangeUnion(rng, [(v, v)]),
   }
-},
-rangeUnion = (rng1, rng2) => {
+}
+and rangeUnion = (rng1, rng2) => {
   match ((rng1, rng2)) {
     ([], _) => rng2,
     (_, []) => rng1,
-    ([(r1start, r1end), ...r1tl], [(r2start, r2end), ...r2tl]) when (
-      r1start <= r2start
-    ) => {
+    ([(r1start, r1end), ...r1tl], [(r2start, r2end), ...r2tl]) when r1start <=
+      r2start => {
       if (r1end + 1 >= r2start) {
         if (r1end <= r2end) {
           rangeUnion([(r1start, r2end), ...r2tl], r1tl)
@@ -315,7 +312,7 @@ let rangeAddCaseAware = (rng: CharRange, c, config) => {
         Ok(rng)
         */
         Err(
-          "NYI: Case-insensitive matching is not supported until grain-lang/grain#661 is resolved."
+          "NYI: Case-insensitive matching is not supported until grain-lang/grain#661 is resolved.",
         )
       }
     },
@@ -324,17 +321,16 @@ let rangeAddCaseAware = (rng: CharRange, c, config) => {
 
 let rangeAddSpanCaseAware = (rng: CharRange, fromC, toC, config) => {
   if (config.caseSensitive) {
-    Ok(rangeAddSpan(rng, fromC, toC))
-  } else {
-    let mut ret = Ok(rng)
-    for (let mut i = fromC; i <= toC; i += 1) {
-      match (ret) {
-        Ok(x) => ret = rangeAddCaseAware(x, Some(i), config),
-        Err(e) => break,
-      }
+    return Ok(rangeAddSpan(rng, fromC, toC))
+  }
+  let mut ret = Ok(rng)
+  for (let mut i = fromC; i <= toC; i += 1) {
+    match (ret) {
+      Ok(x) => ret = rangeAddCaseAware(x, Some(i), config),
+      Err(e) => break,
     }
-    ret
   }
+  return ret
 }
 
 /*
@@ -404,7 +400,7 @@ enum UnicodeCategory {
   OtherPrivateUse,
 }
 
-enum ParsedRegularExpression {
+enum rec ParsedRegularExpression {
   RENever,
   REEmpty,
   REAny,
@@ -415,18 +411,11 @@ enum ParsedRegularExpression {
   REWordBoundary,
   RENotWordBoundary,
   RELiteral(Char),
-  RELiteralString(
-    String
-  ), // <- sequences of literals are flattened into a string
+  RELiteralString(String), // <- sequences of literals are flattened into a string
   REAlts(ParsedRegularExpression, ParsedRegularExpression),
   RESequence(List<ParsedRegularExpression>, Bool), // seq elts, needs backtrack
   REGroup(ParsedRegularExpression, Number), // regex, group ID
-  RERepeat(
-    ParsedRegularExpression,
-    Number,
-    Option<Number>,
-    Bool
-  ), // regex, min, max (None for infinity), true=non-greedy
+  RERepeat(ParsedRegularExpression, Number, Option<Number>, Bool), // regex, min, max (None for infinity), true=non-greedy
   REMaybe(ParsedRegularExpression, Bool), // regex, true=non-greedy
   REConditional(
     ParsedRegularExpression,
@@ -436,12 +425,7 @@ enum ParsedRegularExpression {
     Number,
     Bool
   ), // test, if-true, if-false, n-start, num-n, needs-backtrack
-  RELookahead(
-    ParsedRegularExpression,
-    Bool,
-    Number,
-    Number
-  ), // regex, is-match, n-start, num-n
+  RELookahead(ParsedRegularExpression, Bool, Number, Number), // regex, is-match, n-start, num-n
   RELookbehind(
     ParsedRegularExpression,
     Bool,
@@ -450,30 +434,21 @@ enum ParsedRegularExpression {
     Number,
     Number
   ), // regex, is-match, lb-min, lb-max, n-start, num-n (lb-xx values patched in later)
-  RECut(
-    ParsedRegularExpression,
-    Number,
-    Number,
-    Bool
-  ), // regex, n-start, num-n, needs-backtrack
+  RECut(ParsedRegularExpression, Number, Number, Bool), // regex, n-start, num-n, needs-backtrack
   REReference(Number, Bool), // n, case-sensitive
   RERange(RERange),
-  REUnicodeCategories(
-    List<UnicodeCategory>,
-    Bool
-  ), // symlist, true=match/false=does-not-match
+  REUnicodeCategories(List<UnicodeCategory>, Bool), // symlist, true=match/false=does-not-match
 }
 
 let needsBacktrack = (rx: ParsedRegularExpression) => {
   match (rx) {
-    REAlts(_, _) => true,
-    RESequence(_, nb) => nb,
-    REGroup(_, _) => true,
-    RERepeat(_, _, _, _) => true,
-    REMaybe(_, _) => true,
-    REConditional(_, _, _, _, _, nb) => nb,
-    RECut(_, _, _, nb) => nb,
+    REAlts(_, _) |
+    REGroup(_, _) |
+    RERepeat(_, _, _, _) |
+    REMaybe(_, _) |
     REUnicodeCategories(_, _) => true,
+    RESequence(_, nb) | REConditional(_, _, _, _, _, nb) | RECut(_, _, _, nb) =>
+      nb,
     _ => false,
   }
 }
@@ -500,8 +475,7 @@ let mergeAdjacent = lst => {
           None => false,
           Some(MMChar) => {
             match (hd) {
-              RELiteral(x) => false,
-              RELiteralString(x) => false,
+              RELiteral(_) | RELiteralString(_) => false,
               _ => true,
             }
           },
@@ -514,9 +488,7 @@ let mergeAdjacent = lst => {
       // flatten nested sequences
       [RESequence(rxs1, _), ...tl] => loop(mode, accum, List.append(rxs1, tl)),
       // drop empty elements
-      [REEmpty, ...tl] => loop(mode, accum, tl),
-      [RELiteralString(""), ...tl] => loop(mode, accum, tl),
-      // TODO(#696): Clean up with or-patterns
+      [REEmpty, ...tl] | [RELiteralString(""), ...tl] => loop(mode, accum, tl),
       _ when readyForAccum(l, mode) => {
         match (accum) {
           [] => [],
@@ -531,8 +503,7 @@ let mergeAdjacent = lst => {
           },
         }
       },
-      [] =>
-        fail "impossible (mergeAdjacent)", // avoid warning (can delete once TODO is resolved)
+      [] => fail "impossible (mergeAdjacent)", // avoid warning (can delete once TODO is resolved)
       [RELiteralString(x), ...tl] when Option.isSome(mode) =>
         loop(mode, [x, ...accum], tl),
       [RELiteral(c), ...tl] when Option.isSome(mode) =>
@@ -578,11 +549,10 @@ let makeRECut = (rx, nStart, numN) => {
 }
 
 let makeREConditional = (tst, pces1, pces2, nStart, numN) => {
-  let nb = needsBacktrack(pces1) ||
-    match (pces2) {
-      None => false,
-      Some(p2) => needsBacktrack(p2),
-    }
+  let nb = needsBacktrack(pces1) || match (pces2) {
+    None => false,
+    Some(p2) => needsBacktrack(p2),
+  }
   REConditional(tst, pces1, pces2, nStart, numN, nb)
 }
 
@@ -640,8 +610,8 @@ let rec parseRangeNot = (buf: RegExBuf) => {
       Ok(_) => parseRange(buf),
     }
   }
-},
-parseRange = (buf: RegExBuf) => {
+}
+and parseRange = (buf: RegExBuf) => {
   if (!more(buf)) {
     Err(parseErr(buf, "Missing closing `]`", 0))
   } else {
@@ -664,12 +634,10 @@ parseRange = (buf: RegExBuf) => {
       Ok(_) => parseRangeRest(buf, [], None, None),
     }
   }
-},
-parseClass = (buf: RegExBuf) => {
+}
+and parseClass = (buf: RegExBuf) => {
   if (!more(buf)) {
-    Err(
-      "no chars"
-    ) // caught in handler (we use a Result to cleanly mesh with the Result type below)
+    Err("no chars") // caught in handler (we use a Result to cleanly mesh with the Result type below)
   } else {
     match (peek(buf)) {
       Err(e) => Err(e),
@@ -700,8 +668,8 @@ parseClass = (buf: RegExBuf) => {
       Ok(c) => Err("unknown class: " ++ toString(c)),
     }
   }
-},
-parsePosixCharClass = (buf: RegExBuf) => {
+}
+and parsePosixCharClass = (buf: RegExBuf) => {
   if (!more(buf)) {
     Err(parseErr(buf, "Missing POSIX character class after `[`", 0))
   } else {
@@ -719,15 +687,14 @@ parsePosixCharClass = (buf: RegExBuf) => {
                 Ok(_) => Ok(List.join("", List.reverse(acc))),
               }
             },
-            Ok(c) when (
-              Char.code('a') <= Char.code(c) && Char.code(c) <= Char.code('z')
-            ) => {
+            Ok(c) when Char.code('a') <= Char.code(c) &&
+              Char.code(c) <= Char.code('z') => {
               ignore(eat(buf, c))
               loop([Char.toString(c), ...acc])
             },
             Ok(_) =>
               Err(
-                parseErr(buf, "Invalid character in POSIX character class", 0)
+                parseErr(buf, "Invalid character in POSIX character class", 0),
               ),
           }
         }
@@ -741,7 +708,7 @@ parsePosixCharClass = (buf: RegExBuf) => {
                     rangeAddSpan([], Char.code('a'), Char.code('z')),
                     Char.code('A'),
                     Char.code('Z')
-                  )
+                  ),
                 ),
               "upper" => Ok(rangeAddSpan([], Char.code('A'), Char.code('Z'))),
               "lower" => Ok(rangeAddSpan([], Char.code('a'), Char.code('z'))),
@@ -756,7 +723,7 @@ parsePosixCharClass = (buf: RegExBuf) => {
                     ),
                     Char.code('A'),
                     Char.code('F')
-                  )
+                  ),
                 ),
               "alnum" =>
                 Ok(
@@ -768,7 +735,7 @@ parsePosixCharClass = (buf: RegExBuf) => {
                     ),
                     Char.code('A'),
                     Char.code('Z')
-                  )
+                  ),
                 ),
               "word" =>
                 Ok(
@@ -779,7 +746,7 @@ parsePosixCharClass = (buf: RegExBuf) => {
                       Char.code('F')
                     ),
                     Char.code('_')
-                  )
+                  ),
                 ),
               "blank" => Ok(rangeAdd(rangeAdd([], 0x20), 0x9)), // space and tab
               "space" => Ok(range_s()),
@@ -789,7 +756,7 @@ parsePosixCharClass = (buf: RegExBuf) => {
                     buf,
                     "the [:graph:] character class is not currently supported. For more information, see https://github.com/grain-lang/grain/issues/661",
                     0
-                  )
+                  ),
                 ),
               "print" =>
                 Err(
@@ -797,7 +764,7 @@ parsePosixCharClass = (buf: RegExBuf) => {
                     buf,
                     "the [:print:] character class is not currently supported. For more information, see https://github.com/grain-lang/grain/issues/661",
                     0
-                  )
+                  ),
                 ),
               "cntrl" => Ok(rangeAddSpan([], 0, 31)),
               "ascii" => Ok(rangeAddSpan([], 0, 127)),
@@ -813,18 +780,17 @@ parsePosixCharClass = (buf: RegExBuf) => {
             buf,
             "Expected `:` after `[`. Found: `" ++ Char.toString(c) ++ "`",
             0
-          )
+          ),
         ),
     }
   }
-},
-parseRangeRest =
-  (
-    buf: RegExBuf,
-    rng: CharRange,
-    spanFrom: Option<Number>,
-    mustSpanFrom: Option<Number>,
-  ) => {
+}
+and parseRangeRest = (
+  buf: RegExBuf,
+  rng: CharRange,
+  spanFrom: Option<Number>,
+  mustSpanFrom: Option<Number>,
+) => {
   if (!more(buf)) {
     Err(parseErr(buf, "Missing closing `]`", 0))
   } else {
@@ -848,7 +814,7 @@ parseRangeRest =
                       buf,
                       "misplaced hyphen within square brackets in pattern",
                       1
-                    )
+                    ),
                   ),
                 None => {
                   ignore(eat(buf, '-'))
@@ -866,7 +832,7 @@ parseRangeRest =
                   buf,
                   "misplaced hyphen within square brackets in pattern",
                   1
-                )
+                ),
               ),
             Ok(_) => {
               ignore(eat(buf, '-'))
@@ -886,16 +852,14 @@ parseRangeRest =
                 buf,
                 "escaping backslash at end pattern (within square brackets)",
                 0
-              )
+              ),
             )
           } else {
             match (peek(buf)) {
               Err(e) => Err(e),
-              Ok(c) when (
-                Char.code('a') <= Char.code(c) &&
+              Ok(c) when Char.code('a') <= Char.code(c) &&
                 Char.code(c) <= Char.code('z') ||
-                Char.code('A') <= Char.code(c) && Char.code(c) <= Char.code('Z')
-              ) => {
+                Char.code('A') <= Char.code(c) && Char.code(c) <= Char.code('Z') => {
                 match (mustSpanFrom) {
                   Some(_) =>
                     Err(
@@ -903,7 +867,7 @@ parseRangeRest =
                         buf,
                         "misplaced hyphen within square brackets in pattern",
                         0
-                      )
+                      ),
                     ),
                   None => {
                     let curPos = unbox(buf.cursor)
@@ -911,8 +875,8 @@ parseRangeRest =
                       Err(e) =>
                         Err(
                           "Invalid Regular Expression: illegal alphebetic escape (position " ++
-                          toString(curPos) ++
-                          ")"
+                            toString(curPos) ++
+                            ")",
                         ),
                       Ok(range1) => {
                         match (rangeAddCaseAware(rng, spanFrom, buf.config)) {
@@ -970,15 +934,14 @@ parseRangeRest =
       },
     }
   }
-},
-parseRangeRestSpan =
-  (
-    buf: RegExBuf,
-    c,
-    rng: CharRange,
-    spanFrom: Option<Number>,
-    mustSpanFrom: Option<Number>,
-  ) => {
+}
+and parseRangeRestSpan = (
+  buf: RegExBuf,
+  c,
+  rng: CharRange,
+  spanFrom: Option<Number>,
+  mustSpanFrom: Option<Number>,
+) => {
   match (mustSpanFrom) {
     Some(n) => {
       if (n > c) {
@@ -1004,226 +967,215 @@ parseRangeRestSpan =
 let rec parseAtom = (buf: RegExBuf) => {
   match (peek(buf)) {
     Err(e) => Err(e),
-    Ok(c) =>
-      match (c) {
-        '(' => {
-          if (!moreN(buf, 1)) {
-            Err(parseErr(buf, "Parentheses not closed", 1))
-          } else if (peekN(buf, 1) == Ok('?')) {
-            // fancy group
-            if (!moreN(buf, 2)) {
-              Err(parseErr(buf, "Parentheses not closed", 2))
-            } else {
-              match (peekN(buf, 2)) {
-                Err(e) => Err(e),
-                Ok('>') => {
-                  // cut
-                  ignore(eat(buf, '('))
-                  ignore(eat(buf, '?'))
-                  ignore(eat(buf, '>'))
-                  let preNumGroups = unbox(buf.config.groupNumber)
-                  match (parseRegex(buf)) {
-                    Err(e) => Err(e),
-                    Ok(rx) => {
-                      let postNumGroups = unbox(buf.config.groupNumber)
-                      match (eat(buf, ')')) {
-                        Err(e) => Err(e),
-                        Ok(_) =>
-                          Ok(
-                            makeRECut(
-                              rx,
-                              preNumGroups,
-                              postNumGroups - preNumGroups
-                            )
+    Ok(c) => match (c) {
+      '(' => {
+        if (!moreN(buf, 1)) {
+          Err(parseErr(buf, "Parentheses not closed", 1))
+        } else if (peekN(buf, 1) == Ok('?')) {
+          // fancy group
+          if (!moreN(buf, 2)) {
+            Err(parseErr(buf, "Parentheses not closed", 2))
+          } else {
+            match (peekN(buf, 2)) {
+              Err(e) => Err(e),
+              Ok('>') => {
+                // cut
+                ignore(eat(buf, '('))
+                ignore(eat(buf, '?'))
+                ignore(eat(buf, '>'))
+                let preNumGroups = unbox(buf.config.groupNumber)
+                match (parseRegex(buf)) {
+                  Err(e) => Err(e),
+                  Ok(rx) => {
+                    let postNumGroups = unbox(buf.config.groupNumber)
+                    match (eat(buf, ')')) {
+                      Err(e) => Err(e),
+                      Ok(_) =>
+                        Ok(
+                          makeRECut(
+                            rx,
+                            preNumGroups,
+                            postNumGroups - preNumGroups
                           ),
-                      }
-                    },
-                  }
-                },
-                Ok('(') => {
-                  // conditional
-                  ignore(eat(buf, '('))
-                  ignore(eat(buf, '?'))
-                  ignore(eat(buf, '('))
-                  let tstPreNumGroups = unbox(buf.config.groupNumber)
-                  match (parseTest(buf)) {
-                    Err(e) => Err(e),
-                    Ok(test) => {
-                      let tstSpanNumGroups = unbox(buf.config.groupNumber) -
-                        tstPreNumGroups
-                      match (parsePCEs(buf, false)) {
-                        Err(e) => Err(e),
-                        Ok(pces) => {
-                          if (!more(buf)) {
-                            Err(parseErr(buf, "Parentheses not closed", 0))
-                          } else {
-                            match (peek(buf)) {
-                              Err(e) => Err(e),
-                              Ok('|') => {
-                                ignore(eat(buf, '|'))
-                                match (parsePCEs(buf, false)) {
-                                  Err(e) => Err(e),
-                                  Ok(pces2) => {
-                                    match (peek(buf)) {
-                                      Err(_) =>
-                                        Err(
-                                          parseErr(
-                                            buf,
-                                            "Parentheses not closed",
-                                            0
-                                          )
+                        ),
+                    }
+                  },
+                }
+              },
+              Ok('(') => {
+                // conditional
+                ignore(eat(buf, '('))
+                ignore(eat(buf, '?'))
+                ignore(eat(buf, '('))
+                let tstPreNumGroups = unbox(buf.config.groupNumber)
+                match (parseTest(buf)) {
+                  Err(e) => Err(e),
+                  Ok(test) => {
+                    let tstSpanNumGroups = unbox(buf.config.groupNumber) -
+                      tstPreNumGroups
+                    match (parsePCEs(buf, false)) {
+                      Err(e) => Err(e),
+                      Ok(pces) => {
+                        if (!more(buf)) {
+                          Err(parseErr(buf, "Parentheses not closed", 0))
+                        } else {
+                          match (peek(buf)) {
+                            Err(e) => Err(e),
+                            Ok('|') => {
+                              ignore(eat(buf, '|'))
+                              match (parsePCEs(buf, false)) {
+                                Err(e) => Err(e),
+                                Ok(pces2) => {
+                                  match (peek(buf)) {
+                                    Err(_) =>
+                                      Err(
+                                        parseErr(
+                                          buf,
+                                          "Parentheses not closed",
+                                          0
                                         ),
-                                      Ok(_) => {
-                                        ignore(eat(buf, ')'))
-                                        Ok(
-                                          makeREConditional(
-                                            test,
-                                            makeRESequence(pces),
-                                            Some(makeRESequence(pces2)),
-                                            tstPreNumGroups,
-                                            tstSpanNumGroups
-                                          )
-                                        )
-                                      },
-                                    }
-                                  },
-                                }
-                              },
-                              Ok(')') => {
-                                ignore(eat(buf, ')'))
-                                Ok(
-                                  makeREConditional(
-                                    test,
-                                    makeRESequence(pces),
-                                    None,
-                                    tstPreNumGroups,
-                                    tstSpanNumGroups
-                                  )
-                                )
-                              },
-                              Ok(_) => {
-                                Err(
-                                  parseErr(buf, "Failed to parse condition", 0)
-                                )
-                              },
-                            }
-                          }
-                        },
-                      }
-                    },
-                  }
-                },
-                Ok(c) when (
-                  c == 'i' || c == 's' || c == 'm' || c == '-' || c == ':'
-                ) => {
-                  // match with mode
-                  ignore(eat(buf, '('))
-                  ignore(eat(buf, '?'))
-                  match (parseMode(buf)) {
-                    Err(e) => Err(e),
-                    Ok(config) => {
-                      if (!more(buf)) {
-                        Err(parseErr(buf, "Parentheses not closed", 0))
-                      } else {
-                        match (peek(buf)) {
-                          Err(e) => Err(e),
-                          Ok(':') => {
-                            ignore(eat(buf, ':'))
-                            match (parseRegex(withConfig(buf, config))) {
-                              Err(e) => Err(e),
-                              Ok(rx) => {
-                                match (eat(buf, ')')) {
-                                  Err(e) => Err(e),
-                                  Ok(_) => Ok(rx),
-                                }
-                              },
-                            }
-                          },
-                          Ok(_) => {
-                            Err(
-                              parseErr(
-                                buf,
-                                "expected `:` or another mode after `(?` and a mode sequence; a mode is `i`, `-i`, `m`, `-m`, `s`, or `-s`",
-                                0
+                                      ),
+                                    Ok(_) => {
+                                      ignore(eat(buf, ')'))
+                                      Ok(
+                                        makeREConditional(
+                                          test,
+                                          makeRESequence(pces),
+                                          Some(makeRESequence(pces2)),
+                                          tstPreNumGroups,
+                                          tstSpanNumGroups
+                                        ),
+                                      )
+                                    },
+                                  }
+                                },
+                              }
+                            },
+                            Ok(')') => {
+                              ignore(eat(buf, ')'))
+                              Ok(
+                                makeREConditional(
+                                  test,
+                                  makeRESequence(pces),
+                                  None,
+                                  tstPreNumGroups,
+                                  tstSpanNumGroups
+                                ),
                               )
-                            )
-                          },
+                            },
+                            Ok(_) => {
+                              Err(parseErr(buf, "Failed to parse condition", 0))
+                            },
+                          }
                         }
-                      }
-                    },
-                  }
-                },
-                Ok(_) => {
-                  ignore(eat(buf, '('))
-                  ignore(eat(buf, '?'))
-                  parseLook(buf)
-                },
-              }
-            }
-          } else {
-            // simple group
-            ignore(eat(buf, '('))
-            let groupNum = unbox(buf.config.groupNumber)
-            // Note that this inc operation is side-effecting
-            match (parseRegex(
-              withConfig(buf, configIncGroupNumber(buf.config))
-            )) {
-              Err(e) => Err(e),
-              Ok(r) => {
-                match (eat(buf, ')')) {
+                      },
+                    }
+                  },
+                }
+              },
+              Ok('i' | 's' | 'm' | '-' | ':') => {
+                // match with mode
+                ignore(eat(buf, '('))
+                ignore(eat(buf, '?'))
+                match (parseMode(buf)) {
                   Err(e) => Err(e),
-                  Ok(_) => Ok(REGroup(r, groupNum)),
+                  Ok(config) => {
+                    if (!more(buf)) {
+                      Err(parseErr(buf, "Parentheses not closed", 0))
+                    } else {
+                      match (peek(buf)) {
+                        Err(e) => Err(e),
+                        Ok(':') => {
+                          ignore(eat(buf, ':'))
+                          match (parseRegex(withConfig(buf, config))) {
+                            Err(e) => Err(e),
+                            Ok(rx) => {
+                              match (eat(buf, ')')) {
+                                Err(e) => Err(e),
+                                Ok(_) => Ok(rx),
+                              }
+                            },
+                          }
+                        },
+                        Ok(_) => {
+                          Err(
+                            parseErr(
+                              buf,
+                              "expected `:` or another mode after `(?` and a mode sequence; a mode is `i`, `-i`, `m`, `-m`, `s`, or `-s`",
+                              0
+                            ),
+                          )
+                        },
+                      }
+                    }
+                  },
                 }
               },
+              Ok(_) => {
+                ignore(eat(buf, '('))
+                ignore(eat(buf, '?'))
+                parseLook(buf)
+              },
             }
           }
-        },
-        '[' => {
-          ignore(eat(buf, '['))
-          match (parseRangeNot(buf)) {
+        } else {
+          // simple group
+          ignore(eat(buf, '('))
+          let groupNum = unbox(buf.config.groupNumber)
+          // Note that this inc operation is side-effecting
+          match (parseRegex(withConfig(buf, configIncGroupNumber(buf.config)))) {
             Err(e) => Err(e),
-            Ok(rng) => Ok(makeRERange(rng, rangeLimit)),
-          }
-        },
-        '.' => {
-          ignore(eat(buf, '.'))
-          if (buf.config.multiline) {
-            // if in multiline mode, '.' matches everything but \n
-            Ok(
-              makeRERange(
-                rangeInvert(rangeAdd([], Char.code('\n')), rangeLimit),
-                rangeLimit
-              )
-            )
-          } else {
-            Ok(REAny)
+            Ok(r) => {
+              match (eat(buf, ')')) {
+                Err(e) => Err(e),
+                Ok(_) => Ok(REGroup(r, groupNum)),
+              }
+            },
           }
-        },
-        '^' => {
-          ignore(eat(buf, '^'))
-          Ok(
-            if (buf.config.multiline) {
-              RELineStart
-            } else {
-              REStart
-            }
-          )
-        },
-        '$' => {
-          ignore(eat(buf, '$'))
+        }
+      },
+      '[' => {
+        ignore(eat(buf, '['))
+        match (parseRangeNot(buf)) {
+          Err(e) => Err(e),
+          Ok(rng) => Ok(makeRERange(rng, rangeLimit)),
+        }
+      },
+      '.' => {
+        ignore(eat(buf, '.'))
+        if (buf.config.multiline) {
+          // if in multiline mode, '.' matches everything but \n
           Ok(
-            if (buf.config.multiline) {
-              RELineEnd
-            } else {
-              REEnd
-            }
+            makeRERange(
+              rangeInvert(rangeAdd([], Char.code('\n')), rangeLimit),
+              rangeLimit
+            ),
           )
-        },
-        _ => parseLiteral(buf),
+        } else {
+          Ok(REAny)
+        }
+      },
+      '^' => {
+        ignore(eat(buf, '^'))
+        Ok(if (buf.config.multiline) {
+          RELineStart
+        } else {
+          REStart
+        })
       },
+      '$' => {
+        ignore(eat(buf, '$'))
+        Ok(if (buf.config.multiline) {
+          RELineEnd
+        } else {
+          REEnd
+        })
+      },
+      _ => parseLiteral(buf),
+    },
   }
-},
-parseLook = (buf: RegExBuf) => {
+}
+and parseLook = (buf: RegExBuf) => {
   let preNumGroups = unbox(buf.config.groupNumber)
   let spanNumGroups = () => unbox(buf.config.groupNumber) - preNumGroups
   // (isMatch, isAhead)
@@ -1279,8 +1231,8 @@ parseLook = (buf: RegExBuf) => {
                     box(0),
                     box(0),
                     preNumGroups,
-                    spanNumGroups()
-                  )
+                    spanNumGroups(),
+                  ),
                 )
               }
             },
@@ -1289,8 +1241,8 @@ parseLook = (buf: RegExBuf) => {
       }
     },
   }
-},
-parseTest = (buf: RegExBuf) => {
+}
+and parseTest = (buf: RegExBuf) => {
   if (!more(buf)) {
     Err(parseErr(buf, "Expected test", 0))
   } else {
@@ -1300,9 +1252,8 @@ parseTest = (buf: RegExBuf) => {
         ignore(eat(buf, '?'))
         parseLook(buf)
       },
-      Ok(c) when (
-        Char.code(c) >= Char.code('0') && Char.code(c) <= Char.code('9')
-      ) => {
+      Ok(c) when Char.code(c) >= Char.code('0') &&
+        Char.code(c) <= Char.code('9') => {
         buf.config.references := true
         let curPos = unbox(buf.cursor)
         match (parseInteger(buf, 0)) {
@@ -1310,7 +1261,7 @@ parseTest = (buf: RegExBuf) => {
           Ok(n) => {
             if (unbox(buf.cursor) == curPos) {
               Err(
-                parseErr(buf, "expected `)` after `(?(` followed by digits", 0)
+                parseErr(buf, "expected `)` after `(?(` followed by digits", 0),
               )
             } else {
               match (eat(buf, ')')) {
@@ -1323,28 +1274,27 @@ parseTest = (buf: RegExBuf) => {
       },
       Ok(_) =>
         Err(
-          parseErr(buf, "expected `(?=`, `(?!`, `(?<`, or digit after `(?(`", 0)
+          parseErr(buf, "expected `(?=`, `(?!`, `(?<`, or digit after `(?(`", 0),
         ),
     }
   }
-},
-parseInteger = (buf: RegExBuf, n) => {
+}
+and parseInteger = (buf: RegExBuf, n) => {
   if (!more(buf)) {
     Ok(n)
   } else {
     match (peek(buf)) {
       Err(c) => Err(c),
-      Ok(c) when (
-        Char.code(c) >= Char.code('0') && Char.code(c) <= Char.code('9')
-      ) => {
+      Ok(c) when Char.code(c) >= Char.code('0') &&
+        Char.code(c) <= Char.code('9') => {
         ignore(next(buf))
         parseInteger(buf, 10 * n + (Char.code(c) - Char.code('0')))
       },
       Ok(_) => Ok(n),
     }
   }
-},
-parseMode = (buf: RegExBuf) => {
+}
+and parseMode = (buf: RegExBuf) => {
   let processState = ((cs, ml)) => {
     let withCs = match (cs) {
       None => buf.config,
@@ -1403,8 +1353,8 @@ parseMode = (buf: RegExBuf) => {
     }
   }
   help((None, None))
-},
-parseUnicodeCategories = (buf: RegExBuf, pC: String) => {
+}
+and parseUnicodeCategories = (buf: RegExBuf, pC: String) => {
   if (!more(buf)) {
     Err(parseErr(buf, "Expected unicode category", 0))
   } else {
@@ -1449,7 +1399,7 @@ parseUnicodeCategories = (buf: RegExBuf, pC: String) => {
                     LetterUppercase,
                     LetterTitlecase,
                     LetterModifier,
-                  ]
+                  ],
                 ),
               "Lo" => Ok([LetterOther]),
               "L" =>
@@ -1460,7 +1410,7 @@ parseUnicodeCategories = (buf: RegExBuf, pC: String) => {
                     LetterTitlecase,
                     LetterModifier,
                     LetterOther,
-                  ]
+                  ],
                 ),
               "Nd" => Ok([NumberDecimalDigit]),
               "Nl" => Ok([NumberLetter]),
@@ -1483,7 +1433,7 @@ parseUnicodeCategories = (buf: RegExBuf, pC: String) => {
                     PunctuationConnector,
                     PunctuationDash,
                     PunctuationOther,
-                  ]
+                  ],
                 ),
               "Mn" => Ok([MarkNonSpacing]),
               "Mc" => Ok([MarkSpacingCombining]),
@@ -1512,7 +1462,7 @@ parseUnicodeCategories = (buf: RegExBuf, pC: String) => {
                     OtherSurrogate,
                     OtherNotAssigned,
                     OtherPrivateUse,
-                  ]
+                  ],
                 ),
               "." =>
                 Ok(
@@ -1547,19 +1497,19 @@ parseUnicodeCategories = (buf: RegExBuf, pC: String) => {
                     OtherSurrogate,
                     OtherNotAssigned,
                     OtherPrivateUse,
-                  ]
+                  ],
                 ),
               s =>
                 Err(
                   parseErr(
                     buf,
                     "Unrecognized property name in `\\" ++
-                    pC ++
-                    "`: `" ++
-                    s ++
-                    "`",
+                      pC ++
+                      "`: `" ++
+                      s ++
+                      "`",
                     0
-                  )
+                  ),
                 ),
             }
           },
@@ -1572,8 +1522,8 @@ parseUnicodeCategories = (buf: RegExBuf, pC: String) => {
       Ok(_) => Err(parseErr(buf, "Expected `{` after `\\" ++ pC ++ "`", 0)),
     }
   }
-},
-parseLiteral = (buf: RegExBuf) => {
+}
+and parseLiteral = (buf: RegExBuf) => {
   if (!more(buf)) {
     Err(parseErr(buf, "Expected literal", 0))
   } else {
@@ -1591,7 +1541,7 @@ parseLiteral = (buf: RegExBuf) => {
       Ok(')') => Err(parseErr(buf, "Unmatched `)` in pattern", 0)),
       Ok(c) when buf.config.isPerlRegExp && (c == ']' || c == '}') =>
         Err(
-          parseErr(buf, "unmatched `" ++ Char.toString(c) ++ "` in pattern", 0)
+          parseErr(buf, "unmatched `" ++ Char.toString(c) ++ "` in pattern", 0),
         ),
       // TODO(#691): Enable case-insensitive regular expression matching
       Ok(c) when buf.config.caseSensitive => {
@@ -1607,8 +1557,8 @@ parseLiteral = (buf: RegExBuf) => {
       },
     }
   }
-},
-parseBackslashLiteral = (buf: RegExBuf) => {
+}
+and parseBackslashLiteral = (buf: RegExBuf) => {
   if (!more(buf)) {
     // Special case: EOS after backslash matches null
     Err(parseErr(buf, "Expected to find escaped value after backslash", 0))
@@ -1616,11 +1566,8 @@ parseBackslashLiteral = (buf: RegExBuf) => {
     match (peek(buf)) {
       Err(e) => Err(e),
       // pregexp:
-      Ok(c) when (
-        buf.config.isPerlRegExp &&
-        (Char.code(c) >= Char.code('0') &&
-          Char.code(c) <= Char.code('9'))
-      ) => {
+      Ok(c) when buf.config.isPerlRegExp &&
+        (Char.code(c) >= Char.code('0') && Char.code(c) <= Char.code('9')) => {
         buf.config.references := true
         match (parseInteger(buf, 0)) {
           Err(e) => Err(e),
@@ -1629,11 +1576,11 @@ parseBackslashLiteral = (buf: RegExBuf) => {
           },
         }
       },
-      Ok(c) when (
-        buf.config.isPerlRegExp &&
-        (Char.code(c) >= Char.code('a') && Char.code(c) <= Char.code('z') ||
-          Char.code(c) >= Char.code('A') && Char.code(c) <= Char.code('Z'))
-      ) => {
+      Ok(c) when buf.config.isPerlRegExp &&
+        (
+          Char.code(c) >= Char.code('a') && Char.code(c) <= Char.code('z') ||
+          Char.code(c) >= Char.code('A') && Char.code(c) <= Char.code('Z')
+        ) => {
         match (c) {
           'p' => {
             ignore(eat(buf, 'p'))
@@ -1671,15 +1618,15 @@ parseBackslashLiteral = (buf: RegExBuf) => {
       },
     }
   }
-},
-parseNonGreedy = (buf: RegExBuf) => {
+}
+and parseNonGreedy = (buf: RegExBuf) => {
   let checkNotNested = res => {
     if (!more(buf)) {
       res
     } else {
       match (peek(buf)) {
         Err(e) => Err(e),
-        Ok(c) when c == '?' || c == '*' || c == '+' => {
+        Ok('?' | '*' | '+' as c) => {
           Err(parseErr(buf, "nested '" ++ toString(c) ++ "' in pattern", 0))
         },
         Ok(_) => res,
@@ -1698,8 +1645,8 @@ parseNonGreedy = (buf: RegExBuf) => {
       Ok(_) => checkNotNested(Ok(false)),
     }
   }
-},
-parsePCE = (buf: RegExBuf) => {
+}
+and parsePCE = (buf: RegExBuf) => {
   match (parseAtom(buf)) {
     Err(e) => Err(e),
     Ok(atom) => {
@@ -1762,7 +1709,7 @@ parsePCE = (buf: RegExBuf) => {
                                 buf,
                                 "expected digit or `}` to end repetition specification started with `{`",
                                 0
-                              )
+                              ),
                             ),
                         }
                       },
@@ -1782,7 +1729,7 @@ parsePCE = (buf: RegExBuf) => {
                         buf,
                         "expected digit, `,`, or `}' for repetition specification started with `{`",
                         0
-                      )
+                      ),
                     ),
                 }
               },
@@ -1793,8 +1740,8 @@ parsePCE = (buf: RegExBuf) => {
       }
     },
   }
-},
-parsePCEs = (buf: RegExBuf, toplevel: Bool) => {
+}
+and parsePCEs = (buf: RegExBuf, toplevel: Bool) => {
   if (!more(buf)) {
     Ok([])
   } else {
@@ -1820,8 +1767,8 @@ parsePCEs = (buf: RegExBuf, toplevel: Bool) => {
       },
     }
   }
-},
-parseRegex = (buf: RegExBuf) => {
+}
+and parseRegex = (buf: RegExBuf) => {
   if (!more(buf)) {
     Ok(REEmpty)
   } else {
@@ -1856,8 +1803,8 @@ parseRegex = (buf: RegExBuf) => {
       },
     }
   }
-},
-parseRegexNonEmpty = (buf: RegExBuf) => {
+}
+and parseRegexNonEmpty = (buf: RegExBuf) => {
   match (parsePCEs(buf, false)) {
     Err(e) => Err(e),
     Ok(pces) => {
@@ -1931,8 +1878,8 @@ let rec isAnchored = (re: ParsedRegularExpression) => {
           [] => false,
           [hd, ...tl] => {
             match (hd) {
-              RELookahead(_, _, _, _) => loop(tl),
-              RELookbehind(_, _, _, _, _, _) => loop(tl),
+              RELookahead(_, _, _, _) | RELookbehind(_, _, _, _, _, _) =>
+                loop(tl),
               _ => isAnchored(hd),
             }
           },
@@ -1942,8 +1889,7 @@ let rec isAnchored = (re: ParsedRegularExpression) => {
     },
     REAlts(a, b) => isAnchored(a) && isAnchored(b),
     REConditional(_, rx1, rx2, _, _, _) =>
-      isAnchored(rx1) &&
-        Option.mapWithDefault(isAnchored, false, rx2),
+      isAnchored(rx1) && Option.mapWithDefault(isAnchored, false, rx2),
     REGroup(rx, _) => isAnchored(rx),
     RECut(rx, _, _, _) => isAnchored(rx),
     _ => false,
@@ -1986,15 +1932,14 @@ let rec mustString = (re: ParsedRegularExpression) => {
 
 let rec zeroSized = re => {
   match (re) {
-    REEmpty => true,
-    REStart => true,
-    RELineStart => true,
-    REWordBoundary => true,
-    RENotWordBoundary => true,
-    RELookahead(_, _, _, _) => true,
+    REEmpty |
+    REStart |
+    RELineStart |
+    REWordBoundary |
+    RENotWordBoundary |
+    RELookahead(_, _, _, _) |
     RELookbehind(_, _, _, _, _, _) => true,
-    REGroup(re, _) => zeroSized(re),
-    RECut(re, _, _, _) => zeroSized(re),
+    REGroup(re, _) | RECut(re, _, _, _) => zeroSized(re),
     _ => false,
   }
 }
@@ -2077,37 +2022,29 @@ let rec validate = (re: ParsedRegularExpression, numGroups) => {
   /**
    Computes the range of possible UTF-8 byte lengths for the given character range
    */
-
   let rangeUtf8EncodingLengths = (rng: CharRange) => {
-    let (min, max, _) = List.reduce(((min1, max1, n), (segStart, segEnd)) => {
-      if (rangeOverlaps(rng, segStart, segEnd)) {
-        (min(min1, n), max(max1, n), n + 1)
-      } else {
-        (min1, max1, n + 1)
-      }
-    },
-    (4, 0, 1),
-    [(0, 127), (128, 0x7ff), (0x800, 0x7fff), (0x10000, 0x10ffff)]
+    let (min, max, _) = List.reduce(
+      ((min1, max1, n), (segStart, segEnd)) => {
+        if (rangeOverlaps(rng, segStart, segEnd)) {
+          (min(min1, n), max(max1, n), n + 1)
+        } else {
+          (min1, max1, n + 1)
+        }
+      },
+      (4, 0, 1),
+      [(0, 127), (128, 0x7ff), (0x800, 0x7fff), (0x10000, 0x10ffff)]
     )
     (min, max)
   }
   let rec loop = re => {
     match (re) {
-      RENever => (1, 1, 0),
-      REAny => (1, 1, 0),
-      RELiteral(_) => (1, 1, 0),
-      RERange(_) => (1, 1, 0),
+      RENever | REAny | RELiteral(_) | RERange(_) => (1, 1, 0),
       RELiteralString(s) => {
         let ls = String.length(s)
         (ls, ls, 0)
       },
-      REEmpty => (0, 0, 0),
-      REEnd => (0, 0, 0),
-      RELineEnd => (0, 0, 0),
-      REStart => (0, 0, 1),
-      RELineStart => (0, 0, 1),
-      REWordBoundary => (0, 0, 1),
-      RENotWordBoundary => (0, 0, 1),
+      REEmpty | REEnd | RELineEnd => (0, 0, 0),
+      REStart | RELineStart | REWordBoundary | RENotWordBoundary => (0, 0, 1),
       REAlts(re1, re2) => {
         let (min1, max1, maxL1) = loop(re1)
         let (min2, max2, maxL2) = loop(re2)
@@ -2137,7 +2074,7 @@ let rec validate = (re: ParsedRegularExpression, numGroups) => {
           mustSizes = mergeDependsSizes(oldMustSizes, mustSizes)
           dependsSizes = mergeDependsSizes(oldDependsSizes, dependsSizes)
           let repeatMax = match (repeatMax) {
-            None => Float32.toNumber(Float32.infinity),
+            None => Infinity,
             Some(n) => n,
           }
           (min1 * repeatMin, max1 * repeatMax, maxL1)
@@ -2163,7 +2100,7 @@ let rec validate = (re: ParsedRegularExpression, numGroups) => {
       },
       RELookbehind(re, _, lbMin, lbMax, _, _) => {
         let (min1, max1, maxL1) = loop(re)
-        if (max1 == Float32.toNumber(Float32.infinity)) {
+        if (max1 == Infinity) {
           thrownError = Some(DoesNotMatchBounded)
           (0, 0, 0)
         } else {
@@ -2172,19 +2109,17 @@ let rec validate = (re: ParsedRegularExpression, numGroups) => {
           (0, 0, max(max1, maxL1))
         }
       },
-      RECut(re, _, _, _) => {
-        loop(re)
-      },
+      RECut(re, _, _, _) => loop(re),
       REReference(n, _) => {
         if (n > numGroups) {
           thrownError = Some(BackreferenceTooBig)
           (0, 0, 0)
         } else {
           match (Map.get(n, groupSizes)) {
-            Some(minSize) => (minSize, Float32.toNumber(Float32.infinity), 0),
+            Some(minSize) => (minSize, Infinity, 0),
             None => {
               Map.set(n - 1, true, dependsSizes)
-              (1, Float32.toNumber(Float32.infinity), 0)
+              (1, Infinity, 0)
             },
           }
         }
@@ -2245,46 +2180,42 @@ let matchBufChar = (buf: MatchBuf, pos: Number) => {
 }
 
 enum StackElt {
-  SEPositionProducer(Number -> Option<Number>),
+  SEPositionProducer(Number => Option<Number>),
   SESavedGroup(Number, Option<(Number, Number)>),
 }
 
-let done_m =
-  (
-    buf: MatchBuf,
-    pos: Number,
-    start: Number,
-    limit: Number,
-    end: Number,
-    state,
-    stack,
-  ) =>
-  Some(pos)
-let continue_m =
-  (
-    buf: MatchBuf,
-    pos: Number,
-    start: Number,
-    limit: Number,
-    end: Number,
-    state,
-    stack,
-  ) => {
+let done_m = (
+  buf: MatchBuf,
+  pos: Number,
+  start: Number,
+  limit: Number,
+  end: Number,
+  state,
+  stack,
+) => Some(pos)
+let continue_m = (
+  buf: MatchBuf,
+  pos: Number,
+  start: Number,
+  limit: Number,
+  end: Number,
+  state,
+  stack,
+) => {
   match (stack) {
     [SEPositionProducer(hd), ..._] => hd(pos),
     _ => fail "Impossible: continue_m",
   }
 }
-let limit_m =
-  (
-    buf: MatchBuf,
-    pos: Number,
-    start: Number,
-    limit: Number,
-    end: Number,
-    state,
-    stack,
-  ) => if (pos == limit) Some(pos) else None
+let limit_m = (
+  buf: MatchBuf,
+  pos: Number,
+  start: Number,
+  limit: Number,
+  end: Number,
+  state,
+  stack,
+) => if (pos == limit) Some(pos) else None
 
 let iterateMatcher = (m, size, max) =>
   (
@@ -2296,20 +2227,20 @@ let iterateMatcher = (m, size, max) =>
     state,
     stack,
   ) => {
-  let limit = match (max) {
-    Some(max) => min(limit, pos + max * size),
-    None => limit,
-  }
-  let rec loop = (pos2, n) => {
-    let pos3 = pos2 + size
-    if (pos3 > limit || !m(buf, pos2, start, limit, end, state, stack)) {
-      (pos2, n, size)
-    } else {
-      loop(pos3, n + 1)
+    let limit = match (max) {
+      Some(max) => min(limit, pos + max * size),
+      None => limit,
+    }
+    let rec loop = (pos2, n) => {
+      let pos3 = pos2 + size
+      if (pos3 > limit || !m(buf, pos2, start, limit, end, state, stack)) {
+        (pos2, n, size)
+      } else {
+        loop(pos3, n + 1)
+      }
     }
+    loop(pos, 0)
   }
-  loop(pos, 0)
-}
 
 // single-char matching
 
@@ -2323,16 +2254,13 @@ let charMatcher = (toMatch, next_m) =>
     state,
     stack,
   ) => {
-  if (
-    {
-      pos < limit &&
-        match (matchBufChar(buf, pos)) {
-          Err(_) => false,
-          Ok(c) => toMatch == c,
-        }
-    }
-  ) next_m(buf, pos + 1, start, limit, end, state, stack) else None
-}
+    if ({
+      pos < limit && match (matchBufChar(buf, pos)) {
+        Err(_) => false,
+        Ok(c) => toMatch == c,
+      }
+    }) next_m(buf, pos + 1, start, limit, end, state, stack) else None
+  }
 
 let charTailMatcher = toMatch =>
   (
@@ -2344,50 +2272,49 @@ let charTailMatcher = toMatch =>
     state,
     stack,
   ) => {
-  if (
-    {
-      pos < limit &&
-        match (matchBufChar(buf, pos)) {
-          Err(_) => false,
-          Ok(c) => toMatch == c,
-        }
-    }
-  ) Some(pos + 1) else None
-}
+    if ({
+      pos < limit && match (matchBufChar(buf, pos)) {
+        Err(_) => false,
+        Ok(c) => toMatch == c,
+      }
+    }) Some(pos + 1) else None
+  }
 
 let charMatcherIterated = (toMatch, max) =>
-  iterateMatcher((
-    buf: MatchBuf,
-    pos: Number,
-    start: Number,
-    limit: Number,
-    end: Number,
-    state,
-    stack
-  ) => {
-    match (matchBufChar(buf, pos)) {
-      Err(_) => false,
-      Ok(c) => toMatch == c,
-    }
-  }, 1, max)
+  iterateMatcher(
+    (
+      buf: MatchBuf,
+      pos: Number,
+      start: Number,
+      limit: Number,
+      end: Number,
+      state,
+      stack,
+    ) => {
+      match (matchBufChar(buf, pos)) {
+        Err(_) => false,
+        Ok(c) => toMatch == c,
+      }
+    },
+    1,
+    max
+  )
 
 // string matching
 
 let subArraysEqual = (arr1, start1, arr2, start2, length) => {
   if (
-    Array.length(arr1) - start1 < length || Array.length(arr2) - start2 < length
+    Array.length(arr1) - start1 < length ||
+    Array.length(arr2) - start2 < length
   ) {
-    false
-  } else {
-    let mut result = true
-    for (let mut i = 0; i < length; i += 1) {
-      if (arr1[start1 + i] != arr2[start2 + i]) {
-        result = false
-        break
-      }
+    return false
+  }
+  for (let mut i = 0; i < length; i += 1) {
+    if (arr1[start1 + i] != arr2[start2 + i]) {
+      return false
     }
-    result
   }
+  return true
 }
 
 let stringMatcher = (toMatch, len, next_m) =>
@@ -2400,8 +2327,7 @@ let stringMatcher = (toMatch, len, next_m) =>
     state,
     stack,
   ) => {
-  if (
-    {
+    if ({
       pos + len <= limit &&
         subArraysEqual(
           buf.matchInputExploded,
@@ -2410,9 +2336,8 @@ let stringMatcher = (toMatch, len, next_m) =>
           0,
           len
         )
-    }
-  ) next_m(buf, pos + len, start, limit, end, state, stack) else None
-}
+    }) next_m(buf, pos + len, start, limit, end, state, stack) else None
+  }
 
 let stringTailMatcher = (toMatch, len) =>
   (
@@ -2424,8 +2349,7 @@ let stringTailMatcher = (toMatch, len) =>
     state,
     stack,
   ) => {
-  if (
-    {
+    if ({
       pos + len <= limit &&
         subArraysEqual(
           buf.matchInputExploded,
@@ -2434,27 +2358,50 @@ let stringTailMatcher = (toMatch, len) =>
           0,
           len
         )
-    }
-  ) Some(pos + len) else None
-}
+    }) Some(pos + len) else None
+  }
 
 let stringMatcherIterated = (toMatch, len, max) =>
-  iterateMatcher((
-    buf: MatchBuf,
-    pos: Number,
-    start: Number,
-    limit: Number,
-    end: Number,
-    state,
-    stack
-  ) => {
-    subArraysEqual(buf.matchInputExploded, pos, String.explode(toMatch), 0, len)
-  }, len, max)
-
-// match nothing
-
-let neverMatcher =
-  (
+  iterateMatcher(
+    (
+      buf: MatchBuf,
+      pos: Number,
+      start: Number,
+      limit: Number,
+      end: Number,
+      state,
+      stack,
+    ) => {
+      subArraysEqual(
+        buf.matchInputExploded,
+        pos,
+        String.explode(toMatch),
+        0,
+        len
+      )
+    },
+    len,
+    max
+  )
+
+// match nothing
+
+let neverMatcher = (
+  buf: MatchBuf,
+  pos: Number,
+  start: Number,
+  limit: Number,
+  end: Number,
+  state,
+  stack,
+) => {
+  None
+}
+
+// match any byte
+
+let anyMatcher = next_m =>
+  (
     buf: MatchBuf,
     pos: Number,
     start: Number,
@@ -2463,27 +2410,10 @@ let neverMatcher =
     state,
     stack,
   ) => {
-  None
-}
-
-// match any byte
-
-let anyMatcher = next_m =>
-  (
-    buf: MatchBuf,
-    pos: Number,
-    start: Number,
-    limit: Number,
-    end: Number,
-    state,
-    stack,
-  ) => {
-  if (
-    {
+    if ({
       pos < limit
-    }
-  ) next_m(buf, pos + 1, start, limit, end, state, stack) else None
-}
+    }) next_m(buf, pos + 1, start, limit, end, state, stack) else None
+  }
 
 let anyTailMatcher = () =>
   (
@@ -2495,12 +2425,10 @@ let anyTailMatcher = () =>
     state,
     stack,
   ) => {
-  if (
-    {
+    if ({
       pos < limit
-    }
-  ) Some(pos + 1) else None
-}
+    }) Some(pos + 1) else None
+  }
 
 let anyMatcherIterated = max =>
   (
@@ -2512,12 +2440,12 @@ let anyMatcherIterated = max =>
     state,
     stack,
   ) => {
-  let n = match (max) {
-    None => limit - pos,
-    Some(max) => min(max, limit - pos),
+    let n = match (max) {
+      None => limit - pos,
+      Some(max) => min(max, limit - pos),
+    }
+    (pos + n, n, 1)
   }
-  (pos + n, n, 1)
-}
 
 // match byte in set (range)
 
@@ -2531,16 +2459,13 @@ let rangeMatcher = (rng: CharRange, next_m) =>
     state,
     stack,
   ) => {
-  if (
-    {
-      pos < limit &&
-        match (matchBufChar(buf, pos)) {
-          Err(_) => false,
-          Ok(c) => rangeContains(rng, Char.code(c)),
-        }
-    }
-  ) next_m(buf, pos + 1, start, limit, end, state, stack) else None
-}
+    if ({
+      pos < limit && match (matchBufChar(buf, pos)) {
+        Err(_) => false,
+        Ok(c) => rangeContains(rng, Char.code(c)),
+      }
+    }) next_m(buf, pos + 1, start, limit, end, state, stack) else None
+  }
 
 let rangeTailMatcher = (rng: CharRange) =>
   (
@@ -2552,32 +2477,33 @@ let rangeTailMatcher = (rng: CharRange) =>
     state,
     stack,
   ) => {
-  if (
-    {
-      pos < limit &&
-        match (matchBufChar(buf, pos)) {
-          Err(_) => false,
-          Ok(c) => rangeContains(rng, Char.code(c)),
-        }
-    }
-  ) Some(pos + 1) else None
-}
+    if ({
+      pos < limit && match (matchBufChar(buf, pos)) {
+        Err(_) => false,
+        Ok(c) => rangeContains(rng, Char.code(c)),
+      }
+    }) Some(pos + 1) else None
+  }
 
 let rangeMatcherIterated = (rng: CharRange, max) =>
-  iterateMatcher((
-    buf: MatchBuf,
-    pos: Number,
-    start: Number,
-    limit: Number,
-    end: Number,
-    state,
-    stack
-  ) => {
-    match (matchBufChar(buf, pos)) {
-      Err(_) => false,
-      Ok(c) => rangeContains(rng, Char.code(c)),
-    }
-  }, 1, max)
+  iterateMatcher(
+    (
+      buf: MatchBuf,
+      pos: Number,
+      start: Number,
+      limit: Number,
+      end: Number,
+      state,
+      stack,
+    ) => {
+      match (matchBufChar(buf, pos)) {
+        Err(_) => false,
+        Ok(c) => rangeContains(rng, Char.code(c)),
+      }
+    },
+    1,
+    max
+  )
 
 // zero-width matchers
 
@@ -2591,8 +2517,11 @@ let startMatcher = next_m =>
     state,
     stack,
   ) => {
-  if (pos == start) next_m(buf, pos, start, limit, end, state, stack) else None
-}
+    if (pos == start)
+      next_m(buf, pos, start, limit, end, state, stack)
+    else
+      None
+  }
 
 let endMatcher = next_m =>
   (
@@ -2604,8 +2533,8 @@ let endMatcher = next_m =>
     state,
     stack,
   ) => {
-  if (pos == end) next_m(buf, pos, start, limit, end, state, stack) else None
-}
+    if (pos == end) next_m(buf, pos, start, limit, end, state, stack) else None
+  }
 
 let lineStartMatcher = next_m =>
   (
@@ -2617,9 +2546,11 @@ let lineStartMatcher = next_m =>
     state,
     stack,
   ) => {
-  if (pos == start || matchBufChar(buf, pos - 1) == Ok('\n'))
-    next_m(buf, pos, start, limit, end, state, stack) else None
-}
+    if (pos == start || matchBufChar(buf, pos - 1) == Ok('\n'))
+      next_m(buf, pos, start, limit, end, state, stack)
+    else
+      None
+  }
 
 let lineEndMatcher = next_m =>
   (
@@ -2631,24 +2562,20 @@ let lineEndMatcher = next_m =>
     state,
     stack,
   ) => {
-  if (pos == end || matchBufChar(buf, pos) == Ok('\n'))
-    next_m(buf, pos, start, limit, end, state, stack) else None
-}
+    if (pos == end || matchBufChar(buf, pos) == Ok('\n'))
+      next_m(buf, pos, start, limit, end, state, stack)
+    else
+      None
+  }
 
 let isWordChar = c => {
   match (c) {
     Err(_) => false,
-    Ok(c) when (
-      Char.code('0') <= Char.code(c) && Char.code(c) <= Char.code('9')
-    ) =>
+    Ok(c) when Char.code('0') <= Char.code(c) && Char.code(c) <= Char.code('9') =>
       true,
-    Ok(c) when (
-      Char.code('a') <= Char.code(c) && Char.code(c) <= Char.code('z')
-    ) =>
+    Ok(c) when Char.code('a') <= Char.code(c) && Char.code(c) <= Char.code('z') =>
       true,
-    Ok(c) when (
-      Char.code('A') <= Char.code(c) && Char.code(c) <= Char.code('Z')
-    ) =>
+    Ok(c) when Char.code('A') <= Char.code(c) && Char.code(c) <= Char.code('Z') =>
       true,
     Ok(c) when Char.code('_') <= Char.code(c) => true,
     _ => false,
@@ -2656,8 +2583,10 @@ let isWordChar = c => {
 }
 
 let isWordBoundary = (buf, pos, start, limit, end) => {
-  !((pos == start || !isWordChar(matchBufChar(buf, pos - 1))) ==
-    (pos == end || !isWordChar(matchBufChar(buf, pos))))
+  !(
+    (pos == start || !isWordChar(matchBufChar(buf, pos - 1))) ==
+      (pos == end || !isWordChar(matchBufChar(buf, pos)))
+  )
 }
 
 let wordBoundaryMatcher = next_m =>
@@ -2670,9 +2599,11 @@ let wordBoundaryMatcher = next_m =>
     state,
     stack,
   ) => {
-  if (isWordBoundary(buf, pos, start, limit, end))
-    next_m(buf, pos, start, limit, end, state, stack) else None
-}
+    if (isWordBoundary(buf, pos, start, limit, end))
+      next_m(buf, pos, start, limit, end, state, stack)
+    else
+      None
+  }
 
 let notWordBoundaryMatcher = next_m =>
   (
@@ -2684,9 +2615,11 @@ let notWordBoundaryMatcher = next_m =>
     state,
     stack,
   ) => {
-  if (!isWordBoundary(buf, pos, start, limit, end))
-    next_m(buf, pos, start, limit, end, state, stack) else None
-}
+    if (!isWordBoundary(buf, pos, start, limit, end))
+      next_m(buf, pos, start, limit, end, state, stack)
+    else
+      None
+  }
 
 // Alternatives
 
@@ -2700,11 +2633,11 @@ let altsMatcher = (m1, m2) =>
     state,
     stack,
   ) => {
-  match (m1(buf, pos, start, limit, end, state, stack)) {
-    None => m2(buf, pos, start, limit, end, state, stack),
-    Some(v) => Some(v),
+    match (m1(buf, pos, start, limit, end, state, stack)) {
+      None => m2(buf, pos, start, limit, end, state, stack),
+      Some(v) => Some(v),
+    }
   }
-}
 
 // repeats, greedy (default) and non-greedy
 
@@ -2718,27 +2651,25 @@ let repeatMatcher = (r_m, min, max, next_m) =>
     state,
     stack,
   ) => {
-  let rec rloop = (pos, n) => {
-    if (n < min) {
-      let newStack = [SEPositionProducer(pos => rloop(pos, n + 1)), ...stack]
-      r_m(buf, pos, start, limit, end, state, newStack)
-    } else if (
-      match (max) {
+    let rec rloop = (pos, n) => {
+      if (n < min) {
+        let newStack = [SEPositionProducer(pos => rloop(pos, n + 1)), ...stack]
+        r_m(buf, pos, start, limit, end, state, newStack)
+      } else if (match (max) {
         None => false,
         Some(max) => max == n,
-      }
-    ) {
-      next_m(buf, pos, start, limit, end, state, stack)
-    } else {
-      let newStack = [SEPositionProducer(pos => rloop(pos, n + 1)), ...stack]
-      match (r_m(buf, pos, start, limit, end, state, newStack)) {
-        Some(v) => Some(v),
-        None => next_m(buf, pos, start, limit, end, state, stack),
+      }) {
+        next_m(buf, pos, start, limit, end, state, stack)
+      } else {
+        let newStack = [SEPositionProducer(pos => rloop(pos, n + 1)), ...stack]
+        match (r_m(buf, pos, start, limit, end, state, newStack)) {
+          Some(v) => Some(v),
+          None => next_m(buf, pos, start, limit, end, state, stack),
+        }
       }
     }
+    rloop(pos, 0)
   }
-  rloop(pos, 0)
-}
 
 let rStack = [SEPositionProducer(pos => Some(pos))]
 
@@ -2795,44 +2726,45 @@ let repeatSimpleMatcher = (r_m, min, max, groupN, next_m) =>
     state,
     stack,
   ) => {
-  let rec rloop = (pos, n, backAmt) => {
-    let pos2 = match (max) {
-      Some(max) when n < max => r_m(buf, pos, start, limit, end, state, rStack),
-      Some(_) => None,
-      _ => r_m(buf, pos, start, limit, end, state, rStack),
-    }
-    match (pos2) {
-      Some(pos2) => rloop(pos2, n + 1, pos2 - pos),
-      None => {
-        // Perform backtracking
-        let rec bloop = (pos, n) => {
-          if (n < min) {
-            None
-          } else {
-            addRepeatedGroup(
-              groupN,
-              state,
-              pos,
-              n,
-              backAmt,
-              groupRevert => {
-                match (next_m(buf, pos, start, limit, end, state, stack)) {
-                  Some(v) => Some(v),
-                  None => {
-                    groupRevert()
-                    bloop(pos - backAmt, n - 1)
-                  },
+    let rec rloop = (pos, n, backAmt) => {
+      let pos2 = match (max) {
+        Some(max) when n < max =>
+          r_m(buf, pos, start, limit, end, state, rStack),
+        Some(_) => None,
+        _ => r_m(buf, pos, start, limit, end, state, rStack),
+      }
+      match (pos2) {
+        Some(pos2) => rloop(pos2, n + 1, pos2 - pos),
+        None => {
+          // Perform backtracking
+          let rec bloop = (pos, n) => {
+            if (n < min) {
+              None
+            } else {
+              addRepeatedGroup(
+                groupN,
+                state,
+                pos,
+                n,
+                backAmt,
+                groupRevert => {
+                  match (next_m(buf, pos, start, limit, end, state, stack)) {
+                    Some(v) => Some(v),
+                    None => {
+                      groupRevert()
+                      bloop(pos - backAmt, n - 1)
+                    },
+                  }
                 }
-              }
-            )
+              )
+            }
           }
-        }
-        bloop(pos, n)
-      },
+          bloop(pos, n)
+        },
+      }
     }
+    rloop(pos, 0, 0)
   }
-  rloop(pos, 0, 0)
-}
 
 let repeatSimpleManyMatcher = (r_m, min, max, groupN, next_m) =>
   (
@@ -2844,18 +2776,12 @@ let repeatSimpleManyMatcher = (r_m, min, max, groupN, next_m) =>
     state,
     stack,
   ) => {
-  let (pos2, n, backAmt) = r_m(buf, pos, start, limit, end, state, stack)
-  let rec bloop = (pos, n) => {
-    if (n < min) {
-      None
-    } else {
-      addRepeatedGroup(
-        groupN,
-        state,
-        pos,
-        n,
-        backAmt,
-        groupRevert => {
+    let (pos2, n, backAmt) = r_m(buf, pos, start, limit, end, state, stack)
+    let rec bloop = (pos, n) => {
+      if (n < min) {
+        None
+      } else {
+        addRepeatedGroup(groupN, state, pos, n, backAmt, groupRevert => {
           match (next_m(buf, pos, start, limit, end, state, stack)) {
             Some(v) => Some(v),
             None => {
@@ -2863,12 +2789,11 @@ let repeatSimpleManyMatcher = (r_m, min, max, groupN, next_m) =>
               bloop(pos - backAmt, n - 1)
             },
           }
-        }
-      )
+        })
+      }
     }
+    bloop(pos2, n)
   }
-  bloop(pos2, n)
-}
 
 let lazyRepeatMatcher = (r_m, min, max, next_m) =>
   (
@@ -2880,29 +2805,27 @@ let lazyRepeatMatcher = (r_m, min, max, next_m) =>
     state,
     stack,
   ) => {
-  let rec rloop = (pos, n, min) => {
-    if (n < min) {
-      let newStack = [
-        SEPositionProducer(pos => rloop(pos, n + 1, min)),
-        ...stack
-      ]
-      r_m(buf, pos, start, limit, end, state, newStack)
-    } else if (
-      match (max) {
+    let rec rloop = (pos, n, min) => {
+      if (n < min) {
+        let newStack = [
+          SEPositionProducer(pos => rloop(pos, n + 1, min)),
+          ...stack
+        ]
+        r_m(buf, pos, start, limit, end, state, newStack)
+      } else if (match (max) {
         None => false,
         Some(max) => max == n,
-      }
-    ) {
-      next_m(buf, pos, start, limit, end, state, stack)
-    } else {
-      match (next_m(buf, pos, start, limit, end, state, stack)) {
-        Some(p) => Some(p),
-        None => rloop(pos, n, min + 1),
+      }) {
+        next_m(buf, pos, start, limit, end, state, stack)
+      } else {
+        match (next_m(buf, pos, start, limit, end, state, stack)) {
+          Some(p) => Some(p),
+          None => rloop(pos, n, min + 1),
+        }
       }
     }
+    rloop(pos, 0, min)
   }
-  rloop(pos, 0, min)
-}
 
 let lazyRepeatSimpleMatcher = (r_m, min, max, next_m) =>
   (
@@ -2914,28 +2837,26 @@ let lazyRepeatSimpleMatcher = (r_m, min, max, next_m) =>
     state,
     stack,
   ) => {
-  let rec rloop = (pos, n, min) => {
-    if (n < min) {
-      match (r_m(buf, pos, start, limit, end, state, stack)) {
-        Some(p) => rloop(p, n + 1, min),
-        None => None,
-      }
-    } else if (
-      match (max) {
+    let rec rloop = (pos, n, min) => {
+      if (n < min) {
+        match (r_m(buf, pos, start, limit, end, state, stack)) {
+          Some(p) => rloop(p, n + 1, min),
+          None => None,
+        }
+      } else if (match (max) {
         None => false,
         Some(max) => max == n,
-      }
-    ) {
-      next_m(buf, pos, start, limit, end, state, stack)
-    } else {
-      match (next_m(buf, pos, start, limit, end, state, stack)) {
-        Some(p) => Some(p),
-        None => rloop(pos, n, min + 1),
+      }) {
+        next_m(buf, pos, start, limit, end, state, stack)
+      } else {
+        match (next_m(buf, pos, start, limit, end, state, stack)) {
+          Some(p) => Some(p),
+          None => rloop(pos, n, min + 1),
+        }
       }
     }
+    rloop(pos, 0, min)
   }
-  rloop(pos, 0, min)
-}
 
 // Recording and referencing group matches
 
@@ -2949,12 +2870,12 @@ let groupPushMatcher = (n, next_m) =>
     state,
     stack,
   ) => {
-  let newStack = [
-    SESavedGroup(pos, if (Array.length(state) > 0) state[n] else None),
-    ...stack
-  ]
-  next_m(buf, pos, start, limit, end, state, newStack)
-}
+    let newStack = [
+      SESavedGroup(pos, if (Array.length(state) > 0) state[n] else None),
+      ...stack
+    ]
+    next_m(buf, pos, start, limit, end, state, newStack)
+  }
 
 let groupSetMatcher = (n, next_m) =>
   (
@@ -2966,56 +2887,57 @@ let groupSetMatcher = (n, next_m) =>
     state,
     stack,
   ) => {
-  match (stack) {
-    [SESavedGroup(oldPos, oldSpan), ...stackTl] => {
-      if (Array.length(state) > 0) {
-        state[n] = Some((oldPos, pos))
-      }
-      match (next_m(buf, pos, start, limit, end, state, stackTl)) {
-        Some(v) => Some(v),
-        None => {
-          if (Array.length(state) > 0) {
-            state[n] = oldSpan
-          }
-          None
-        },
-      }
-    },
-    _ => fail "Impossible: groupSetMatcher",
+    match (stack) {
+      [SESavedGroup(oldPos, oldSpan), ...stackTl] => {
+        if (Array.length(state) > 0) {
+          state[n] = Some((oldPos, pos))
+        }
+        match (next_m(buf, pos, start, limit, end, state, stackTl)) {
+          Some(v) => Some(v),
+          None => {
+            if (Array.length(state) > 0) {
+              state[n] = oldSpan
+            }
+            None
+          },
+        }
+      },
+      _ => fail "Impossible: groupSetMatcher",
+    }
   }
-}
 
-let makeReferenceMatcher = eq => (n, next_m) =>
-  (
-    buf: MatchBuf,
-    pos: Number,
-    start: Number,
-    limit: Number,
-    end: Number,
-    state,
-    stack,
-  ) => {
-  match (state[n]) {
-    None => None,
-    Some((refStart, refEnd)) => {
-      let len = refEnd - refStart
-      if (
-        pos + len <= limit &&
-        subArraysEqual(
-          buf.matchInputExploded,
-          refStart,
-          buf.matchInputExploded,
-          pos,
-          len
-        )
-      ) {
-        next_m(buf, pos + len, start, limit, end, state, stack)
-      } else {
-        None
+let makeReferenceMatcher = eq =>
+  (n, next_m) =>
+    (
+      buf: MatchBuf,
+      pos: Number,
+      start: Number,
+      limit: Number,
+      end: Number,
+      state,
+      stack,
+    ) => {
+      match (state[n]) {
+        None => None,
+        Some((refStart, refEnd)) => {
+          let len = refEnd - refStart
+          if (
+            pos + len <= limit &&
+            subArraysEqual(
+              buf.matchInputExploded,
+              refStart,
+              buf.matchInputExploded,
+              pos,
+              len
+            )
+          ) {
+            next_m(buf, pos + len, start, limit, end, state, stack)
+          } else {
+            None
+          }
+        },
       }
-    },
-  }
-}
+    }
 
 let referenceMatcher = makeReferenceMatcher(((a, b)) => a == b)
 
@@ -3027,8 +2949,9 @@ let asciiCharToLower = c => {
   }
 }
 
-let referenceMatcherCaseInsensitive = makeReferenceMatcher(((a, b)) =>
-  asciiCharToLower(a) == asciiCharToLower(b))
+let referenceMatcherCaseInsensitive = makeReferenceMatcher(
+  ((a, b)) => asciiCharToLower(a) == asciiCharToLower(b)
+)
 
 // Lookahead, Lookbehind, Conditionals, and Cut
 
@@ -3042,29 +2965,29 @@ let lookaheadMatcher = (isMatch, sub_m, nStart, numN, next_m) =>
     state,
     stack,
   ) => {
-  let oldState = saveGroups(state, nStart, numN)
-  let ret = match (sub_m(buf, pos, start, limit, end, state, stack)) {
-    Some(_) when isMatch => {
-      match (next_m(buf, pos, start, limit, end, state, stack)) {
-        Some(p) => Some(p),
-        None => {
-          restoreGroups(state, oldState, nStart, numN)
-          None
-        },
-      }
-    },
-    Some(_) => {
-      restoreGroups(state, oldState, nStart, numN)
-      None
-    },
-    None when isMatch => {
-      restoreGroups(state, oldState, nStart, numN)
-      None
-    },
-    _ => next_m(buf, pos, start, limit, end, state, stack),
+    let oldState = saveGroups(state, nStart, numN)
+    let ret = match (sub_m(buf, pos, start, limit, end, state, stack)) {
+      Some(_) when isMatch => {
+        match (next_m(buf, pos, start, limit, end, state, stack)) {
+          Some(p) => Some(p),
+          None => {
+            restoreGroups(state, oldState, nStart, numN)
+            None
+          },
+        }
+      },
+      Some(_) => {
+        restoreGroups(state, oldState, nStart, numN)
+        None
+      },
+      None when isMatch => {
+        restoreGroups(state, oldState, nStart, numN)
+        None
+      },
+      _ => next_m(buf, pos, start, limit, end, state, stack),
+    }
+    ret
   }
-  ret
-}
 
 let lookbehindMatcher = (isMatch, lbMin, lbMax, sub_m, nStart, numN, next_m) =>
   (
@@ -3076,39 +2999,39 @@ let lookbehindMatcher = (isMatch, lbMin, lbMax, sub_m, nStart, numN, next_m) =>
     state,
     stack,
   ) => {
-  let lbMinPos = max(start, pos - lbMax)
-  let rec loop = lbPos => {
-    if (lbPos < lbMinPos) {
-      if (isMatch) {
-        None
-      } else {
-        next_m(buf, pos, start, limit, end, state, stack)
-      }
-    } else {
-      let oldState = saveGroups(state, nStart, numN)
-      match (sub_m(buf, lbPos, start, pos, end, state, stack)) {
-        Some(_) when isMatch => {
-          match (next_m(buf, pos, start, limit, end, state, stack)) {
-            Some(p) => Some(p),
-            None => {
-              restoreGroups(state, oldState, nStart, numN)
-              None
-            },
-          }
-        },
-        _ when isMatch => {
-          loop(lbPos - 1)
-        },
-        Some(_) => {
-          restoreGroups(state, oldState, nStart, numN)
+    let lbMinPos = max(start, pos - lbMax)
+    let rec loop = lbPos => {
+      if (lbPos < lbMinPos) {
+        if (isMatch) {
           None
-        },
-        _ => next_m(buf, pos, start, limit, end, state, stack),
+        } else {
+          next_m(buf, pos, start, limit, end, state, stack)
+        }
+      } else {
+        let oldState = saveGroups(state, nStart, numN)
+        match (sub_m(buf, lbPos, start, pos, end, state, stack)) {
+          Some(_) when isMatch => {
+            match (next_m(buf, pos, start, limit, end, state, stack)) {
+              Some(p) => Some(p),
+              None => {
+                restoreGroups(state, oldState, nStart, numN)
+                None
+              },
+            }
+          },
+          _ when isMatch => {
+            loop(lbPos - 1)
+          },
+          Some(_) => {
+            restoreGroups(state, oldState, nStart, numN)
+            None
+          },
+          _ => next_m(buf, pos, start, limit, end, state, stack),
+        }
       }
     }
+    loop(pos - lbMin)
   }
-  loop(pos - lbMin)
-}
 
 let conditionalReferenceMatcher = (n, m1, m2) =>
   (
@@ -3120,12 +3043,12 @@ let conditionalReferenceMatcher = (n, m1, m2) =>
     state,
     stack,
   ) => {
-  if (Option.isSome(state[n])) {
-    m1(buf, pos, start, limit, end, state, stack)
-  } else {
-    m2(buf, pos, start, limit, end, state, stack)
+    if (Option.isSome(state[n])) {
+      m1(buf, pos, start, limit, end, state, stack)
+    } else {
+      m2(buf, pos, start, limit, end, state, stack)
+    }
   }
-}
 
 let conditionalLookMatcher = (tst_m, m1, m2, nStart, numN) =>
   (
@@ -3137,19 +3060,19 @@ let conditionalLookMatcher = (tst_m, m1, m2, nStart, numN) =>
     state,
     stack,
   ) => {
-  let oldState = saveGroups(state, nStart, numN)
-  let res = match (tst_m(buf, pos, start, limit, end, state, [])) {
-    Some(_) => m1(buf, pos, start, limit, end, state, stack),
-    None => m2(buf, pos, start, limit, end, state, stack),
-  }
-  match (res) {
-    Some(p) => Some(p),
-    None => {
-      restoreGroups(state, oldState, nStart, numN)
-      None
-    },
+    let oldState = saveGroups(state, nStart, numN)
+    let res = match (tst_m(buf, pos, start, limit, end, state, [])) {
+      Some(_) => m1(buf, pos, start, limit, end, state, stack),
+      None => m2(buf, pos, start, limit, end, state, stack),
+    }
+    match (res) {
+      Some(p) => Some(p),
+      None => {
+        restoreGroups(state, oldState, nStart, numN)
+        None
+      },
+    }
   }
-}
 
 let cutMatcher = (sub_m, nStart, numN, next_m) =>
   (
@@ -3161,20 +3084,20 @@ let cutMatcher = (sub_m, nStart, numN, next_m) =>
     state,
     stack,
   ) => {
-  let oldState = saveGroups(state, nStart, numN)
-  match (sub_m(buf, pos, start, limit, end, state, [])) {
-    None => None,
-    Some(_) => {
-      match (next_m(buf, pos, start, limit, end, state, stack)) {
-        None => {
-          restoreGroups(state, oldState, nStart, numN)
-          None
-        },
-        Some(p) => Some(p),
-      }
-    },
+    let oldState = saveGroups(state, nStart, numN)
+    match (sub_m(buf, pos, start, limit, end, state, [])) {
+      None => None,
+      Some(_) => {
+        match (next_m(buf, pos, start, limit, end, state, stack)) {
+          None => {
+            restoreGroups(state, oldState, nStart, numN)
+            None
+          },
+          Some(p) => Some(p),
+        }
+      },
+    }
   }
-}
 
 // Unicode characters in UTF-8 encoding
 
@@ -3188,8 +3111,8 @@ let unicodeCategoriesMatcher = (cats, isMatch, next_m) =>
     state,
     stack,
   ) => {
-  fail "NYI: unicodeCategoriesMatcher is not supported until grain-lang/grain#661 is resolved."
-}
+    fail "NYI: unicodeCategoriesMatcher is not supported until grain-lang/grain#661 is resolved."
+  }
 
 // -------
 // Regex matcher compilation
@@ -3241,8 +3164,7 @@ let compileRegexToMatcher = (re: ParsedRegularExpression) => {
       },
       REAlts(re1, re2) =>
         altsMatcher(compile(re1, next_m), compile(re2, next_m)),
-      REMaybe(re, true) =>
-        altsMatcher(next_m, compile(re, next_m)), // non-greedy
+      REMaybe(re, true) => altsMatcher(next_m, compile(re, next_m)), // non-greedy
       REMaybe(re, _) => altsMatcher(compile(re, next_m), next_m),
       RERepeat(actualRe, min, max, nonGreedy) => {
         // Special case: group around simple pattern in non-lazy repeat
@@ -3252,11 +3174,10 @@ let compileRegexToMatcher = (re: ParsedRegularExpression) => {
           _ => actualRe,
         }
         let simple = !needsBacktrack(re)
-        let groupN = if (simple)
-          match (actualRe) {
-            REGroup(_, n) => Some(n),
-            _ => None,
-          } else None
+        let groupN = if (simple) match (actualRe) {
+          REGroup(_, n) => Some(n),
+          _ => None,
+        } else None
         match (compileMatcherRepeater(re, min, max)) {
           Some(matcher) when !nonGreedy =>
             repeatSimpleManyMatcher(matcher, min, max, groupN, next_m),
@@ -3317,8 +3238,7 @@ let interp = (compiledRe, matchBuffer, pos, start, limitOrEnd, state) => {
   compiledRe(matchBuffer, pos, start, limitOrEnd, limitOrEnd, state, [])
 }
 
-// Should be exported as abstract type when possible
-record RegularExpression {
+abstract record RegularExpression {
   reParsed: ParsedRegularExpression,
   reNumGroups: Number,
   reReferences: Bool,
@@ -3331,16 +3251,12 @@ record RegularExpression {
     Number,
     Array<Option<(Number, Number)>>,
     List<StackElt>,
-  ) -> Option<Number>,
+  ) => Option<Number>,
   reMustString: Option<String>,
   reIsAnchored: Bool,
   reStartRange: Option<RERange>,
 }
 
-/**
- * @section Values: Functions for working with regular expressions.
- */
-
 // TODO(#661): re-add the following pieces of documentation:
 /*
  [Under POSIX character classes]
@@ -3489,7 +3405,7 @@ record RegularExpression {
  *
  * @since 0.4.3
  */
-export let make = (regexString: String) => {
+provide let make = (regexString: String) => {
   let buf = makeRegExBuf(regexString)
   match (parseRegex(buf)) {
     Err(e) => Err(e),
@@ -3510,7 +3426,7 @@ export let make = (regexString: String) => {
               reMustString: mustString(parsed),
               reIsAnchored: isAnchored(parsed),
               reStartRange: startRange(parsed),
-            }
+            },
           )
         },
       }
@@ -3532,11 +3448,12 @@ let checkMustString = (ms, buf: MatchBuf, pos, endPos) => {
     None => true,
     Some(ms) => {
       let toCheck = if (
-        pos == 0 && endPos == Array.length(buf.matchInputExploded)
+        pos == 0 &&
+        endPos == Array.length(buf.matchInputExploded)
       ) {
         buf.matchInput
       } else {
-        String.slice(pos, endPos, buf.matchInput)
+        String.slice(pos, end=endPos, buf.matchInput)
       }
       Option.isSome(String.indexOf(ms, toCheck))
     },
@@ -3548,15 +3465,14 @@ let checkStartRange = (startRange, buf, pos, endPos) => {
   rangeContains(startRange, Char.code(buf.matchInputExploded[pos]))
 }
 
-let searchMatch =
-  (
-    rx: RegularExpression,
-    buf: MatchBuf,
-    pos,
-    startPos,
-    endPos,
-    state,
-  ) => {
+let searchMatch = (
+  rx: RegularExpression,
+  buf: MatchBuf,
+  pos,
+  startPos,
+  endPos,
+  state,
+) => {
   if (!checkMustString(rx.reMustString, buf, pos, endPos)) {
     None
   } else {
@@ -3568,8 +3484,7 @@ let searchMatch =
         None
       } else {
         match (startRange) {
-          Some(_) when pos == endPos =>
-            None, // Can't possibly match if chars are required and we are at EOS
+          Some(_) when pos == endPos => None, // Can't possibly match if chars are required and we are at EOS
           Some(rng) when !checkStartRange(rng, buf, pos, endPos) =>
             loop(pos + 1),
           _ => {
@@ -3592,48 +3507,18 @@ let searchMatch =
  * of a regular expression match. The results can be obtained using
  * the following accessors:
  *
- * ```grain
- * group : Number -> Option<String>
- * ```
- *
- * Returns the contents of the given group. Note that group 0 contains
- * the entire matched substring, and group 1 contains the first parenthesized group.
- *
- * ```grain
- * groupPosition : Number -> Option<(Number, Number)>
- * ```
- *
- * Returns the position of the given group.
- *
- * ```grain
- * numGroups : Number
- * ```
- *
- * The number of defined groups in this match object (including group 0).
- *
- * ```grain
- * allGroups : () -> Array<Option<String>>
- * ```
- *
- * Returns the contents of all groups matched in this match object.
- *
- * ```grain
- * allGroupPositions : () -> Array<Option<(Number, Number)>>
- * ```
- *
- * Returns the positions of all groups matched in this match object.
- *
  * @since 0.4.3
  */
-export record MatchResult {
+provide record MatchResult {
   /**
-   * Returns the contents of the given group
+   * Returns the contents of the given group. Note that group 0 contains
+   * the entire matched substring, and group 1 contains the first parenthesized group.
    */
-  group: Number -> Option<String>,
+  group: Number => Option<String>,
   /**
    * Returns the position of the given group
    */
-  groupPosition: Number -> Option<(Number, Number)>,
+  groupPosition: Number => Option<(Number, Number)>,
   /**
    * Returns the number of defined groups in this match object (includes group 0)
    */
@@ -3641,11 +3526,11 @@ export record MatchResult {
   /**
    * Returns the contents of all groups matched in this match object
    */
-  allGroups: () -> Array<Option<String>>,
+  allGroups: () => Array<Option<String>>,
   /**
    * Returns the positions of all groups matched in this match object
    */
-  allGroupPositions: () -> Array<Option<(Number, Number)>>,
+  allGroupPositions: () => Array<Option<(Number, Number)>>,
 }
 
 let makeMatchResult = (origString, start, end, state) => {
@@ -3663,7 +3548,7 @@ let makeMatchResult = (origString, start, end, state) => {
   }
   let getMatchGroup = n => {
     match (getMatchGroupPosition(n)) {
-      Some((start, end)) => Some(String.slice(start, end, origString)),
+      Some((start, end)) => Some(String.slice(start, end=end, origString)),
       None => None,
     }
   }
@@ -3678,7 +3563,7 @@ let makeMatchResult = (origString, start, end, state) => {
   let getAllMatchGroups = () => {
     Array.map(o => match (o) {
       None => None,
-      Some((start, end)) => Some(String.slice(start, end, origString)),
+      Some((start, end)) => Some(String.slice(start, end=end, origString)),
     }, getAllMatchGroupPositions())
   }
   {
@@ -3693,12 +3578,14 @@ let makeMatchResult = (origString, start, end, state) => {
 // Helpers for user-facing match functionality
 
 let fastDriveRegexIsMatch = (rx, string, startOffset, endOffset) => {
-  let state =
-    if (rx.reReferences) Array.make(rx.reNumGroups, None)
-    else Array.make(0, None)
-  let toWrap =
-    if (startOffset == 0 && endOffset == String.length(string)) string
-    else String.slice(startOffset, endOffset, string)
+  let state = if (rx.reReferences)
+    Array.make(rx.reNumGroups, None)
+  else
+    Array.make(0, None)
+  let toWrap = if (startOffset == 0 && endOffset == String.length(string))
+    string
+  else
+    String.slice(startOffset, end=endOffset, string)
   let buf = makeMatchBuffer(toWrap)
   Option.isSome(
     searchMatch(rx, buf, 0, 0, Array.length(buf.matchInputExploded), state)
@@ -3710,18 +3597,14 @@ let rec fastDriveRegexMatchAll = (rx, string, startOffset, endOffset) => {
     []
   } else {
     let state = Array.make(rx.reNumGroups, None)
-    let toWrap =
-      if (startOffset == 0 && endOffset == String.length(string)) string
-      else String.slice(startOffset, endOffset, string)
+    let toWrap = if (startOffset == 0 && endOffset == String.length(string))
+      string
+    else
+      String.slice(startOffset, end=endOffset, string)
     let buf = makeMatchBuffer(toWrap)
-    match (searchMatch(
-      rx,
-      buf,
-      0,
-      0,
-      Array.length(buf.matchInputExploded),
-      state
-    )) {
+    match (
+      searchMatch(rx, buf, 0, 0, Array.length(buf.matchInputExploded), state)
+    ) {
       None => [],
       Some((startPos, endPos)) =>
         [
@@ -3750,18 +3633,14 @@ let rec fastDriveRegexMatchAll = (rx, string, startOffset, endOffset) => {
 
 let fastDriveRegexMatch = (rx, string, startOffset, endOffset) => {
   let state = Array.make(rx.reNumGroups, None)
-  let toWrap =
-    if (startOffset == 0 && endOffset == String.length(string)) string
-    else String.slice(startOffset, endOffset, string)
+  let toWrap = if (startOffset == 0 && endOffset == String.length(string))
+    string
+  else
+    String.slice(startOffset, end=endOffset, string)
   let buf = makeMatchBuffer(toWrap)
-  match (searchMatch(
-    rx,
-    buf,
-    0,
-    0,
-    Array.length(buf.matchInputExploded),
-    state
-  )) {
+  match (
+    searchMatch(rx, buf, 0, 0, Array.length(buf.matchInputExploded), state)
+  ) {
     None => None,
     Some((startPos, endPos)) => {
       Some(
@@ -3776,7 +3655,7 @@ let fastDriveRegexMatch = (rx, string, startOffset, endOffset) => {
                 Some((start + startOffset, end + startOffset)),
             }
           }, state)
-        )
+        ),
       )
     },
   }
@@ -3792,7 +3671,7 @@ let fastDriveRegexMatch = (rx, string, startOffset, endOffset) => {
  *
  * @since 0.4.3
  */
-export let isMatch = (rx: RegularExpression, string: String) => {
+provide let isMatch = (rx: RegularExpression, string: String) => {
   fastDriveRegexIsMatch(rx, string, 0, String.length(string))
 }
 
@@ -3809,13 +3688,12 @@ export let isMatch = (rx: RegularExpression, string: String) => {
  *
  * @since 0.4.3
  */
-export let isMatchRange =
-  (
-    rx: RegularExpression,
-    string: String,
-    start: Number,
-    end: Number,
-  ) => {
+provide let isMatchRange = (
+  rx: RegularExpression,
+  string: String,
+  start: Number,
+  end: Number,
+) => {
   fastDriveRegexIsMatch(rx, string, start, end)
 }
 
@@ -3829,7 +3707,7 @@ export let isMatchRange =
  *
  * @since 0.4.3
  */
-export let find = (rx: RegularExpression, string: String) => {
+provide let find = (rx: RegularExpression, string: String) => {
   fastDriveRegexMatch(rx, string, 0, String.length(string))
 }
 
@@ -3846,13 +3724,12 @@ export let find = (rx: RegularExpression, string: String) => {
  *
  * @since 0.4.3
  */
-export let findRange =
-  (
-    rx: RegularExpression,
-    string: String,
-    start: Number,
-    end: Number,
-  ) => {
+provide let findRange = (
+  rx: RegularExpression,
+  string: String,
+  start: Number,
+  end: Number,
+) => {
   fastDriveRegexMatch(rx, string, start, end)
 }
 
@@ -3862,7 +3739,7 @@ export let findRange =
  * @param string: The string to search
  * @returns The list of matches
  */
-export let findAll = (rx: RegularExpression, string: String) => {
+provide let findAll = (rx: RegularExpression, string: String) => {
   fastDriveRegexMatchAll(rx, string, 0, String.length(string))
 }
 
@@ -3879,36 +3756,33 @@ export let findAll = (rx: RegularExpression, string: String) => {
  *
  * @since 0.4.3
  */
-export let findAllRange =
-  (
-    rx: RegularExpression,
-    string: String,
-    start: Number,
-    end: Number,
-  ) => {
+provide let findAllRange = (
+  rx: RegularExpression,
+  string: String,
+  start: Number,
+  end: Number,
+) => {
   fastDriveRegexMatchAll(rx, string, start, end)
 }
 
-let computeReplacement =
-  (
-    matchBuf: MatchBuf,
-    replacementString: String,
-    start,
-    end,
-    state,
-  ) => {
+let computeReplacement = (
+  matchBuf: MatchBuf,
+  replacementString: String,
+  start,
+  end,
+  state,
+) => {
   let replacementExploded = String.explode(replacementString)
   let len = Array.length(replacementExploded)
   let mut acc = []
-  let getBeforeMatch = () => String.slice(0, start, matchBuf.matchInput)
-  let getAfterMatch = () =>
-    String.slice(end, String.length(matchBuf.matchInput), matchBuf.matchInput)
+  let getBeforeMatch = () => String.slice(0, end=start, matchBuf.matchInput)
+  let getAfterMatch = () => String.slice(end, matchBuf.matchInput)
   let getInputSubstr = n => {
     if (n == 0) {
-      String.slice(start, end, matchBuf.matchInput)
+      String.slice(start, end=end, matchBuf.matchInput)
     } else if (n - 1 < Array.length(state)) {
       match (state[n - 1]) {
-        Some((start, end)) => String.slice(start, end, matchBuf.matchInput),
+        Some((start, end)) => String.slice(start, end=end, matchBuf.matchInput),
         None => "",
       }
     } else {
@@ -3916,8 +3790,10 @@ let computeReplacement =
     }
   }
   let consRange = (start, end, lst) => {
-    if (start == end) lst
-    else [String.slice(start, end, replacementString), ...lst]
+    if (start == end)
+      lst
+    else
+      [String.slice(start, end=end, replacementString), ...lst]
   }
   let rec loop = (pos, since) => {
     if (pos == len) {
@@ -3931,34 +3807,30 @@ let computeReplacement =
       } else if (c == Some('\'')) {
         consRange(since, pos, [getAfterMatch(), ...loop(pos + 2, pos + 2)])
       } else {
-        consRange(
-          since,
-          pos,
-          {
-            if (c == Some('$')) {
-              loop(pos + 2, pos + 1)
-            } else if (c == Some('.')) {
-              loop(pos + 2, pos + 2)
-            } else {
-              let rec dLoop = (pos, accum) => {
-                if (pos == len) {
-                  [getInputSubstr(accum)]
+        consRange(since, pos, {
+          if (c == Some('$')) {
+            loop(pos + 2, pos + 1)
+          } else if (c == Some('.')) {
+            loop(pos + 2, pos + 2)
+          } else {
+            let rec dLoop = (pos, accum) => {
+              if (pos == len) {
+                [getInputSubstr(accum)]
+              } else {
+                let c = replacementExploded[pos]
+                if (
+                  Char.code('0') <= Char.code(c) &&
+                  Char.code(c) <= Char.code('9')
+                ) {
+                  dLoop(pos + 1, 10 * accum + (Char.code(c) - Char.code('0')))
                 } else {
-                  let c = replacementExploded[pos]
-                  if (
-                    Char.code('0') <= Char.code(c) &&
-                    Char.code(c) <= Char.code('9')
-                  ) {
-                    dLoop(pos + 1, 10 * accum + (Char.code(c) - Char.code('0')))
-                  } else {
-                    [getInputSubstr(accum), ...loop(pos, pos)]
-                  }
+                  [getInputSubstr(accum), ...loop(pos, pos)]
                 }
               }
-              dLoop(pos + 1, 0)
             }
+            dLoop(pos + 1, 0)
           }
-        )
+        })
       }
     } else {
       loop(pos + 1, since)
@@ -3968,13 +3840,12 @@ let computeReplacement =
   List.reduceRight(String.concat, "", res)
 }
 
-let regexReplaceHelp =
-  (
-    rx: RegularExpression,
-    toSearch: String,
-    replacement: String,
-    all: Bool,
-  ) => {
+let regexReplaceHelp = (
+  rx: RegularExpression,
+  toSearch: String,
+  replacement: String,
+  all: Bool,
+) => {
   let buf = makeMatchBuffer(toSearch)
   let rec loop = searchPos => {
     let state = Array.make(rx.reNumGroups, None)
@@ -3993,7 +3864,7 @@ let regexReplaceHelp =
           ""
         } else {
           String.concat(
-            String.slice(searchPos, searchPos + 1, toSearch),
+            String.slice(searchPos, end=searchPos + 1, toSearch),
             loop(searchPos + 1)
           )
         }
@@ -4003,15 +3874,13 @@ let regexReplaceHelp =
     }
     match (poss) {
       None =>
-        if (searchPos == 0) toSearch
-        else String.slice(searchPos, String.length(toSearch), toSearch),
+        if (searchPos == 0) toSearch else String.slice(searchPos, toSearch),
       Some((start, end)) =>
         String.concat(
-          String.slice(searchPos, start, toSearch),
+          String.slice(searchPos, end=start, toSearch),
           String.concat(
             computeReplacement(buf, replacement, start, end, state),
-            if (all) recur(start, end)
-            else String.slice(end, String.length(toSearch), toSearch)
+            if (all) recur(start, end) else String.slice(end, toSearch)
           )
         ),
     }
@@ -4039,12 +3908,11 @@ let regexReplaceHelp =
  *
  * @since 0.4.3
  */
-export let replace =
-  (
-    rx: RegularExpression,
-    toSearch: String,
-    replacement: String,
-  ) => {
+provide let replace = (
+  rx: RegularExpression,
+  toSearch: String,
+  replacement: String,
+) => {
   regexReplaceHelp(rx, toSearch, replacement, false)
 }
 
@@ -4061,12 +3929,11 @@ export let replace =
  *
  * @since 0.4.3
  */
-export let replaceAll =
-  (
-    rx: RegularExpression,
-    toSearch: String,
-    replacement: String,
-  ) => {
+provide let replaceAll = (
+  rx: RegularExpression,
+  toSearch: String,
+  replacement: String,
+) => {
   regexReplaceHelp(rx, toSearch, replacement, true)
 }
 
@@ -4090,10 +3957,10 @@ let regexSplitHelp = (rx: RegularExpression, str: String, all: Bool) => {
         Some((start, end)) => {
           if (i == 0) {
             // Add the string between this match and the last match
-            out = [String.slice(currentLocation, start, str), ...out]
+            out = [String.slice(currentLocation, end=start, str), ...out]
           } else {
             // This adds the groups back in
-            out = [String.slice(start, end, str), ...out]
+            out = [String.slice(start, end=end, str), ...out]
           }
           if (end > currentLocation) currentLocation = end
         },
@@ -4101,7 +3968,7 @@ let regexSplitHelp = (rx: RegularExpression, str: String, all: Bool) => {
       }
     }, locations)
   }, regexMatches)
-  out = [String.slice(currentLocation, String.length(str), str), ...out]
+  out = [String.slice(currentLocation, str), ...out]
   List.reverse(out)
 }
 
@@ -4119,7 +3986,7 @@ let regexSplitHelp = (rx: RegularExpression, str: String, all: Bool) => {
  *
  * @since v0.5.5
  */
-export let split = (rx: RegularExpression, str: String) => {
+provide let split = (rx: RegularExpression, str: String) => {
   regexSplitHelp(rx, str, false)
 }
 
@@ -4137,6 +4004,6 @@ export let split = (rx: RegularExpression, str: String) => {
  *
  * @since v0.5.5
  */
-export let splitAll = (rx: RegularExpression, str: String) => {
+provide let splitAll = (rx: RegularExpression, str: String) => {
   regexSplitHelp(rx, str, true)
 }