refactor(array): use native reduceWithIndex instead of reimplementing it

Author: glennsl

src/Core__Array.mjs

@@ -46,15 +46,6 @@ function sort(arr, cmp) {
   return result;
 }
 
-function reduceWithIndex(a, x, f) {
-  var f$1 = Curry.__3(f);
-  var r = x;
-  for(var i = 0 ,i_finish = a.length; i < i_finish; ++i){
-    r = f$1(r, a[i], i);
-  }
-  return r;
-}
-
 function findIndexOpt(array, finder) {
   var index = array.findIndex(finder);
   if (index !== -1) {
@@ -137,7 +128,6 @@ export {
   sort ,
   indexOfOpt ,
   lastIndexOfOpt ,
-  reduceWithIndex ,
   findIndexOpt ,
   reverse ,
   filterMap ,

src/Core__Array.res

@@ -128,17 +128,7 @@ let sort = (arr, cmp) => {
 @send external mapWithIndex: (array<'a>, ('a, int) => 'b) => array<'b> = "map"
 
 @send external reduce: (array<'b>, ('a, 'b) => 'a, 'a) => 'a = "reduce"
-
-let reduceWithIndexU = (a, x, f) => {
-  let r = ref(x)
-  for i in 0 to length(a) - 1 {
-    r.contents = f(. r.contents, getUnsafe(a, i), i)
-  }
-  r.contents
-}
-
-let reduceWithIndex = (a, x, f) => reduceWithIndexU(a, x, (. a, b, c) => f(a, b, c))
-
+@send external reduceWithIndex: (array<'b>, ('a, 'b, int) => 'a, 'a) => 'a = "reduce"
 @send
 external reduceRight: (array<'b>, ('a, 'b) => 'a, 'a) => 'a = "reduceRight"
 

src/Core__Array.resi

@@ -73,25 +73,28 @@ let lastIndexOfOpt: (array<'a>, 'a) => option<int>
 external reduce: (array<'b>, ('a, 'b) => 'a, 'a) => 'a = "reduce"
 
 /**
-  `reduceRight(xs, f, init)`
+  `reduceWithIndex(xs, f, init)`
 
-  Works like `Array.reduce`; except that function `f` is applied to each item of `xs` from the last back to the first.
+  Applies `f` to each element of `xs` from beginning to end. Function `f` has three parameters: the item from the array and an “accumulator”, which starts with a value of `init` and the index of each element. `reduceWithIndex` returns the final value of the accumulator.
 
   ```res example
-  Array.reduceRight(["a", "b", "c", "d"], (a, b) => a ++ b, "") == "dcba"
+  Array.reduceWithIndex([1, 2, 3, 4], (acc, x, i) => acc + x + i, 0) == 16
   ```
 */
 @send
-external reduceRight: (array<'b>, ('a, 'b) => 'a, 'a) => 'a = "reduceRight"
+external reduceWithIndex: (array<'b>, ('a, 'b, int) => 'a, 'a) => 'a = "reduce"
 
 /**
-  Applies `f` to each element of `xs` from beginning to end. Function `f` has three parameters: the item from the array and an “accumulator”, which starts with a value of `init` and the index of each element. `reduceWithIndex` returns the final value of the accumulator.
+  `reduceRight(xs, f, init)`
+
+  Works like `Array.reduce`; except that function `f` is applied to each item of `xs` from the last back to the first.
 
   ```res example
-  Array.reduceWithIndex([1, 2, 3, 4], 0, (acc, x, i) => acc + x + i) == 16
+  Array.reduceRight(["a", "b", "c", "d"], (a, b) => a ++ b, "") == "dcba"
   ```
 */
-let reduceWithIndex: (array<'a>, 'b, ('b, 'a, int) => 'b) => 'b
+@send
+external reduceRight: (array<'b>, ('a, 'b) => 'a, 'a) => 'a = "reduceRight"
 
 @send external some: (array<'a>, 'a => bool) => bool = "some"
 @send external someWithIndex: (array<'a>, ('a, int) => bool) => bool = "some"

test/ArrayTests.mjs

@@ -82,6 +82,49 @@ Test.run([
         "ArrayTests.res",
         18,
         13,
+        30
+      ],
+      "reduceWithIndex"
+    ], [
+        1,
+        2,
+        3
+      ].reduce((function (acc, v, i) {
+            return {
+                    hd: v + i | 0,
+                    tl: acc
+                  };
+          }), /* [] */0), eq, {
+      hd: 5,
+      tl: {
+        hd: 3,
+        tl: {
+          hd: 1,
+          tl: /* [] */0
+        }
+      }
+    });
+
+Test.run([
+      [
+        "ArrayTests.res",
+        24,
+        13,
+        38
+      ],
+      "reduceWithIndex - empty"
+    ], [].reduce((function (acc, v, i) {
+            return {
+                    hd: v + i | 0,
+                    tl: acc
+                  };
+          }), /* [] */0), eq, /* [] */0);
+
+Test.run([
+      [
+        "ArrayTests.res",
+        31,
+        13,
         26
       ],
       "reduceRight"
@@ -103,7 +146,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        23,
+        36,
         20,
         41
       ],
@@ -113,7 +156,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        25,
+        38,
         20,
         38
       ],
@@ -133,7 +176,7 @@ var arr = [
 Test.run([
       [
         "ArrayTests.res",
-        28,
+        41,
         13,
         38
       ],
@@ -143,7 +186,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        39,
+        52,
         13,
         24
       ],
@@ -169,7 +212,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        44,
+        57,
         20,
         42
       ],
@@ -188,7 +231,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        46,
+        59,
         13,
         32
       ],
@@ -203,7 +246,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        52,
+        65,
         20,
         30
       ],
@@ -220,7 +263,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        54,
+        67,
         13,
         34
       ],
@@ -238,7 +281,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        59,
+        72,
         20,
         41
       ],
@@ -252,7 +295,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        60,
+        73,
         20,
         38
       ],
@@ -262,7 +305,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        63,
+        76,
         13,
         22
       ],
@@ -284,7 +327,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        68,
+        81,
         20,
         40
       ],
@@ -303,7 +346,7 @@ Test.run([
 Test.run([
       [
         "ArrayTests.res",
-        70,
+        83,
         13,
         30
       ],

test/ArrayTests.res

@@ -14,6 +14,19 @@ Test.run(
 Test.run(__POS_OF__("reduce"), Array.reduce([1, 2, 3], List.add, list{}), eq, list{3, 2, 1})
 Test.run(__POS_OF__("reduce - empty"), Array.reduce([], List.add, list{}), eq, list{})
 
+Test.run(
+  __POS_OF__("reduceWithIndex"),
+  Array.reduceWithIndex([1, 2, 3], (acc, v, i) => list{v + i, ...acc}, list{}),
+  eq,
+  list{5, 3, 1},
+)
+Test.run(
+  __POS_OF__("reduceWithIndex - empty"),
+  Array.reduceWithIndex([], (acc, v, i) => list{v + i, ...acc}, list{}),
+  eq,
+  list{},
+)
+
 Test.run(
   __POS_OF__("reduceRight"),
   Array.reduceRight([1, 2, 3], List.add, list{}),