diff --git a/CHANGELOG.md b/CHANGELOG.md
index e7c4d996..5d63b1c9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,7 @@
 ## Next version
 
 - 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
 
 ## 1.0.0
 
diff --git a/src/Core__Array.mjs b/src/Core__Array.mjs
index d8ee402f..f33b3840 100644
--- a/src/Core__Array.mjs
+++ b/src/Core__Array.mjs
@@ -127,15 +127,12 @@ function toShuffled(xs) {
 }
 
 function filterMap(a, f) {
-  var f$1 = function (a) {
-    return f(a);
-  };
   var l = a.length;
   var r = new Array(l);
   var j = 0;
   for(var i = 0; i < l; ++i){
     var v = a[i];
-    var v$1 = f$1(v);
+    var v$1 = f(v);
     if (v$1 !== undefined) {
       r[j] = Caml_option.valFromOption(v$1);
       j = j + 1 | 0;
diff --git a/src/Core__Array.res b/src/Core__Array.res
index 9059ed4c..165237b2 100644
--- a/src/Core__Array.res
+++ b/src/Core__Array.res
@@ -210,7 +210,7 @@ let toShuffled = xs => {
   result
 }
 
-let filterMapU = (a, f) => {
+let filterMap = (a, f) => {
   let l = length(a)
   let r = makeUninitializedUnsafe(l)
   let j = ref(0)
@@ -227,8 +227,6 @@ let filterMapU = (a, f) => {
   r
 }
 
-let filterMap = (a, f) => filterMapU(a, a => f(a))
-
 let keepSome = filterMap(_, x => x)
 
 @send external flatMap: (array<'a>, 'a => array<'b>) => array<'b> = "flatMap"
diff --git a/src/Core__List.mjs b/src/Core__List.mjs
index cc778f56..bf07d0cf 100644
--- a/src/Core__List.mjs
+++ b/src/Core__List.mjs
@@ -510,24 +510,18 @@ function concat(xs, ys) {
 }
 
 function map(xs, f) {
-  var f$1 = function (x) {
-    return f(x);
-  };
   if (!xs) {
     return /* [] */0;
   }
   var cell = {
-    hd: f$1(xs.hd),
+    hd: f(xs.hd),
     tl: /* [] */0
   };
-  copyAuxWithMap(xs.tl, cell, f$1);
+  copyAuxWithMap(xs.tl, cell, f);
   return cell;
 }
 
 function zipBy(l1, l2, f) {
-  var f$1 = function (x, y) {
-    return f(x, y);
-  };
   if (!l1) {
     return /* [] */0;
   }
@@ -535,44 +529,38 @@ function zipBy(l1, l2, f) {
     return /* [] */0;
   }
   var cell = {
-    hd: f$1(l1.hd, l2.hd),
+    hd: f(l1.hd, l2.hd),
     tl: /* [] */0
   };
-  copyAuxWithMap2(f$1, l1.tl, l2.tl, cell);
+  copyAuxWithMap2(f, l1.tl, l2.tl, cell);
   return cell;
 }
 
 function mapWithIndex(xs, f) {
-  var f$1 = function (i, x) {
-    return f(i, x);
-  };
   if (!xs) {
     return /* [] */0;
   }
   var cell = {
-    hd: f$1(0, xs.hd),
+    hd: f(0, xs.hd),
     tl: /* [] */0
   };
-  copyAuxWithMapI(f$1, 1, xs.tl, cell);
+  copyAuxWithMapI(f, 1, xs.tl, cell);
   return cell;
 }
 
 function makeBy(n, f) {
-  var f$1 = function (x) {
-    return f(x);
-  };
   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;
@@ -735,9 +723,6 @@ function concatMany(xs) {
 }
 
 function mapReverse(l, f) {
-  var f$1 = function (x) {
-    return f(x);
-  };
   var _accu = /* [] */0;
   var _xs = l;
   while(true) {
@@ -748,33 +733,26 @@ function mapReverse(l, f) {
     }
     _xs = xs.tl;
     _accu = {
-      hd: f$1(xs.hd),
+      hd: f(xs.hd),
       tl: accu
     };
     continue ;
   };
 }
 
-function forEach(xs, f) {
-  var _xs = xs;
-  var f$1 = function (x) {
-    return f(x);
-  };
+function forEach(_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 f$1 = function (i, x) {
-    return f(i, x);
-  };
   var _xs = l;
   var _i = 0;
   while(true) {
@@ -783,55 +761,44 @@ function forEachWithIndex(l, f) {
     if (!xs) {
       return ;
     }
-    f$1(i, xs.hd);
+    f(i, xs.hd);
     _i = i + 1 | 0;
     _xs = xs.tl;
     continue ;
   };
 }
 
-function reduce(l, accu, f) {
-  var _l = l;
-  var _accu = accu;
-  var f$1 = function (acc, x) {
-    return f(acc, x);
-  };
+function reduce(_l, _accu, f) {
   while(true) {
-    var accu$1 = _accu;
-    var l$1 = _l;
-    if (!l$1) {
-      return accu$1;
+    var accu = _accu;
+    var l = _l;
+    if (!l) {
+      return accu;
     }
-    _accu = f$1(accu$1, l$1.hd);
-    _l = l$1.tl;
+    _accu = f(accu, l.hd);
+    _l = l.tl;
     continue ;
   };
 }
 
-function reduceReverseUnsafeU(l, accu, f) {
+function reduceReverseUnsafe(l, accu, f) {
   if (l) {
-    return f(reduceReverseUnsafeU(l.tl, accu, f), l.hd);
+    return f(reduceReverseUnsafe(l.tl, accu, f), l.hd);
   } else {
     return accu;
   }
 }
 
-function reduceReverse(l, accu, f) {
-  var f$1 = function (a, b) {
-    return f(a, b);
-  };
+function reduceReverse(l, acc, f) {
   var len = length(l);
   if (len < 1000) {
-    return reduceReverseUnsafeU(l, accu, f$1);
+    return reduceReverseUnsafe(l, acc, f);
   } else {
-    return Belt_Array.reduceReverseU(toArray(l), accu, f$1);
+    return Belt_Array.reduceReverseU(toArray(l), acc, f);
   }
 }
 
 function reduceWithIndex(l, acc, f) {
-  var f$1 = function (acc, x, i) {
-    return f(acc, x, i);
-  };
   var _l = l;
   var _acc = acc;
   var _i = 0;
@@ -843,16 +810,13 @@ function reduceWithIndex(l, acc, f) {
       return acc$1;
     }
     _i = i + 1 | 0;
-    _acc = f$1(acc$1, l$1.hd, i);
+    _acc = f(acc$1, l$1.hd, i);
     _l = l$1.tl;
     continue ;
   };
 }
 
 function mapReverse2(l1, l2, f) {
-  var f$1 = function (a, b) {
-    return f(a, b);
-  };
   var _l1 = l1;
   var _l2 = l2;
   var _accu = /* [] */0;
@@ -867,7 +831,7 @@ function mapReverse2(l1, l2, f) {
       return accu;
     }
     _accu = {
-      hd: f$1(l1$1.hd, l2$1.hd),
+      hd: f(l1$1.hd, l2$1.hd),
       tl: accu
     };
     _l2 = l2$1.tl;
@@ -876,128 +840,101 @@ function mapReverse2(l1, l2, f) {
   };
 }
 
-function forEach2(l1, l2, f) {
-  var _l1 = l1;
-  var _l2 = l2;
-  var f$1 = function (a, b) {
-    return f(a, b);
-  };
+function forEach2(_l1, _l2, f) {
   while(true) {
-    var l2$1 = _l2;
-    var l1$1 = _l1;
-    if (!l1$1) {
+    var l2 = _l2;
+    var l1 = _l1;
+    if (!l1) {
       return ;
     }
-    if (!l2$1) {
+    if (!l2) {
       return ;
     }
-    f$1(l1$1.hd, l2$1.hd);
-    _l2 = l2$1.tl;
-    _l1 = l1$1.tl;
+    f(l1.hd, l2.hd);
+    _l2 = l2.tl;
+    _l1 = l1.tl;
     continue ;
   };
 }
 
-function reduce2(l1, l2, acc, f) {
-  var _l1 = l1;
-  var _l2 = l2;
-  var _accu = acc;
-  var f$1 = function (a, b, c) {
-    return f(a, b, c);
-  };
+function reduce2(_l1, _l2, _accu, f) {
   while(true) {
     var accu = _accu;
-    var l2$1 = _l2;
-    var l1$1 = _l1;
-    if (!l1$1) {
+    var l2 = _l2;
+    var l1 = _l1;
+    if (!l1) {
       return accu;
     }
-    if (!l2$1) {
+    if (!l2) {
       return accu;
     }
-    _accu = f$1(accu, l1$1.hd, l2$1.hd);
-    _l2 = l2$1.tl;
-    _l1 = l1$1.tl;
+    _accu = f(accu, l1.hd, l2.hd);
+    _l2 = l2.tl;
+    _l1 = l1.tl;
     continue ;
   };
 }
 
-function reduceReverse2UnsafeU(l1, l2, accu, f) {
+function reduceReverse2Unsafe(l1, l2, accu, f) {
   if (l1 && l2) {
-    return f(reduceReverse2UnsafeU(l1.tl, l2.tl, accu, f), l1.hd, l2.hd);
+    return f(reduceReverse2Unsafe(l1.tl, l2.tl, accu, f), l1.hd, l2.hd);
   } else {
     return accu;
   }
 }
 
 function reduceReverse2(l1, l2, acc, f) {
-  var f$1 = function (a, b, c) {
-    return f(a, b, c);
-  };
   var len = length(l1);
   if (len < 1000) {
-    return reduceReverse2UnsafeU(l1, l2, acc, f$1);
+    return reduceReverse2Unsafe(l1, l2, acc, f);
   } else {
-    return Belt_Array.reduceReverse2U(toArray(l1), toArray(l2), acc, f$1);
+    return Belt_Array.reduceReverse2U(toArray(l1), toArray(l2), acc, f);
   }
 }
 
-function every(xs, p) {
-  var _xs = xs;
-  var p$1 = function (x) {
-    return p(x);
-  };
+function every(_xs, p) {
   while(true) {
-    var xs$1 = _xs;
-    if (!xs$1) {
+    var xs = _xs;
+    if (!xs) {
       return true;
     }
-    if (!p$1(xs$1.hd)) {
+    if (!p(xs.hd)) {
       return false;
     }
-    _xs = xs$1.tl;
+    _xs = xs.tl;
     continue ;
   };
 }
 
-function some(xs, p) {
-  var _xs = xs;
-  var p$1 = function (x) {
-    return p(x);
-  };
+function some(_xs, p) {
   while(true) {
-    var xs$1 = _xs;
-    if (!xs$1) {
+    var xs = _xs;
+    if (!xs) {
       return false;
     }
-    if (p$1(xs$1.hd)) {
+    if (p(xs.hd)) {
       return true;
     }
-    _xs = xs$1.tl;
+    _xs = xs.tl;
     continue ;
   };
 }
 
-function every2(l1, l2, p) {
-  var _l1 = l1;
-  var _l2 = l2;
-  var p$1 = function (a, b) {
-    return p(a, b);
-  };
+function every2(_l1, _l2, p) {
   while(true) {
-    var l2$1 = _l2;
-    var l1$1 = _l1;
-    if (!l1$1) {
+    var l2 = _l2;
+    var l1 = _l1;
+    if (!l1) {
       return true;
     }
-    if (!l2$1) {
+    if (!l2) {
       return true;
     }
-    if (!p$1(l1$1.hd, l2$1.hd)) {
+    if (!p(l1.hd, l2.hd)) {
       return false;
     }
-    _l2 = l2$1.tl;
-    _l1 = l1$1.tl;
+    _l2 = l2.tl;
+    _l1 = l1.tl;
     continue ;
   };
 }
@@ -1069,102 +1006,82 @@ function equal(_l1, _l2, p) {
   };
 }
 
-function some2(l1, l2, p) {
-  var _l1 = l1;
-  var _l2 = l2;
-  var p$1 = function (a, b) {
-    return p(a, b);
-  };
+function some2(_l1, _l2, p) {
   while(true) {
-    var l2$1 = _l2;
-    var l1$1 = _l1;
-    if (!l1$1) {
+    var l2 = _l2;
+    var l1 = _l1;
+    if (!l1) {
       return false;
     }
-    if (!l2$1) {
+    if (!l2) {
       return false;
     }
-    if (p$1(l1$1.hd, l2$1.hd)) {
+    if (p(l1.hd, l2.hd)) {
       return true;
     }
-    _l2 = l2$1.tl;
-    _l1 = l1$1.tl;
+    _l2 = l2.tl;
+    _l1 = l1.tl;
     continue ;
   };
 }
 
-function has(xs, x, eq) {
-  var _xs = xs;
-  var eq$1 = function (a, b) {
-    return eq(a, b);
-  };
+function has(_xs, x, eq) {
   while(true) {
-    var xs$1 = _xs;
-    if (!xs$1) {
+    var xs = _xs;
+    if (!xs) {
       return false;
     }
-    if (eq$1(xs$1.hd, x)) {
+    if (eq(xs.hd, x)) {
       return true;
     }
-    _xs = xs$1.tl;
+    _xs = xs.tl;
     continue ;
   };
 }
 
-function getAssoc(xs, x, eq) {
-  var _xs = xs;
-  var eq$1 = function (a, b) {
-    return eq(a, b);
-  };
+function getAssoc(_xs, x, eq) {
   while(true) {
-    var xs$1 = _xs;
-    if (!xs$1) {
+    var xs = _xs;
+    if (!xs) {
       return ;
     }
-    var match = xs$1.hd;
-    if (eq$1(match[0], x)) {
+    var match = xs.hd;
+    if (eq(match[0], x)) {
       return Caml_option.some(match[1]);
     }
-    _xs = xs$1.tl;
+    _xs = xs.tl;
     continue ;
   };
 }
 
-function hasAssoc(xs, x, eq) {
-  var _xs = xs;
-  var eq$1 = function (a, b) {
-    return eq(a, b);
-  };
+function hasAssoc(_xs, x, eq) {
   while(true) {
-    var xs$1 = _xs;
-    if (!xs$1) {
+    var xs = _xs;
+    if (!xs) {
       return false;
     }
-    if (eq$1(xs$1.hd[0], x)) {
+    if (eq(xs.hd[0], x)) {
       return true;
     }
-    _xs = xs$1.tl;
+    _xs = xs.tl;
     continue ;
   };
 }
 
 function removeAssoc(xs, x, eq) {
-  var eq$1 = function (a, b) {
-    return eq(a, b);
-  };
   if (!xs) {
     return /* [] */0;
   }
   var l = xs.tl;
   var pair = xs.hd;
-  if (eq$1(pair[0], x)) {
+  if (eq(pair[0], x)) {
     return l;
   }
   var cell = {
     hd: pair,
     tl: /* [] */0
   };
-  var removed = removeAssocAuxWithMap(l, x, cell, eq$1);
+  var removed = removeAssocAuxWithMap(l, x, cell, eq);
   if (removed) {
     return cell;
   } else {
@@ -1173,9 +1090,6 @@ function removeAssoc(xs, x, eq) {
 }
 
 function setAssoc(xs, x, k, eq) {
-  var eq$1 = function (a, b) {
-    return eq(a, b);
-  };
   if (!xs) {
     return {
             hd: [
@@ -1187,7 +1101,7 @@ function setAssoc(xs, x, k, eq) {
   }
   var l = xs.tl;
   var pair = xs.hd;
-  if (eq$1(pair[0], x)) {
+  if (eq(pair[0], x)) {
     return {
             hd: [
               x,
@@ -1200,7 +1114,7 @@ function setAssoc(xs, x, k, eq) {
     hd: pair,
     tl: /* [] */0
   };
-  var replaced = setAssocAuxWithMap(l, x, k, cell, eq$1);
+  var replaced = setAssocAuxWithMap(l, x, k, cell, eq);
   if (replaced) {
     return cell;
   } else {
@@ -1220,43 +1134,35 @@ function sort(xs, cmp) {
   return fromArray(arr);
 }
 
-function getBy(xs, p) {
-  var _xs = xs;
-  var p$1 = function (a) {
-    return p(a);
-  };
+function getBy(_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 filter(xs, p) {
-  var _xs = xs;
-  var p$1 = function (x) {
-    return p(x);
-  };
+function filter(_xs, p) {
   while(true) {
-    var xs$1 = _xs;
-    if (!xs$1) {
+    var xs = _xs;
+    if (!xs) {
       return /* [] */0;
     }
-    var t = xs$1.tl;
-    var h = xs$1.hd;
-    if (p$1(h)) {
+    var t = xs.tl;
+    var h = xs.hd;
+    if (p(h)) {
       var cell = {
         hd: h,
         tl: /* [] */0
       };
-      copyAuxWitFilter(p$1, t, cell);
+      copyAuxWitFilter(p, t, cell);
       return cell;
     }
     _xs = t;
@@ -1265,9 +1171,6 @@ function filter(xs, p) {
 }
 
 function filterWithIndex(xs, p) {
-  var p$1 = function (x, i) {
-    return p(x, i);
-  };
   var _xs = xs;
   var _i = 0;
   while(true) {
@@ -1278,12 +1181,12 @@ function filterWithIndex(xs, p) {
     }
     var t = xs$1.tl;
     var h = xs$1.hd;
-    if (p$1(h, i)) {
+    if (p(h, i)) {
       var cell = {
         hd: h,
         tl: /* [] */0
       };
-      copyAuxWithFilterIndex(p$1, t, cell, i + 1 | 0);
+      copyAuxWithFilterIndex(p, t, cell, i + 1 | 0);
       return cell;
     }
     _i = i + 1 | 0;
@@ -1292,24 +1195,20 @@ function filterWithIndex(xs, p) {
   };
 }
 
-function filterMap(xs, p) {
-  var _xs = xs;
-  var p$1 = function (x) {
-    return p(x);
-  };
+function filterMap(_xs, p) {
   while(true) {
-    var xs$1 = _xs;
-    if (!xs$1) {
+    var xs = _xs;
+    if (!xs) {
       return /* [] */0;
     }
-    var t = xs$1.tl;
-    var h = p$1(xs$1.hd);
+    var t = xs.tl;
+    var h = p(xs.hd);
     if (h !== undefined) {
       var cell = {
         hd: Caml_option.valFromOption(h),
         tl: /* [] */0
       };
-      copyAuxWitFilterMap(p$1, t, cell);
+      copyAuxWitFilterMap(p, t, cell);
       return cell;
     }
     _xs = t;
@@ -1318,9 +1217,6 @@ function filterMap(xs, p) {
 }
 
 function partition(l, p) {
-  var p$1 = function (x) {
-    return p(x);
-  };
   if (!l) {
     return [
             /* [] */0,
@@ -1336,8 +1232,8 @@ function partition(l, p) {
     hd: h,
     tl: /* [] */0
   };
-  var b = p$1(h);
-  partitionAux(p$1, l.tl, nextX, nextY);
+  var b = p(h);
+  partitionAux(p, l.tl, nextX, nextY);
   if (b) {
     return [
             nextX,
diff --git a/src/Core__List.res b/src/Core__List.res
index e4d4edef..e14bc492 100644
--- a/src/Core__List.res
+++ b/src/Core__List.res
@@ -379,7 +379,7 @@ let concat = (xs, ys) =>
     cell
   }
 
-let mapU = (xs, f) =>
+let map = (xs, f) =>
   switch xs {
   | list{} => list{}
   | list{h, ...t} =>
@@ -388,9 +388,7 @@ let mapU = (xs, f) =>
     cell
   }
 
-let map = (xs, f) => mapU(xs, x => f(x))
-
-let zipByU = (l1, l2, f) =>
+let zipBy = (l1, l2, f) =>
   switch (l1, l2) {
   | (list{a1, ...l1}, list{a2, ...l2}) =>
     let cell = mutableCell(f(a1, a2), list{})
@@ -399,9 +397,7 @@ let zipByU = (l1, l2, f) =>
   | (list{}, _) | (_, list{}) => list{}
   }
 
-let zipBy = (l1, l2, f) => zipByU(l1, l2, (x, y) => f(x, y))
-
-let mapWithIndexU = (xs, f) =>
+let mapWithIndex = (xs, f) =>
   switch xs {
   | list{} => list{}
   | list{h, ...t} =>
@@ -410,9 +406,7 @@ let mapWithIndexU = (xs, f) =>
     cell
   }
 
-let mapWithIndex = (xs, f) => mapWithIndexU(xs, (i, x) => f(i, x))
-
-let makeByU = (n, f) =>
+let makeBy = (n, f) =>
   if n <= 0 {
     list{}
   } else {
@@ -429,8 +423,6 @@ let makeByU = (n, f) =>
     headX
   }
 
-let makeBy = (n, f) => makeByU(n, x => f(x))
-
 let make = (type a, n, v: a): list<a> =>
   if n <= 0 {
     list{}
@@ -550,20 +542,16 @@ let rec mapRevAux = (f, accu, xs) =>
   | list{a, ...l} => mapRevAux(f, list{f(a), ...accu}, l)
   }
 
-let mapReverseU = (l, f) => mapRevAux(f, list{}, l)
+let mapReverse = (l, f) => mapRevAux(f, list{}, l)
 
-let mapReverse = (l, f) => mapReverseU(l, x => f(x))
-
-let rec forEachU = (xs, f) =>
+let rec forEach = (xs, f) =>
   switch xs {
   | list{} => ()
   | list{a, ...l} =>
     f(a)->ignore
-    forEachU(l, f)
+    forEach(l, f)
   }
 
-let forEach = (xs, f) => forEachU(xs, x => f(x))
-
 let rec iteri = (xs, i, f) =>
   switch xs {
   | list{} => ()
@@ -572,43 +560,36 @@ let rec iteri = (xs, i, f) =>
     iteri(l, i + 1, f)
   }
 
-let forEachWithIndexU = (l, f) => iteri(l, 0, f)
-let forEachWithIndex = (l, f) => forEachWithIndexU(l, (i, x) => f(i, x))
+let forEachWithIndex = (l, f) => iteri(l, 0, f)
 
-let rec reduceU = (l, accu, f) =>
+let rec reduce = (l, accu, f) =>
   switch l {
   | list{} => accu
-  | list{a, ...l} => reduceU(l, f(accu, a), f)
+  | list{a, ...l} => reduce(l, f(accu, a), f)
   }
 
-let reduce = (l, accu, f) => reduceU(l, accu, (acc, x) => f(acc, x))
-
-let rec reduceReverseUnsafeU = (l, accu, f) =>
+let rec reduceReverseUnsafe = (l, accu, f) =>
   switch l {
   | list{} => accu
-  | list{a, ...l} => f(reduceReverseUnsafeU(l, accu, f), a)
+  | list{a, ...l} => f(reduceReverseUnsafe(l, accu, f), a)
   }
 
-let reduceReverseU = (type a b, l: list<a>, acc: b, f) => {
+let reduceReverse = (type a b, l: list<a>, acc: b, f) => {
   let len = length(l)
   if len < 1000 {
-    reduceReverseUnsafeU(l, acc, f)
+    reduceReverseUnsafe(l, acc, f)
   } else {
     A.reduceReverseU(toArray(l), acc, f)
   }
 }
 
-let reduceReverse = (l, accu, f) => reduceReverseU(l, accu, (a, b) => f(a, b))
-
-let rec reduceWithIndexAuxU = (l, acc, f, i) =>
+let rec reduceWithIndexAux = (l, acc, f, i) =>
   switch l {
   | list{} => acc
-  | list{x, ...xs} => reduceWithIndexAuxU(xs, f(acc, x, i), f, i + 1)
+  | list{x, ...xs} => reduceWithIndexAux(xs, f(acc, x, i), f, i + 1)
   }
 
-let reduceWithIndexU = (l, acc, f) => reduceWithIndexAuxU(l, acc, f, 0)
-
-let reduceWithIndex = (l, acc, f) => reduceWithIndexU(l, acc, (acc, x, i) => f(acc, x, i))
+let reduceWithIndex = (l, acc, f) => reduceWithIndexAux(l, acc, f, 0)
 
 let rec mapRevAux2 = (l1, l2, accu, f) =>
   switch (l1, l2) {
@@ -616,70 +597,56 @@ let rec mapRevAux2 = (l1, l2, accu, f) =>
   | (_, list{}) | (list{}, _) => accu
   }
 
-let mapReverse2U = (l1, l2, f) => mapRevAux2(l1, l2, list{}, f)
+let mapReverse2 = (l1, l2, f) => mapRevAux2(l1, l2, list{}, f)
 
-let mapReverse2 = (l1, l2, f) => mapReverse2U(l1, l2, (a, b) => f(a, b))
-
-let rec forEach2U = (l1, l2, f) =>
+let rec forEach2 = (l1, l2, f) =>
   switch (l1, l2) {
   | (list{a1, ...l1}, list{a2, ...l2}) =>
     f(a1, a2)->ignore
-    forEach2U(l1, l2, f)
+    forEach2(l1, l2, f)
   | (list{}, _) | (_, list{}) => ()
   }
 
-let forEach2 = (l1, l2, f) => forEach2U(l1, l2, (a, b) => f(a, b))
-
-let rec reduce2U = (l1, l2, accu, f) =>
+let rec reduce2 = (l1, l2, accu, f) =>
   switch (l1, l2) {
-  | (list{a1, ...l1}, list{a2, ...l2}) => reduce2U(l1, l2, f(accu, a1, a2), f)
+  | (list{a1, ...l1}, list{a2, ...l2}) => reduce2(l1, l2, f(accu, a1, a2), f)
   | (list{}, _) | (_, list{}) => accu
   }
 
-let reduce2 = (l1, l2, acc, f) => reduce2U(l1, l2, acc, (a, b, c) => f(a, b, c))
-
-let rec reduceReverse2UnsafeU = (l1, l2, accu, f) =>
+let rec reduceReverse2Unsafe = (l1, l2, accu, f) =>
   switch (l1, l2) {
   | (list{}, list{}) => accu
-  | (list{a1, ...l1}, list{a2, ...l2}) => f(reduceReverse2UnsafeU(l1, l2, accu, f), a1, a2)
+  | (list{a1, ...l1}, list{a2, ...l2}) => f(reduceReverse2Unsafe(l1, l2, accu, f), a1, a2)
   | (_, list{}) | (list{}, _) => accu
   }
 
-let reduceReverse2U = (type a b c, l1: list<a>, l2: list<b>, acc: c, f) => {
+let reduceReverse2 = (type a b c, l1: list<a>, l2: list<b>, acc: c, f) => {
   let len = length(l1)
   if len < 1000 {
-    reduceReverse2UnsafeU(l1, l2, acc, f)
+    reduceReverse2Unsafe(l1, l2, acc, f)
   } else {
     A.reduceReverse2U(toArray(l1), toArray(l2), acc, f)
   }
 }
 
-let reduceReverse2 = (l1, l2, acc, f) => reduceReverse2U(l1, l2, acc, (a, b, c) => f(a, b, c))
-
-let rec everyU = (xs, p) =>
+let rec every = (xs, p) =>
   switch xs {
   | list{} => true
-  | list{a, ...l} => p(a) && everyU(l, p)
+  | list{a, ...l} => p(a) && every(l, p)
   }
 
-let every = (xs, p) => everyU(xs, x => p(x))
-
-let rec someU = (xs, p) =>
+let rec some = (xs, p) =>
   switch xs {
   | list{} => false
-  | list{a, ...l} => p(a) || someU(l, p)
+  | list{a, ...l} => p(a) || some(l, p)
   }
 
-let some = (xs, p) => someU(xs, x => p(x))
-
-let rec every2U = (l1, l2, p) =>
+let rec every2 = (l1, l2, p) =>
   switch (l1, l2) {
   | (_, list{}) | (list{}, _) => true
-  | (list{a1, ...l1}, list{a2, ...l2}) => p(a1, a2) && every2U(l1, l2, p)
+  | (list{a1, ...l1}, list{a2, ...l2}) => p(a1, a2) && every2(l1, l2, p)
   }
 
-let every2 = (l1, l2, p) => every2U(l1, l2, (a, b) => p(a, b))
-
 let rec compareLength = (l1, l2) =>
   switch (l1, l2) {
   | (list{}, list{}) => Core__Ordering.equal
@@ -715,44 +682,36 @@ let rec equal = (l1, l2, p) =>
     }
   }
 
-let rec some2U = (l1, l2, p) =>
+let rec some2 = (l1, l2, p) =>
   switch (l1, l2) {
   | (list{}, _) | (_, list{}) => false
-  | (list{a1, ...l1}, list{a2, ...l2}) => p(a1, a2) || some2U(l1, l2, p)
+  | (list{a1, ...l1}, list{a2, ...l2}) => p(a1, a2) || some2(l1, l2, p)
   }
 
-let some2 = (l1, l2, p) => some2U(l1, l2, (a, b) => p(a, b))
-
-let rec hasU = (xs, x, eq) =>
+let rec has = (xs, x, eq) =>
   switch xs {
   | list{} => false
-  | list{a, ...l} => eq(a, x) || hasU(l, x, eq)
+  | list{a, ...l} => eq(a, x) || has(l, x, eq)
   }
 
-let has = (xs, x, eq) => hasU(xs, x, (a, b) => eq(a, b))
-
-let rec getAssocU = (xs, x, eq) =>
+let rec getAssoc = (xs, x, eq) =>
   switch xs {
   | list{} => None
   | list{(a, b), ...l} =>
     if eq(a, x) {
       Some(b)
     } else {
-      getAssocU(l, x, eq)
+      getAssoc(l, x, eq)
     }
   }
 
-let getAssoc = (xs, x, eq) => getAssocU(xs, x, (a, b) => eq(a, b))
-
-let rec hasAssocU = (xs, x, eq) =>
+let rec hasAssoc = (xs, x, eq) =>
   switch xs {
   | list{} => false
-  | list{(a, _), ...l} => eq(a, x) || hasAssocU(l, x, eq)
+  | list{(a, _), ...l} => eq(a, x) || hasAssoc(l, x, eq)
   }
 
-let hasAssoc = (xs, x, eq) => hasAssocU(xs, x, (a, b) => eq(a, b))
-
-let removeAssocU = (xs, x, eq) =>
+let removeAssoc = (xs, x, eq) =>
   switch xs {
   | list{} => list{}
   | list{(a, _) as pair, ...l} =>
@@ -769,9 +728,7 @@ let removeAssocU = (xs, x, eq) =>
     }
   }
 
-let removeAssoc = (xs, x, eq) => removeAssocU(xs, x, (a, b) => eq(a, b))
-
-let setAssocU = (xs, x, k, eq) =>
+let setAssoc = (xs, x, k, eq) =>
   switch xs {
   | list{} => list{(x, k)}
   | list{(a, _) as pair, ...l} =>
@@ -788,28 +745,24 @@ let setAssocU = (xs, x, k, eq) =>
     }
   }
 
-let setAssoc = (xs, x, k, eq) => setAssocU(xs, x, k, (a, b) => eq(a, b))
-
 let sort = (xs, cmp) => {
   let arr = toArray(xs)
   Core__Array.sort(arr, cmp)
   fromArray(arr)
 }
 
-let rec getByU = (xs, p) =>
+let rec getBy = (xs, p) =>
   switch xs {
   | list{} => None
   | list{x, ...l} =>
     if p(x) {
       Some(x)
     } else {
-      getByU(l, p)
+      getBy(l, p)
     }
   }
 
-let getBy = (xs, p) => getByU(xs, a => p(a))
-
-let rec filterU = (xs, p) =>
+let rec filter = (xs, p) =>
   switch xs {
   | list{} => list{}
   | list{h, ...t} =>
@@ -818,13 +771,11 @@ let rec filterU = (xs, p) =>
       copyAuxWitFilter(p, t, cell)
       cell
     } else {
-      filterU(t, p)
+      filter(t, p)
     }
   }
 
-let filter = (xs, p) => filterU(xs, x => p(x))
-
-let filterWithIndexU = (xs, p) => {
+let filterWithIndex = (xs, p) => {
   let rec auxFilterWithIndex = (xs, p, i) =>
     switch xs {
     | list{} => list{}
@@ -840,9 +791,7 @@ let filterWithIndexU = (xs, p) => {
   auxFilterWithIndex(xs, p, 0)
 }
 
-let filterWithIndex = (xs, p) => filterWithIndexU(xs, (x, i) => p(x, i))
-
-let rec filterMapU = (xs, p) =>
+let rec filterMap = (xs, p) =>
   switch xs {
   | list{} => list{}
   | list{h, ...t} =>
@@ -851,13 +800,11 @@ let rec filterMapU = (xs, p) =>
       let cell = mutableCell(h, list{})
       copyAuxWitFilterMap(p, t, cell)
       cell
-    | None => filterMapU(t, p)
+    | None => filterMap(t, p)
     }
   }
 
-let filterMap = (xs, p) => filterMapU(xs, x => p(x))
-
-let partitionU = (l, p) =>
+let partition = (l, p) =>
   switch l {
   | list{} => (list{}, list{})
   | list{h, ...t} =>
@@ -884,8 +831,6 @@ let partitionU = (l, p) =>
     }
   }
 
-let partition = (l, p) => partitionU(l, x => p(x))
-
 let unzip = xs =>
   switch xs {
   | list{} => (list{}, list{})