@grain/stdlib 0.6.6 → 0.7.0

package/json.gr

@@ -17,6 +17,8 @@ from "runtime/bigint" include Bigint as BI
 from "runtime/dataStructures" include DataStructures
 from "runtime/numbers" include Numbers
 from "runtime/numberUtils" include NumberUtils
+from "runtime/utf8" include Utf8
+use Utf8.{ getCodePoint }
 from "runtime/string" include String as RuntimeString
 from "runtime/unsafe/tags" include Tags
 from "runtime/unsafe/wasmi32" include WasmI32
@@ -28,7 +30,7 @@ from "char" include Char
 from "string" include String
 from "list" include List
 from "uint8" include Uint8
-use RuntimeString.{ toString as runtimeToString, getCodePoint }
+use RuntimeString.{ toString as runtimeToString }
 use Numbers.{ coerceNumberToWasmI32 }
 use DataStructures.{ tagSimpleNumber, untagSimpleNumber }
 
@@ -1026,8 +1028,8 @@ let makeJsonWriter = (format: FormattingSettings, buffer: Buffer.Buffer) => {
   // escapes it when needed, but requires to keep track of the previous code
   // point in the iteration so it's more complicated and handled separately.
   let emitCodePoint = if (
-    !format.escapeAllControlPoints &&
-    !format.escapeNonASCII
+    !format.escapeAllControlPoints
+    && !format.escapeNonASCII
   ) {
     (codePoint: Number) => {
       if (codePoint > 31 && codePoint != 0x0022 && codePoint != 0x005C) {
@@ -1042,10 +1044,10 @@ let makeJsonWriter = (format: FormattingSettings, buffer: Buffer.Buffer) => {
     // from 31 to 127.
     (codePoint: Number) => {
       if (
-        codePoint > 31 &&
-        codePoint != 0x0022 &&
-        codePoint != 0x005C &&
-        codePoint < 128
+        codePoint > 31
+        && codePoint != 0x0022
+        && codePoint != 0x005C
+        && codePoint < 128
       ) {
         Buffer.addCharFromCodePoint(codePoint, buffer)
       } else {
@@ -1059,11 +1061,11 @@ let makeJsonWriter = (format: FormattingSettings, buffer: Buffer.Buffer) => {
     // codepoints, but covering that would be overkill.
     (codePoint: Number) => {
       if (
-        codePoint > 31 &&
-          codePoint != 0x0022 &&
-          codePoint != 0x005C &&
-          codePoint < 127 ||
-        codePoint > 159
+        codePoint > 31
+          && codePoint != 0x0022
+          && codePoint != 0x005C
+          && codePoint < 127
+        || codePoint > 159
       ) {
         Buffer.addCharFromCodePoint(codePoint, buffer)
       } else {
@@ -1077,10 +1079,10 @@ let makeJsonWriter = (format: FormattingSettings, buffer: Buffer.Buffer) => {
     // 127 (Delete).
     (codePoint: Number) => {
       if (
-        codePoint > 31 &&
-        codePoint != 0x0022 &&
-        codePoint != 0x005C &&
-        codePoint < 127
+        codePoint > 31
+        && codePoint != 0x0022
+        && codePoint != 0x005C
+        && codePoint < 127
       ) {
         // fast path for chars that never need any escaping
         Buffer.addCharFromCodePoint(codePoint, buffer)
@@ -1321,6 +1323,7 @@ let rec readCodePoint = (bytePosition: Number, string: String) => {
 
   if (bytePositionW32 < byteSize) {
     let codePoint = getCodePoint(ptr)
+
     tagSimpleNumber(codePoint)
   } else {
     _END_OF_INPUT
@@ -1364,8 +1367,8 @@ let skipWhiteSpace = (parserState: JsonParserState) => {
   // isAtEndOfInput is not strictly necessary here
   // could remove as an optimization
   while (
-    isInterTokenWhiteSpace(parserState.currentCodePoint) &&
-    !isAtEndOfInput(parserState)
+    isInterTokenWhiteSpace(parserState.currentCodePoint)
+    && !isAtEndOfInput(parserState)
   ) {
     next(parserState)
     void
@@ -1426,10 +1429,10 @@ let expectCodePointAndAdvance = (
     next(parserState)
     None
   } else {
-    let detail = "expected " ++
-      formatCodePointOrEOF(expectedCodePoint) ++
-      ", found " ++
-      formatCodePointOrEOF(c)
+    let detail = "expected "
+      ++ formatCodePointOrEOF(expectedCodePoint)
+      ++ ", found "
+      ++ formatCodePointOrEOF(c)
     Some(buildUnexpectedTokenError(parserState, detail))
   }
 }
@@ -1438,9 +1441,9 @@ let atoiFast = buffer => {
   let mut result = 0
   for (let mut i = 0; i < bufLen; i += 1) {
     use Uint8.{ (-) }
-    result = (result << 1) +
-      (result << 3) +
-      Uint8.toNumber(Buffer.getUint8(i, buffer) - 48us)
+    result = (result << 1)
+      + (result << 3)
+      + Uint8.toNumber(Buffer.getUint8(i, buffer) - 48us)
   }
   result
 }
@@ -1467,8 +1470,8 @@ let rec parseValue = (parserState: JsonParserState) => {
     0x39 => parseNumberValue(parserState), // '9'
     0x2D => parseNumberValue(parserState), // '-'
     c => {
-      let detail = "expected start of a JSON value, found " ++
-        formatCodePointOrEOF(c)
+      let detail = "expected start of a JSON value, found "
+        ++ formatCodePointOrEOF(c)
       Err(buildUnexpectedTokenError(parserState, detail))
     },
   }
@@ -1655,20 +1658,20 @@ and parseString = (parserState: JsonParserState) => {
                     if (hexDigitCodePoint >= 48 && hexDigitCodePoint <= 57) { // 0..9
                       digit -= 48
                     } else if (
-                      hexDigitCodePoint >= 65 &&
-                      hexDigitCodePoint <= 70
+                      hexDigitCodePoint >= 65
+                      && hexDigitCodePoint <= 70
                     ) { // A..F
                       digit -= 55 // (65 - 10)
                     } else if (
-                      hexDigitCodePoint >= 97 &&
-                      hexDigitCodePoint <= 102
+                      hexDigitCodePoint >= 97
+                      && hexDigitCodePoint <= 102
                     ) { // a..f
                       digit -= 87 // (97 - 10)
                     } else {
                       let digitsSoFar = 3 - digitIndex
                       let detail =
-                        "expected exactly 4 hexadecimal digits in the UTF-16 escape sequence, found only " ++
-                          runtimeToString(digitsSoFar)
+                        "expected exactly 4 hexadecimal digits in the UTF-16 escape sequence, found only "
+                          ++ runtimeToString(digitsSoFar)
                       return Err(buildUnexpectedTokenError(parserState, detail))
                     }
 
@@ -1700,19 +1703,19 @@ and parseString = (parserState: JsonParserState) => {
                       // iteration of the loop.
                       highSurrogate = codeUnit
                     } else if (
-                      isCodePointInBasicMultilingualPlane(codeUnit) &&
-                      !isLowSurrogate(codeUnit)
+                      isCodePointInBasicMultilingualPlane(codeUnit)
+                      && !isLowSurrogate(codeUnit)
                     ) {
                       let codePoint = codeUnit
                       Buffer.addCharFromCodePoint(codePoint, buffer)
                       break
                     } else {
                       let message =
-                        "Invalid character escape sequence at position " ++
-                          runtimeToString(escapeStartPos) ++
-                          ": expected a Unicode code point in Basic Multilingual Plane (U+0000..U+FFFF) or a high surrogate (0xD800..0xDBFF) of a UTF-16 surrogate pair, found " ++
-                          "0x" ++
-                          toHexWithZeroPadding(codeUnit, 4)
+                        "Invalid character escape sequence at position "
+                          ++ runtimeToString(escapeStartPos)
+                          ++ ": expected a Unicode code point in Basic Multilingual Plane (U+0000..U+FFFF) or a high surrogate (0xD800..0xDBFF) of a UTF-16 surrogate pair, found "
+                          ++ "0x"
+                          ++ toHexWithZeroPadding(codeUnit, 4)
                       return Err(InvalidUTF16SurrogatePair(message))
                     }
                   } else {
@@ -1728,11 +1731,11 @@ and parseString = (parserState: JsonParserState) => {
                       break
                     } else {
                       let message =
-                        "Invalid character escape sequence at position " ++
-                          runtimeToString(escapeStartPos) ++
-                          ": expected a low surrogate (0xDC00..0xDFFF) in the second code unit of the UTF-16 sequence, found " ++
-                          "0x" ++
-                          toHexWithZeroPadding(codeUnit, 4)
+                        "Invalid character escape sequence at position "
+                          ++ runtimeToString(escapeStartPos)
+                          ++ ": expected a low surrogate (0xDC00..0xDFFF) in the second code unit of the UTF-16 sequence, found "
+                          ++ "0x"
+                          ++ toHexWithZeroPadding(codeUnit, 4)
                       return Err(InvalidUTF16SurrogatePair(message))
                     }
                   }
@@ -1742,8 +1745,8 @@ and parseString = (parserState: JsonParserState) => {
                 // JSON doesn't allow arbitrary characters to be preceded by backslash escape.
                 // Only the ones above.
                 let detail =
-                  "expected a valid escape sequence or the end of string, found " ++
-                    formatCodePointOrEOF(unexpectedCodePoint)
+                  "expected a valid escape sequence or the end of string, found "
+                    ++ formatCodePointOrEOF(unexpectedCodePoint)
                 return Err(buildUnexpectedTokenError(parserState, detail))
               },
             }
@@ -1816,8 +1819,8 @@ and parseNumberValue = (parserState: JsonParserState) => {
     unexpectedCodePoint => {
       // The integer part of the number has to have at least one digit.
       // JSON doesn't allow numbers starting with decimal separator like ".1".
-      let detail = "expected a decimal digit, found " ++
-        formatCodePointOrEOF(unexpectedCodePoint)
+      let detail = "expected a decimal digit, found "
+        ++ formatCodePointOrEOF(unexpectedCodePoint)
       return Err(buildUnexpectedTokenError(parserState, detail))
     },
   }
@@ -2061,11 +2064,323 @@ provide let parse: (str: String) => Result<Json, JsonParseError> = (str: String)
   } else {
     match (root) {
       Ok(_) => {
-        let detail = "expected end of input, found " ++
-          formatCodePointOrEOF(parserState.currentCodePoint)
+        let detail = "expected end of input, found "
+          ++ formatCodePointOrEOF(parserState.currentCodePoint)
         Err(buildUnexpectedTokenError(parserState, detail))
       },
       e => e,
     }
   }
 }
+
+/**
+ * Utilities for accessing and updating JSON data.
+ *
+ * @example
+ * let obj = JsonObject([("x", JsonNumber(123))])
+ * assert get(property("x") ||> number, obj) == Some(123)
+ * @example
+ * let obj = JsonObject([("x", JsonNumber(123))])
+ * assert set(property("x") ||> number, 321, obj) ==
+ *   Some(JsonObject([("x", JsonNumber(321))]))
+ *
+ * @since v0.7.0
+ */
+provide module Lenses {
+  /**
+   * A structure which provides functionality for accessing and setting JSON
+   * data.
+   *
+   * @since v0.7.0
+   */
+  provide record Lens<a, b> {
+    /**
+     * A function which reads a value from the subject.
+     */
+    get: (subject: a) => Option<b>,
+    /**
+     * A function which immutably updates a value in the subject.
+     */
+    set: (newValue: b, subject: a) => Option<a>,
+  }
+
+  /**
+   * Reads the value focused on by the given lens from the input data.
+   *
+   * @param lens: The lens to apply to the subject data
+   * @param subject: The data which will have the lens applied to it
+   * @returns `Some(data)` containing the data read by the lens if the lens matches the given data, or `None` if the data cannot be matched to the lens
+   *
+   * @example assert get(number, JsonNumber(123)) == Some(123)
+   * @example assert get(string, JsonString("abc")) == Some("abc")
+   * @example assert get(number, JsonString("abc")) == None
+   */
+  provide let get = (lens, subject) => lens.get(subject)
+
+  /**
+   * Sets the value focused on by the given lens from the input data to the
+   * desired new value.
+   *
+   * @param lens: The lens to apply to the subject data
+   * @param newValue: The new value to set at the focus of the lens
+   * @param subject: The data which will have the lens applied to it
+   * @returns `Some(data)` containing the new data after the lens substitution if the lens matches the given data, or `None` if the data cannot be matched to the lens
+   *
+   * @example assert set(number, 123, JsonBoolean(true)) == Some(JsonNumber(123))
+   * @example assert set(property("a"), JsonNumber(123), JsonObject([("a", JsonNull)])) == Some(JsonObject([("a", JsonNumber(123))]))
+   * @example assert set(property("a"), JsonNumber(123), JsonBoolean(true)) == None
+   */
+  provide let set = (lens, newValue, subject) => lens.set(newValue, subject)
+
+  /**
+   * Updates the value focused on by the given lens from the input data by
+   * applying a function to it and setting the focus to the result of the function
+   *
+   * @param lens: The lens to apply to the subject data
+   * @param fn: The function to apply to the matched data at the lens if matched
+   * @param subject: The data which will have the lens applied to it
+   * @returns `Some(data)` containing the new data after the lens mapping has been applied if the lens matches the given data, or `None` if the data cannot be matched to the lens
+   *
+   * @example assert map(number, x => x * 2, JsonNumber(5)) == Some(JsonNumber(10))
+   * @example
+   * assert map(property("x"), x => JsonArray([x, x]), JsonObject([("x", JsonNumber(1))])) ==
+   *   Some(JsonObject([("x", JsonArray([JsonNumber(1), JsonNumber(1)]))]))
+   * @example assert map(number, x => x * 2, JsonString("abc")) == None
+   */
+  provide let map = (lens, fn, subject) => {
+    match (lens.get(subject)) {
+      Some(lensVal) => lens.set(fn(lensVal), subject),
+      None => None,
+    }
+  }
+
+  /**
+   * A lens whose focus is a JSON value.
+   *
+   * @example assert get(json, JsonString("abc")) == Some(JsonString("abc"))
+   *
+   * @since v0.7.0
+   */
+  provide let json = {
+    get: json => Some(json),
+    set: (newValue, _) => Some(newValue),
+  }
+
+  /**
+   * A lens whose focus is a JSON boolean value.
+   *
+   * @example assert get(boolean, JsonBoolean(true)) == Some(true)
+   *
+   * @since v0.7.0
+   */
+  provide let boolean = {
+    get: json => {
+      match (json) {
+        JsonBoolean(val) => Some(val),
+        _ => None,
+      }
+    },
+    set: (newValue, _) => Some(JsonBoolean(newValue)),
+  }
+
+  /**
+   * A lens whose focus is a JSON string value.
+   *
+   * @example assert get(string, JsonString("abc")) == Some("abc")
+   *
+   * @since v0.7.0
+   */
+  provide let string = {
+    get: json => {
+      match (json) {
+        JsonString(val) => Some(val),
+        _ => None,
+      }
+    },
+    set: (newValue, _) => Some(JsonString(newValue)),
+  }
+
+  /**
+   * A lens whose focus is a JSON number value.
+   *
+   * @example assert get(number, JsonNumber(123)) == Some(123)
+   *
+   * @since v0.7.0
+   */
+  provide let number = {
+    get: json => {
+      match (json) {
+        JsonNumber(val) => Some(val),
+        _ => None,
+      }
+    },
+    set: (newValue, _) => Some(JsonNumber(newValue)),
+  }
+
+  /**
+   * A lens whose focus is a JSON array.
+   *
+   * @example assert get(array, JsonArray([JsonNumber(123)])) == Some([JsonNumber(123)])
+   *
+   * @since v0.7.0
+   */
+  provide let array = {
+    get: json => {
+      match (json) {
+        JsonArray(val) => Some(val),
+        _ => None,
+      }
+    },
+    set: (newValue, _) => Some(JsonArray(newValue)),
+  }
+
+  /**
+   * A lens whose focus is the property pair list of a JSON object.
+   *
+   * @example assert get(objectProperties, JsonObject([("a", JsonNumber(123))])) == Some([("a", JsonNumber(123))])
+   *
+   * @since v0.7.0
+   */
+  provide let objectProperties = {
+    get: json => {
+      match (json) {
+        JsonObject(val) => Some(val),
+        _ => None,
+      }
+    },
+    set: (newValue, _) => Some(JsonObject(newValue)),
+  }
+
+  let rec replaceFirst = (acc, list, propertyName, newValue) => {
+    match (list) {
+      [first, ...rest] => {
+        let (firstKey, firstVal) = first
+        if (firstKey == propertyName) {
+          List.append(List.reverse([(firstKey, newValue), ...acc]), rest)
+        } else {
+          replaceFirst([first, ...acc], rest, propertyName, newValue)
+        }
+      },
+      [] => List.reverse([(propertyName, newValue), ...acc]),
+    }
+  }
+
+  /**
+   * Creates a lens whose focus is a given property of a JSON object.
+   *
+   * @param propertyName: The property name of the JSON object to focus on
+   * @returns A lens whose focus is the given property of a JSON object
+   *
+   * @example assert get(property("x"), JsonObject([("x", JsonNumber(123))])) == Some(JsonNumber(123))
+   * @example
+   * assert set(property("x"), JsonString("new"), JsonObject([("x", JsonNumber(123))])) ==
+   *   Some(JsonObject([("x", JsonString("new"))]))
+   *
+   * @since v0.7.0
+   */
+  provide let property = propertyName =>
+    { get: json => match (json) {
+      JsonObject(props) => {
+        match (List.find(((k, _)) => k == propertyName, props)) {
+          Some((_, v)) => Some(v),
+          None => None,
+        }
+      },
+      _ => None,
+    }, set: (newValue, json) => {
+      match (json) {
+        JsonObject(props) =>
+          Some(JsonObject(replaceFirst([], props, propertyName, newValue))),
+        _ => None,
+      }
+    } }
+
+  /**
+   * Wraps a lens to permit nullable values in addition to the original value
+   * type of the given lens. During a `get` operation if the lens matches then
+   * the result will be enclosed in `Some`; if the lens does not match but the
+   * value focused is null, then the lens will still successfully match and
+   * `None` will be returned.
+   *
+   * @example assert get(nullable(number), JsonNumber(123)) == Some(Some(123))
+   * @example assert get(nullable(number), JsonNull) == Some(None)
+   * @example assert get(nullable(number), JsonString("abc")) == None
+   * @example assert set(nullable(number), Some(123), JsonString("abc")) == Some(JsonNumber(123))
+   *
+   * @since v0.7.0
+   */
+  provide let nullable = lens =>
+    { get: json => {
+      match (get(lens, json)) {
+        Some(x) => Some(Some(x)),
+        None => {
+          match (json) {
+            JsonNull => Some(None),
+            _ => {
+              match (get(lens, json)) {
+                Some(x) => Some(Some(x)),
+                None => None,
+              }
+            },
+          }
+        },
+      }
+    }, set: (newValue, json) => {
+      match (newValue) {
+        Some(x) => lens.set(x, json),
+        None => Some(JsonNull),
+      }
+    } }
+
+  /**
+   * Reverse lens composition.
+   *
+   * @param lens1: The lens which will be applied first
+   * @param lens2: The lens which will be applied second
+   * @returns A lens which combines the two given lenses, passing through the first and then the second
+   *
+   * @example assert get(property("x") ||> number, JsonObject([("x", JsonNumber(123))])) == Some(123)
+   * @example
+   * assert set(property("x") ||> string, "new", JsonObject([("x", JsonNumber(123))])) ==
+   *   Some(JsonObject([("x", JsonString("new"))]))
+   *
+   * @since v0.7.0
+   */
+  let (||>) = (lens1, lens2) =>
+    { get: json => {
+      match (lens1.get(json)) {
+        Some(x) => lens2.get(x),
+        None => None,
+      }
+    }, set: (newValue, target) => {
+      match (lens1.get(target)) {
+        Some(x) => match (lens2.set(newValue, x)) {
+          Some(y) => lens1.set(y, target),
+          None => None,
+        },
+        None => None,
+      }
+    } }
+
+  /**
+   * Creates a lens whose focus is a given property path within a JSON object tree.
+   *
+   * @param propertyNames: The property path of the JSON object to create a focus on
+   * @returns A lens whose focus is the given property path of a JSON object
+   *
+   * @example
+   * let nestedObj = JsonObject([("a", JsonObject([("b", JsonNumber(123))]))])
+   * assert get(propertyPath(["a", "b"]), nestedObj) == Some(JsonNumber(123))
+   *
+   * @since v0.7.0
+   */
+  provide let propertyPath = propertyNames => {
+    List.reduce(
+      (lensAcc, propertyName) => lensAcc ||> property(propertyName),
+      json,
+      propertyNames
+    )
+  }
+
+  provide { (||>) }
+}