@grain/stdlib 0.5.3 → 0.5.5

package/list.gr

@@ -230,10 +230,12 @@ export let rec flatMap = (fn, list) => {
  *
  * @since v0.1.0
  */
-export let every = (fn, list) => {
-  reduce((acc, value) => {
-    acc && fn(value)
-  }, true, list)
+export let rec every = (fn, list) => {
+  match (list) {
+    [] => true,
+    // The short-circuiting of `&&` makes this tail-recursive
+    [first, ...rest] => fn(first) && every(fn, rest),
+  }
 }
 
 /**
@@ -246,10 +248,12 @@ export let every = (fn, list) => {
  *
  * @since v0.1.0
  */
-export let some = (fn, list) => {
-  reduce((acc, value) => {
-    acc || fn(value)
-  }, false, list)
+export let rec some = (fn, list) => {
+  match (list) {
+    [] => false,
+    // The short-circuiting of `||` makes this tail-recursive
+    [first, ...rest] => fn(first) || some(fn, rest),
+  }
 }
 
 /**
@@ -433,13 +437,15 @@ export let rec flatten = list => {
 
 /**
  * Inserts a new value into a list at the specified index.
- * Fails if the index is out-of-bounds.
  *
  * @param value: The value to insert
  * @param index: The index to update
  * @param list: The list to update
  * @returns The new list
  *
+ * @throws Failure(String): When `index` is negative
+ * @throws Failure(String): When `index` is more than 0 and greater than the list size
+ *
  * @since v0.1.0
  */
 export let rec insert = (value, index, list) => {
@@ -477,12 +483,14 @@ export let count = (fn, list) => {
 
 /**
  * Split a list into two, with the first list containing the required number of elements.
- * Fails if the input list doesn't contain at least the required amount of elements.
  *
  * @param count: The number of elements required
  * @param list: The list to split
  * @returns Two lists where the first contains exactly the required amount of elements and the second contains any remaining elements
  *
+ * @throws Failure(String): When `count` is negative
+ * @throws Failure(String): When the list doesn't contain at least the required amount of elements
+ *
  * @since v0.1.0
  */
 export let part = (count, list) => {
@@ -509,19 +517,19 @@ export let part = (count, list) => {
  * If value is negative, list elements will be rotated by the
  * specified amount to the right. See examples.
  *
- * Fails if the input list doesn't contain at least the required amount of elements.
- *
  * @param count: The number of elements to rotate by
  * @param list: The list to be rotated
  *
  * @example List.rotate(2, [1, 2, 3, 4, 5]) // [3, 4, 5, 1, 2]
  * @example List.rotate(-1, [1, 2, 3, 4, 5]) // [5, 1, 2, 3, 4]
  *
+ * @throws Failure(String): When the list doesn't contain at least the required amount of elements
+ *
  * @since v0.1.0
  */
 export let rotate = (count, list) => {
-  let (beginning, end) = if (count >= 0) part(count, list)
-    else part(length(list) + count, list)
+  let (beginning, end) =
+    if (count >= 0) part(count, list) else part(length(list) + count, list)
   append(end, beginning)
 }
 
@@ -552,7 +560,7 @@ export let unique = list => {
  * Produces a new list filled with tuples of elements from both given lists.
  * The first tuple will contain the first item of each list, the second tuple
  * will contain the second item of each list, and so on.
- * 
+ *
  * Calling this function with lists of different sizes will cause the returned
  * list to have the length of the smaller list.
  *
@@ -562,7 +570,7 @@ export let unique = list => {
  *
  * @example List.zip([1, 2, 3], [4, 5, 6]) // [(1, 4), (2, 5), (3, 6)]
  * @example List.zip([1, 2, 3], [4, 5]) // [(1, 4), (2, 5)]
- * 
+ *
  * @since v0.5.3
  */
 export let zip = (list1, list2) => {
@@ -582,7 +590,7 @@ export let zip = (list1, list2) => {
  * applying the function to the first elements of each list, the second element
  * will contain the result of applying the function to the second elements of
  * each list, and so on.
- * 
+ *
  * Calling this function with lists of different sizes will cause the returned
  * list to have the length of the smaller list.
  *
@@ -593,7 +601,7 @@ export let zip = (list1, list2) => {
  *
  * @example List.zipWith((a, b) => a + b, [1, 2, 3], [4, 5, 6]) // [5, 7, 9]
  * @example List.zipWith((a, b) => a * b, [1, 2, 3], [4, 5]) // [4, 10]
- * 
+ *
  * @since v0.5.3
  */
 export let zipWith = (fn, list1, list2) => {
@@ -625,12 +633,12 @@ export let unzip = list => {
  * Produces a new list with the specified number of elements removed from
  * the beginning of the input list.
  *
- * Fails if the specified amount is a negative number.
- *
  * @param count: The amount of elements to remove
  * @param list: The input list
  * @returns The new list without the dropped elements
  *
+ * @throws Failure(String): When `count` is negative
+ *
  * @since v0.2.0
  */
 export let rec drop = (count, list) => {
@@ -667,12 +675,12 @@ export let rec dropWhile = (fn, list) => {
  * Produces a new list with–at most—the specified amount elements from
  * the beginning of the input list.
  *
- * Fails if the specified amount is a negative number.
- *
  * @param count: The amount of elements to keep
  * @param list: The input list
  * @returns The new list containing the taken elements
  *
+ * @throws Failure(String): When `count` is negative
+ *
  * @since v0.2.0
  */
 export let rec take = (count, list) => {
@@ -769,13 +777,14 @@ export let product = (list1, list2) => {
  * Provides the subset of a list given zero-based start index and amount of elements
  * to include.
  *
- * Fails if the start index or amount of elements are negative numbers.
- *
  * @param start: The index of the list where the subset will begin (inclusive)
  * @param length: The amount of elements to be included in the subset
  * @param list: The input list
  * @returns The subset of the list
  *
+ * @throws Failure(String): When `start` is negative
+ * @throws Failure(String): When `length` is negative
+ *
  * @since v0.2.0
  */
 export let sub = (start, length, list) => {

package/list.md

@@ -674,7 +674,6 @@ insert : (a, Number, List<a>) -> List<a>
 ```
 
 Inserts a new value into a list at the specified index.
-Fails if the index is out-of-bounds.
 
 Parameters:
 
@@ -690,6 +689,13 @@ Returns:
 |----|-----------|
 |`List<a>`|The new list|
 
+Throws:
+
+`Failure(String)`
+
+* When `index` is negative
+* When `index` is more than 0 and greater than the list size
+
 ### List.**count**
 
 <details>
@@ -735,7 +741,6 @@ part : (Number, List<a>) -> (List<a>, List<a>)
 ```
 
 Split a list into two, with the first list containing the required number of elements.
-Fails if the input list doesn't contain at least the required amount of elements.
 
 Parameters:
 
@@ -750,6 +755,13 @@ Returns:
 |----|-----------|
 |`(List<a>, List<a>)`|Two lists where the first contains exactly the required amount of elements and the second contains any remaining elements|
 
+Throws:
+
+`Failure(String)`
+
+* When `count` is negative
+* When the list doesn't contain at least the required amount of elements
+
 ### List.**rotate**
 
 <details disabled>
@@ -766,8 +778,6 @@ Rotates list elements by the specified amount to the left.
 If value is negative, list elements will be rotated by the
 specified amount to the right. See examples.
 
-Fails if the input list doesn't contain at least the required amount of elements.
-
 Parameters:
 
 |param|type|description|
@@ -775,6 +785,12 @@ Parameters:
 |`count`|`Number`|The number of elements to rotate by|
 |`list`|`List<a>`|The list to be rotated|
 
+Throws:
+
+`Failure(String)`
+
+* When the list doesn't contain at least the required amount of elements
+
 Examples:
 
 ```grain
@@ -943,8 +959,6 @@ drop : (Number, List<a>) -> List<a>
 Produces a new list with the specified number of elements removed from
 the beginning of the input list.
 
-Fails if the specified amount is a negative number.
-
 Parameters:
 
 |param|type|description|
@@ -958,6 +972,12 @@ Returns:
 |----|-----------|
 |`List<a>`|The new list without the dropped elements|
 
+Throws:
+
+`Failure(String)`
+
+* When `count` is negative
+
 ### List.**dropWhile**
 
 <details disabled>
@@ -1000,8 +1020,6 @@ take : (Number, List<a>) -> List<a>
 Produces a new list with–at most—the specified amount elements from
 the beginning of the input list.
 
-Fails if the specified amount is a negative number.
-
 Parameters:
 
 |param|type|description|
@@ -1015,6 +1033,12 @@ Returns:
 |----|-----------|
 |`List<a>`|The new list containing the taken elements|
 
+Throws:
+
+`Failure(String)`
+
+* When `count` is negative
+
 ### List.**takeWhile**
 
 <details disabled>
@@ -1152,8 +1176,6 @@ sub : (Number, Number, List<a>) -> List<a>
 Provides the subset of a list given zero-based start index and amount of elements
 to include.
 
-Fails if the start index or amount of elements are negative numbers.
-
 Parameters:
 
 |param|type|description|
@@ -1168,6 +1190,13 @@ Returns:
 |----|-----------|
 |`List<a>`|The subset of the list|
 
+Throws:
+
+`Failure(String)`
+
+* When `start` is negative
+* When `length` is negative
+
 ### List.**join**
 
 <details disabled>

package/map.gr

@@ -9,7 +9,7 @@ import Array from "array"
 import { hash } from "hash"
 import Memory from "runtime/unsafe/memory"
 import WasmI32 from "runtime/unsafe/wasmi32"
-import { allocateArray } from "runtime/dataStructures"
+import { allocateArray, untagSimpleNumber } from "runtime/dataStructures"
 
 // TODO: Consider implementing this as List<(Box<k>, Box<v>)>
 record Bucket<k, v> {
@@ -418,19 +418,6 @@ export let fromList = list => {
   map
 }
 
-let setInArray = array => {
-  @disableGC
-  let rec iter = (i, key, value) => {
-    array[i] = (key, value)
-    // no decRef on key and value, since they are stored in array
-    Memory.decRef(WasmI32.fromGrain(iter))
-    Memory.incRef(WasmI32.fromGrain((+)))
-    Memory.incRef(WasmI32.fromGrain(i))
-    i + 1
-  }
-  iter
-}
-
 /**
  * Converts a map into an array of its key-value pairs.
  *
@@ -439,20 +426,24 @@ let setInArray = array => {
  *
  * @since v0.2.0
  */
-@disableGC
-export let rec toArray = map => {
-  let length = WasmI32.shrS(WasmI32.fromGrain(map.size), 1n)
-  let array = WasmI32.toGrain(allocateArray(length)): Array<a>
-  Memory.incRef(WasmI32.fromGrain(setInArray))
-  Memory.incRef(WasmI32.fromGrain(array))
-  let setInArray = setInArray(array)
-  Memory.incRef(WasmI32.fromGrain(reduce))
-  Memory.incRef(WasmI32.fromGrain(setInArray))
-  Memory.incRef(WasmI32.fromGrain(map))
-  reduce(setInArray, 0, map)
-  Memory.decRef(WasmI32.fromGrain(setInArray))
-  Memory.decRef(WasmI32.fromGrain(map))
-  Memory.decRef(WasmI32.fromGrain(toArray))
+@unsafe
+export let toArray: Map<a, b> -> Array<(a, b)> = map => {
+  let length = untagSimpleNumber(map.size)
+  let array = WasmI32.toGrain(allocateArray(length))
+  @unsafe
+  let reducer = (i, key, value) => {
+    // Assign the values into the array.
+    // We store them directly to prevent GC on uninitialized array data.
+    let array = WasmI32.fromGrain(array)
+    let item = (key, value)
+    WasmI32.store(
+      WasmI32.add(array, WasmI32.mul(untagSimpleNumber(i), 4n)),
+      Memory.incRef(WasmI32.fromGrain(item)),
+      8n
+    )
+    i + 1
+  }
+  reduce(reducer, 0, map)
   array
 }
 

package/marshal.gr

@@ -54,7 +54,7 @@ let roundTo8 = n => {
 @unsafe
 let isHeapPtr = value =>
   (value & Tags._GRAIN_GENERIC_TAG_MASK) ==
-  Tags._GRAIN_GENERIC_HEAP_TAG_TYPE
+    Tags._GRAIN_GENERIC_HEAP_TAG_TYPE
 
 @unsafe
 let rec size = (value, acc, valuesSeen, toplevel) => {
@@ -157,9 +157,9 @@ let rec size = (value, acc, valuesSeen, toplevel) => {
             },
             t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => {
               acc +
-              16n +
-              size(load(value, 8n), 0n, valuesSeen, false) +
-              size(load(value, 12n), 0n, valuesSeen, false)
+                16n +
+                size(load(value, 8n), 0n, valuesSeen, false) +
+                size(load(value, 12n), 0n, valuesSeen, false)
             },
             _ => {
               fail "Unknown number type"