@grain/stdlib 0.6.6 → 0.7.1

package/regex.gr

@@ -118,11 +118,11 @@ let withConfig = (buf: RegExBuf, config: RegExParserConfig) => {
 // Parsing internals for recursive descent
 
 let parseErr = (buf: RegExBuf, msg: String, posShift) => {
-  "Invalid Regular Expression: " ++
-    msg ++
-    " (position " ++
-    toString(unbox(buf.cursor) + posShift) ++
-    ")"
+  "Invalid Regular Expression: "
+    ++ msg
+    ++ " (position "
+    ++ toString(unbox(buf.cursor) + posShift)
+    ++ ")"
 }
 
 let next = (buf: RegExBuf) => {
@@ -167,11 +167,11 @@ let eat = (buf: RegExBuf, char: Char) => {
       Err(
         parseErr(
           buf,
-          "Expected character '" ++
-            Char.toString(char) ++
-            ", but found character '" ++
-            Char.toString(ret) ++
-            "'",
+          "Expected character '"
+            ++ Char.toString(char)
+            ++ ", but found character '"
+            ++ Char.toString(ret)
+            ++ "'",
           0
         ),
       )
@@ -244,8 +244,8 @@ 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)
@@ -687,8 +687,8 @@ and 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])
             },
@@ -857,9 +857,10 @@ and parseRangeRest = (
           } else {
             match (peek(buf)) {
               Err(e) => Err(e),
-              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') => {
+              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') => {
                 match (mustSpanFrom) {
                   Some(_) =>
                     Err(
@@ -874,9 +875,9 @@ and parseRangeRest = (
                     match (parseClass(buf)) {
                       Err(e) =>
                         Err(
-                          "Invalid Regular Expression: illegal alphebetic escape (position " ++
-                            toString(curPos) ++
-                            ")",
+                          "Invalid Regular Expression: illegal alphebetic escape (position "
+                            ++ toString(curPos)
+                            ++ ")",
                         ),
                       Ok(range1) => {
                         match (rangeAddCaseAware(rng, spanFrom, buf.config)) {
@@ -1011,8 +1012,8 @@ let rec parseAtom = (buf: RegExBuf) => {
                 match (parseTest(buf)) {
                   Err(e) => Err(e),
                   Ok(test) => {
-                    let tstSpanNumGroups = unbox(buf.config.groupNumber) -
-                      tstPreNumGroups
+                    let tstSpanNumGroups = unbox(buf.config.groupNumber)
+                      - tstPreNumGroups
                     match (parsePCEs(buf, false)) {
                       Err(e) => Err(e),
                       Ok(pces) => {
@@ -1252,8 +1253,8 @@ and 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)) {
@@ -1285,8 +1286,8 @@ and parseInteger = (buf: RegExBuf, 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')))
       },
@@ -1503,11 +1504,11 @@ and parseUnicodeCategories = (buf: RegExBuf, pC: String) => {
                 Err(
                   parseErr(
                     buf,
-                    "Unrecognized property name in `\\" ++
-                      pC ++
-                      "`: `" ++
-                      s ++
-                      "`",
+                    "Unrecognized property name in `\\"
+                      ++ pC
+                      ++ "`: `"
+                      ++ s
+                      ++ "`",
                     0
                   ),
                 ),
@@ -1566,8 +1567,8 @@ and 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),
@@ -1576,10 +1577,10 @@ and 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' => {
@@ -2304,8 +2305,8 @@ let charMatcherIterated = (toMatch, max) =>
 
 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
   ) {
     return false
   }
@@ -2328,8 +2329,8 @@ let stringMatcher = (toMatch, len, next_m) =>
     stack,
   ) => {
     if ({
-      pos + len <= limit &&
-        subArraysEqual(
+      pos + len <= limit
+        && subArraysEqual(
           buf.matchInputExploded,
           pos,
           String.explode(toMatch),
@@ -2350,8 +2351,8 @@ let stringTailMatcher = (toMatch, len) =>
     stack,
   ) => {
     if ({
-      pos + len <= limit &&
-        subArraysEqual(
+      pos + len <= limit
+        && subArraysEqual(
           buf.matchInputExploded,
           pos,
           String.explode(toMatch),
@@ -2584,8 +2585,8 @@ 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)))
   )
 }
 
@@ -2922,8 +2923,8 @@ let makeReferenceMatcher = eq =>
         Some((refStart, refEnd)) => {
           let len = refEnd - refStart
           if (
-            pos + len <= limit &&
-            subArraysEqual(
+            pos + len <= limit
+            && subArraysEqual(
               buf.matchInputExploded,
               refStart,
               buf.matchInputExploded,
@@ -3448,8 +3449,8 @@ 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 {
@@ -3819,8 +3820,8 @@ let computeReplacement = (
               } else {
                 let c = replacementExploded[pos]
                 if (
-                  Char.code('0') <= Char.code(c) &&
-                  Char.code(c) <= Char.code('9')
+                  Char.code('0') <= Char.code(c)
+                  && Char.code(c) <= Char.code('9')
                 ) {
                   dLoop(pos + 1, 10 * accum + (Char.code(c) - Char.code('0')))
                 } else {

package/regex.md

@@ -46,13 +46,13 @@ the following accessors:
 
 Fields:
 
-|name|type|description|
-|----|----|-----------|
-|`group`|`Number => Option<String>`|Returns the contents of the given group. Note that group 0 contains<br/>the entire matched substring, and group 1 contains the first parenthesized group.|
-|`groupPosition`|`Number => Option<(Number, Number)>`|Returns the position of the given group|
-|`numGroups`|`Number`|Returns the number of defined groups in this match object (includes group 0)|
-|`allGroups`|`() => Array<Option<String>>`|Returns the contents of all groups matched in this match object|
-|`allGroupPositions`|`() => Array<Option<(Number, Number)>>`|Returns the positions of all groups matched in this match object|
+| name                | type                                    | description                                                                                                                                               |
+| ------------------- | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `group`             | `Number => Option<String>`              | Returns the contents of the given group. Note that group 0 contains<br/>the entire matched substring, and group 1 contains the first parenthesized group. |
+| `groupPosition`     | `Number => Option<(Number, Number)>`    | Returns the position of the given group                                                                                                                   |
+| `numGroups`         | `Number`                                | Returns the number of defined groups in this match object (includes group 0)                                                                              |
+| `allGroups`         | `() => Array<Option<String>>`           | Returns the contents of all groups matched in this match object                                                                                           |
+| `allGroupPositions` | `() => Array<Option<(Number, Number)>>` | Returns the positions of all groups matched in this match object                                                                                          |
 
 ## Values
 
@@ -66,7 +66,7 @@ No other changes yet.
 </details>
 
 ```grain
-make : (regexString: String) => Result<RegularExpression, String>
+make: (regexString: String) => Result<RegularExpression, String>
 ```
 
 Compiles the given pattern string into a regular expression object.
@@ -155,15 +155,15 @@ The *POSIX* classes are as follows:
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`regexString`|`String`|The regular expression to compile|
+| param         | type     | description                       |
+| ------------- | -------- | --------------------------------- |
+| `regexString` | `String` | The regular expression to compile |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Result<RegularExpression, String>`|The compiled regular expression|
+| type                                | description                     |
+| ----------------------------------- | ------------------------------- |
+| `Result<RegularExpression, String>` | The compiled regular expression |
 
 Examples:
 
@@ -179,23 +179,23 @@ No other changes yet.
 </details>
 
 ```grain
-isMatch : (rx: RegularExpression, string: String) => Bool
+isMatch: (rx: RegularExpression, string: String) => Bool
 ```
 
 Determines if the given regular expression has a match in the given string.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`rx`|`RegularExpression`|The regular expression to search for|
-|`string`|`String`|The string to search within|
+| param    | type                | description                          |
+| -------- | ------------------- | ------------------------------------ |
+| `rx`     | `RegularExpression` | The regular expression to search for |
+| `string` | `String`            | The string to search within          |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Bool`|`true` if the RegExp matches the string or `false` otherwise|
+| type   | description                                                  |
+| ------ | ------------------------------------------------------------ |
+| `Bool` | `true` if the RegExp matches the string or `false` otherwise |
 
 Examples:
 
@@ -211,7 +211,7 @@ No other changes yet.
 </details>
 
 ```grain
-isMatchRange :
+isMatchRange:
   (rx: RegularExpression, string: String, start: Number, end: Number) => Bool
 ```
 
@@ -219,18 +219,18 @@ Determines if the given regular expression has a match in the given string betwe
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`rx`|`RegularExpression`|The regular expression to search for|
-|`string`|`String`|The string to search|
-|`start`|`Number`|The start offset to search between|
-|`end`|`Number`|The end offset to search between|
+| param    | type                | description                          |
+| -------- | ------------------- | ------------------------------------ |
+| `rx`     | `RegularExpression` | The regular expression to search for |
+| `string` | `String`            | The string to search                 |
+| `start`  | `Number`            | The start offset to search between   |
+| `end`    | `Number`            | The end offset to search between     |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Bool`|`true` if the RegExp matches the string in the given range, otherwise `false`|
+| type   | description                                                                   |
+| ------ | ----------------------------------------------------------------------------- |
+| `Bool` | `true` if the RegExp matches the string in the given range, otherwise `false` |
 
 Examples:
 
@@ -250,23 +250,23 @@ No other changes yet.
 </details>
 
 ```grain
-find : (rx: RegularExpression, string: String) => Option<MatchResult>
+find: (rx: RegularExpression, string: String) => Option<MatchResult>
 ```
 
 Returns the first match for the given regular expression contained within the given string.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`rx`|`RegularExpression`|The regular expression to search for|
-|`string`|`String`|The string to search|
+| param    | type                | description                          |
+| -------- | ------------------- | ------------------------------------ |
+| `rx`     | `RegularExpression` | The regular expression to search for |
+| `string` | `String`            | The string to search                 |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Option<MatchResult>`|The match result, if any|
+| type                  | description              |
+| --------------------- | ------------------------ |
+| `Option<MatchResult>` | The match result, if any |
 
 Examples:
 
@@ -282,7 +282,7 @@ No other changes yet.
 </details>
 
 ```grain
-findRange :
+findRange:
   (rx: RegularExpression, string: String, start: Number, end: Number) =>
    Option<MatchResult>
 ```
@@ -292,18 +292,18 @@ between the given start/end range.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`rx`|`RegularExpression`|The regular expression to search for|
-|`string`|`String`|The string to search|
-|`start`|`Number`|The start offset to search between|
-|`end`|`Number`|The end offset to search between|
+| param    | type                | description                          |
+| -------- | ------------------- | ------------------------------------ |
+| `rx`     | `RegularExpression` | The regular expression to search for |
+| `string` | `String`            | The string to search                 |
+| `start`  | `Number`            | The start offset to search between   |
+| `end`    | `Number`            | The end offset to search between     |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Option<MatchResult>`|The match result, if any|
+| type                  | description              |
+| --------------------- | ------------------------ |
+| `Option<MatchResult>` | The match result, if any |
 
 Examples:
 
@@ -314,23 +314,23 @@ Regex.findRange(Result.unwrap(Regex.make("ca+[at]")), "caaat", 0, 5)
 ### Regex.**findAll**
 
 ```grain
-findAll : (rx: RegularExpression, string: String) => List<MatchResult>
+findAll: (rx: RegularExpression, string: String) => List<MatchResult>
 ```
 
 Returns all matches for the given regular expression contained within the given string.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`rx`|`RegularExpression`|The regular expression to search for|
-|`string`|`String`|The string to search|
+| param    | type                | description                          |
+| -------- | ------------------- | ------------------------------------ |
+| `rx`     | `RegularExpression` | The regular expression to search for |
+| `string` | `String`            | The string to search                 |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`List<MatchResult>`|The list of matches|
+| type                | description         |
+| ------------------- | ------------------- |
+| `List<MatchResult>` | The list of matches |
 
 ### Regex.**findAllRange**
 
@@ -340,7 +340,7 @@ No other changes yet.
 </details>
 
 ```grain
-findAllRange :
+findAllRange:
   (rx: RegularExpression, string: String, start: Number, end: Number) =>
    List<MatchResult>
 ```
@@ -350,18 +350,18 @@ between the given start/end range.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`rx`|`RegularExpression`|The regular expression to search for|
-|`string`|`String`|The string to search|
-|`start`|`Number`|The start offset to search between|
-|`end`|`Number`|The end offset to search between|
+| param    | type                | description                          |
+| -------- | ------------------- | ------------------------------------ |
+| `rx`     | `RegularExpression` | The regular expression to search for |
+| `string` | `String`            | The string to search                 |
+| `start`  | `Number`            | The start offset to search between   |
+| `end`    | `Number`            | The end offset to search between     |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`List<MatchResult>`|The list of matches|
+| type                | description         |
+| ------------------- | ------------------- |
+| `List<MatchResult>` | The list of matches |
 
 Examples:
 
@@ -377,7 +377,7 @@ No other changes yet.
 </details>
 
 ```grain
-replace :
+replace:
   (rx: RegularExpression, toSearch: String, replacement: String) => String
 ```
 
@@ -393,17 +393,17 @@ Replacement strings support the following syntax:
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`rx`|`RegularExpression`|The regular expression to search for|
-|`toSearch`|`String`|The string to search|
-|`replacement`|`String`|The string that replaces matches|
+| param         | type                | description                          |
+| ------------- | ------------------- | ------------------------------------ |
+| `rx`          | `RegularExpression` | The regular expression to search for |
+| `toSearch`    | `String`            | The string to search                 |
+| `replacement` | `String`            | The string that replaces matches     |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`String`|The given string with the appropriate replacements, if any|
+| type     | description                                                |
+| -------- | ---------------------------------------------------------- |
+| `String` | The given string with the appropriate replacements, if any |
 
 Examples:
 
@@ -419,7 +419,7 @@ No other changes yet.
 </details>
 
 ```grain
-replaceAll :
+replaceAll:
   (rx: RegularExpression, toSearch: String, replacement: String) => String
 ```
 
@@ -428,17 +428,17 @@ See `replace` for replacement string syntax.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`rx`|`RegularExpression`|The regular expression to search for|
-|`toSearch`|`String`|The string to search|
-|`replacement`|`String`|The string that replaces matches|
+| param         | type                | description                          |
+| ------------- | ------------------- | ------------------------------------ |
+| `rx`          | `RegularExpression` | The regular expression to search for |
+| `toSearch`    | `String`            | The string to search                 |
+| `replacement` | `String`            | The string that replaces matches     |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`String`|The input string with the appropriate replacements, if any|
+| type     | description                                                |
+| -------- | ---------------------------------------------------------- |
+| `String` | The input string with the appropriate replacements, if any |
 
 Examples:
 
@@ -454,7 +454,7 @@ No other changes yet.
 </details>
 
 ```grain
-split : (rx: RegularExpression, str: String) => List<String>
+split: (rx: RegularExpression, str: String) => List<String>
 ```
 
 Splits the given string at the first match for the given regular expression.
@@ -464,16 +464,16 @@ will be included in the output list.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`rx`|`RegularExpression`|The regular expression to match|
-|`str`|`String`|The string to split|
+| param | type                | description                     |
+| ----- | ------------------- | ------------------------------- |
+| `rx`  | `RegularExpression` | The regular expression to match |
+| `str` | `String`            | The string to split             |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`List<String>`|A list of the split segments|
+| type           | description                  |
+| -------------- | ---------------------------- |
+| `List<String>` | A list of the split segments |
 
 Examples:
 
@@ -489,7 +489,7 @@ No other changes yet.
 </details>
 
 ```grain
-splitAll : (rx: RegularExpression, str: String) => List<String>
+splitAll: (rx: RegularExpression, str: String) => List<String>
 ```
 
 Splits the given string at every match for the given regular expression.
@@ -499,16 +499,16 @@ will be included in the output list.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`rx`|`RegularExpression`|The regular expression to match|
-|`str`|`String`|The string to split|
+| param | type                | description                     |
+| ----- | ------------------- | ------------------------------- |
+| `rx`  | `RegularExpression` | The regular expression to match |
+| `str` | `String`            | The string to split             |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`List<String>`|A list of the split segments|
+| type           | description                  |
+| -------------- | ---------------------------- |
+| `List<String>` | A list of the split segments |
 
 Examples: