nri-prelude-0.6.0.6: A Prelude inspired by the Elm programming language
Safe HaskellNone
LanguageHaskell2010

Array

Description

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

Synopsis

Arrays

data Array a Source #

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

Instances details
Eq a => Eq (Array a) Source # 
Instance details

Defined in Array

Methods

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

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

Show a => Show (Array a) Source # 
Instance details

Defined in Array

Methods

showsPrec :: Int -> Array a -> ShowS #

show :: Array a -> String #

showList :: [Array a] -> ShowS #

Creation

empty :: Array a Source #

Return an empty array.

length empty == 0

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

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 Source #

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 Source #

Create an array from a List.

Query

isEmpty :: Array a -> Bool Source #

Determine if an array is empty.

isEmpty empty == True

length :: Array a -> Int Source #

Return the length of an array.

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

get :: Int -> Array a -> Maybe a Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

Create a list of elements from an array.

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

toIndexedList :: Array a -> List (Int, a) Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

Keep elements that pass the test.

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