List

Utilities for working with lists.

1

from "list" include List

Values

Functions and constants included in the List module.

List.init

1

init : (length: Number, fn: (Number => a)) => List<a>

Creates a new list of the specified length where each element is initialized with the result of an initializer function. The initializer is called with the index of each list element.

Parameters:

Returns:

Examples:

1

List.init(5, n => n + 3) // [3, 4, 5, 6, 7]

List.length

1

length : (list: List<a>) => Number

Computes the length of the input list.

Parameters:

Returns:

List.isEmpty

1

isEmpty : (list: List<a>) => Bool

Determines if the list contains no elements.

Parameters:

Returns:

List.reverse

1

reverse : (list: List<a>) => List<a>

Creates a new list with all elements in reverse order.

Parameters:

Returns:

List.append

1

append : (list1: List<a>, list2: List<a>) => List<a>

Creates a new list with the elements of the first list followed by the elements of the second list.

Parameters:

Returns:

List.contains

1

contains : (search: a, list: List<a>) => Bool

Checks if the value is an element of the input list. Uses the generic == structural equality operator.

Parameters:

Returns:

List.reduce

1

reduce : (fn: ((a, b) => a), initial: a, list: List<b>) => a

Combines all elements of a list using a reducer function, starting from the “head”, or left side, of the list.

In List.reduce(fn, initial, list), fn is called with an accumulator and each element of the list, and returns a new accumulator. The final value is the last accumulator returned. The accumulator starts with value initial.

Parameters:

Returns:

Examples:

1

List.reduce((a, b) => a + b, 0, [1, 2, 3]) // 6

List.reduceRight

1

reduceRight : (fn: ((a, b) => b), initial: b, list: List<a>) => b

Combines all elements of a list using a reducer function, starting from the “end”, or right side, of the list.

In List.reduceRight(fn, initial, list), fn is called with each element of the list and an accumulator, and returns a new accumulator. The final value is the last accumulator returned. The accumulator starts with value initial.

Parameters:

Returns:

Examples:

1

List.reduceRight((a, b) => b ++ a, "", ["baz", "bar", "foo"]) // "foobarbaz"

List.map

1

map : (fn: (a => b), list: List<a>) => List<b>

Produces a new list initialized with the results of a mapper function called on each element of the input list.

Parameters:

Returns:

List.mapi

1

mapi : (fn: ((a, Number) => b), list: List<a>) => List<b>

Produces a new list initialized with the results of a mapper function called on each element of the input list and its index.

Parameters:

Returns:

List.flatMap

1

flatMap : (fn: (a => List<b>), list: List<a>) => List<b>

Produces a new list by calling a function on each element of the input list. Each iteration produces an intermediate list, which are all appended to produce a “flattened” list of all results.

Parameters:

Returns:

List.every

1

every : (fn: (a => Bool), list: List<a>) => Bool

Checks that the given condition is satisfied for all elements in the input list.

Parameters:

Returns:

List.some

1

some : (fn: (a => Bool), list: List<a>) => Bool

Checks that the given condition is satisfied at least once by an element in the input list.

Parameters:

Returns:

List.forEach

1

forEach : (fn: (a => Void), list: List<a>) => Void

Iterates a list, calling an iterator function on each element.

Parameters:

List.forEachi

1

forEachi : (fn: ((a, Number) => Void), list: List<a>) => Void

Iterates a list, calling an iterator function on each element. Also passes the index as the second argument to the function.

Parameters:

List.filter

1

filter : (fn: (a => Bool), list: List<a>) => List<a>

Produces a new list by calling a function on each element of the input list and only including it in the result list if the element satisfies the condition.

Parameters:

Returns:

List.filteri

1

filteri : (fn: ((a, Number) => Bool), list: List<a>) => List<a>

Produces a new list by calling a function on each element of the input list and only including it in the result list if the element satisfies the condition. Also passes the index to the function.

Parameters:

Returns:

List.reject

1

reject : (fn: (a => Bool), list: List<a>) => List<a>

Produces a new list by calling a function on each element of the input list and excluding it from the result list if the element satisfies the condition.

Parameters:

Returns:

List.head

1

head : (list: List<a>) => Option<a>

Provides Some(element) containing the first element, or “head”, of the input list or None if the list is empty.

Parameters:

Returns:

List.tail

1

tail : (list: List<a>) => Option<List<a>>

Provides Some(tail) containing all list items except the first element, or “tail”, of the input list or None if the list is empty.

Parameters:

Returns:

List.nth

1

nth : (index: Number, list: List<a>) => Option<a>

Provides Some(element) containing the element in the list at the specified index or None if the index is out-of-bounds or the list is empty.

Parameters:

Returns:

List.flatten

1

flatten : (list: List<List<a>>) => List<a>

Flattens nested lists.

Parameters:

Returns:

Examples:

1

List.flatten([[1, 2], [3, 4]]) // [1, 2, 3, 4]

List.insert

1

insert : (index: Number, value: a, list: List<a>) => List<a>

Inserts a new value into a list at the specified index.

Parameters:

Returns:

Throws:

Failure(String)

• When index is negative
• When index is more than 0 and greater than the list size

List.count

1

count : (fn: (a => Bool), list: List<a>) => Number

Counts the number of elements in a list that satisfy the given condition.

Parameters:

Returns:

List.part

1

part : (count: Number, list: List<a>) => (List<a>, List<a>)

Split a list into two, with the first list containing the required number of elements.

Parameters:

Returns:

Throws:

Failure(String)

• When count is negative
• When the list doesn’t contain at least the required amount of elements

List.rotate

1

rotate : (n: Number, list: List<a>) => List<a>

Rotates list elements by the specified amount to the left, such that nth element is the first in the new list.

If value is negative, list elements will be rotated by the specified amount to the right. See examples.

Parameters:

Examples:

1

List.rotate(2, [1, 2, 3, 4, 5]) // [3, 4, 5, 1, 2]

1

List.rotate(-1, [1, 2, 3, 4, 5]) // [5, 1, 2, 3, 4]

1

List.rotate(-7, [1, 2, 3, 4, 5]) // [4, 5, 1, 2, 3]

List.unique

1

unique : (list: List<a>) => List<a>

Produces a new list with any duplicates removed. Uses the generic == structural equality operator.

Parameters:

Returns:

List.zip

1

zip : (list1: List<a>, list2: List<b>) => List<(a, b)>

Produces a new list filled with tuples of elements from both given lists. The first tuple will contain the first item of each list, the second tuple will contain the second item of each list, and so on.

Calling this function with lists of different sizes will cause the returned list to have the length of the smaller list.

Parameters:

Returns:

Examples:

1

List.zip([1, 2, 3], [4, 5, 6]) // [(1, 4), (2, 5), (3, 6)]

1

List.zip([1, 2, 3], [4, 5]) // [(1, 4), (2, 5)]

List.zipWith

1

zipWith : (fn: ((a, b) => c), list1: List<a>, list2: List<b>) => List<c>

Produces a new list filled with elements defined by applying a function on pairs from both given lists. The first element will contain the result of applying the function to the first elements of each list, the second element will contain the result of applying the function to the second elements of each list, and so on.

Calling this function with lists of different sizes will cause the returned list to have the length of the smaller list.

Parameters:

Returns:

Examples:

1

List.zipWith((a, b) => a + b, [1, 2, 3], [4, 5, 6]) // [5, 7, 9]

1

List.zipWith((a, b) => a * b, [1, 2, 3], [4, 5]) // [4, 10]

List.unzip

1

unzip : (list: List<(a, b)>) => (List<a>, List<b>)

Produces two lists by splitting apart a list of tuples.

Parameters:

Returns:

List.drop

1

drop : (count: Number, list: List<a>) => List<a>

Produces a new list with the specified number of elements removed from the beginning of the input list.

Parameters:

Returns:

Throws:

Failure(String)

• When count is negative

List.dropWhile

1

dropWhile : (fn: (a => Bool), list: List<a>) => List<a>

Produces a new list with the elements removed from the beginning of the input list until they no longer satisfy the given condition. Stops when the predicate function returns false.

Parameters:

Returns:

List.take

1

take : (count: Number, list: List<a>) => List<a>

Produces a new list with–at most—the specified amount elements from the beginning of the input list.

Parameters:

Returns:

Throws:

Failure(String)

• When count is negative

List.takeWhile

1

takeWhile : (fn: (a => Bool), list: List<a>) => List<a>

Produces a new list with elements from the beginning of the input list as long as they satisfy the given condition. Stops when the predicate function returns false.

Parameters:

Returns:

List.find

1

find : (fn: (a => Bool), list: List<a>) => Option<a>

Finds the first element in a list that satifies the given condition.

Parameters:

Returns:

List.findIndex

1

findIndex : (fn: (a => Bool), list: List<a>) => Option<Number>

Finds the first index in a list where the element satifies the given condition.

Parameters:

Returns:

List.product

1

product : (list1: List<a>, list2: List<b>) => List<(a, b)>

Combines two lists into a Cartesian product of tuples containing all ordered pairs (a, b).

Parameters:

Returns:

List.sub

1

sub : (start: Number, length: Number, list: List<a>) => List<a>

Provides the subset of a list given zero-based start index and amount of elements to include.

Parameters:

Returns:

Throws:

Failure(String)

• When start is negative
• When length is negative

List.join

1

join : (separator: String, list: List<String>) => String

Combine the given list of strings into one string with the specified separator inserted between each item.

Parameters:

Returns:

List.revAppend

1

revAppend : (list1: List<a>, list2: List<a>) => List<a>

Reverses the first list and appends the second list to the end.

Parameters:

Returns:

List.sort

1

sort : (?compare: ((num1: a, num2: a) => Number), list: List<a>) => List<a>

Sorts the given list based on a given comparator function. The resulting list is sorted in increasing order.

Ordering is calculated using a comparator function which takes two list elements and must return 0 if both are equal, a positive number if the first is greater, and a negative number if the first is smaller.

Parameters:

Returns: