The elements in an array must have the same type.
type Array a
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.
empty : Array a
Return an empty array.
repeat : Int -> a -> Array a
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).
initialize : Int -> (Int -> a) -> Array a
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]
fromList : List a -> Array a
isEmpty : Array a -> Bool
length : Array a -> Int
push : a -> Array a -> Array a
Push an element to the end of an array.
push 3 (fromList [1,2]) == fromList [1,2,3]
append : Array a -> Array a -> Array a
Append two arrays to a new one.
append (repeat 2 42) (repeat 3 81) == fromList [42,42,81,81,81]
get : Int -> Array a -> Maybe a
Return Just the element at the index or Nothing if the index is out of range.
get 0 (fromList [0,5,3]) == Just 0 get 2 (fromList [0,5,3]) == Just 3 get 5 (fromList [0,5,3]) == Nothing get -1 (fromList [0,5,3]) == Nothing
set : Int -> a -> Array a -> Array a
Set the element at a particular index. Returns an updated array. If the index is out of range, the array is unaltered.
slice : Int -> Int -> Array a -> Array a
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
toList : Array a -> List a
Create a list of elements from an array.
toList (fromList [3,5,8]) == [3,5,8]
toIndexedList : Array a -> List (Int, a)
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")]
map : (a -> b) -> Array a -> Array b
Apply a function on every element in an array.
map sqrt (fromList [1,4,9]) == fromList [1,2,3]
indexedMap : (Int -> a -> b) -> Array a -> Array b
Apply a function on every element with its index as first argument.
indexedMap (*) (fromList [5,5,5]) == fromList [0,5,10]
filter : (a -> Bool) -> Array a -> Array a
Keep only elements that satisfy the predicate:
filter isEven (fromList [1,2,3,4,5,6]) == (fromList [2,4,6])
foldl : (a -> b -> b) -> b -> Array a -> b
Reduce an array from the left. Read foldl as “fold from the left”.
foldl (::)  (fromList [1,2,3]) == [3,2,1]
foldr : (a -> b -> b) -> b -> Array a -> b
Reduce an array from the right. Read foldr as “fold from the right”.
foldr (+) 0 (repeat 3 5) == 15