Skip to content

Belt: clean up uncurried handling; deprecate xxxU functions #6941

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Aug 7, 2024
Merged

Belt: clean up uncurried handling; deprecate xxxU functions #6941

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
628e752
Belt: clean up uncurried handling; deprecate xxxU functions
cknitt Aug 7, 2024
479cc3b
CHANGELOG
cknitt Aug 7, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions jscomp/build_tests/super_errors/expected/arity_mismatch3.res.expected
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,8 +1,8 @@

We've found a bug for you!
/.../fixtures/arity_mismatch3.res:1:21-33
/.../fixtures/arity_mismatch3.res:1:20-30

1 │ Belt.Array.mapU([], (. a, b) => 1)
1 │ Belt.Array.map([], (a, b) => 1)
2 │

This function expected 1 argument, but got 2
2 changes: 1 addition & 1 deletion jscomp/build_tests/super_errors/fixtures/arity_mismatch3.res
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1 +1 @@
Belt.Array.mapU([], (. a, b) => 1)
Belt.Array.map([], (a, b) => 1)
30 changes: 0 additions & 30 deletions jscomp/others/belt.res
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -77,36 +77,6 @@ let greaterThan2UniqueAndSorted =
Js.log2("result", greaterThan2UniqueAndSorted)
```

## Curried vs. Uncurried Callbacks

For functions taking a callback parameter, there are usually two versions
available:

- curried (no suffix)
- uncurried (suffixed with `U`)

E.g.:

## Examples

```rescript
let forEach: (t<'a>, 'a => unit) => unit

let forEachU: (t<'a>, (. 'a) => unit) => unit
```

The uncurried version will be faster in some cases, but for simplicity we recommend to stick with the curried version unless you need the extra performance.

The two versions can be invoked as follows:

## Examples

```rescript
["a", "b", "c"]->Belt.Array.forEach(x => Js.log(x))

["a", "b", "c"]->Belt.Array.forEachU((. x) => Js.log(x))
```

## Specialized Collections

For collections types like set or map, Belt provides both a generic module as well as specialized, more efficient implementations for string and int keys.
Expand Down
131 changes: 53 additions & 78 deletions jscomp/others/belt_Array.res
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -116,7 +116,7 @@ let make = (l, f) =>

/* See #6575. We could also check for maximum array size, but this depends
on whether we create a float array or a regular one... */
let makeByU = (l, f) =>
let makeBy = (l, f) =>
if l <= 0 {
[]
} else {
Expand All @@ -127,16 +127,12 @@ let makeByU = (l, f) =>
res
}

let makeBy = (l, f) => makeByU(l, a => f(a))

let makeByAndShuffleU = (l, f) => {
let u = makeByU(l, f)
let makeByAndShuffle = (l, f) => {
let u = makeBy(l, f)
shuffleInPlace(u)
u
}

let makeByAndShuffle = (l, f) => makeByAndShuffleU(l, a => f(a))

let range = (start, finish) => {
let cut = finish - start
if cut < 0 {
Expand Down Expand Up @@ -176,7 +172,7 @@ let zip = (xs, ys) => {
s
}

let zipByU = (xs, ys, f) => {
let zipBy = (xs, ys, f) => {
let (lenx, leny) = (length(xs), length(ys))
let len = Pervasives.min(lenx, leny)
let s = makeUninitializedUnsafe(len)
Expand All @@ -186,8 +182,6 @@ let zipByU = (xs, ys, f) => {
s
}

let zipBy = (xs, ys, f) => zipByU(xs, ys, (a, b) => f(a, b))

let concat = (a1, a2) => {
let l1 = length(a1)
let l2 = length(a2)
Expand Down Expand Up @@ -325,14 +319,12 @@ let blit = (~src as a1, ~srcOffset as ofs1, ~dst as a2, ~dstOffset as ofs2, ~len
}
}

let forEachU = (a, f) =>
let forEach = (a, f) =>
for i in 0 to length(a) - 1 {
f(getUnsafe(a, i))
}

let forEach = (a, f) => forEachU(a, a => f(a))

let mapU = (a, f) => {
let map = (a, f) => {
let l = length(a)
let r = makeUninitializedUnsafe(l)
for i in 0 to l - 1 {
Expand All @@ -341,13 +333,9 @@ let mapU = (a, f) => {
r
}

let map = (a, f) => mapU(a, a => f(a))
let flatMap = (a, f) => concatMany(map(a, f))

let flatMapU = (a, f) => concatMany(mapU(a, f))

let flatMap = (a, f) => flatMapU(a, a => f(a))

let getByU = (a, p) => {
let getBy = (a, p) => {
let l = length(a)
let i = ref(0)
let r = ref(None)
Expand All @@ -361,9 +349,7 @@ let getByU = (a, p) => {
r.contents
}

let getBy = (a, p) => getByU(a, a => p(a))

let getIndexByU = (a, p) => {
let getIndexBy = (a, p) => {
let l = length(a)
let i = ref(0)
let r = ref(None)
Expand All @@ -377,9 +363,7 @@ let getIndexByU = (a, p) => {
r.contents
}

let getIndexBy = (a, p) => getIndexByU(a, a => p(a))

let keepU = (a, f) => {
let keep = (a, f) => {
let l = length(a)
let r = makeUninitializedUnsafe(l)
let j = ref(0)
Expand All @@ -394,9 +378,7 @@ let keepU = (a, f) => {
r
}

let keep = (a, f) => keepU(a, a => f(a))

let keepWithIndexU = (a, f) => {
let keepWithIndex = (a, f) => {
let l = length(a)
let r = makeUninitializedUnsafe(l)
let j = ref(0)
Expand All @@ -411,9 +393,7 @@ let keepWithIndexU = (a, f) => {
r
}

let keepWithIndex = (a, f) => keepWithIndexU(a, (a, i) => f(a, i))

let keepMapU = (a, f) => {
let keepMap = (a, f) => {
let l = length(a)
let r = makeUninitializedUnsafe(l)
let j = ref(0)
Expand All @@ -430,16 +410,12 @@ let keepMapU = (a, f) => {
r
}

let keepMap = (a, f) => keepMapU(a, a => f(a))

let forEachWithIndexU = (a, f) =>
let forEachWithIndex = (a, f) =>
for i in 0 to length(a) - 1 {
f(i, getUnsafe(a, i))
}

let forEachWithIndex = (a, f) => forEachWithIndexU(a, (a, b) => f(a, b))

let mapWithIndexU = (a, f) => {
let mapWithIndex = (a, f) => {
let l = length(a)
let r = makeUninitializedUnsafe(l)
for i in 0 to l - 1 {
Expand All @@ -448,29 +424,23 @@ let mapWithIndexU = (a, f) => {
r
}

let mapWithIndex = (a, f) => mapWithIndexU(a, (a, b) => f(a, b))

let reduceU = (a, x, f) => {
let reduce = (a, x, f) => {
let r = ref(x)
for i in 0 to length(a) - 1 {
r.contents = f(r.contents, getUnsafe(a, i))
}
r.contents
}

let reduce = (a, x, f) => reduceU(a, x, (a, b) => f(a, b))

let reduceReverseU = (a, x, f) => {
let reduceReverse = (a, x, f) => {
let r = ref(x)
for i in length(a) - 1 downto 0 {
r.contents = f(r.contents, getUnsafe(a, i))
}
r.contents
}

let reduceReverse = (a, x, f) => reduceReverseU(a, x, (a, b) => f(a, b))

let reduceReverse2U = (a, b, x, f) => {
let reduceReverse2 = (a, b, x, f) => {
let r = ref(x)
let len = Pervasives.min(length(a), length(b))
for i in len - 1 downto 0 {
Expand All @@ -479,18 +449,14 @@ let reduceReverse2U = (a, b, x, f) => {
r.contents
}

let reduceReverse2 = (a, b, x, f) => reduceReverse2U(a, b, x, (a, b, c) => f(a, b, c))

let reduceWithIndexU = (a, x, f) => {
let reduceWithIndex = (a, x, f) => {
let r = ref(x)
for i in 0 to length(a) - 1 {
r.contents = f(r.contents, getUnsafe(a, i), i)
}
r.contents
}

let reduceWithIndex = (a, x, f) => reduceWithIndexU(a, x, (a, b, c) => f(a, b, c))

let rec everyAux = (arr, i, b, len) =>
if i == len {
true
Expand All @@ -509,20 +475,16 @@ let rec someAux = (arr, i, b, len) =>
someAux(arr, i + 1, b, len)
}

let everyU = (arr, b) => {
let every = (arr, b) => {
let len = length(arr)
everyAux(arr, 0, b, len)
}

let every = (arr, f) => everyU(arr, b => f(b))

let someU = (arr, b) => {
let some = (arr, b) => {
let len = length(arr)
someAux(arr, 0, b, len)
}

let some = (arr, f) => someU(arr, b => f(b))

let rec everyAux2 = (arr1, arr2, i, b, len) =>
if i == len {
true
Expand All @@ -541,15 +503,11 @@ let rec someAux2 = (arr1, arr2, i, b, len) =>
someAux2(arr1, arr2, i + 1, b, len)
}

let every2U = (a, b, p) => everyAux2(a, b, 0, p, Pervasives.min(length(a), length(b)))
let every2 = (a, b, p) => everyAux2(a, b, 0, p, Pervasives.min(length(a), length(b)))

let every2 = (a, b, p) => every2U(a, b, (a, b) => p(a, b))
let some2 = (a, b, p) => someAux2(a, b, 0, p, Pervasives.min(length(a), length(b)))

let some2U = (a, b, p) => someAux2(a, b, 0, p, Pervasives.min(length(a), length(b)))

let some2 = (a, b, p) => some2U(a, b, (a, b) => p(a, b))

let eqU = (a, b, p) => {
let eq = (a, b, p) => {
let lena = length(a)
let lenb = length(b)
if lena == lenb {
Expand All @@ -559,8 +517,6 @@ let eqU = (a, b, p) => {
}
}

let eq = (a, b, p) => eqU(a, b, (a, b) => p(a, b))

let rec everyCmpAux2 = (arr1, arr2, i, b, len) =>
if i == len {
0
Expand All @@ -573,7 +529,7 @@ let rec everyCmpAux2 = (arr1, arr2, i, b, len) =>
}
}

let cmpU = (a, b, p) => {
let cmp = (a, b, p) => {
let lena = length(a)
let lenb = length(b)
if lena > lenb {
Expand All @@ -585,9 +541,7 @@ let cmpU = (a, b, p) => {
}
}

let cmp = (a, b, p) => cmpU(a, b, (a, b) => p(a, b))

let partitionU = (a, f) => {
let partition = (a, f) => {
let l = length(a)
let i = ref(0)
let j = ref(0)
Expand All @@ -608,8 +562,6 @@ let partitionU = (a, f) => {
(a1, a2)
}

let partition = (a, f) => partitionU(a, x => f(x))

let unzip = a => {
let l = length(a)
let a1 = makeUninitializedUnsafe(l)
Expand All @@ -622,7 +574,7 @@ let unzip = a => {
(a1, a2)
}

let joinWithU = (a, sep, toString) =>
let joinWith = (a, sep, toString) =>
switch length(a) {
| 0 => ""
| l =>
Expand All @@ -637,16 +589,39 @@ let joinWithU = (a, sep, toString) =>
aux(0, "")
}

let joinWith = (a, sep, toString) => joinWithU(a, sep, x => toString(x))

let initU = (n, f) => {
let init = (n, f) => {
let v = makeUninitializedUnsafe(n)
for i in 0 to n - 1 {
setUnsafe(v, i, f(i))
}
v
}

let init = (n, f) => initU(n, i => f(i))
let cmpU = cmp
let eqU = eq
let every2U = every2
let everyU = every
let flatMapU = flatMap
let forEachU = forEach
let forEachWithIndexU = forEachWithIndex
let getByU = getBy
let getIndexByU = getIndexBy
let initU = init
let joinWithU = joinWith
let keepMapU = keepMap
let keepU = keep
let keepWithIndexU = keepWithIndex
let makeByAndShuffleU = makeByAndShuffle
let makeByU = makeBy
let mapU = map
let mapWithIndexU = mapWithIndex
let partitionU = partition
let reduceReverse2U = reduceReverse2
let reduceReverseU = reduceReverse
let reduceU = reduce
let reduceWithIndexU = reduceWithIndex
let some2U = some2
let someU = some
let zipByU = zipBy

@send external push: (t<'a>, 'a) => unit = "push"
Loading