Array

Fast immutable arrays. The elements in an array must have the same type.

Arrays

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

Instances

Eq a => Eq (Array a)

Defined in Array

Methods

(==) :: Array a -> Array a -> Bool

(/=) :: Array a -> Array a -> Bool

Show a => Show (Array a)

Defined in Array

Methods

showsPrec :: Int -> Array a -> ShowS

show :: Array a -> String

showList :: [Array a] -> ShowS

Creation

empty :: Array a

Return an empty array.

length empty == 0

initialize :: Int -> (Int -> a) -> Array a

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]

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

fromList :: List a -> Array a

Create an array from a List.

Query

isEmpty :: Array a -> Bool

Determine if an array is empty.

isEmpty empty == True

length :: Array a -> Int

Return the length of an array.

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

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,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

Manipulate

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.

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

push :: a -> Array a -> Array a

Push an element onto 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]

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

Lists

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")]

Transform

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]

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

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]

filter :: (a -> Bool) -> Array a -> Array a

Keep elements that pass the test.

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