@grain/stdlib 0.6.4 → 0.6.6

package/int64.md

@@ -13,6 +13,14 @@ No other changes yet.
 from "int64" include Int64
 ```
 
+```grain
+1L
+```
+
+```grain
+-1L
+```
+
 ## Values
 
 Functions and constants included in the Int64 module.
@@ -92,6 +100,12 @@ Returns:
 |----|-----------|
 |`Int64`|The Uint64 represented as an Int64|
 
+Examples:
+
+```grain
+Int64.fromUint64(1uL) == 1L
+```
+
 ### Int64.**incr**
 
 <details disabled>
@@ -117,6 +131,16 @@ Returns:
 |----|-----------|
 |`Int64`|The incremented value|
 
+Examples:
+
+```grain
+Int64.incr(1L) == 2L
+```
+
+```grain
+Int64.incr(-2L) == -1L
+```
+
 ### Int64.**decr**
 
 <details disabled>
@@ -142,6 +166,16 @@ Returns:
 |----|-----------|
 |`Int64`|The decremented value|
 
+Examples:
+
+```grain
+Int64.decr(2L) == 1L
+```
+
+```grain
+Int64.decr(0L) == -1L
+```
+
 ### Int64.**(+)**
 
 <details>
@@ -175,6 +209,13 @@ Returns:
 |----|-----------|
 |`Int64`|The sum of the two operands|
 
+Examples:
+
+```grain
+use Int64.{ (+) }
+assert 1L + 1L == 2L
+```
+
 ### Int64.**(-)**
 
 <details>
@@ -208,6 +249,13 @@ Returns:
 |----|-----------|
 |`Int64`|The difference of the two operands|
 
+Examples:
+
+```grain
+use Int64.{ (-) }
+assert 2L - 1L == 1L
+```
+
 ### Int64.**(*)**
 
 <details>
@@ -241,6 +289,13 @@ Returns:
 |----|-----------|
 |`Int64`|The product of the two operands|
 
+Examples:
+
+```grain
+use Int64.{ (*) }
+assert 2L * 2L == 4L
+```
+
 ### Int64.**(/)**
 
 <details>
@@ -274,6 +329,13 @@ Returns:
 |----|-----------|
 |`Int64`|The quotient of its operands|
 
+Examples:
+
+```grain
+use Int64.{ (/) }
+assert 8L / 2L == 4L
+```
+
 ### Int64.**rem**
 
 <details disabled>
@@ -300,6 +362,12 @@ Returns:
 |----|-----------|
 |`Int64`|The remainder of its operands|
 
+Examples:
+
+```grain
+Int64.rem(8L, 3L) == 2L
+```
+
 ### Int64.**(%)**
 
 <details>
@@ -340,6 +408,13 @@ Throws:
 
 * When `y` is zero
 
+Examples:
+
+```grain
+use Int64.{ (%) }
+assert -5L % 3L == 1L
+```
+
 ### Int64.**rotl**
 
 <details disabled>
@@ -366,6 +441,16 @@ Returns:
 |----|-----------|
 |`Int64`|The rotated value|
 
+Examples:
+
+```grain
+Int64.rotl(1L, 1L) == 2L
+```
+
+```grain
+Int64.rotl(1L, 2L) == 4L
+```
+
 ### Int64.**rotr**
 
 <details disabled>
@@ -392,6 +477,16 @@ Returns:
 |----|-----------|
 |`Int64`|The rotated value|
 
+Examples:
+
+```grain
+Int64.rotr(2L, 1L) == 1L
+```
+
+```grain
+Int64.rotr(4L, 2L) == 1L
+```
+
 ### Int64.**(<<)**
 
 <details>
@@ -425,6 +520,13 @@ Returns:
 |----|-----------|
 |`Int64`|The shifted value|
 
+Examples:
+
+```grain
+use Int64.{ (<<) }
+assert (5L << 1L) == 10L
+```
+
 ### Int64.**(>>)**
 
 <details>
@@ -458,6 +560,13 @@ Returns:
 |----|-----------|
 |`Int64`|The shifted value|
 
+Examples:
+
+```grain
+use Int64.{ (>>) }
+assert (5L >> 1L) == 2L
+```
+
 ### Int64.**(==)**
 
 <details>
@@ -491,6 +600,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int64.{ (==) }
+assert 1L == 1L
+```
+
 ### Int64.**(!=)**
 
 <details>
@@ -524,6 +640,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is not equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int64.{ (!=) }
+assert 1L != 2L
+```
+
 ### Int64.**eqz**
 
 <details disabled>
@@ -549,6 +672,16 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is equal to zero or `false` otherwise|
 
+Examples:
+
+```grain
+Int64.eqz(0L) == true
+```
+
+```grain
+Int64.eqz(1L) == false
+```
+
 ### Int64.**(<)**
 
 <details>
@@ -582,6 +715,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is less than the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int64.{ (<) }
+assert 1L < 2L
+```
+
 ### Int64.**(>)**
 
 <details>
@@ -615,6 +755,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is greater than the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int64.{ (>) }
+assert 2L > 1L
+```
+
 ### Int64.**(<=)**
 
 <details>
@@ -648,6 +795,18 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is less than or equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int64.{ (<=) }
+assert 1L <= 2L
+```
+
+```grain
+use Int64.{ (<=) }
+assert 1L <= 1L
+```
+
 ### Int64.**(>=)**
 
 <details>
@@ -681,6 +840,18 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is greater than or equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int64.{ (>=) }
+assert 2L >= 1L
+```
+
+```grain
+use Int64.{ (>=) }
+assert 1L >= 1L
+```
+
 ### Int64.**lnot**
 
 <details disabled>
@@ -706,6 +877,12 @@ Returns:
 |----|-----------|
 |`Int64`|Containing the inverted bits of the given value|
 
+Examples:
+
+```grain
+Int64.lnot(-5L) == 4L
+```
+
 ### Int64.**(&)**
 
 <details>
@@ -739,6 +916,13 @@ Returns:
 |----|-----------|
 |`Int64`|Containing a `1` in each bit position for which the corresponding bits of both operands are `1`|
 
+Examples:
+
+```grain
+use Int64.{ (&) }
+assert (3L & 4L) == 0L
+```
+
 ### Int64.**(|)**
 
 <details>
@@ -772,6 +956,13 @@ Returns:
 |----|-----------|
 |`Int64`|Containing a `1` in each bit position for which the corresponding bits of either or both operands are `1`|
 
+Examples:
+
+```grain
+use Int64.{ (|) }
+assert (3L | 4L) == 7L
+```
+
 ### Int64.**(^)**
 
 <details>
@@ -805,6 +996,13 @@ Returns:
 |----|-----------|
 |`Int64`|Containing a `1` in each bit position for which the corresponding bits of either but not both operands are `1`|
 
+Examples:
+
+```grain
+use Int64.{ (^) }
+assert (3L ^ 5L) == 6L
+```
+
 ### Int64.**clz**
 
 <details disabled>
@@ -830,6 +1028,16 @@ Returns:
 |----|-----------|
 |`Int64`|The amount of leading zeros|
 
+Examples:
+
+```grain
+Int64.clz(1L) == 63L
+```
+
+```grain
+Int64.clz(4L) == 61L
+```
+
 ### Int64.**ctz**
 
 <details disabled>
@@ -855,6 +1063,16 @@ Returns:
 |----|-----------|
 |`Int64`|The amount of trailing zeros|
 
+Examples:
+
+```grain
+Int64.ctz(1L) == 0L
+```
+
+```grain
+Int64.ctz(4L) == 2L
+```
+
 ### Int64.**popcnt**
 
 <details disabled>
@@ -880,6 +1098,16 @@ Returns:
 |----|-----------|
 |`Int64`|The amount of 1-bits in its operand|
 
+Examples:
+
+```grain
+Int64.popcnt(1L) == 1L
+```
+
+```grain
+Int64.popcnt(3L) == 2L
+```
+
 ### Int64.**(\*\*)**
 
 <details disabled>
@@ -906,3 +1134,10 @@ Returns:
 |----|-----------|
 |`Int64`|The base raised to the given power|
 
+Examples:
+
+```grain
+from Int64 use { (**) }
+assert 2L ** 3L == 8L
+```
+

package/list.gr

@@ -9,6 +9,10 @@
  */
 module List
 
+from "runtime/unsafe/memory" include Memory
+from "runtime/unsafe/wasmi32" include WasmI32
+from "runtime/dataStructures" include DataStructures
+
 /**
  * Creates a new list of the specified length where each element is
  * initialized with the result of an initializer function. The initializer
@@ -842,6 +846,51 @@ provide let sub = (start, length, list) => {
   take(length, drop(start, list))
 }
 
+// List.join helpers
+@unsafe
+let rec computeJoinSize = (sepSize: WasmI32, size: WasmI32, lst: List<String>) => {
+  use WasmI32.{ (+) }
+  use DataStructures.{ stringSize }
+  match (lst) {
+    [] => size,
+    [hd] => size + stringSize(WasmI32.fromGrain(hd)),
+    [hd, ...tl] => {
+      let size = size + stringSize(WasmI32.fromGrain(hd)) + sepSize
+      ignore(hd)
+      computeJoinSize(sepSize, size, tl)
+    },
+  }
+}
+@unsafe
+let rec buildJoinedString = (
+  strPtr: WasmI32,
+  sepPtr: WasmI32,
+  sepSize: WasmI32,
+  offset: WasmI32,
+  lst: List<String>,
+) => {
+  use WasmI32.{ (+) }
+  use DataStructures.{ stringSize }
+  match (lst) {
+    [] => void,
+    // Last element
+    [hd] => {
+      let ptr = WasmI32.fromGrain(hd)
+      let size = stringSize(ptr)
+      Memory.copy(offset, ptr + 8n, size)
+      ignore(hd)
+    },
+    [hd, ...tl] => {
+      let ptr = WasmI32.fromGrain(hd)
+      let size = stringSize(ptr)
+      Memory.copy(offset, ptr + 8n, size)
+      ignore(hd)
+      let offset = offset + size
+      Memory.copy(offset, sepPtr, sepSize)
+      buildJoinedString(strPtr, sepPtr, sepSize, offset + sepSize, tl)
+    },
+  }
+}
 /**
  * Combine the given list of strings into one string with the specified
  * separator inserted between each item.
@@ -852,25 +901,17 @@ provide let sub = (start, length, list) => {
  *
  * @since v0.4.0
  */
+@unsafe
 provide let join = (separator: String, list: List<String>) => {
-  let rec iter = (sep, acc, rem) => {
-    match (rem) {
-      [] => acc,
-      [hd, ...tl] => {
-        let newAcc = match (acc) {
-          None => Some(hd),
-          Some(s) => Some(hd ++ sep ++ s),
-        }
-        iter(sep, newAcc, tl)
-      },
-    }
-  }
-
-  // Reverse and reduce to take advantage of TCE
-  match (iter(separator, None, reverse(list))) {
-    None => "",
-    Some(s) => s,
-  }
+  use WasmI32.{ (+), (-), (<=) }
+  use DataStructures.{ allocateString, stringSize }
+  let sepPtr = WasmI32.fromGrain(separator)
+  let sepSize = stringSize(sepPtr)
+  let strSize = computeJoinSize(sepSize, 0n, list)
+  let newString = allocateString(strSize)
+  buildJoinedString(newString, sepPtr + 8n, sepSize, newString + 8n, list)
+  ignore(sepPtr)
+  return WasmI32.toGrain(newString): String
 }
 
 /**

package/map.gr

@@ -436,13 +436,14 @@ provide let toArray = (map: Map<a, b>) => {
     use WasmI32.{ (+) as addWasmI32 }
     // Assign the values into the array.
     // We store them directly to prevent GC on uninitialized array data.
-    let array = WasmI32.fromGrain(array)
+    let arrayPtr = WasmI32.fromGrain(array)
     let item = (key, value)
     WasmI32.store(
-      addWasmI32(array, untagSimpleNumber(i) * 4n),
+      addWasmI32(arrayPtr, untagSimpleNumber(i) * 4n),
       Memory.incRef(WasmI32.fromGrain(item)),
       8n
     )
+    ignore(array)
     i + 1
   }
   reduce(reducer, 0, map)

package/package.json

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

package/pervasives.md

@@ -855,9 +855,16 @@ Returns:
 
 ### Pervasives.**print**
 
-<details disabled>
-<summary tabindex="-1">Added in <code>0.1.0</code></summary>
-No other changes yet.
+<details>
+<summary>Added in <code>0.1.0</code></summary>
+<table>
+<thead>
+<tr><th>version</th><th>changes</th></tr>
+</thead>
+<tbody>
+<tr><td><code>0.6.0</code></td><td>Added support for custom suffixes</td></tr>
+</tbody>
+</table>
 </details>
 
 ```grain