API / Belt / List

List

Collection functions for manipulating the list data structures, a singly-linked list.

Prefer Array if you need any of the following:

  • Random access of element

  • Better interop with JavaScript

  • Better memory usage & performance.

t

RESCRIPT
type t<'a> = list<'a>

'a t is compatible with built-in list type

length

RESCRIPT
let length: t<'a> => int

Returns the length of a list.

Examples

RESCRIPT
Belt.List.length(list{1, 2, 3}) // 3

size

RESCRIPT
let size: t<'a> => int

See Belt.List.length

head

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.head(list{}) // None Belt.List.head(list{1, 2, 3}) // Some(1)

headExn

RESCRIPT
let headExn: t<'a> => 'a

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

Examples

RESCRIPT
Belt.List.headExn(list{1, 2, 3}) // 1 Belt.List.headExn(list{}) // Raises an Error

tail

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.tail(list{1, 2, 3}) // Some(list{2, 3}) Belt.List.tail(list{}) // None

tailExn

RESCRIPT
let tailExn: t<'a> => t<'a>

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

Examples

RESCRIPT
Belt.List.tailExn(list{1, 2, 3}) // list{2, 3} Belt.List.tailExn(list{}) // Raises an Error

add

RESCRIPT
let add: (t<'a>, 'a) => t<'a>

Adds value to the beginning of someList.

Examples

RESCRIPT
Belt.List.add(list{2, 3}, 1) // list{1, 2, 3} Belt.List.add(list{"World", "!"}, "Hello") // list{"Hello", "World", "!"}

get

RESCRIPT
let get: (t<'a>, int) => option<'a>

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

Examples

RESCRIPT
let abc = list{"A", "B", "C"} abc->Belt.List.get(1) // Some("B") abc->Belt.List.get(4) // None

getExn

RESCRIPT
let getExn: (t<'a>, int) => 'a

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

Examples

RESCRIPT
let abc = list{"A", "B", "C"} abc->Belt.List.getExn(1) // "B" abc->Belt.List.getExn(4) // Raises an Error

make

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.make(3, 1) // list{1, 1, 1}

makeByU

RESCRIPT
let makeByU: (int, int => 'a) => t<'a>

Uncurried version of makeBy

makeBy

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.makeBy(5, i => i) // list{0, 1, 2, 3, 4} Belt.List.makeBy(5, i => i * i) // list{0, 1, 4, 9, 16}

shuffle

RESCRIPT
let shuffle: t<'a> => t<'a>

Returns a new list in random order.

Examples

RESCRIPT
Belt.List.shuffle(list{1, 2, 3}) // list{2, 1, 3}

drop

RESCRIPT
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.

Examples

RESCRIPT
list{1, 2, 3}->Belt.List.drop(2) // Some(list{3}) list{1, 2, 3}->Belt.List.drop(3) // Some(list{}) list{1, 2, 3}->Belt.List.drop(4) // None

take

RESCRIPT
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.

Examples

RESCRIPT
list{1, 2, 3}->Belt.List.take(1) // Some(list{1}) list{1, 2, 3}->Belt.List.take(2) // Some(list{1, 2}) list{1, 2, 3}->Belt.List.take(4) // None

splitAt

RESCRIPT
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.

Examples

RESCRIPT
list{"Hello", "World"}->Belt.List.splitAt(1) // Some((list{"Hello"}, list{"World"})) list{0, 1, 2, 3, 4}->Belt.List.splitAt(2) // Some((list{0, 1}, list{2, 3, 4}))

concat

RESCRIPT
let concat: (t<'a>, t<'a>) => t<'a>

Returns the list obtained by adding secondList after firstList.

Examples

RESCRIPT
Belt.List.concat(list{1, 2, 3}, list{4, 5}) // list{1, 2, 3, 4, 5}

concatMany

RESCRIPT
let concatMany: array<t<'a>> => t<'a>

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

Examples

RESCRIPT
Belt.List.concatMany([list{1, 2, 3}, list{}, list{3}]) // list{1, 2, 3, 3}

reverseConcat

RESCRIPT
let reverseConcat: (t<'a>, t<'a>) => t<'a>

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

Examples

RESCRIPT
Belt.List.reverseConcat(list{1, 2}, list{3, 4}) // list{2, 1, 3, 4}

flatten

RESCRIPT
let flatten: t<t<'a>> => t<'a>

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

Examples

RESCRIPT
Belt.List.flatten(list{list{1, 2, 3}, list{}, list{3}}) // list{1, 2, 3, 3}

mapU

RESCRIPT
let mapU: (t<'a>, 'a => 'b) => t<'b>

Uncurried version of map.

map

RESCRIPT
let map: (t<'a>, 'a => 'b) => t<'b>

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

Examples

RESCRIPT
list{1, 2}->Belt.List.map(x => x + 1) // list{3, 4}

zip

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.zip(list{1, 2}, list{3, 4, 5}) // list{(1, 3), (2, 4)}

zipByU

RESCRIPT
let zipByU: (t<'a>, t<'b>, ('a, 'b) => 'c) => t<'c>

Uncurried version of zipBy.

zipBy

RESCRIPT
let zipBy: (t<'a>, t<'b>, ('a, 'b) => 'c) => t<'c>

See Belt.List.zip

Examples

RESCRIPT
Belt.List.zipBy(list{1, 2, 3}, list{4, 5}, (a, b) => 2 * a + b) // list{6, 9}

mapWithIndexU

RESCRIPT
let mapWithIndexU: (t<'a>, (int, 'a) => 'b) => t<'b>

Uncurried version of mapWithIndex.

mapWithIndex

RESCRIPT
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.

Examples

RESCRIPT
list{1, 2, 3}->Belt.List.mapWithIndex((index, x) => index + x) // list{1, 3, 5}

fromArray

RESCRIPT
let fromArray: array<'a> => t<'a>

Converts the given array to a list.

Examples

RESCRIPT
Belt.List.fromArray([1, 2, 3]) // list{1, 2, 3}

toArray

RESCRIPT
let toArray: t<'a> => array<'a>

Converts the given list to an array.

Examples

RESCRIPT
Belt.List.toArray(list{1, 2, 3}) // [1, 2, 3]

reverse

RESCRIPT
let reverse: t<'a> => t<'a>

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

Examples

RESCRIPT
Belt.List.reverse(list{1, 2, 3}) /* list{3, 2, 1} */

mapReverseU

RESCRIPT
let mapReverseU: (t<'a>, 'a => 'b) => t<'b>

Uncurried version of mapReverse.

mapReverse

RESCRIPT
let mapReverse: (t<'a>, 'a => 'b) => t<'b>

Equivalent to:

RES
map(someList, f)->reverse

Examples

RESCRIPT
list{3, 4, 5}->Belt.List.mapReverse(x => x * x) /* list{25, 16, 9} */

forEachU

RESCRIPT
let forEachU: (t<'a>, 'a => 'b) => unit

Uncurried version of forEach.

forEach

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.forEach(list{"a", "b", "c"}, x => Js.log("Item: " ++ x)) /* prints: Item: a Item: b Item: c */

forEachWithIndexU

RESCRIPT
let forEachWithIndexU: (t<'a>, (int, 'a) => 'b) => unit

Uncurried version of forEachWithIndex.

forEachWithIndex

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.forEachWithIndex(list{"a", "b", "c"}, (index, x) => { Js.log("Item " ++ Belt.Int.toString(index) ++ " is " ++ x) }) /* prints: Item 0 is a Item 1 is b Item 2 is cc */

reduceU

RESCRIPT
let reduceU: (t<'a>, 'b, ('b, 'a) => 'b) => 'b

Uncurried version of reduce.

reduce

RESCRIPT
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.

Examples

RESCRIPT
list{1, 2, 3, 4}->Belt.List.reduce(0, (a, b) => a + b) /* 10 */ /* same as */ list{1, 2, 3, 4}->Belt.List.reduce(0, (acc, item) => acc + item) /* 10 */

reduceWithIndexU

RESCRIPT
let reduceWithIndexU: (t<'a>, 'b, ('b, 'a, int) => 'b) => 'b

Uncurried version of reduceWithIndex.

reduceWithIndex

RESCRIPT
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.

Examples

RESCRIPT
list{1, 2, 3, 4}->Belt.List.reduceWithIndex(0, (acc, item, index) => acc + item + index) /* 16 */

reduceReverseU

RESCRIPT
let reduceReverseU: (t<'a>, 'b, ('b, 'a) => 'b) => 'b

Uncurried version of reduceReverse.

reduceReverse

RESCRIPT
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.

Examples

RESCRIPT
list{1, 2, 3, 4}->Belt.List.reduceReverse(0, (a, b) => a + b) /* 10 */ list{1, 2, 3, 4}->Belt.List.reduceReverse(10, (a, b) => a - b) /* 0 */ list{1, 2, 3, 4}->Belt.List.reduceReverse(list{}, Belt.List.add) // list{1, 2, 3, 4}

mapReverse2U

RESCRIPT
let mapReverse2U: (t<'a>, t<'b>, ('a, 'b) => 'c) => t<'c>

Uncurried version of mapReverse2.

mapReverse2

RESCRIPT
let mapReverse2: (t<'a>, t<'b>, ('a, 'b) => 'c) => t<'c>

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

Examples

RESCRIPT
Belt.List.mapReverse2(list{1, 2, 3}, list{1, 2}, (a, b) => a + b) // list{4, 2}

forEach2U

RESCRIPT
let forEach2U: (t<'a>, t<'b>, ('a, 'b) => 'c) => unit

Uncurried version of forEach2.

forEach2

RESCRIPT
let forEach2: (t<'a>, t<'b>, ('a, 'b) => 'c) => unit

Stops at the length of the shorter list.

Examples

RESCRIPT
Belt.List.forEach2(list{"Z", "Y"}, list{"A", "B", "C"}, (x, y) => Js.log2(x, y)) /* prints: "Z" "A" "Y" "B" */

reduce2U

RESCRIPT
let reduce2U: (t<'b>, t<'c>, 'a, ('a, 'b, 'c) => 'a) => 'a

Uncurried version of reduce2.

reduce2

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.reduce2(list{1, 2, 3}, list{4, 5}, 0, (acc, x, y) => acc + x * x + y) /* 0 + (1 * 1 + 4) + (2 * 2 + 5) */

reduceReverse2U

RESCRIPT
let reduceReverse2U: (t<'a>, t<'b>, 'c, ('c, 'a, 'b) => 'c) => 'c

Uncurried version of reduceReverse2.

reduceReverse2

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.reduceReverse2(list{1, 2, 3}, list{4, 5}, 0, (acc, x, y) => acc + x * x + y) /* + (1 * 1 + 4) + (2 * 2 + 5) */

everyU

RESCRIPT
let everyU: (t<'a>, 'a => bool) => bool

Uncurried version of every.

every

RESCRIPT
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.

Examples

RESCRIPT
let isBelow10 = value => value < 10 list{1, 9, 8, 2}->Belt.List.every(isBelow10) /* true */ list{1, 99, 8, 2}->Belt.List.every(isBelow10) /* false */

someU

RESCRIPT
let someU: (t<'a>, 'a => bool) => bool

Uncurried version of some.

some

RESCRIPT
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.

Examples

RESCRIPT
let isAbove100 = value => value > 100 list{101, 1, 2, 3}->Belt.List.some(isAbove100) /* true */ list{1, 2, 3, 4}->Belt.List.some(isAbove100) /* false */

every2U

RESCRIPT
let every2U: (t<'a>, t<'b>, ('a, 'b) => bool) => bool

Uncurried version of every2.

every2

RESCRIPT
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)))

Examples

RESCRIPT
Belt.List.every2(list{1, 2, 3}, list{0, 1}, (a, b) => a > b) /* true */ Belt.List.every2(list{}, list{1}, (a, b) => a > b) /* true */ Belt.List.every2(list{2, 3}, list{1}, (a, b) => a > b) /* true */ Belt.List.every2(list{0, 1}, list{5, 0}, (a, b) => a > b) /* false */

some2U

RESCRIPT
let some2U: (t<'a>, t<'b>, ('a, 'b) => bool) => bool

Uncurried version of some2.

some2

RESCRIPT
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)))

Examples

RESCRIPT
Belt.List.some2(list{1, 2, 3}, list{0, 1}, (a, b) => a > b) /* true */ Belt.List.some2(list{}, list{1}, (a, b) => a > b) /* false */ Belt.List.some2(list{2, 3}, list{1}, (a, b) => a > b) /* true */ Belt.List.some2(list{0, 1}, list{5, 0}, (a, b) => a > b) /* true */

cmpByLength

RESCRIPT
let cmpByLength: (t<'a>, t<'a>) => int

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).

Examples

RESCRIPT
Belt.List.cmpByLength(list{1, 2}, list{3, 4, 5, 6}) /* -1 */ Belt.List.cmpByLength(list{1, 2, 3}, list{4, 5, 6}) /* = 0 */ Belt.List.cmpByLength(list{1, 2, 3, 4}, list{5, 6}) /* = 1 */

cmpU

RESCRIPT
let cmpU: (t<'a>, t<'a>, ('a, 'a) => int) => int

Uncurried version of cmp.

cmp

RESCRIPT
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).

Examples

RESCRIPT
Belt.List.cmp(list{3}, list{3, 7}, (a, b) => compare(a, b)) /* (-1) */ Belt.List.cmp(list{5, 3}, list{5}, (a, b) => compare(a, b)) /* 1 */ Belt.List.cmp(list{1, 3, 5}, list{1, 4, 2}, (a, b) => compare(a, b)) /* (-1) */ Belt.List.cmp(list{1, 3, 5}, list{1, 2, 3}, (a, b) => compare(a, b)) /* 1 */ Belt.List.cmp(list{1, 3, 5}, list{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.

eqU

RESCRIPT
let eqU: (t<'a>, t<'a>, ('a, 'a) => bool) => bool

Uncurried version of eq.

eq

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.eq(list{1, 2, 3}, list{1, 2}, (a, b) => a == b) /* false */ Belt.List.eq(list{1, 2}, list{1, 2}, (a, b) => a == b) /* true */ Belt.List.eq(list{1, 2, 3}, list{(-1), (-2), (-3)}, (a, b) => abs(a) == abs(b)) /* true */

hasU

RESCRIPT
let hasU: (t<'a>, 'b, ('a, 'b) => bool) => bool

Uncurried version of has.

has

RESCRIPT
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.

Examples

RESCRIPT
list{1, 2, 3}->Belt.List.has(2, (a, b) => a == b) /* true */ list{1, 2, 3}->Belt.List.has(4, (a, b) => a == b) /* false */ list{(-1), (-2), (-3)}->Belt.List.has(2, (a, b) => abs(a) == abs(b)) /* true */

getByU

RESCRIPT
let getByU: (t<'a>, 'a => bool) => option<'a>

Uncurried version of getBy.

getBy

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.getBy(list{1, 4, 3, 2}, x => x > 3) /* Some(4) */ Belt.List.getBy(list{1, 4, 3, 2}, x => x > 4) /* None */

keepU

RESCRIPT
let keepU: (t<'a>, 'a => bool) => t<'a>

Uncurried version of keep.

keep

RESCRIPT
let keep: (t<'a>, 'a => bool) => t<'a>

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

Examples

RESCRIPT
let isEven = x => mod(x, 2) == 0 Belt.List.keep(list{1, 2, 3, 4}, isEven) /* list{2, 4} */ Belt.List.keep(list{None, Some(2), Some(3), None}, Belt.Option.isSome) /* list{Some(2), Some(3)} */

filter

Deprecated

This function will soon be deprecated. Please, use List.keep instead.

RESCRIPT
let filter: (t<'a>, 'a => bool) => t<'a>

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

Examples

RESCRIPT
let isEven = x => mod(x, 2) == 0 Belt.List.filter(list{1, 2, 3, 4}, isEven) /* list{2, 4} */ Belt.List.filter(list{None, Some(2), Some(3), None}, Belt.Option.isSome) /* list{Some(2), Some(3)} */

keepWithIndexU

RESCRIPT
let keepWithIndexU: (t<'a>, ('a, int) => bool) => t<'a>

Uncurried version of keepWithIndex.

keepWithIndex

RESCRIPT
let keepWithIndex: (t<'a>, ('a, int) => bool) => t<'a>

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

Examples

RESCRIPT
let isEven = x => mod(x, 2) == 0 Belt.List.keepWithIndex(list{1, 2, 3, 4}, (_x, index) => isEven(index)) /* list{1, 3} */

filterWithIndex

Deprecated

This function will soon be deprecated. Please, use List.keepWithIndex
instead.

RESCRIPT
let filterWithIndex: (t<'a>, ('a, int) => bool) => t<'a>

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

Examples

RESCRIPT
let isEven = x => mod(x, 2) == 0 Belt.List.filterWithIndex(list{1, 2, 3, 4}, (_x, index) => isEven(index)) /* list{1, 3} */

keepMapU

RESCRIPT
let keepMapU: (t<'a>, 'a => option<'b>) => t<'b>

Uncurried version of keepMap.

keepMap

RESCRIPT
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.

Examples

RESCRIPT
let isEven = x => mod(x, 2) == 0 list{1, 2, 3, 4} ->Belt.List.keepMap(x => if (isEven(x)) { Some(x) } else { None } ) /* list{2, 4} */ list{Some(1), Some(2), None}->Belt.List.keepMap(x => x) /* list{1, 2} */

partitionU

RESCRIPT
let partitionU: (t<'a>, 'a => bool) => (t<'a>, t<'a>)

Uncurried version of partition.

partition

RESCRIPT
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:

RESCRIPT
(elementsThatSatisfies, elementsThatDoesNotSatisfy)

Examples

RESCRIPT
Belt.List.partition(list{1, 2, 3, 4}, x => x > 2) /* (list{3, 4}, list{1, 2}) */

unzip

RESCRIPT
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.

Examples

RESCRIPT
Belt.List.unzip(list{(1, 2), (3, 4)}) /* (list{1, 3}, list{2, 4}) */ Belt.List.unzip(list{("H", "W"), ("e", "o"), ("l", "r"), ("l", "l"), ("o", "d"), (" ", "!")}) /* (list{"H", "e", "l", "l", "o", " "}, list{"W", "o", "r", "l", "d", "!"}) */

getAssocU

RESCRIPT
let getAssocU: (t<('a, 'c)>, 'b, ('a, 'b) => bool) => option<'c>

Uncurried version of getAssoc.

getAssoc

RESCRIPT
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.

Examples

RESCRIPT
list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.getAssoc(3, (a, b) => a == b) /* Some("c") */ list{(9, "morning"), (15, "afternoon"), (22, "night")} ->Belt.List.getAssoc(15, (k, item) => k /* 15 */ == item /* 9, 5, 22 */) /* Some("afternoon") */

hasAssocU

RESCRIPT
let hasAssocU: (t<('a, 'c)>, 'b, ('a, 'b) => bool) => bool

Uncurried version of hasAssoc.

hasAssoc

RESCRIPT
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.

Examples

RESCRIPT
list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.hasAssoc(1, (a, b) => a == b) /* true */ list{(9, "morning"), (15, "afternoon"), (22, "night")} ->Belt.List.hasAssoc(25, (k, item) => k /* 25 */ == item /* 9, 5, 22 */) /* false */

removeAssocU

RESCRIPT
let removeAssocU: (t<('a, 'c)>, 'b, ('a, 'b) => bool) => t<('a, 'c)>

Uncurried version of removeAssoc.

removeAssoc

RESCRIPT
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.

Examples

RESCRIPT
list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.removeAssoc(1, (a, b) => a == b) /* list{(2, "b"), (3, "c")} */ list{(9, "morning"), (15, "afternoon"), (22, "night")} ->Belt.List.removeAssoc(9, (k, item) => k /* 9 */ == item /* 9, 5, 22 */) /* list{(15, "afternoon"), (22, "night")} */

setAssocU

RESCRIPT
let setAssocU: (t<('a, 'c)>, 'a, 'c, ('a, 'a) => bool) => t<('a, 'c)>

Uncurried version of setAssoc.

setAssoc

RESCRIPT
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.

Examples

RESCRIPT
list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.setAssoc(2, "x", (a, b) => a == b) /* list{(1, "a"), (2, "x"), (3, "c")} */ list{(1, "a"), (3, "c")}->Belt.List.setAssoc(2, "b", (a, b) => a == b) /* list{(2, "b"), (1, "a"), (3, "c")} */ list{(9, "morning"), (3, "morning?!"), (22, "night")} ->Belt.List.setAssoc(15, "afternoon", (a, b) => mod(a, 12) == mod(b, 12)) /* list{(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.

sortU

RESCRIPT
let sortU: (t<'a>, ('a, 'a) => int) => t<'a>

Uncurried version of sort.

sort

RESCRIPT
let sort: (t<'a>, ('a, 'a) => int) => t<'a>

Returns a sorted list.

Examples

RESCRIPT
Belt.List.sort(list{5, 4, 9, 3, 7}, (a, b) => a - b) // list{3, 4, 5, 7, 9}