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.

add

RES

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

Adds value to the beginning of someList.

Examples

RES
Belt.List.add(list{2, 3}, 1) // list{1, 2, 3}

Belt.List.add(list{"World", "!"}, "Hello") == list{"Hello", "World", "!"}

cmp

RES

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

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

cmpByLength

RES

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

RES
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

Deprecated

Use cmp instead

RES

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

Uncurried version of cmp.

concat

RES

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

Returns the list obtained by adding secondList after firstList.

Examples

RES
Belt.List.concat(list{1, 2, 3}, list{4, 5}) == list{1, 2, 3, 4, 5}

concatMany

RES

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

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

Examples

RES
Belt.List.concatMany([list{1, 2, 3}, list{}, list{3}]) == list{1, 2, 3, 3}

drop

RES

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

RES
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

eq

RES

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

RES
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

eqU

Deprecated

Use eq instead

RES

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

Uncurried version of eq.

every

RES

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

RES
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

every2

RES

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

RES
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

every2U

Deprecated

Use every2 instead

RES

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

Uncurried version of every2.

everyU

Deprecated

Use every instead

RES

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

Uncurried version of every.

filter

Deprecated

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

RES

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

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

Examples

RES
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)}

filterWithIndex

Deprecated

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

RES

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

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

Examples

RES
let isEven = x => mod(x, 2) == 0

Belt.List.filterWithIndex(list{1, 2, 3, 4}, (_x, index) => isEven(index)) == list{1, 3}

flatten

RES

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

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

Examples

RES
Belt.List.flatten(list{list{1, 2, 3}, list{}, list{3}}) == list{1, 2, 3, 3}

forEach

RES

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

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

forEach2

RES

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

Stops at the length of the shorter list.

Examples

RES
Belt.List.forEach2(list{"Z", "Y"}, list{"A", "B", "C"}, (x, y) => Js.log2(x, y))

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

forEach2U

Deprecated

Use forEach2 instead

RES

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

Uncurried version of forEach2.

forEachU

Deprecated

Use forEach instead

RES

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

Uncurried version of forEach.

forEachWithIndex

RES

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

RES
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
*/

forEachWithIndexU

Deprecated

Use forEachWithIndex instead

RES

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

Uncurried version of forEachWithIndex.

fromArray

RES

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

Converts the given array to a list.

Examples

RES
Belt.List.fromArray([1, 2, 3]) == list{1, 2, 3}

get

RES

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

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

Examples

RES
let abc = list{"A", "B", "C"}

abc->Belt.List.get(1) == Some("B")

abc->Belt.List.get(4) == None

getAssoc

RES

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

RES
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
) == Some("afternoon")
/* 9, 5, 22 */

getAssocU

Deprecated

Use getAssoc instead

RES

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

Uncurried version of getAssoc.

getBy

RES

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

RES
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

getByU

Deprecated

Use getBy instead

RES

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

Uncurried version of getBy.

getExn

RES

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

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

Examples

RES
let abc = list{"A", "B", "C"}

abc->Belt.List.getExn(1) == "B"

switch abc->Belt.List.getExn(4) {
// Throws an Error
| exception _ => assert(true)
| _ => assert(false)
}

getOrThrow

RES

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

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

Examples

RES
let abc = list{"A", "B", "C"}

abc->Belt.List.getOrThrow(1) == "B"

switch abc->Belt.List.getOrThrow(4) {
// Throws an Error
| exception _ => assert(true)
| _ => assert(false)
}

has

RES

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

RES
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

hasAssoc

RES

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

RES
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
) == false
/* 9, 5, 22 */

hasAssocU

Deprecated

Use hasAssoc instead

RES

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

Uncurried version of hasAssoc.

hasU

Deprecated

Use has instead

RES

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

Uncurried version of has.

head

RES

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

RES
Belt.List.head(list{}) == None
Belt.List.head(list{1, 2, 3}) == Some(1)

headExn

RES

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

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

Examples

RES
Belt.List.headExn(list{1, 2, 3}) == 1

switch Belt.List.headExn(list{}) {
// Throws an Error
| exception _ => assert(true)
| _ => assert(false)
}

headOrThrow

RES

let headOrThrow: t<'a> => 'a

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

Examples

RES
Belt.List.headOrThrow(list{1, 2, 3}) == 1

switch Belt.List.headOrThrow(list{}) {
// Throws an Error
| exception _ => assert(true)
| _ => assert(false)
}

keep

RES

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

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

Examples

RES
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)}

keepMap

RES

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

RES
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}

keepMapU

Deprecated

Use keepMap instead

RES

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

Uncurried version of keepMap.

keepU

Deprecated

Use keep instead

RES

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

Uncurried version of keep.

keepWithIndex

RES

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

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

Examples

RES
let isEven = x => mod(x, 2) == 0

Belt.List.keepWithIndex(list{1, 2, 3, 4}, (_x, index) => isEven(index)) == list{1, 3}

keepWithIndexU

Deprecated

Use keepWithIndex instead

RES

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

Uncurried version of keepWithIndex.

length

RES

let length: t<'a> => int

Returns the length of a list.

Examples

RES
Belt.List.length(list{1, 2, 3}) == 3

make

RES

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

RES
Belt.List.make(3, 1) == list{1, 1, 1}

makeBy

RES

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

RES
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}

makeByU

Deprecated

Use makeBy instead

RES

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

Uncurried version of makeBy

map

RES

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

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

Examples

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

mapReverse

RES

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

Equivalent to Belt.List.map(someList, f)->Belt.List.reverse

Examples

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

mapReverse2

RES

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

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

Examples

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

mapReverse2U

Deprecated

Use mapReverse2 instead

RES

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

Uncurried version of mapReverse2.

mapReverseU

Deprecated

Use mapReverse instead

RES

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

Uncurried version of mapReverse.

mapU

Deprecated

Use map instead

RES

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

Uncurried version of map.

mapWithIndex

RES

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

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

mapWithIndexU

Deprecated

Use mapWithIndex instead

RES

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

Uncurried version of mapWithIndex.

partition

RES

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)

Examples

RES
list{1, 2, 3, 4}->Belt.List.partition(x => x > 2) == (list{3, 4}, list{1, 2})

partitionU

Deprecated

Use partition instead

RES

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

Uncurried version of partition.

reduce

RES

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

RES
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

reduce2

RES

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

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

reduce2U

Deprecated

Use reduce2 instead

RES

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

Uncurried version of reduce2.

reduceReverse

RES

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

RES
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}

reduceReverse2

RES

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

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

reduceReverse2U

Deprecated

Use reduceReverse2 instead

RES

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

Uncurried version of reduceReverse2.

reduceReverseU

Deprecated

Use reduceReverse instead

RES

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

Uncurried version of reduceReverse.

reduceU

Deprecated

Use reduce instead

RES

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

Uncurried version of reduce.

reduceWithIndex

RES

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

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

reduceWithIndexU

Deprecated

Use reduceWithIndex instead

RES

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

Uncurried version of reduceWithIndex.

removeAssoc

RES

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

RES
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
) == list{(15, "afternoon"), (22, "night")}
/* 9, 5, 22 */

removeAssocU

Deprecated

Use removeAssoc instead

RES

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

Uncurried version of removeAssoc.

reverse

RES

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

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

Examples

RES
Belt.List.reverse(list{1, 2, 3}) == list{3, 2, 1}

reverseConcat

RES

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

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

Examples

RES
Belt.List.reverseConcat(list{1, 2}, list{3, 4}) == list{2, 1, 3, 4}

setAssoc

RES

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

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

setAssocU

Deprecated

Use setAssoc instead

RES

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

Uncurried version of setAssoc.

shuffle

RES

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

Returns a new list in random order.

Examples

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

size

RES

let size: t<'a> => int

See Belt.List.length

some

RES

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

RES
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

some2

RES

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

RES
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

some2U

Deprecated

Use some2 instead

RES

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

Uncurried version of some2.

someU

Deprecated

Use some instead

RES

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

Uncurried version of some.

sort

RES

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

Returns a sorted list.

Examples

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

sortU

Deprecated

Use sort instead

RES

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

Uncurried version of sort.

splitAt

RES

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

RES
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}))

t

RES

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

'a t is compatible with built-in list type

tail

RES

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

RES
Belt.List.tail(list{1, 2, 3}) == Some(list{2, 3})

Belt.List.tail(list{}) == None

tailExn

RES

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

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

Examples

RES
Belt.List.tailExn(list{1, 2, 3}) == list{2, 3}

switch Belt.List.tailExn(list{}) {
// Throws an Error
| exception _ => assert(true)
| _ => assert(false)
}

tailOrThrow

RES

let tailOrThrow: t<'a> => t<'a>

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

Examples

RES
Belt.List.tailOrThrow(list{1, 2, 3}) == list{2, 3}

switch Belt.List.tailOrThrow(list{}) {
// Throws an Error
| exception _ => assert(true)
| _ => assert(false)
}

take

RES

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

RES
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

toArray

RES

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

Converts the given list to an array.

Examples

RES
Belt.List.toArray(list{1, 2, 3}) == [1, 2, 3]

unzip

RES

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

RES
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", "!"})

zip

RES

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

RES
Belt.List.zip(list{1, 2}, list{3, 4, 5}) == list{(1, 3), (2, 4)}

zipBy

RES

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

See Belt.List.zip

Examples

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

zipByU

Deprecated

Use zipBy instead

RES

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

Uncurried version of zipBy.