Align List api with other modules (rescript-lang#195)

* Align List api with other modules

* Changelog

---------

Co-authored-by: Gabriel Nordeborn <[email protected]>

Author: 2 people

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 - BREAKING: Fixes the type of `RegExp.Result.t` to be `array<option<string>>` instead of `array<string>`. https://github.com/rescript-association/rescript-core/pull/233.
 - BREAKING: Adds typed bindings to `Intl`, replacing the options type of `{..}` with records. https://github.com/rescript-association/rescript-core/pull/65
+- Align List api with other modules (`List.getBy` -> `List.find` etc.). https://github.com/rescript-association/rescript-core/pull/195
 - Add `Dict.forEach`, `Dict.forEachWithKey` and `Dict.mapValues` https://github.com/rescript-association/rescript-core/pull/181
 - Remove internal xxxU helper functions that are not needed anymore in uncurried mode. https://github.com/rescript-association/rescript-core/pull/191
 - Rename `Object.empty` to `Object.make` for consistency.

src/Core__List.mjs

@@ -371,7 +371,7 @@ function copyAuxWithMapI(f, _i, _cellX, _prec) {
       return ;
     }
     var next = {
-      hd: f(i, cellX.hd),
+      hd: f(cellX.hd, i),
       tl: /* [] */0
     };
     prec.tl = next;
@@ -545,27 +545,26 @@ function mapWithIndex(xs, f) {
     return /* [] */0;
   }
   var cell = {
-    hd: f$1(0, xs.hd),
+    hd: f$1(xs.hd, 0),
     tl: /* [] */0
   };
   copyAuxWithMapI(f$1, 1, xs.tl, cell);
   return cell;
 }
 
-function makeBy(n, f) {
-  var f$1 = Curry.__1(f);
+function fromInitializerU(n, f) {
   if (n <= 0) {
     return /* [] */0;
   }
   var headX = {
-    hd: f$1(0),
+    hd: f(0),
     tl: /* [] */0
   };
   var cur = headX;
   var i = 1;
   while(i < n) {
     var v = {
-      hd: f$1(i),
+      hd: f(i),
       tl: /* [] */0
     };
     cur.tl = v;
@@ -575,6 +574,10 @@ function makeBy(n, f) {
   return headX;
 }
 
+function fromInitializer(n, f) {
+  return fromInitializerU(n, Curry.__1(f));
+}
+
 function make(n, v) {
   if (n <= 0) {
     return /* [] */0;
@@ -677,7 +680,7 @@ function reverse(l) {
   return reverseConcat(l, /* [] */0);
 }
 
-function flattenAux(_prec, _xs) {
+function flatAux(_prec, _xs) {
   while(true) {
     var xs = _xs;
     var prec = _prec;
@@ -691,7 +694,7 @@ function flattenAux(_prec, _xs) {
   };
 }
 
-function flatten(_xs) {
+function flat(_xs) {
   while(true) {
     var xs = _xs;
     if (!xs) {
@@ -703,7 +706,7 @@ function flatten(_xs) {
         hd: match.hd,
         tl: /* [] */0
       };
-      flattenAux(copyAuxCont(match.tl, cell), xs.tl);
+      flatAux(copyAuxCont(match.tl, cell), xs.tl);
       return cell;
     }
     _xs = xs.tl;
@@ -746,37 +749,44 @@ function mapReverse(l, f) {
   };
 }
 
-function forEach(xs, f) {
-  var _xs = xs;
-  var f$1 = Curry.__1(f);
+function forEachU(_xs, f) {
   while(true) {
-    var xs$1 = _xs;
-    if (!xs$1) {
+    var xs = _xs;
+    if (!xs) {
       return ;
     }
-    f$1(xs$1.hd);
-    _xs = xs$1.tl;
+    f(xs.hd);
+    _xs = xs.tl;
     continue ;
   };
 }
 
-function forEachWithIndex(l, f) {
-  var _xs = l;
-  var _i = 0;
-  var f$1 = Curry.__2(f);
+function forEach(xs, f) {
+  forEachU(xs, Curry.__1(f));
+}
+
+function forEachWithIndexAux(_xs, _i, f) {
   while(true) {
     var i = _i;
     var xs = _xs;
     if (!xs) {
       return ;
     }
-    f$1(i, xs.hd);
+    f(xs.hd, i);
     _i = i + 1 | 0;
     _xs = xs.tl;
     continue ;
   };
 }
 
+function forEachWithIndexU(l, f) {
+  forEachWithIndexAux(l, 0, f);
+}
+
+function forEachWithIndex(l, f) {
+  forEachWithIndexAux(l, 0, Curry.__2(f));
+}
+
 function reduce(l, accu, f) {
   var _l = l;
   var _accu = accu;
@@ -1175,23 +1185,25 @@ function sort(xs, cmp) {
   return fromArray(arr);
 }
 
-function getBy(xs, p) {
-  var _xs = xs;
-  var p$1 = Curry.__1(p);
+function findU(_xs, p) {
   while(true) {
-    var xs$1 = _xs;
-    if (!xs$1) {
+    var xs = _xs;
+    if (!xs) {
       return ;
     }
-    var x = xs$1.hd;
-    if (p$1(x)) {
+    var x = xs.hd;
+    if (p(x)) {
       return Caml_option.some(x);
     }
-    _xs = xs$1.tl;
+    _xs = xs.tl;
     continue ;
   };
 }
 
+function find(xs, p) {
+  return findU(xs, Curry.__1(p));
+}
+
 function filter(xs, p) {
   var _xs = xs;
   var p$1 = Curry.__1(p);
@@ -1350,15 +1362,16 @@ export {
   get ,
   getExn ,
   make ,
-  makeBy ,
+  fromInitializerU ,
+  fromInitializer ,
   toShuffled ,
   drop ,
   take ,
   splitAt ,
   concat ,
   concatMany ,
   reverseConcat ,
-  flatten ,
+  flat ,
   map ,
   zip ,
   zipBy ,
@@ -1367,7 +1380,9 @@ export {
   toArray ,
   reverse ,
   mapReverse ,
+  forEachU ,
   forEach ,
+  forEachWithIndexU ,
   forEachWithIndex ,
   reduce ,
   reduceWithIndex ,
@@ -1384,7 +1399,8 @@ export {
   compare ,
   equal ,
   has ,
-  getBy ,
+  findU ,
+  find ,
   filter ,
   filterWithIndex ,
   filterMap ,

src/Core__List.res

@@ -283,7 +283,7 @@ let rec copyAuxWithMap2 = (f, cellX, cellY, prec) =>
 let rec copyAuxWithMapI = (f, i, cellX, prec) =>
   switch cellX {
   | list{h, ...t} =>
-    let next = mutableCell(f(. i, h), list{})
+    let next = mutableCell(f(. h, i), list{})
     unsafeMutateTail(prec, next)
     copyAuxWithMapI(f, i + 1, t, next)
   | list{} => ()
@@ -405,14 +405,14 @@ let mapWithIndexU = (xs, f) =>
   switch xs {
   | list{} => list{}
   | list{h, ...t} =>
-    let cell = mutableCell(f(. 0, h), list{})
+    let cell = mutableCell(f(. h, 0), list{})
     copyAuxWithMapI(f, 1, t, cell)
     cell
   }
 
 let mapWithIndex = (xs, f) => mapWithIndexU(xs, (. i, x) => f(i, x))
 
-let makeByU = (n, f) =>
+let fromInitializerU = (n, f) =>
   if n <= 0 {
     list{}
   } else {
@@ -429,7 +429,7 @@ let makeByU = (n, f) =>
     headX
   }
 
-let makeBy = (n, f) => makeByU(n, (. x) => f(x))
+let fromInitializer = (n, f) => fromInitializerU(n, (. x) => f(x))
 
 let make = (type a, n, v: a): list<a> =>
   if n <= 0 {
@@ -515,19 +515,19 @@ let rec reverseConcat = (l1, l2) =>
 
 let reverse = l => reverseConcat(l, list{})
 
-let rec flattenAux = (prec, xs) =>
+let rec flatAux = (prec, xs) =>
   switch xs {
   | list{} => unsafeMutateTail(prec, list{})
-  | list{h, ...r} => flattenAux(copyAuxCont(h, prec), r)
+  | list{h, ...r} => flatAux(copyAuxCont(h, prec), r)
   }
 
-let rec flatten = xs =>
+let rec flat = xs =>
   switch xs {
   | list{} => list{}
-  | list{list{}, ...xs} => flatten(xs)
+  | list{list{}, ...xs} => flat(xs)
   | list{list{h, ...t}, ...r} =>
     let cell = mutableCell(h, list{})
-    flattenAux(copyAuxCont(t, cell), r)
+    flatAux(copyAuxCont(t, cell), r)
     cell
   }
 
@@ -564,16 +564,16 @@ let rec forEachU = (xs, f) =>
 
 let forEach = (xs, f) => forEachU(xs, (. x) => f(x))
 
-let rec iteri = (xs, i, f) =>
+let rec forEachWithIndexAux = (xs, i, f) =>
   switch xs {
   | list{} => ()
   | list{a, ...l} =>
-    f(. i, a)->ignore
-    iteri(l, i + 1, f)
+    f(. a, i)
+    forEachWithIndexAux(l, i + 1, f)
   }
 
-let forEachWithIndexU = (l, f) => iteri(l, 0, f)
-let forEachWithIndex = (l, f) => forEachWithIndexU(l, (. i, x) => f(i, x))
+let forEachWithIndexU = (l, f) => forEachWithIndexAux(l, 0, f)
+let forEachWithIndex = (l, f) => forEachWithIndexAux(l, 0, (. x, i) => f(x, i))
 
 let rec reduceU = (l, accu, f) =>
   switch l {
@@ -796,18 +796,18 @@ let sort = (xs, cmp) => {
   fromArray(arr)
 }
 
-let rec getByU = (xs, p) =>
+let rec findU = (xs, p) =>
   switch xs {
   | list{} => None
   | list{x, ...l} =>
     if p(. x) {
       Some(x)
     } else {
-      getByU(l, p)
+      findU(l, p)
     }
   }
 
-let getBy = (xs, p) => getByU(xs, (. a) => p(a))
+let find = (xs, p) => findU(xs, (. a) => p(a))
 
 let rec filterU = (xs, p) =>
   switch xs {