ImmutableArray

An immutable array implementation, providing fast arbitrary lookups and modifications.

1

import ImmutableArray from "immutablearray"

Types

Type declarations included in the ImmutableArray module.

ImmutableArray.ImmutableArray

1

type ImmutableArray<a>

Values

Functions and constants for working with immutable arrays.

ImmutableArray.empty

1

empty : ImmutableArray<a>

An empty array.

ImmutableArray.isEmpty

1

isEmpty : ImmutableArray<a> -> Bool

Determines if the array contains no elements.

Parameters:

Returns:

ImmutableArray.length

1

length : ImmutableArray<a> -> Number

Provides the length of the input array.

Parameters:

Returns:

Examples:

1

length(fromList([1, 2, 3, 4, 5])) == 5

ImmutableArray.get

1

get : (Number, ImmutableArray<a>) -> a

Retrieves the element from the array at the specified index. A negative index is treated as an offset from the end of the array.

Parameters:

Returns:

Throws:

IndexOutOfBounds

• When the index being accessed is outside the array’s bounds

Examples:

1

get(1, fromList([1, 2, 3, 4])) == 2

1

get(-1, fromList([1, 2, 3, 4])) == 4

ImmutableArray.set

1

set : (Number, a, ImmutableArray<a>) -> ImmutableArray<a>

Creates a new array in which the element at the specified index is set to a new value. A negative index is treated as an offset from the end of the array.

Parameters:

Returns:

Throws:

IndexOutOfBounds

• When the index being updated is outside the array’s bounds

Examples:

1

set(1, 9, fromList([1, 2, 3, 4, 5])) == fromList([1, 9, 3, 4, 5])

ImmutableArray.append

1

append : (ImmutableArray<a>, ImmutableArray<a>) -> ImmutableArray<a>

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

Parameters:

Returns:

Examples:

1

append(fromList([1, 2]), fromList([3, 4, 5])) == fromList([1, 2, 3, 4, 5])

ImmutableArray.concat

1

concat : List<ImmutableArray<a>> -> ImmutableArray<a>

Creates a single array containing the elements of all arrays in the provided list.

Parameters:

Returns:

Examples:

1

concat([fromList([1, 2]), fromList([3, 4]), fromList([5, 6])]) == fromList([1, 2, 3, 4, 5, 6])

ImmutableArray.init

1

init : (Number, (Number -> a)) -> ImmutableArray<a>

Creates a new array 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 array element.

Parameters:

Returns:

Examples:

1

init(5, i => i + 3) == fromList([3, 4, 5, 6, 7])

ImmutableArray.make

1

make : (Number, a) -> ImmutableArray<a>

Creates a new array of the specified length with each element being initialized with the given value.

Parameters:

Returns:

Examples:

1

make(5, "foo") == fromList(["foo", "foo", "foo", "foo", "foo"])

ImmutableArray.forEach

1

forEach : ((a -> Void), ImmutableArray<a>) -> Void

Iterates an array, calling an iterator function on each element.

Parameters:

ImmutableArray.cycle

1

cycle : ((a -> Void), Number, ImmutableArray<a>) -> Void

Iterates an array a given number of times, calling an iterator function on each element.

Parameters:

ImmutableArray.map

1

map : ((a -> b), ImmutableArray<a>) -> ImmutableArray<b>

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

Parameters:

Returns:

ImmutableArray.reduce

1

reduce : (((a, b) -> a), a, ImmutableArray<b>) -> a

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

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

Parameters:

Returns:

Examples:

1

reduce((acc, x) => acc + x, 0, fromList([1, 2, 3])) == 6

ImmutableArray.reduceRight

1

reduceRight : (((a, b) -> b), b, ImmutableArray<a>) -> b

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

In ImmutableArray.reduceRight(fn, initial, array), fn is called with each element of the array 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

reduceRight((x, acc) => acc ++ x, "", fromList(["baz", "bar", "foo"])) == "foobarbaz"

ImmutableArray.flatMap

1

flatMap : ((a -> ImmutableArray<b>), ImmutableArray<a>) -> ImmutableArray<b>

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

Parameters:

Returns:

Examples:

1

flatMap(n => fromList([n, n + 1]), fromList([1, 3, 5])) == fromList([1, 2, 3, 4, 5, 6])

ImmutableArray.fromList

1

fromList : List<a> -> ImmutableArray<a>

Converts the input list to an array.

Parameters:

Returns:

ImmutableArray.toList

1

toList : ImmutableArray<a> -> List<a>

Converts the input array to a list.

Parameters:

Returns:

ImmutableArray.filter

1

filter : ((a -> Bool), ImmutableArray<a>) -> ImmutableArray<a>

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

Parameters:

Returns:

ImmutableArray.every

1

every : ((a -> Bool), ImmutableArray<a>) -> Bool

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

Parameters:

Returns:

ImmutableArray.some

1

some : ((a -> Bool), ImmutableArray<a>) -> Bool

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

Parameters:

Returns:

ImmutableArray.reverse

1

reverse : ImmutableArray<a> -> ImmutableArray<a>

Creates a new array with all elements in reverse order.

Parameters:

Returns:

ImmutableArray.contains

1

contains : (a, ImmutableArray<a>) -> Bool

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

Parameters:

Returns:

ImmutableArray.find

1

find : ((a -> Bool), ImmutableArray<a>) -> Option<a>

Finds the first element in an array that satifies the given condition.

Parameters:

Returns:

ImmutableArray.findIndex

1

findIndex : ((a -> Bool), ImmutableArray<a>) -> Option<Number>

Finds the first index in an array where the element satifies the given condition.

Parameters:

Returns:

ImmutableArray.product

1

product : (ImmutableArray<a>, ImmutableArray<b>) -> ImmutableArray<(a, b)>

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

Parameters:

Returns:

ImmutableArray.count

1

count : ((a -> Bool), ImmutableArray<a>) -> Number

Counts the number of elements in an array that satisfy the given condition.

Parameters:

Returns:

ImmutableArray.unique

1

unique : ImmutableArray<a> -> ImmutableArray<a>

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

Parameters:

Returns:

ImmutableArray.zip

1

zip : (ImmutableArray<a>, ImmutableArray<b>) -> ImmutableArray<(a, b)>

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

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

Parameters:

Returns:

ImmutableArray.zipWith

1
2

zipWith :
  (((a, b) -> c), ImmutableArray<a>, ImmutableArray<b>) -> ImmutableArray<c>

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

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

Parameters:

Returns:

Examples:

1

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

1

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

ImmutableArray.unzip

1

unzip : ImmutableArray<(a, b)> -> (ImmutableArray<a>, ImmutableArray<b>)

Produces two arrays by splitting apart an array of tuples.

Parameters:

Returns:

ImmutableArray.join

1

join : (String, ImmutableArray<String>) -> String

Concatenates an array of strings into a single string, separated by a separator string.

Parameters:

Returns:

ImmutableArray.slice

1

slice : (Number, Number, ImmutableArray<a>) -> ImmutableArray<a>

Slices an array given zero-based start and end indexes. The value at the end index will not be included in the result.

If either index is a negative number, it will be treated as a reverse index from the end of the array.

Parameters:

Returns:

Examples:

1

slice(0, 2, fromList(['a', 'b', 'c'])) == fromList(['a', 'b'])

1

slice(1, -1, fromList(['a', 'b', 'c'])) == fromList(['b'])

ImmutableArray.sort

1

sort : (((a, a) -> Number), ImmutableArray<a>) -> ImmutableArray<a>

Sorts the given array based on a given comparator function.

Ordering is calculated using a comparator function which takes two array 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:

ImmutableArray.rotate

1

rotate : (Number, ImmutableArray<a>) -> ImmutableArray<a>

Rotates array elements by the specified amount to the left.

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

Parameters:

Examples:

1

rotate(2, fromList([1, 2, 3, 4, 5])) == fromList([3, 4, 5, 1, 2])

1

rotate(-1, fromList([1, 2, 3, 4, 5])) == fromList([5, 1, 2, 3, 4])