feat(stdlib): Add Array.tryInit (#2209)

Co-authored-by: Oscar Spencer <oscar.spen@gmail.com>

Author: spotandjake

compiler/test/stdlib/array.test.gr

@@ -7,6 +7,20 @@ from "range" include Range
 
 let arr = [> 1, 2, 3]
 
+// Array.make
+assert Array.make(5, 10) == [> 10, 10, 10, 10, 10]
+assert Array.make(0, 10) == [>]
+
+// Array.init
+assert Array.init(5, n => n + 3) == [> 3, 4, 5, 6, 7]
+assert Array.init(0, n => n + 3) == [>]
+
+// Array.tryInit
+assert Array.tryInit(5, n => Ok(n + 3)) == Ok([> 3, 4, 5, 6, 7])
+assert Array.tryInit(0, n => Ok(n + 3)) == Ok([>])
+assert Array.tryInit(3, n => if (n == 1) Err("stop") else Ok(n)) == Err("stop")
+assert Array.tryInit(0, n => if (n == 1) Err("stop") else Ok(n)) == Ok([>])
+
 // Array.get
 
 assert Array.get(1, arr) == 2

stdlib/array.gr

@@ -120,15 +120,64 @@ provide let init = (length: Number, fn: Number => a) => {
   let mut index = 0n
   for (let mut i = 0n; i < byteLength; i += 4n) {
     WasmI32.store(
-      array + i,
+      array,
       Memory.incRef(WasmI32.fromGrain(fn(tagSimpleNumber(index)))),
-      _ARRAY_DATA_OFFSET
+      _ARRAY_DATA_OFFSET + i
     )
     index += 1n
   }
   WasmI32.toGrain(array): Array<a>
 }
 
+/**
+ * Creates a new array where each element is initialized with the `Ok`
+ * result value of an initializer function. The initializer is called with the
+ * index of each element, and returns the new array if all calls to the
+ * initializer succeed or the first error otherwise.
+ *
+ * @param length: The length of the new array
+ * @param fn: The initializer function to call with each index, where the `Ok` value returned will be used to initialize each element
+ * @returns `Ok(array)` if all elements were successfully initialized or `Err(error)` if the initializer function returned an error
+ *
+ * @throws InvalidArgument(String): When `length` is not an integer
+ * @throws InvalidArgument(String): When `length` is negative
+ *
+ * @example Array.tryInit(5, n => Ok(n + 3)) == [> 3, 4, 5, 6, 7]
+ * @example Array.tryInit(5, n => if (n == 1) Err("stop") else Ok(n)) == Err("stop")
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let tryInit = (length: Number, fn: Number => Result<a, b>) => {
+  use WasmI32.{ (+), (*), (<) }
+  checkLength(length)
+  let length = coerceNumberToWasmI32(length)
+  let byteLength = length * 4n
+  let array = allocateArray(length)
+  let mut index = 0n
+  for (let mut i = 0n; i < byteLength; i += 4n) {
+    let value = fn(tagSimpleNumber(index))
+    match (value) {
+      Ok(value) => {
+        WasmI32.store(
+          array,
+          Memory.incRef(WasmI32.fromGrain(value)),
+          _ARRAY_DATA_OFFSET + i
+        )
+        index += 1n
+      },
+      Err(e) => {
+        for (let mut j = 0n; j < i; j += 4n) {
+          ignore(Memory.decRef(WasmI32.load(array, _ARRAY_DATA_OFFSET + j)))
+        }
+        Memory.free(array)
+        return Err(e)
+      },
+    }
+  }
+  return Ok(WasmI32.toGrain(array): Array<a>)
+}
+
 /**
  * An alias for normal syntactic array access, i.e. `array[n]`.
  *

stdlib/array.md

@@ -143,6 +143,53 @@ Examples:
 Array.init(5, n => n + 3) == [> 3, 4, 5, 6, 7]
 ```
 
+### Array.**tryInit**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+tryInit :
+  (length: Number, fn: (Number => Result<a, b>)) => Result<Array<a>, b>
+```
+
+Creates a new array where each element is initialized with the `Ok`
+result value of an initializer function. The initializer is called with the
+index of each element, and returns the new array if all calls to the
+initializer succeed or the first error otherwise.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`length`|`Number`|The length of the new array|
+|`fn`|`Number => Result<a, b>`|The initializer function to call with each index, where the `Ok` value returned will be used to initialize each element|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Result<Array<a>, b>`|`Ok(array)` if all elements were successfully initialized or `Err(error)` if the initializer function returned an error|
+
+Throws:
+
+`InvalidArgument(String)`
+
+* When `length` is not an integer
+* When `length` is negative
+
+Examples:
+
+```grain
+Array.tryInit(5, n => Ok(n + 3)) == [> 3, 4, 5, 6, 7]
+```
+
+```grain
+Array.tryInit(5, n => if (n == 1) Err("stop") else Ok(n)) == Err("stop")
+```
+
 ### Array.**get**
 
 <details>