Belt: clean up uncurried handling; deprecate xxxU functions

Author: cknitt

belt-cppo/belt_Set.cppo.res

@@ -20,17 +20,11 @@ let maximum = N.maximum
 let maxUndefined = N.maxUndefined
 
 let forEach = N.forEach
-let forEachU = N.forEachU
 let reduce = N.reduce
-let reduceU = N.reduceU
 let every = N.every
-let everyU = N.everyU
 let some = N.some
-let someU = N.someU
 let keep = N.keepShared
-let keepU = N.keepSharedU
 let partition = N.partitionShared
-let partitionU = N.partitionSharedU
 
 let size = N.size
 let toList = N.toList
@@ -231,3 +225,10 @@ let rec diff = (s1: t, s2: t) =>
       N.joinShared(ll, v1, rr)
     }
   }
+
+let forEachU = forEach
+let reduceU = reduce
+let everyU = every
+let someU = some
+let keepU = keep
+let partitionU = partition

belt-cppo/hashmap.cppo.res

@@ -191,12 +191,9 @@ let has = (h, key) => {
 let make = (~hintSize) => C.make(~hintSize, ~hash=(), ~eq=())
 let clear = C.clear
 let size = h => h.C.size
-let forEachU = N.forEachU
 let forEach = N.forEach
-let reduceU = N.reduceU
 let reduce = N.reduce
 let logStats = N.logStats
-let keepMapInPlaceU = N.keepMapInPlaceU
 let keepMapInPlace = N.keepMapInPlace
 let toArray = N.toArray
 let copy = N.copy
@@ -223,3 +220,7 @@ let mergeMany = (h, arr) => {
     set(h, k, v)
   }
 }
+
+let forEachU = forEach
+let reduceU = reduce
+let keepMapInPlaceU = keepMapInPlace

belt-cppo/hashset.cppo.res

@@ -136,9 +136,7 @@ let make = (~hintSize) => C.make(~hintSize, ~hash=(), ~eq=())
 
 let clear = C.clear
 let size = h => h.C.size
-let forEachU = N.forEachU
 let forEach = N.forEach
-let reduceU = N.reduceU
 let reduce = N.reduce
 let logStats = N.logStats
 let toArray = N.toArray
@@ -162,3 +160,6 @@ let mergeMany = (h, arr) => {
     add(h, A.getUnsafe(arr, i))
   }
 }
+
+let forEachU = forEach
+let reduceU = reduce

belt-cppo/internal_map.cppo.res

@@ -174,7 +174,7 @@ let split = (x: key, n) =>
   | Some(n) => splitAux(x, n)
   }
 
-let rec mergeU = (s1, s2, f) =>
+let rec merge = (s1, s2, f) =>
   switch (s1, s2) {
   | (None, None) => None
   | (Some(n) /* (Node (l1, v1, d1, r1, h1), _) */, _)
@@ -185,15 +185,14 @@ let rec mergeU = (s1, s2, f) =>
     } =>
     let {N.left: l1, key: v1, value: d1, right: r1} = n
     let (l2, d2, r2) = split(v1, s2)
-    N.concatOrJoin(mergeU(l1, l2, f), v1, f(v1, Some(d1), d2), mergeU(r1, r2, f))
+    N.concatOrJoin(merge(l1, l2, f), v1, f(v1, Some(d1), d2), merge(r1, r2, f))
   | (_, Some(n)) /* Node (l2, v2, d2, r2, h2) */ =>
     let {N.left: l2, key: v2, value: d2, right: r2} = n
     let (l1, d1, r1) = split(v2, s1)
-    N.concatOrJoin(mergeU(l1, l2, f), v2, f(v2, d1, Some(d2)), mergeU(r1, r2, f))
+    N.concatOrJoin(merge(l1, l2, f), v2, f(v2, d1, Some(d2)), merge(r1, r2, f))
   | _ => assert(false)
   }
 
-let merge = (s1, s2, f) => mergeU(s1, s2, (a, b, c) => f(a, b, c))
 
 let rec compareAux = (e1, e2, vcmp) =>
   switch (e1, e2) {
@@ -212,7 +211,7 @@ let rec compareAux = (e1, e2, vcmp) =>
   | (_, _) => 0
   }
 
-let cmpU = (s1, s2, cmp) => {
+let cmp = (s1, s2, cmp) => {
   let (len1, len2) = (N.size(s1), N.size(s2))
   if len1 == len2 {
     compareAux(N.stackAllLeft(s1, list{}), N.stackAllLeft(s2, list{}), cmp)
@@ -223,8 +222,6 @@ let cmpU = (s1, s2, cmp) => {
   }
 }
 
-let cmp = (s1, s2, f) => cmpU(s1, s2, (a, b) => f(a, b))
-
 let rec eqAux = (e1, e2, eq) =>
   switch (e1, e2) {
   | (list{h1, ...t1}, list{h2, ...t2}) =>
@@ -236,7 +233,7 @@ let rec eqAux = (e1, e2, eq) =>
   | (_, _) => true
   } /* end */
 
-let eqU = (s1, s2, eq) => {
+let eq = (s1, s2, eq) => {
   let (len1, len2) = (N.size(s1), N.size(s2))
   if len1 == len2 {
     eqAux(N.stackAllLeft(s1, list{}), N.stackAllLeft(s2, list{}), eq)
@@ -245,8 +242,6 @@ let eqU = (s1, s2, eq) => {
   }
 }
 
-let eq = (s1, s2, f) => eqU(s1, s2, (a, b) => f(a, b))
-
 let rec addMutate = (t: t<_>, x, data): t<_> =>
   switch t {
   | None => N.singleton(x, data)
@@ -275,7 +270,7 @@ let fromArray = (xs: array<(key, _)>) => {
   if len == 0 {
     None
   } else {
-    let next = ref(S.strictlySortedLengthU(xs, ((x0, _), (y0, _)) => x0 < y0))
+    let next = ref(S.strictlySortedLength(xs, ((x0, _), (y0, _)) => x0 < y0))
 
     let result = ref(
       if next.contents >= 0 {
@@ -292,3 +287,7 @@ let fromArray = (xs: array<(key, _)>) => {
     result.contents
   }
 }
+
+let cmpU = cmp
+let eqU = eq
+let mergeU = merge

belt-cppo/map.cppo.res

@@ -25,21 +25,14 @@ let minimum = N.minimum
 let minUndefined = N.minUndefined
 let maximum = N.maximum
 let maxUndefined = N.maxUndefined
-let forEachU = N.forEachU
+let findFirstBy = N.findFirstBy
 let forEach = N.forEach
-let mapU = N.mapU
 let map = N.map
-let mapWithKeyU = N.mapWithKeyU
 let mapWithKey = N.mapWithKey
-let reduceU = N.reduceU
 let reduce = N.reduce
-let everyU = N.everyU
 let every = N.every
-let someU = N.someU
 let some = N.some
-let keepU = N.keepSharedU
 let keep = N.keepShared
-let partitionU = N.partitionSharedU
 let partition = N.partitionShared
 let size = N.size
 let toList = N.toList
@@ -65,7 +58,7 @@ let rec set = (t, newK: key, newD: _) =>
     }
   }
 
-let rec updateU = (t, x: key, f) =>
+let rec update = (t, x: key, f) =>
   switch t {
   | None =>
     switch f(None) {
@@ -91,14 +84,14 @@ let rec updateU = (t, x: key, f) =>
     } else {
       let {N.left: l, right: r, value: v} = n
       if x < k {
-        let ll = updateU(l, x, f)
+        let ll = update(l, x, f)
         if l === ll {
           t
         } else {
           N.bal(ll, k, v, r)
         }
       } else {
-        let rr = updateU(r, x, f)
+        let rr = update(r, x, f)
         if r === rr {
           t
         } else {
@@ -108,8 +101,6 @@ let rec updateU = (t, x: key, f) =>
     }
   }
 
-let update = (t, x, f) => updateU(t, x, a => f(a))
-
 let rec removeAux = (n, x: key) => {
   let {N.left: l, key: v, right: r} = n
   if x == v {
@@ -169,9 +160,6 @@ let removeMany = (t, keys) => {
   }
 }
 
-let findFirstByU = N.findFirstByU
-let findFirstBy = N.findFirstBy
-
 let mergeMany = (h, arr) => {
   let len = A.length(arr)
   let v = ref(h)
@@ -185,15 +173,26 @@ let mergeMany = (h, arr) => {
 /* let mergeArray = mergeMany */
 
 let has = I.has
-let cmpU = I.cmpU
 let cmp = I.cmp
-let eqU = I.eqU
 let eq = I.eq
 let get = I.get
 let getUndefined = I.getUndefined
 let getWithDefault = I.getWithDefault
 let getExn = I.getExn
 let split = I.split
-let mergeU = I.mergeU
 let merge = I.merge
 let fromArray = I.fromArray
+
+let cmpU = cmp
+let eqU = eq
+let everyU = every
+let findFirstByU = findFirstBy
+let forEachU = forEach
+let keepU = keep
+let mapU = map
+let mapWithKeyU = mapWithKey
+let mergeU = merge
+let partitionU = partition
+let reduceU = reduce
+let someU = some
+let updateU = update

belt-cppo/mapm.cppo.res

@@ -35,18 +35,12 @@ let set = (m: t<_>, k, v) => {
   }
 }
 
-let forEachU = (d, f) => N.forEachU(d.data, f)
-let forEach = (d, f) => forEachU(d, (a, b) => f(a, b))
-let mapU = (d, f) => {data: N.mapU(d.data, f)}
-let map = (d, f) => mapU(d, a => f(a))
-let mapWithKeyU = (d, f) => {data: N.mapWithKeyU(d.data, f)}
-let mapWithKey = (d, f) => mapWithKeyU(d, (a, b) => f(a, b))
-let reduceU = (d, acc, f) => N.reduceU(d.data, acc, f)
-let reduce = (d, acc, f) => reduceU(d, acc, (a, b, c) => f(a, b, c))
-let everyU = (d, f) => N.everyU(d.data, f)
-let every = (d, f) => everyU(d, (a, b) => f(a, b))
-let someU = (d, f) => N.someU(d.data, f)
-let some = (d, f) => someU(d, (a, b) => f(a, b))
+let forEach = (d, f) => N.forEach(d.data, f)
+let map = (d, f) => {data: N.map(d.data, f)}
+let mapWithKey = (d, f) => {data: N.mapWithKey(d.data, f)}
+let reduce = (d, acc, f) => N.reduce(d.data, acc, f)
+let every= (d, f) => N.every(d.data, f)
+let some = (d, f) => N.some(d.data, f)
 let size = d => N.size(d.data)
 let toList = d => N.toList(d.data)
 let toArray = d => N.toArray(d.data)
@@ -133,14 +127,14 @@ let rec updateDone = (t, x: key, f) =>
     }
   }
 
-let updateU = (t, x, f) => {
+let update = (t, x, f) => {
   let oldRoot = t.data
   let newRoot = updateDone(oldRoot, x, f)
   if newRoot !== oldRoot {
     t.data = newRoot
   }
 }
-let update = (t, x, f) => updateU(t, x, a => f(a))
+
 let rec removeArrayMutateAux = (t, xs, i, len) =>
   if i < len {
     let ele = A.getUnsafe(xs, i)
@@ -171,13 +165,21 @@ let removeMany = (d: t<_>, xs) => {
 
 let fromArray = xs => {data: I.fromArray(xs)}
 
-let cmpU = (d0, d1, f) => I.cmpU(d0.data, d1.data, f)
-let cmp = (d0, d1, f) => cmpU(d0, d1, (a, b) => f(a, b))
+let cmp = (d0, d1, f) => I.cmp(d0.data, d1.data, f)
 
-let eqU = (d0, d1, f) => I.eqU(d0.data, d1.data, f)
-let eq = (d0, d1, f) => eqU(d0, d1, (a, b) => f(a, b))
+let eq = (d0, d1, f) => I.eq(d0.data, d1.data, f)
 
 let get = (d, x) => I.get(d.data, x)
 let getUndefined = (d, x) => I.getUndefined(d.data, x)
 let getWithDefault = (d, x, def) => I.getWithDefault(d.data, x, def)
 let getExn = (d, x) => I.getExn(d.data, x)
+
+let cmpU = cmp
+let eqU = eq
+let everyU = every
+let forEachU = forEach
+let mapU = map
+let mapWithKeyU = mapWithKey
+let reduceU = reduce
+let someU = some
+let updateU = update

belt-cppo/setm.cppo.res

@@ -203,25 +203,14 @@ let mergeMany = (d, arr) => d.data = addArrayMutate(d.data, arr)
 let make = () => {data: None}
 
 let isEmpty = d => N.isEmpty(d.data)
-
 let minimum = d => N.minimum(d.data)
-
 let minUndefined = d => N.minUndefined(d.data)
-
 let maximum = d => N.maximum(d.data)
-
 let maxUndefined = d => N.maxUndefined(d.data)
-
-let forEachU = (d, f) => N.forEachU(d.data, f)
-let forEach = (d, f) => forEachU(d, a => f(a))
-
-let reduceU = (d, acc, cb) => N.reduceU(d.data, acc, cb)
-let reduce = (d, acc, cb) => reduceU(d, acc, (a, b) => cb(a, b))
-
-let everyU = (d, p) => N.everyU(d.data, p)
-let every = (d, p) => everyU(d, a => p(a))
-let someU = (d, p) => N.someU(d.data, p)
-let some = (d, p) => someU(d, a => p(a))
+let forEach = (d, f) => N.forEach(d.data, f)
+let reduce = (d, acc, cb) => N.reduce(d.data, acc, cb)
+let every = (d, p) => N.every(d.data, p)
+let some = (d, p) => N.some(d.data, p)
 let size = d => N.size(d.data)
 let toList = d => N.toList(d.data)
 let toArray = d => N.toArray(d.data)
@@ -262,14 +251,12 @@ let split = (d, key) => {
   }
 }
 
-let keepU = (d, p) => {data: N.keepCopyU(d.data, p)}
-let keep = (d, p) => keepU(d, a => p(a))
+let keep = (d, p) => {data: N.keepCopy(d.data, p)}
 
-let partitionU = (d, p) => {
-  let (a, b) = N.partitionCopyU(d.data, p)
+let partition = (d, p) => {
+  let (a, b) = N.partitionCopy(d.data, p)
   ({data: a}, {data: b})
 }
-let partition = (d, p) => partitionU(d, a => p(a))
 
 let subset = (a, b) => I.subset(a.data, b.data)
 let intersect = (dataa, datab) => {
@@ -344,3 +331,10 @@ let union = (dataa: t, datab: t): t => {
 let has = (d, x) => I.has(d.data, x)
 
 let copy = d => {data: N.copy(d.data)}
+
+let everyU = every
+let forEachU = forEach
+let keepU = keep
+let partitionU = partition
+let reduceU = reduce
+let someU = some

belt/src/belt.res

@@ -103,8 +103,6 @@ The two versions can be invoked as follows:
 
 ```rescript
 ["a", "b", "c"]->Belt.Array.forEach(x => Js.log(x))
-
-["a", "b", "c"]->Belt.Array.forEachU(x => Js.log(x))
 ```
 
 ## Specialized Collections