List

t('a)

RE
type t('a) = list('a);

length

RE
let length: t('a) => int;

Returns the length of a list.

RE
Belt.List.length([1, 2, 3]); /* 3 */

size

RE
let size: t('a) => int;

See: length

head

RE
let head: t('a) => option('a);

Returns Some(value) where value is the first element in the list, or None if someList is an empty list.

RE
Belt.List.head([]); /* None */

Belt.List.head([1, 2, 3]); /* Some(1) */

headExn

RE
let headExn: t('a) => 'a;

Same as head, but raises an exception if someList is empty. Use with care.

RE
Belt.List.headExn([1, 2, 3]); /* 1 */

Belt.List.headExn([]); /* Raises an Error */

tail

RE
let tail: t('a) => option(t('a));

Returns None if someList is empty, otherwise it returns Some(tail) where tail is everything except the first element of someList.

RE
Belt.List.tail([1, 2, 3]); /* Some([2, 3]) */

Belt.List.tail([]); /* None */

tailExn

RE
let tailExn: t('a) => t('a);

Same as tail, but raises an exception if someList is empty. Use with care.

RE
Belt.List.tailExn([1, 2, 3]); /* [2, 3] */

Belt.List.tailExn([]); /* Raises an Error */

add

RE
let add: (t('a), 'a) => t('a);

Adds value to the beginning of someList.

RE
Belt.List.add([2, 3], 1); /* [1, 2, 3] */

Belt.List.add(["World", "!"], "Hello"); /* ["Hello", "World", "!"] */

get

RE
let get: (t('a), int) => option('a);

Return the nth element in someList, or None if index is larger than the length.

RE
let abc = ["A", "B", "C"];

abc->Belt.List.get(1); /* Some("B") */

abc->Belt.List.get(4); /* None */

getExn

RE
let getExn: (t('a), int) => 'a;

Same as get, but raises an exception if index is larger than the length. Use with care.

RE
let abc = ["A", "B", "C"];

abc->Belt.List.getExn(1); /* "B" */

abc->Belt.List.getExn(4); /* Raises an Error */

make

let make: (int, 'a) => t('a);

Returns a list of length numItems with each element filled with value v. Returns an empty list if numItems is negative.

RE
Belt.List.make(3, 1); /* [1, 1, 1] */

makeBy

RE
let makeBy: (int, int => 'a) => t('a);

Return a list of length numItems with element i initialized with f(i). Returns an empty list if numItems is negative.

RE
Belt.List.makeBy(5, i => i); /* [0, 1, 2, 3, 4] */

Belt.List.makeBy(5, i => i * i); /* [0, 1, 4, 9, 16] */

makeByU

RE
let makeByU: (int, [@bs] (int => 'a)) => t('a);

Uncurried version of makeBy

shuffle

RE
let shuffle: t('a) => t('a);

Returns a new list in random order.

RE
Belt.List.shuffle([1, 2, 3]); /* [2, 1, 3] */

drop

RE
let drop: (t('a), int) => option(t('a));

Return a new list, dropping the first n elements. Returns None if someList has fewer than n elements.

RE
[1, 2, 3]->Belt.List.drop(2); /* Some([3]) */

[1, 2, 3]->Belt.List.drop(3); /* Some([]) */

[1, 2, 3]->Belt.List.drop(4); /* None */

take

RE
let take: (t('a), int) => option(t('a));

Returns a list with the first n elements from someList, or None if someList has fewer than n elements.

RE
[1, 2, 3]->Belt.List.take(1); /* Some([1]) */

[1, 2, 3]->Belt.List.take(2); /* Some([1, 2]) */

[1, 2, 3]->Belt.List.take(4); /* None */

splitAt

RE
let splitAt: (t('a), int) => option((list('a), list('a)));

Split the list someList at index. Returns None when the length of someList is less than index.

RE
["Hello", "World"]->Belt.List.splitAt(1); /* Some((["Hello"], ["World"])) */

[0, 1, 2, 3, 4]->Belt.List.splitAt(2); /* Some(([0, 1], [2, 3, 4])) */

concat

RE
let concat: (t('a), t('a)) => t('a);

Returns the list obtained by adding secondList after firstList.

RE
Belt.List.concat([1, 2, 3], [4, 5]); /* [1, 2, 3, 4, 5] */

concatMany

RE
let concatMany: array(t('a)) => t('a);

Returns the list obtained by concatenating all the lists in array a, in order.

RE
Belt.List.concatMany([|[1, 2, 3], [], [3], [4]|]); /* [1, 2, 3, 3, 4] */

reverseConcat

RE
let reverseConcat: (t('a), t('a)) => t('a);

Equivalent to writing: concat(reverse(firstList), secondList)

RE
Belt.List.reverseConcat([1, 2], [3, 4]); /* [2, 1, 3, 4] */

flatten

RE
let flatten: t(t('a)) => t('a);

Return the list obtained by concatenating all the lists in list ls, in order.

RE
Belt.List.flatten([[1, 2, 3], [], [3], [4]]); /* [1, 2, 3, 3, 4] */

map

RE
let map: (t('a), 'a => 'b) => t('b);

Returns a new list with f applied to each element of someList.

RE
[1, 2]->Belt.List.map(x => x + 1); /* [3, 4] */

mapU

RE
let mapU: (t('a), [@bs] ('a => 'b)) => t('b);

Uncurried version of map.

zip

RE
let zip: (t('a), t('b)) => t(('a, 'b));

Returns a list of pairs from the two lists with the length of the shorter list.

RE
Belt.List.zip([1, 2], [3, 4, 5]); /* [(1, 3), (2, 4)] */

zipBy

RE
let zipBy: (t('a), t('b), ('a, 'b) => 'c) => t('c);

See: zip

Equivalent to:

RE
zip(firstList, secondList) |> List.map(((x, y)) => f(x, y));

RE
Belt.List.zipBy([1, 2, 3], [4, 5], (a, b) => 2 * a + b); /* [6, 9] */

zipByU

RE
let zipByU: (t('a), t('b), [@bs] (('a, 'b) => 'c)) => t('c);

Uncurried version of zipBy.

mapWithIndex

RE
let mapWithIndex: (t('a), (int, 'a) => 'b) => t('b);

Applies f to each element of someList. Function f takes two arguments: the index starting from 0 and the element from someList, in that order.

RE
[1, 2, 3]->Belt.List.mapWithIndex((index, x) => index + x); /* [1, 3, 5] */

mapWithIndexU

RE
let mapWithIndexU: (t('a), [@bs] ((int, 'a) => 'b)) => t('b);

Uncurried version of mapWithIndex.

fromArray

RE
let fromArray: array('a) => t('a);

Converts the given array to a list.

RE
Belt.List.fromArray([|1, 2, 3|]); /* [1, 2, 3] */

toArray

RE
let toArray: t('a) => array('a);

Converts the given list to an array.

RE
Belt.List.toArray([1, 2, 3]); /* [|1, 2, 3|] */

reverse

RE
let reverse: t('a) => t('a);

Returns a new list whose elements are those of someList in reversed order.

RE
Belt.List.reverse([1, 2, 3]); /* [3, 2, 1] */

mapReverse

RE
let mapReverse: (t('a), 'a => 'b) => t('b);

Equivalent to:

RE
map(someList, f)->reverse;

RE
[3, 4, 5]->Belt.List.mapReverse(x => x * x); /* [25, 16, 9] */

mapReverseU

RE
let mapReverseU: (t('a), [@bs] ('a => 'b)) => t('b);

Uncurried version of mapReverse.

forEach

RE
let forEach: (t('a), 'a => 'b) => unit;

Call f on each element of someList from the beginning to end. f returns unit, so no new array is created. Use forEach when you are primarily concerned with repetitively creating side effects.

RE
Belt.List.forEach(["a", "b", "c"], x => Js.log("Item: " ++ x));
/*
  prints:
    Item: a
    Item: b
    Item: c
*/

forEachU

RE
let forEachU: (t('a), [@bs] ('a => 'b)) => unit;

Uncurried version of forEach.

forEachWithIndex

RE
let forEachWithIndex: (t('a), (int, 'a) => 'b) => unit;

Call f on each element of someList from beginning to end. Function f takes two arguments: the index starting from 0 and the element from someList. f returns unit.

RE
Belt.List.forEachWithIndex(["a", "b", "c"], (index, x) => Js.log("Item " ++ string_of_int(index) ++ " is " ++ x));
/*  prints:
      Item 0 is a
      Item 1 is b
      Item 2 is cc
    */

forEachWithIndexU

RE
let forEachWithIndexU: (t('a), [@bs] ((int, 'a) => 'b)) => unit;

Uncurried version of forEachWithIndex.

reduce

RE
let reduce: (t('a), 'b, ('b, 'a) => 'b) => 'b;

Applies f to each element of someList from beginning to end. Function f has two parameters: the item from the list and an “accumulator”, which starts with a value of initialValue. reduce returns the final value of the accumulator.

RE
[1, 2, 3, 4]->Belt.List.reduce(0, (+)); /* 10 */

/* same as */

[1, 2, 3, 4]->Belt.List.reduce(0, (acc, item) => acc + item); /* 10 */

reduceU

RE
let reduceU: (t('a), 'b, [@bs] (('b, 'a) => 'b)) => 'b;

Uncurried version of reduce.

reduceWithIndex

RE
let reduceWithIndex: (t('a), 'b, ('b, 'a, int) => 'b) => 'b;

Applies f to each element of someList from beginning to end. Function f has three parameters: the item from the list and an “accumulator”, which starts with a value of initialValue and the index of each element. reduceWithIndex returns the final value of the accumulator.

RE
[1, 2, 3, 4]->Belt.List.reduceWithIndex(0, (acc, item, index) => acc + item + index); /* 16 */

reduceWithIndexU

RE
let reduceWithIndexU: (t('a), 'b, [@bs] (('b, 'a, int) => 'b)) => 'b;

Uncurried version of reduceWithIndex.

reduceReverse

RE
let reduceReverse: (t('a), 'b, ('b, 'a) => 'b) => 'b;

Works like reduce, except that function f is applied to each item of someList from the last back to the first.

RE
[1, 2, 3, 4]->Belt.List.reduceReverse(0, (+)); /* 10 */

[1, 2, 3, 4]->Belt.List.reduceReverse(10, (-)); /* 0 */

[1, 2, 3, 4]->Belt.List.reduceReverse([], Belt.List.add); /* [1, 2, 3, 4] */

reduceReverseU

RE
let reduceReverseU: (t('a), 'b, [@bs] (('b, 'a) => 'b)) => 'b;

Uncurried version of reduceReverse.

mapReverse2

RE
let mapReverse2: (t('a), t('b), ('a, 'b) => 'c) => t('c);

Equivalent to: zipBy(xs, ys, f)->reverse

RE

Belt.List.mapReverse2([1, 2, 3], [1, 2], (+)); /* [4, 2] */

mapReverse2U

RE
let mapReverse2U: (t('a), t('b), [@bs] (('a, 'b) => 'c)) => t('c);

Uncurried version of mapReverse2.

forEach2

RE
let forEach2: (t('a), t('b), ('a, 'b) => 'c) => unit;

Stops at the length of the shorter list.

RE
Belt.List.forEach2(["Z", "Y"], ["A", "B", "C"], (x, y) => Js.log2(x, y));

/* prints:
"Z" "A"
"Y" "B"
*/

forEach2U

RE
let forEach2U: (t('a), t('b), (.'a, 'b) => 'c) => unit;

Uncurried version of forEach2.

reduce2

RE
let reduce2: (t('b), t('c), 'a, ('a, 'b, 'c) => 'a) => 'a;

Applies f to each element of firstList and secondList from beginning to end. Stops with the shorter list. Function f has three parameters: an “accumulator” which starts with a value of initialValue, an item from firstList, and an item from secondList. reduce2 returns the final value of the accumulator.

RE
Belt.List.reduce2([1, 2, 3], [4, 5], 0, (acc, x, y) => acc + x * x + y); /* 0 + (1 * 1 + 4) + (2 * 2 + 5) */

reduce2U

RE
let reduce2U: (t('b), t('c), 'a, (.'a, 'b, 'c) => 'a) => 'a;

Uncurried version of reduce2.

reduceReverse2

RE
let reduceReverse2: (t('a), t('b), 'c, ('c, 'a, 'b) => 'c) => 'c;

Applies f to each element of firstList and secondList from end to beginning. Stops with the shorter list. Function f has three parameters: an “accumulator” which starts with a value of init, an item from firstList, and an item from secondList. reduce2 returns the final value of the accumulator.

RE
Belt.List.reduceReverse2([1, 2, 3], [4, 5], 0, (acc, x, y) => acc + x * x + y); /*  + (1 * 1 + 4) + (2 * 2 + 5) */

reduceReverse2U

RE
let reduceReverse2U: (t('a), t('b), 'c, (.'c, 'a, 'b) => 'c) => 'c;

Uncurried version of reduceReverse2.

every

RE
let every: (t('a), 'a => bool) => bool;

Returns true if all elements satisfy pred, where pred is a predicate: a function taking an element and returning a bool.

RE
let isBelow10 = value => value < 10;

[1, 9, 8, 2]->Belt.List.every(isBelow10); /* true */

[1, 99, 8, 2]->Belt.List.every(isBelow10); /* false */

everyU

RE
let everyU: (t('a), (.'a) => bool) => bool;

Uncurried version of every.

some

RE
let some: (t('a), 'a => bool) => bool;

Returns true if at least one of the elements in someList satisfies pred, where pred is a predicate: a function taking an element and returning a bool.

RE
let isAbove100 = value => value > 100;

[101, 1, 2, 3]->Belt.List.some(isAbove100); /* true */

[1, 2, 3, 4]->Belt.List.some(isAbove100); /* false */

someU

RE
let someU: (t('a), (.'a => bool)) => bool;

Uncurried version of some.

every2

RE
let every2: (t('a), t('b), ('a, 'b) => bool) => bool;

Returns true if predicate pred(a, b) is true for all pairs of elements up to the shorter length (i.e. min(length(firstList), length(secondList)))

RE
Belt.List.every2([1, 2, 3], [0, 1], (>)); /* true */

Belt.List.every2([], [1], (a, b) => a > b); /* true */

Belt.List.every2([2, 3], [1], (a, b) => a > b); /* true */

Belt.List.every2([0, 1], [5, 0], (a, b) => a > b); /* false */

every2U

RE
let every2U: (t('a), t('b), [@bs] (('a, 'b) => bool)) => bool;

Uncurried version of every2.

some2

RE
let some2: (t('a), t('b), ('a, 'b) => bool) => bool;

Returns true if predicate pred(a, b) is true for any pair of elements up to the shorter length (i.e. min(length(firstList), length(secondList)))

RE
Belt.List.some2([1, 2, 3], [0, 1], (>)); /* true */

Belt.List.some2([], [1], (a, b) => a > b); /* false */

Belt.List.some2([2, 3], [1], (a, b) => a > b); /* true */

Belt.List.some2([0, 1], [5, 0], (a, b) => a > b); /* true */

some2U

RE
let some2U: (t('a), t('b), [@bs] (('a, 'b) => bool)) => bool;

Uncurried version of some2.

cmpByLength

RE
let cmpByLength: (t('a), t('a)) => int;

RE
cmpByLength(firstList, secondList);

Compare two lists solely by length. Returns -1 if length(firstList) is less than length(secondList), 0 if length(firstList) equals length(secondList), and 1 if length(firstList) is greater than length(secondList).

RE
Belt.List.cmpByLength([1, 2], [3, 4, 5, 6]); /* (-1) */

Belt.List.cmpByLength([1, 2, 3], [4, 5, 6]); /* = 0 */

Belt.List.cmpByLength([1, 2, 3, 4], [5, 6]); /* = 1 */

cmp

RE
let cmp: (t('a), t('a), ('a, 'a) => int) => int;

Compare elements one by one compareFn(a, b). compareFn returns a negative number if a is "less than" b, zero if a is "equal to" b, a positive number if a is "greater than" b.

The comparison returns the first non-zero result of compareFn, or zero if compareFn returns zero for all a and b.

If all items have compared equal, but firstList is exhausted first, return -1. (firstList is shorter). If all items have compared equal, but secondList is exhausted first, return 1 (firstList is longer).

RE
Belt.List.cmp([3], [3, 7], (a, b) => compare(a, b)); /* (-1) */

Belt.List.cmp([5, 3], [5], (a, b) => compare(a, b)); /* 1 */

Belt.List.cmp([1, 3, 5], [1, 4, 2], (a, b) => compare(a, b)); /* (-1) */

Belt.List.cmp([1, 3, 5], [1, 2, 3], (a, b) => compare(a, b)); /* 1 */

Belt.List.cmp([1, 3, 5], [1, 3, 5], (a, b) => compare(a, b)); /* 0 */

Please note: The total ordering of List is different from Array, for Array, we compare the length first and, only if the lengths are equal, elements one by one. For lists, we just compare elements one by one.

cmpU

RE
let cmpU: (t('a), t('a), [@bs] (('a, 'a) => int)) => int;

Uncurried version of cmp.

eq

RE
let eq: (t('a), t('a), ('a, 'a) => bool) => bool;

Check equality of firstList and secondList using eqElem for equality on elements, where eqElem is a function that returns true if items x and y meet some criterion for equality, false otherwise. eq false if length of firstList and secondList are not the same.

RE
Belt.List.eq([1, 2, 3], [1, 2], (==)); /* false */

Belt.List.eq([1, 2], [1, 2], (==)); /* true */

Belt.List.eq([1, 2, 3], [(-1), (-2), (-3)], (a, b) => abs(a) == abs(b)); /* true */

eqU

RE
let eqU: (t('a), t('a), [@bs] (('a, 'a) => bool)) => bool;

Uncurried version of eqU.

has

RE
let has: (t('a), 'b, ('a, 'b) => bool) => bool;

Returns true if the list contains at least one element for which eqFunction(x) returns true.

RE
[1, 2, 3]->Belt.List.has(2, (==)); /* true */

[1, 2, 3]->Belt.List.has(4, (==)); /* false */

[(-1), (-2), (-3)]->Belt.List.has(2, (a, b) => abs(a) == abs(b)); /* true */

hasU

RE
let hasU: (t('a), 'b, [@bs] (('a, 'b) => bool)) => bool;

Uncurried version of has.

getBy

RE
let getBy: (t('a), 'a => bool) => option('a);

Returns Some(value) for the first value in someList that satisfies the predicate function pred. Returns None if no element satisfies the function.

RE
Belt.List.getBy([1, 4, 3, 2], x => x > 3); /* Some(4) */

Belt.List.getBy([1, 4, 3, 2], x => x > 4); /* None */

getByU

RE
let getByU: (t('a), [@bs] ('a => bool)) => option('a);

Uncurried version of getBy.

keep

RE
let keep: (t('a), 'a => bool) => t('a);

Returns a list of all elements in someList which satisfy the predicate function pred.

RE
let isEven = x => x mod 2 == 0;

Belt.List.keep([1, 2, 3, 4], isEven); /* [2, 4] */

Belt.List.keep([None, Some(2), Some(3), None], Belt.Option.isSome); /* [Some(2), Some(3)] */

keepU

RE
let keepU: (t('a), [@bs] ('a => bool)) => t('a);

Uncurried version of keep.

filter

RE
let filter: (t('a), 'a => bool) => t('a);

Returns a list of all elements in someList which satisfy the predicate function pred.

RE
let isEven = x => x mod 2 == 0;

Belt.List.filter([1, 2, 3, 4], isEven); /* [2, 4] */

Belt.List.filter([None, Some(2), Some(3), None], Belt.Option.isSome); /* [Some(2), Some(3)] */

keepWithIndex

RE
let keepWithIndex: (t('a), ('a, int) => bool) => t('a);

Returns a list of all elements in someList which satisfy the predicate function pred.

RE
let isEven = x => x mod 2 == 0;

Belt.List.keepWithIndex([1, 2, 3, 4], (_x, index) => isEven(index)); /* [1, 3] */

keepWithIndexU

RE
let keepWithIndexU: (t('a), [@bs] (('a, int) => bool)) => t('a);

Uncurried version of keepWithIndex.

filterWithIndex

RE
let filterWithIndex: (t('a), ('a, int) => bool) => t('a);

Returns a list of all elements in someList which satisfy the predicate function pred.

RE
let isEven = x => x mod 2 == 0;

Belt.List.filterWithIndex([1, 2, 3, 4], (_x, index) => isEven(index)); /* [1, 3] */

keepMap

RE
let keepMap: (t('a), 'a => option('b)) => t('b);

Applies f to each element of someList. If f(x) returns Some(value), then value is kept in the resulting list. If f(x) returns None, the element is not retained in the result.

RE
let isEven = x => x mod 2 == 0;

[1, 2, 3, 4]
->Belt.List.keepMap(x =>
    if (isEven(x)) {
      Some(x);
    } else {
      None;
    }
  ); /* [2, 4] */

[Some(1), Some(2), None]->Belt.List.keepMap(x => x); /* [1, 2] */

keepMapU

RE
let keepMapU: (t('a), [@bs] ('a => option('b))) => t('b);

Uncurried version of keepMap.

partition

RE
let partition: (t('a), 'a => bool) => (t('a), t('a));

Creates a pair of lists; the first list consists of all elements of someList that satisfy the predicate function pred; the second list consists of all elements of someList that do not satisfy `pred.

In other words:

([elementsThatSatisfies], [elementsThatDoesNotSatisfy]);

RE
Belt.List.partition([1, 2, 3, 4], x => x > 2); /* ([3, 4], [1, 2]) */

partitionU

RE
let partitionU: (t('a), [@bs] ('a => bool)) => (t('a), t('a));

Uncurried version of partition.

unzip

RE
let unzip: t(('a, 'b)) => (t('a), t('b));

Takes a list of pairs and creates a pair of lists. The first list contains all the first items of the pairs; the second list contains all the second items.

RE
Belt.List.unzip([(1, 2), (3, 4)]); /* ([1, 3], [2, 4]) */

Belt.List.unzip([("H", "W"), ("e", "o"), ("l", "r"), ("l", "l"), ("o", "d"), (" ", "!")]);
/* (["H", "e", "l", "l", "o", " "], ["W", "o", "r", "l", "d", "!"]); */

getAssoc

RE
let getAssoc: (t(('a, 'c)), 'b, ('a, 'b) => bool) => option('c);

Return the second element of a pair in someList where the first element equals k as per the predicate function eqFunction, or None if not found.

RE
[(1, "a"), (2, "b"), (3, "c")]->Belt.List.getAssoc(3, (==)); /* Some("c") */

[(9, "morning"), (15, "afternoon"), (22, "night")]
->Belt.List.getAssoc(15, (k, item) => k /* 15 */ == item /* 9, 5, 22 */);
/* Some("afternoon"); */

getAssocU

RE
let getAssocU: (t(('a, 'c)), 'b, [@bs] (('a, 'b) => bool)) => option('c);

Uncurried version of getAssoc.

hasAssoc

RE
let hasAssoc: (t(('a, 'c)), 'b, ('a, 'b) => bool) => bool;

Returns true if there is a pair in someList where the first element equals k as per the predicate function eqFunction.

RE
[(1, "a"), (2, "b"), (3, "c")]->Belt.List.hasAssoc(1, (==)); /* true */

[(9, "morning"), (15, "afternoon"), (22, "night")]
->Belt.List.hasAssoc(25, (k, item) => k /* 25 */ == item /* 9, 5, 22 */); /* false */

hasAssocU

RE
let hasAssocU: (t(('a, 'c)), 'b, [@bs] (('a, 'b) => bool)) => bool;

Uncurried version of hasAssoc.

removeAssoc

RE
let removeAssoc: (t(('a, 'c)), 'b, ('a, 'b) => bool) => t(('a, 'c));

Return a list after removing the first pair whose first value is k per the equality predicate eqFunction; if not found, return a new list identical to someList.

RE
[(1, "a"), (2, "b"), (3, "c")]->Belt.List.removeAssoc(1, (==)); /* [(2, "b"), (3, "c")] */

[(9, "morning"), (15, "afternoon"), (22, "night")]
->Belt.List.removeAssoc(9, (k, item) => k /* 9 */ == item /* 9, 5, 22 */);
/* [(15, "afternoon"), (22, "night")] */

removeAssocU

RE
let removeAssocU: (t(('a, 'c)), 'b, [@bs] (('a, 'b) => bool)) => t(('a, 'c));

Uncurried version of removeAssoc.

setAssoc

RE
let setAssoc: (t(('a, 'c)), 'a, 'c, ('a, 'a) => bool) => t(('a, 'c));

If k exists in someList by satisfying the eqFunction predicate, return a new list with the key and value replaced by the new k and v; otherwise, return a new list with the pair k, v added to the head of someList.

RE
[(1, "a"), (2, "b"), (3, "c")]->Belt.List.setAssoc(2, "x", (==)); /* [(1, "a"), (2, "x"), (3, "c")]; */

[(1, "a"), (3, "c")]->Belt.List.setAssoc(2, "b", (==)); /* [(2, "b"), (1, "a"), (3, "c")] */

[(9, "morning"), (3, "morning?!"), (22, "night")]
->Belt.List.setAssoc(15, "afternoon", (a, b) => a mod 12 == b mod 12);
/* [(9, "morning"), (15, "afternoon"), (22, "night")] */

Please note

In the last example, since: 15 mod 12 equals 3 mod 12

Both the key and the value are replaced in the list.

setAssocU

RE
let setAssocU: (t(('a, 'c)), 'a, 'c, [@bs] (('a, 'a) => bool)) => t(('a, 'c));

Uncurried version of setAssoc.

sort

RE
let sort: (t('a), ('a, 'a) => int) => t('a);

Returns a sorted list.

RE
Belt.List.sort([5, 4, 9, 3, 7], (a, b) => a - b); /* [3, 4, 5, 7, 9] */

sortU

RE
let sortU: (t('a), [@bs] (('a, 'a) => int)) => t('a);

Uncurried version of sort.