@grain/stdlib 0.5.0 → 0.5.3

package/buffer.gr

@@ -83,21 +83,21 @@ let checkIsIndexInBounds = (i, len, buf) => {
 let addInt8help = (value, buffer) => {
   autogrow(_8BIT_LEN, buffer)
   let index = buffer.len
-  buffer.len = buffer.len + _8BIT_LEN
+  buffer.len += _8BIT_LEN
   Bytes.setInt8(index, value, buffer.data)
 }
 
 let addInt16help = (value, buffer) => {
   autogrow(_16BIT_LEN, buffer)
   let index = buffer.len
-  buffer.len = buffer.len + _16BIT_LEN
+  buffer.len += _16BIT_LEN
   Bytes.setInt16(index, value, buffer.data)
 }
 
 let addInt32help = (value, buffer) => {
   autogrow(_32BIT_LEN, buffer)
   let index = buffer.len
-  buffer.len = buffer.len + _32BIT_LEN
+  buffer.len += _32BIT_LEN
   Bytes.setInt32(index, value, buffer.data)
 }
 
@@ -255,7 +255,7 @@ export let addBytes = (bytes, buffer) => {
   let dst = WasmI32.fromGrain(buffer.data)
   appendBytes(0n, off, len, src, dst)
 
-  buffer.len = buffer.len + bytelen
+  buffer.len += bytelen
 }
 
 /**
@@ -278,7 +278,7 @@ export let addString = (string, buffer) => {
   let dst = WasmI32.fromGrain(buffer.data)
   appendBytes(0n, off, len, src, dst)
 
-  buffer.len = buffer.len + bytelen
+  buffer.len += bytelen
 }
 
 /**
@@ -318,7 +318,7 @@ export let addStringSlice = (start: Number, end, string, buffer) => {
   let dst = WasmI32.fromGrain(buffer.data)
   appendBytes(srcOff, dstOff, coerceNumberToWasmI32(bytelen), src, dst)
 
-  buffer.len = buffer.len + bytelen
+  buffer.len += bytelen
 }
 
 /**
@@ -339,32 +339,34 @@ export let addBytesSlice =
     bytes: Bytes,
     buffer: Buffer,
   ) => {
-  let (-) = WasmI32.sub
-  let (<) = WasmI32.ltS
-  let (>) = WasmI32.gtS
-  let (>=) = WasmI32.geS
-
-  // bounds check start
-  let bytelen = WasmI32.load(WasmI32.fromGrain(bytes), 4n)
-  let srcOff = coerceNumberToWasmI32(start)
-  if (srcOff < 0n || srcOff >= bytelen) {
-    throw Exception.IndexOutOfBounds
-  }
+  if (length != 0) {
+    let (-) = WasmI32.sub
+    let (<) = WasmI32.ltS
+    let (>) = WasmI32.gtS
+    let (>=) = WasmI32.geS
+
+    // bounds check start
+    let bytelen = WasmI32.load(WasmI32.fromGrain(bytes), 4n)
+    let srcOff = coerceNumberToWasmI32(start)
+    if (srcOff < 0n || srcOff >= bytelen) {
+      throw Exception.IndexOutOfBounds
+    }
 
-  // bounds check length
-  let len = coerceNumberToWasmI32(length)
-  if (len < 0n || len > bytelen - srcOff) {
-    throw Exception.IndexOutOfBounds
-  }
+    // bounds check length
+    let len = coerceNumberToWasmI32(length)
+    if (len < 0n || len > bytelen - srcOff) {
+      throw Exception.IndexOutOfBounds
+    }
 
-  autogrow(length, buffer)
+    autogrow(length, buffer)
 
-  let dstOff = coerceNumberToWasmI32(buffer.len)
-  let src = WasmI32.fromGrain(bytes)
-  let dst = WasmI32.fromGrain(buffer.data)
-  appendBytes(srcOff, dstOff, len, src, dst)
+    let dstOff = coerceNumberToWasmI32(buffer.len)
+    let src = WasmI32.fromGrain(bytes)
+    let dst = WasmI32.fromGrain(buffer.data)
+    appendBytes(srcOff, dstOff, len, src, dst)
 
-  buffer.len = buffer.len + length
+    buffer.len += length
+  }
 }
 
 /**
@@ -588,7 +590,7 @@ export let setFloat32 = (index, value, buffer) => {
 export let addFloat32 = (value, buffer) => {
   autogrow(_32BIT_LEN, buffer)
   let index = buffer.len
-  buffer.len = buffer.len + _32BIT_LEN
+  buffer.len += _32BIT_LEN
   setFloat32(index, value, buffer)
 }
 
@@ -631,7 +633,7 @@ export let setInt64 = (index, value, buffer) => {
 export let addInt64 = (value, buffer) => {
   autogrow(_64BIT_LEN, buffer)
   let index = buffer.len
-  buffer.len = buffer.len + _64BIT_LEN
+  buffer.len += _64BIT_LEN
   setInt64(index, value, buffer)
 }
 
@@ -674,6 +676,6 @@ export let setFloat64 = (index, value, buffer) => {
 export let addFloat64 = (value, buffer) => {
   autogrow(_64BIT_LEN, buffer)
   let index = buffer.len
-  buffer.len = buffer.len + _64BIT_LEN
+  buffer.len += _64BIT_LEN
   setFloat64(index, value, buffer)
 }

package/buffer.md

@@ -309,7 +309,7 @@ Parameters:
 <tr><th>version</th><th>changes</th></tr>
 </thead>
 <tbody>
-<tr><td><code>next</code></td><td>Now takes the end offset instead of length</td></tr>
+<tr><td><code>0.5.0</code></td><td>Now takes the end offset instead of length</td></tr>
 </tbody>
 </table>
 </details>

package/bytes.md

@@ -284,7 +284,7 @@ Parameters:
 ### Bytes.**clear**
 
 <details disabled>
-<summary tabindex="-1">Added in <code>next</code></summary>
+<summary tabindex="-1">Added in <code>0.5.0</code></summary>
 No other changes yet.
 </details>
 

package/exception.gr

@@ -1,11 +1,37 @@
+/**
+ * @module Exception: Utilities for working with the Exception type.
+ *
+ * The Exception type represents an error that has occured during computation.
+ *
+ * @example import Exception from "exception"
+ *
+ * @since 0.3.0
+ */
+
 import WasmI32 from "runtime/unsafe/wasmi32"
 import Memory from "runtime/unsafe/memory"
 import Exception from "runtime/exception"
 
+/**
+ * @section Values: Functions included in the Exception module.
+ */
+
+/**
+ * Registers an exception printer. When an exception is thrown, all registered
+ * printers are called in order from the most recently registered printer to
+ * the least recently registered printer. The first `Some` value returned is
+ * used as the exception's string value.
+ *
+ * @param printer: The exception printer to register
+ * @since v0.3.0
+ */
 @disableGC
-export let rec registerPrinter = (f: Exception -> Option<String>) => {
+export let rec registerPrinter = (printer: Exception -> Option<String>) => {
+  // This function _must_ be @disableGC because the printer list uses
+  // unsafe types. Not really a memory leak as this list is never collected
+
   // no need to increment refcount on f; we just don't decRef it at the end of the function
-  Exception.printers = WasmI32.fromGrain((f, Exception.printers))
+  Exception.printers = WasmI32.fromGrain((printer, Exception.printers))
   Memory.decRef(WasmI32.fromGrain(registerPrinter))
   void
 }

package/exception.md

@@ -1,6 +1,43 @@
+---
+title: Exception
+---
+
+Utilities for working with the Exception type.
+
+The Exception type represents an error that has occured during computation.
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.3.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+import Exception from "exception"
+```
+
+## Values
+
+Functions included in the Exception module.
+
 ### Exception.**registerPrinter**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.3.0</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 registerPrinter : (Exception -> Option<String>) -> Void
 ```
 
+Registers an exception printer. When an exception is thrown, all registered
+printers are called in order from the most recently registered printer to
+the least recently registered printer. The first `Some` value returned is
+used as the exception's string value.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`printer`|`Exception -> Option<String>`|The exception printer to register|
+

package/float32.gr

@@ -13,6 +13,56 @@ import {
   coerceFloat32ToNumber as toNumber,
 } from "runtime/numbers"
 
+/**
+ * @section Constants: Float32 constant values.
+ */
+
+/**
+ * Infinity represented as a Float32 value.
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let infinity = {
+  let ptr = newFloat32(
+    WasmF32.reinterpretI32(0b01111111100000000000000000000000n)
+  )
+  WasmI32.toGrain(ptr): Float32
+}
+
+/**
+ * NaN (Not a Number) represented as a Float32 value.
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let nan = {
+  let ptr = newFloat32(
+    WasmF32.reinterpretI32(0b01111111100000000000000000000001n)
+  )
+  WasmI32.toGrain(ptr): Float32
+}
+
+/**
+ * Pi represented as a Float32 value.
+ * 
+ * @since v0.5.2
+ */
+export let pi = 3.1415927f
+
+/**
+ * Tau represented as a Float32 value.
+ * 
+ * @since v0.5.2
+ */
+export let tau = 6.2831853f
+
+/**
+ * Euler's number represented as a Float32 value.
+ * 
+ * @since v0.5.2
+ */
+export let e = 2.7182817f
 /**
  * @section Conversions: Functions for converting between Numbers and the Float32 type.
  */
@@ -176,33 +226,3 @@ export let gte = (x: Float32, y: Float32) => {
   let yv = WasmF32.load(WasmI32.fromGrain(y), 8n)
   WasmF32.ge(xv, yv)
 }
-
-/**
- * @section Constants: Float32 constant values.
- */
-
-/**
- * Infinity represented as a Float32 value.
- * 
- * @since v0.4.0
- */
-@unsafe
-export let infinity = {
-  let ptr = newFloat32(
-    WasmF32.reinterpretI32(0b01111111100000000000000000000000n)
-  )
-  WasmI32.toGrain(ptr): Float32
-}
-
-/**
- * NaN (Not a Number) represented as a Float32 value.
- * 
- * @since v0.4.0
- */
-@unsafe
-export let nan = {
-  let ptr = newFloat32(
-    WasmF32.reinterpretI32(0b01111111100000000000000000000001n)
-  )
-  WasmI32.toGrain(ptr): Float32
-}

package/float32.md

@@ -13,6 +13,75 @@ No other changes yet.
 import Float32 from "float32"
 ```
 
+## Constants
+
+Float32 constant values.
+
+### Float32.**infinity**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.4.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+infinity : Float32
+```
+
+Infinity represented as a Float32 value.
+
+### Float32.**nan**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.4.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+nan : Float32
+```
+
+NaN (Not a Number) represented as a Float32 value.
+
+### Float32.**pi**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.2</code></summary>
+No other changes yet.
+</details>
+
+```grain
+pi : Float32
+```
+
+Pi represented as a Float32 value.
+
+### Float32.**tau**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.2</code></summary>
+No other changes yet.
+</details>
+
+```grain
+tau : Float32
+```
+
+Tau represented as a Float32 value.
+
+### Float32.**e**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.2</code></summary>
+No other changes yet.
+</details>
+
+```grain
+e : Float32
+```
+
+Euler's number represented as a Float32 value.
+
 ## Conversions
 
 Functions for converting between Numbers and the Float32 type.
@@ -283,33 +352,3 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is greater than or equal to the second value or `false` otherwise|
 
-## Constants
-
-Float32 constant values.
-
-### Float32.**infinity**
-
-<details disabled>
-<summary tabindex="-1">Added in <code>0.4.0</code></summary>
-No other changes yet.
-</details>
-
-```grain
-infinity : Float32
-```
-
-Infinity represented as a Float32 value.
-
-### Float32.**nan**
-
-<details disabled>
-<summary tabindex="-1">Added in <code>0.4.0</code></summary>
-No other changes yet.
-</details>
-
-```grain
-nan : Float32
-```
-
-NaN (Not a Number) represented as a Float32 value.
-

package/float64.gr

@@ -13,6 +13,61 @@ import {
   coerceFloat64ToNumber as toNumber,
 } from "runtime/numbers"
 
+/**
+ * @section Constants: Float64 constant values.
+ */
+
+/**
+ * Infinity represented as a Float64 value.
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let infinity = {
+  let ptr = newFloat64(
+    WasmF64.reinterpretI64(
+      0b0111111111110000000000000000000000000000000000000000000000000000N
+    )
+  )
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * NaN (Not a Number) represented as a Float64 value.
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let nan = {
+  let ptr = newFloat64(
+    WasmF64.reinterpretI64(
+      0b0111111111110000000000000000000000000000000000000000000000000001N
+    )
+  )
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * Pi represented as a Float64 value.
+ * 
+ * @since v0.5.2
+ */
+export let pi = 3.141592653589793d
+
+/**
+ * Tau represented as a Float64 value.
+ * 
+ * @since v0.5.2
+ */
+export let tau = 6.283185307179586d
+
+/**
+ * Euler's number represented as a Float64 value.
+ * 
+ * @since v0.5.2
+ */
+export let e = 2.718281828459045d
+
 /**
  * @section Conversions: Functions for converting between Numbers and the Float64 type.
  */
@@ -176,37 +231,3 @@ export let gte = (x: Float64, y: Float64) => {
   let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
   WasmF64.ge(xv, yv)
 }
-
-/**
- * @section Constants: Float64 constant values.
- */
-
-/**
- * Infinity represented as a Float64 value.
- * 
- * @since v0.4.0
- */
-@unsafe
-export let infinity = {
-  let ptr = newFloat64(
-    WasmF64.reinterpretI64(
-      0b0111111111110000000000000000000000000000000000000000000000000000N
-    )
-  )
-  WasmI32.toGrain(ptr): Float64
-}
-
-/**
- * NaN (Not a Number) represented as a Float64 value.
- * 
- * @since v0.4.0
- */
-@unsafe
-export let nan = {
-  let ptr = newFloat64(
-    WasmF64.reinterpretI64(
-      0b0111111111110000000000000000000000000000000000000000000000000001N
-    )
-  )
-  WasmI32.toGrain(ptr): Float64
-}

package/float64.md

@@ -13,6 +13,75 @@ No other changes yet.
 import Float64 from "float64"
 ```
 
+## Constants
+
+Float64 constant values.
+
+### Float64.**infinity**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.4.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+infinity : Float64
+```
+
+Infinity represented as a Float64 value.
+
+### Float64.**nan**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.4.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+nan : Float64
+```
+
+NaN (Not a Number) represented as a Float64 value.
+
+### Float64.**pi**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.2</code></summary>
+No other changes yet.
+</details>
+
+```grain
+pi : Float64
+```
+
+Pi represented as a Float64 value.
+
+### Float64.**tau**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.2</code></summary>
+No other changes yet.
+</details>
+
+```grain
+tau : Float64
+```
+
+Tau represented as a Float64 value.
+
+### Float64.**e**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.2</code></summary>
+No other changes yet.
+</details>
+
+```grain
+e : Float64
+```
+
+Euler's number represented as a Float64 value.
+
 ## Conversions
 
 Functions for converting between Numbers and the Float64 type.
@@ -283,33 +352,3 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is greater than or equal to the second value or `false` otherwise|
 
-## Constants
-
-Float64 constant values.
-
-### Float64.**infinity**
-
-<details disabled>
-<summary tabindex="-1">Added in <code>0.4.0</code></summary>
-No other changes yet.
-</details>
-
-```grain
-infinity : Float64
-```
-
-Infinity represented as a Float64 value.
-
-### Float64.**nan**
-
-<details disabled>
-<summary tabindex="-1">Added in <code>0.4.0</code></summary>
-No other changes yet.
-</details>
-
-```grain
-nan : Float64
-```
-
-NaN (Not a Number) represented as a Float64 value.
-