@grain/stdlib 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.6.2](https://github.com/grain-lang/grain/compare/stdlib-v0.6.1...stdlib-v0.6.2) (2024-04-01)
+
+
+### Miscellaneous Chores
+
+* **stdlib:** Synchronize Grain versions
+
+## [0.6.1](https://github.com/grain-lang/grain/compare/stdlib-v0.6.0...stdlib-v0.6.1) (2024-03-29)
+
+
+### Bug Fixes
+
+* **stdlib:** Avoid WASI random_get in Hash stdlib during module startup ([#2078](https://github.com/grain-lang/grain/issues/2078)) ([7eadfb0](https://github.com/grain-lang/grain/commit/7eadfb097e64b043c860d27d21d36d4bfea1ea96))
+* **stdlib:** Implement `print` using a single element io vec ([#2066](https://github.com/grain-lang/grain/issues/2066)) ([9eeb0f2](https://github.com/grain-lang/grain/commit/9eeb0f2edb14facc619c1ede27a5700a27e64e3f))
+
 ## [0.6.0](https://github.com/grain-lang/grain/compare/stdlib-v0.5.13...stdlib-v0.6.0) (2024-03-04)
 
 

package/hash.gr

@@ -43,9 +43,15 @@ from "wasi/random" include Random
 from "result" include Result
 
 @unsafe
-let seed = {
+let mut seed = 0n
+
+@unsafe
+let initalize = () => {
+  // Delay initialization to the first call to `hash` to prevent WASI calls
+  // during startup
   let random = Random.random()
-  coerceNumberToWasmI32(Result.unwrap(random))
+  seed = coerceNumberToWasmI32(Result.unwrap(random))
+  seed
 }
 
 @unsafe
@@ -239,6 +245,8 @@ let rec hashOne = (val, depth) => {
  *
  * @param anything: The value to hash
  * @returns A hash for the given value
+ * 
+ * @throws Failure(String): If WASI random_get fails
  *
  * @example assert Hash.hash(1) == Hash.hash(1)
  * @example assert Hash.hash("Hello World") == Hash.hash("Hello World")
@@ -247,7 +255,11 @@ let rec hashOne = (val, depth) => {
  */
 @unsafe
 provide let hash = anything => {
-  h = seed
+  h = if (WasmI32.eqz(seed)) {
+    initalize()
+  } else {
+    seed
+  }
 
   hashOne(WasmI32.fromGrain(anything), 0n)
   finalize(0n)

package/hash.md

@@ -50,6 +50,12 @@ Returns:
 |----|-----------|
 |`Number`|A hash for the given value|
 
+Throws:
+
+`Failure(String)`
+
+* If WASI random_get fails
+
 Examples:
 
 ```grain

package/json.gr

@@ -55,10 +55,25 @@ let _Float64_BOXED_VALUE_OFFSET = 8n
  * ])
  */
 provide enum rec Json {
+  /**
+   * Represents the JSON `null` value.
+   */
   JsonNull,
+  /**
+   * Represents a JSON boolean value.
+   */
   JsonBoolean(Bool),
+  /**
+   * Represents a JSON number value.
+   */
   JsonNumber(Number),
+  /**
+   * Represents a JSON string value.
+   */
   JsonString(String),
+  /**
+   * Represents a JSON array value.
+   */
   JsonArray(List<Json>),
   // Note that JsonObject here is deliberately defined as a simple list of key value pair tuples as opposed
   // to for example a Map in order to accommodate the fact that the ECMA-404 standard doesn't prohibit
@@ -67,6 +82,9 @@ provide enum rec Json {
   // has the benefit of List's immutability. It's a conscious decision that sacrifices ease of use of the
   // API for lossless handing of these edge cases with intention of later building more ergonomic APIs on a
   // higher level of abstraction.
+  /**
+   * Represents a JSON object value, as a list of (key, value).
+   */
   JsonObject(List<(String, Json)>),
 }
 
@@ -494,7 +512,6 @@ let emitEscapedUnicodeSequence = (codePoint: Number, buffer: Buffer.Buffer) => {
     // High surrogate
     let lowSurrogate = (uPrime & 0b00000000001111111111) + 0xDC00
     // Low surrogate
-
     emitUTF16EscapeSequence(highSurrogate, buffer)
     emitUTF16EscapeSequence(lowSurrogate, buffer)
   }
@@ -558,21 +575,9 @@ let printNumberWasmI64 = (value: WasmI64, buffer: Buffer.Buffer) => {
   Buffer.addString(s, buffer)
 }
 
-@unsafe
-let isFinite = (value: WasmF64) => {
-  use WasmF64.{ (==), (-) }
-  value - value == 0.0W
-}
-
-@unsafe
-let isNaN = (value: WasmF64) => {
-  use WasmF64.{ (!=) }
-  value != value
-}
-
 @unsafe
 let printNumberWasmF64 = (value: WasmF64, buffer: Buffer.Buffer) => {
-  if (isFinite(value)) {
+  if (NumberUtils.isFinite(value)) {
     let s = NumberUtils.dtoa(value)
     Buffer.addString(s, buffer)
     None
@@ -585,7 +590,7 @@ let printNumberWasmF64 = (value: WasmF64, buffer: Buffer.Buffer) => {
     // directly. Other possible choices were to throw exceptions or to
     // continue formatting without representing these values correctly
     // (like JavaScript's JSON.stringify).
-    if (isNaN(value)) {
+    if (NumberUtils.isNaN(value)) {
       Some(InvalidNumber("NaN is not allowed in JsonNumber"))
     } else if (value < 0.0W) {
       Some(InvalidNumber("-Infinity is not allowed in JsonNumber"))
@@ -1558,20 +1563,22 @@ and parseString = (parserState: JsonParserState) => {
     // '"'
     Some(e) => return Err(e),
     None => {
-      let mut done = false
       let buffer = parserState.bufferParse
       Buffer.clear(buffer)
 
-      while (!done) {
+      while (true) {
         match (parserState.currentCodePoint) {
           0x22 => { // '"'
             next(parserState)
-            done = true
             break
           },
-          -1 => {
-            // just end the loop without setting done to true
-            break
+          -1 => { // EOF
+            return Err(
+              buildUnexpectedTokenError(
+                parserState,
+                "unexpected end of string value"
+              ),
+            )
           },
           0x5C => { // '\'
             // Keep the starting position for better error reporting.
@@ -1757,17 +1764,8 @@ and parseString = (parserState: JsonParserState) => {
         }
       }
 
-      if (done) {
-        let s = Buffer.toString(buffer)
-        return Ok(s)
-      } else {
-        return Err(
-          buildUnexpectedTokenError(
-            parserState,
-            "unexpected end of string value"
-          ),
-        )
-      }
+      let s = Buffer.toString(buffer)
+      return Ok(s)
     },
   }
 }
@@ -1887,10 +1885,14 @@ and parseNumberValue = (parserState: JsonParserState) => {
       }
     },
   }
-  if (result == 0 && isNegative)
-    return Ok(JsonNumber(-0.0))
-  else
-    return Ok(JsonNumber(if (isNegative) result * -1 else result))
+
+  let result = if (result == 0 && isNegative) {
+    -0.0
+  } else {
+    if (isNegative) result * -1 else result
+  }
+
+  return Ok(JsonNumber(result))
 }
 and parseArray = (parserState: JsonParserState) => {
   match (expectCodePointAndAdvance(0x5B, parserState)) {
@@ -1901,10 +1903,9 @@ and parseArray = (parserState: JsonParserState) => {
 
       let mut elems = []: List<Json>
 
-      let mut done = false
       let mut first = true
       let mut trailingComma = false
-      while (!done) {
+      while (true) {
         let c = parserState.currentCodePoint
         match (c) {
           0x2C => { // ','
@@ -1922,12 +1923,12 @@ and parseArray = (parserState: JsonParserState) => {
           },
           0x5D => { // ']'
             next(parserState)
-            done = true
             break
           },
-          -1 => {
-            // just end the loop without setting done to true
-            break
+          -1 => { // EOF
+            return Err(
+              buildUnexpectedTokenError(parserState, "unexpected end of array"),
+            )
           },
           _ => {
             // note that parseValue skips initial and final whitespace
@@ -1947,12 +1948,8 @@ and parseArray = (parserState: JsonParserState) => {
         return Err(
           buildUnexpectedTokenError(parserState, "unexpected end of array"),
         )
-      } else if (done) {
-        return Ok(JsonArray(List.reverse(elems)))
       } else {
-        return Err(
-          buildUnexpectedTokenError(parserState, "unexpected end of array"),
-        )
+        return Ok(JsonArray(List.reverse(elems)))
       }
     },
   }
@@ -1964,12 +1961,11 @@ and parseObject = (parserState: JsonParserState) => {
     None => {
       let mut entries = []: List<(String, Json)>
 
-      let mut done = false
       let mut first = true
 
       // one iteration of this loop should correspond to a key-value pair
       let mut trailingComma = false
-      while (!done) {
+      while (true) {
         skipWhiteSpace(parserState)
 
         let c = parserState.currentCodePoint
@@ -1994,7 +1990,6 @@ and parseObject = (parserState: JsonParserState) => {
               return Err(buildUnexpectedTokenError(parserState, detail))
             }
             next(parserState)
-            done = true
             break
           },
           _ => {
@@ -2027,15 +2022,7 @@ and parseObject = (parserState: JsonParserState) => {
       }
       // end of entry loop
 
-      if (done) {
-        return Ok(JsonObject(List.reverse(entries)))
-      } else {
-        // This branch is not expected to actually execute,
-        // but in case it does, may just as well do the right thing.
-        return Err(
-          buildUnexpectedTokenError(parserState, "unexpected end of object"),
-        )
-      }
+      return Ok(JsonObject(List.reverse(entries)))
     },
   }
 }

package/json.md

@@ -40,6 +40,44 @@ enum Json {
 
 Data structure representing JSON in Grain.
 
+Variants:
+
+```grain
+JsonNull
+```
+
+Represents the JSON `null` value.
+
+```grain
+JsonBoolean(Bool)
+```
+
+Represents a JSON boolean value.
+
+```grain
+JsonNumber(Number)
+```
+
+Represents a JSON number value.
+
+```grain
+JsonString(String)
+```
+
+Represents a JSON string value.
+
+```grain
+JsonArray(List<Json>)
+```
+
+Represents a JSON array value.
+
+```grain
+JsonObject(List<(String, Json)>)
+```
+
+Represents a JSON object value, as a list of (key, value).
+
 Examples:
 
 ```grain

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grain/stdlib",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "The standard library for the Grain language.",
   "license": "MIT",
   "homepage": "https://grain-lang.org",

package/runtime/numberUtils.gr

@@ -1452,13 +1452,13 @@ let get_dtoa_buf = () => {
 }
 
 @unsafe
-let isFinite = value => {
+provide let isFinite = value => {
   use WasmF64.{ (==), (-) }
   value - value == 0.0W
 }
 
 @unsafe
-let isNaN = value => {
+provide let isNaN = value => {
   use WasmF64.{ (!=) }
   value != value
 }

package/runtime/numberUtils.md

@@ -60,6 +60,18 @@ utoa64 : (value: WasmI64, radix: WasmI32) => String
 itoa64 : (value: WasmI64, radix: WasmI32) => String
 ```
 
+### NumberUtils.**isFinite**
+
+```grain
+isFinite : (value: WasmF64) => Bool
+```
+
+### NumberUtils.**isNaN**
+
+```grain
+isNaN : (value: WasmF64) => Bool
+```
+
 ### NumberUtils.**dtoa**
 
 ```grain

package/runtime/string.gr

@@ -861,20 +861,20 @@ provide let print = (value, suffix="\n") => {
   // First convert the value to string, if it isn't one already.
   let valuePtr = WasmI32.fromGrain(value)
   let s = toString(value)
-  let ptr = WasmI32.fromGrain(s)
-  let suffixPtr = WasmI32.fromGrain(suffix)
-  // iov: [<ptr to string> <nbytes of string> <ptr to end sequence> <nbytes of end sequence>] (32 bytes)
+  let combined = concat(s, suffix)
+  let ptr = WasmI32.fromGrain(combined)
+  // iov: [<ptr to string> <nbytes of string>]
   // buf: <iov> <written>
   // fd_write(STDOUT (1), iov, len(iov), written)
-  let buf = Memory.malloc(36n)
+  let buf = Memory.malloc(20n)
   let iov = buf
-  let written = buf + 32n
+  let written = buf + 16n
   WasmI32.store(iov, ptr + 8n, 0n)
   WasmI32.store(iov, WasmI32.load(ptr, 4n), 4n)
-  WasmI32.store(iov, suffixPtr + 8n, 8n)
-  WasmI32.store(iov, WasmI32.load(suffixPtr, 4n), 12n)
-  fd_write(1n, iov, 2n, written)
+  fd_write(1n, iov, 1n, written)
   Memory.free(buf)
+  ignore(value)
+  ignore(suffix)
   void
 }