Belt: clean up uncurried handling; deprecate xxxU functions (#7)

* Belt: clean up uncurried handling; deprecate xxxU functions

* review changes

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/belt_Set.cppo.resi

@@ -90,18 +90,21 @@ equal elements.
 */
 let eq: (t, t) => bool
 
+@deprecated("Use `forEach` instead")
 let forEachU: (t, value => unit) => unit
 
 /**
 `forEach(s, f)` applies `f` in turn to all elements of `s`. In increasing order
 */
 let forEach: (t, value => unit) => unit
 
+@deprecated("Use `reduce` instead")
 let reduceU: (t, 'a, ('a, value) => 'a) => 'a
 
 /** Iterate in increasing order. */
 let reduce: (t, 'a, ('a, value) => 'a) => 'a
 
+@deprecated("Use `every` instead")
 let everyU: (t, value => bool) => bool
 
 /**
@@ -110,6 +113,7 @@ unspecified.
 */
 let every: (t, value => bool) => bool
 
+@deprecated("Use `some` instead")
 let someU: (t, value => bool) => bool
 
 /**
@@ -118,13 +122,15 @@ let someU: (t, value => bool) => bool
 */
 let some: (t, value => bool) => bool
 
+@deprecated("Use `keep` instead")
 let keepU: (t, value => bool) => t
 
 /**
 `keep(p, s)` returns the set of all elements in `s` that satisfy predicate `p`.
 */
 let keep: (t, value => bool) => t
 
+@deprecated("Use `partition` instead")
 let partitionU: (t, value => bool) => (t, t)
 
 /**

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/hashmap.cppo.resi

@@ -27,12 +27,15 @@ let has: (t<'b>, key) => bool
 
 let remove: (t<'a>, key) => unit
 
+@deprecated("Use `forEach` instead")
 let forEachU: (t<'b>, (key, 'b) => unit) => unit
 let forEach: (t<'b>, (key, 'b) => unit) => unit
 
+@deprecated("Use `reduce` instead")
 let reduceU: (t<'b>, 'c, ('c, key, 'b) => 'c) => 'c
 let reduce: (t<'b>, 'c, ('c, key, 'b) => 'c) => 'c
 
+@deprecated("Use `keepMapInPlace` instead")
 let keepMapInPlaceU: (t<'a>, (key, 'a) => option<'a>) => unit
 let keepMapInPlace: (t<'a>, (key, 'a) => option<'a>) => unit
 

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/hashset.cppo.resi

@@ -55,9 +55,11 @@ let has: (t, key) => bool
 
 let remove: (t, key) => unit
 
+@deprecated("Use `forEach` instead")
 let forEachU: (t, key => unit) => unit
 let forEach: (t, key => unit) => unit
 
+@deprecated("Use `reduce` instead")
 let reduceU: (t, 'c, ('c, key) => 'c) => 'c
 let reduce: (t, 'c, ('c, key) => 'c) => 'c
 

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,16 +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) {
   | (list{h1, ...t1}, list{h2, ...t2}) =>
@@ -212,7 +210,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 +221,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 +232,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 +241,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 +269,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 +286,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