Add Array.equal, Array.compare

Author: cknitt

src/Core__Array.mjs

@@ -24,6 +24,52 @@ function fromInitializer(length, f) {
   return arr;
 }
 
+function equal(a, b, eq) {
+  var eq$1 = Curry.__2(eq);
+  var len = a.length;
+  if (len === b.length) {
+    var _i = 0;
+    while(true) {
+      var i = _i;
+      if (i === len) {
+        return true;
+      }
+      if (!eq$1(a[i], b[i])) {
+        return false;
+      }
+      _i = i + 1 | 0;
+      continue ;
+    };
+  } else {
+    return false;
+  }
+}
+
+function compare(a, b, cmp) {
+  var cmp$1 = Curry.__2(cmp);
+  var lenA = a.length;
+  var lenB = b.length;
+  if (lenA > lenB) {
+    return 1;
+  } else if (lenA < lenB) {
+    return -1;
+  } else {
+    var _i = 0;
+    while(true) {
+      var i = _i;
+      if (i === lenA) {
+        return 0;
+      }
+      var c = cmp$1(a[i], b[i]);
+      if (c !== 0) {
+        return c;
+      }
+      _i = i + 1 | 0;
+      continue ;
+    };
+  }
+}
+
 function indexOfOpt(arr, item) {
   var index = arr.indexOf(item);
   if (index !== -1) {
@@ -126,6 +172,8 @@ function findMap(arr, f) {
 export {
   make ,
   fromInitializer ,
+  equal ,
+  compare ,
   indexOfOpt ,
   lastIndexOfOpt ,
   reduce ,

src/Core__Array.res

@@ -37,6 +37,52 @@ let fromInitializer = (~length, f) =>
 
 @get external length: array<'a> => int = "length"
 
+let rec equalFromIndexU = (a, b, i, eq, len) =>
+  if i === len {
+    true
+  } else if eq(. a->getUnsafe(i), b->getUnsafe(i)) {
+    equalFromIndexU(a, b, i + 1, eq, len)
+  } else {
+    false
+  }
+
+let equalU = (a, b, eq) => {
+  let len = a->length
+  if len === b->length {
+    equalFromIndexU(a, b, 0, eq, len)
+  } else {
+    false
+  }
+}
+
+let equal = (a, b, eq) => equalU(a, b, (. a, b) => eq(a, b))
+
+let rec compareFromIndexU = (a, b, i, cmp, len) =>
+  if i === len {
+    0
+  } else {
+    let c = cmp(. a->getUnsafe(i), b->getUnsafe(i))
+    if c === 0 {
+      compareFromIndexU(a, b, i + 1, cmp, len)
+    } else {
+      c
+    }
+  }
+
+let compareU = (a, b, cmp) => {
+  let lenA = a->length
+  let lenB = b->length
+  if lenA > lenB {
+    1
+  } else if lenA < lenB {
+    -1
+  } else {
+    compareFromIndexU(a, b, 0, cmp, lenA)
+  }
+}
+
+let compare = (a, b, cmp) => compareU(a, b, (. a, b) => cmp(a, b))
+
 @send external copyAllWithin: (array<'a>, ~target: int) => array<'a> = "copyWithin"
 
 @send

src/Core__Array.resi

@@ -27,6 +27,10 @@ let make: (~length: int, 'a) => array<'a>
 */
 let fromInitializer: (~length: int, int => 'a) => array<'a>
 
+let equal: (array<'a>, array<'a>, ('a, 'a) => bool) => bool
+
+let compare: (array<'a>, array<'a>, ('a, 'a) => int) => int
+
 @val external isArray: 'a => bool = "Array.isArray"
 
 /**