Safe Haskell | None |
---|---|
Language | Haskell2010 |
Fast immutable arrays. The elements in an array must have the same type.
Synopsis
- data Array a
- empty :: Array a
- initialize :: Int -> (Int -> a) -> Array a
- repeat :: Int -> a -> Array a
- fromList :: List a -> Array a
- isEmpty :: Array a -> Bool
- length :: Array a -> Int
- get :: Int -> Array a -> Maybe a
- set :: Int -> a -> Array a -> Array a
- push :: a -> Array a -> Array a
- append :: Array a -> Array a -> Array a
- slice :: Int -> Int -> Array a -> Array a
- toList :: Array a -> List a
- toIndexedList :: Array a -> List (Int, a)
- map :: (a -> b) -> Array a -> Array b
- indexedMap :: (Int -> a -> b) -> Array a -> Array b
- foldr :: (a -> b -> b) -> b -> Array a -> b
- foldl :: (a -> b -> b) -> b -> Array a -> b
- filter :: (a -> Bool) -> Array a -> Array a
Arrays
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.
Creation
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)
.
Query
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