Representation of fast immutable arrays. You can create arrays of integers (Array Int) or strings (Array String) or any other type of value you can dream up.

Return an empty array.

length empty == 0

Initialize an array. initialize n f creates an array of length n with the element at index i initialized to the result of (f i).

initialize 4 identity    == fromList [0,1,2,3]
initialize 4 (\n -> n*n) == fromList [0,1,4,9]
initialize 4 (always 0)  == fromList [0,0,0,0]

Creates an array with a given length, filled with a default element.

repeat 5 0     == fromList [0,0,0,0,0]
repeat 3 "cat" == fromList ["cat","cat","cat"]

Notice that repeat 3 x is the same as initialize 3 (always x).

Create an array from a list.

Determine if an array is empty.

isEmpty empty == True

Return the length of an array.

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

Return Just the element at the index or Nothing if the index is out of range.

get  0 (fromList [0,1,2]) == Just 0
get  2 (fromList [0,1,2]) == Just 2
get  5 (fromList [0,1,2]) == Nothing
get -1 (fromList [0,1,2]) == Nothing

Set the element at a particular index. Returns an updated array. If the index is out of range, the array is unaltered.

set 1 7 (fromList [1,2,3]) == fromList [1,7,3]

Push an element onto the end of an array.

push 3 (fromList [1,2]) == fromList [1,2,3]

Append one array onto another one.

append (repeat 2 42) (repeat 3 81) == fromList [42,42,81,81,81]

Get a sub-section of an array: (slice start end array). The start is a zero-based index where we will start our slice. The end is a zero-based index that indicates the end of the slice. The slice extracts up to but not including end.

slice  0  3 (fromList [0,1,2,3,4]) == fromList [0,1,2]
slice  1  4 (fromList [0,1,2,3,4]) == fromList [1,2,3]

Both the start and end indexes can be negative, indicating an offset from the end of the array.

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

This makes it pretty easy to pop the last element off of an array: slice 0 -1 array

Create a list of elements from an array.

toList (fromList [3,5,8]) == [3,5,8]

Create an indexed list from an array. Each element of the array will be paired with its index.

toIndexedList (fromList ["cat","dog"]) == [(0,"cat"), (1,"dog")]

Reduce an array from the left. Read foldl as fold from the left.

foldl (::) [] (fromList [1,2,3]) == [3,2,1]

Reduce an array from the right. Read foldr as fold from the right.

foldr (+) 0 (repeat 3 5) == 15

Keep only elements that satisfy the predicate.

filter isEven (fromList [1..6]) == (fromList [2,4,6])

Apply a function on every element in an array.

map sqrt (fromList [1,4,9]) == fromList [1,2,3]

Apply a function on every element with its index as first argument.

indexedMap (*) (fromList [5,5,5]) == fromList [0,5,10]

Return the array represented as a string (toString <| Array.fromList [1,2,3]) == "Array [1,2,3]"