Data.Array.Base
Maintainer : libraries@haskell.org
Stability : experimental
Portability : non-portable (MPTCs, uses Control.Monad.ST)
Basis for IArray and MArray. Not intended for external consumption;
use IArray or MArray instead.
WARNING
This module is considered internal.
The Package Versioning Policy does not apply.
The contents of this module may change in any way whatsoever
and without any warning between minor versions of this package.
Authors importing this module are expected to track development
closely.
IArray a e
Class of immutable array types.
An array type has the form (a i e) where a is the array type
constructor (kind * -> * -> *), i is the index type (a member of
the class Ix), and e is the element type. The IArray class is
parameterised over both a and e, so that instances specialised to
certain element types can be defined.
Ix i => a i e -> (i, i)
Extracts the bounds of an immutable array
Ix i => a i e -> Int
Ix i => (i, i) -> [(Int, e)] -> a i e
Ix i => a i e -> Int -> e
Ix i => a i e -> [(Int, e)] -> a i e
Ix i => (e -> e' -> e) -> a i e -> [(Int, e')] -> a i e
Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> a i e
Ix i => (i, i) -> Int
Ix i => (i, i) -> Int -> i -> Int
(IArray a e, Ix i) => a i e -> [(Int, e)] -> ST s (STArray s i e)
(IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(Int, e')] -> ST s (STArray s i e)
Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (STArray s i e)
(IArray a e, Ix i) => (i, i) -> [(i, e)] -> a i e
Constructs an immutable array from a pair of bounds and a list of
initial associations.
The bounds are specified as a pair of the lowest and highest bounds in
the array respectively. For example, a one-origin vector of length 10
has bounds (1,10), and a one-origin 10 by 10 matrix has bounds
((1,1),(10,10)).
An association is a pair of the form (i,x), which defines the value of
the array at index i to be x. The array is undefined if any index
in the list is out of bounds. If any two associations in the list have
the same index, the value at that index is implementation-dependent.
(In GHC, the last value specified for that index is used.
Other implementations will also do this for unboxed arrays, but Haskell
98 requires that for Array the value at such indices is bottom.)
Because the indices must be checked for these errors, array is
strict in the bounds argument and in the indices of the association
list. Whether array is strict or non-strict in the elements depends
on the array type: Array is a non-strict array type, but
all of the UArray arrays are strict. Thus in a
non-strict array, recurrences such as the following are possible:
a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i \<- [2..100]])
Not every index within the bounds of the array need appear in the
association list, but the values associated with indices that do not
appear will be undefined.
If, in any dimension, the lower bound is greater than the upper bound,
then the array is legal, but empty. Indexing an empty array always
gives an array-bounds error, but bounds still yields the bounds with
which the array was constructed.
Argument 0bounds of the array: (lowest,highest)
Argument 1list of associations
(IArray a e, Ix i) => (i, i) -> [e] -> a i e
Constructs an immutable array from a list of initial elements.
The list gives the elements of the array in ascending order
beginning with the lowest index.
(IArray a e, Ix i) => (i, i) -> (i -> e) -> a i e
Constructs an immutable array using a generator function.
Ix i => (i, i) -> [e] -> ST s (STArray s i e)
(MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [e] -> ST s (STUArray s i e)
ListUArray e = forall i. Ix i => (i, i) -> [e] -> UArray i e
!function
(IArray a e, Ix i) => a i e -> i -> e
Returns the element of an immutable array at the specified index,
or throws an exception if the index is out of bounds.
!?function
(IArray a e, Ix i) => a i e -> i -> Maybe e
Returns Just the element of an immutable array at the specified index,
or Nothing if the index is out of bounds.
(IArray a e, Ix i) => a i e -> [i]
Returns a list of all the valid indices in an array.
(IArray a e, Ix i) => a i e -> [e]
Returns a list of all the elements of an array, in the same order
as their indices.
(IArray a e, Ix i) => a i e -> [(i, e)]
Returns the contents of an array as a list of associations.
(IArray a e, Ix i) => (e -> e' -> e) -> e -> (i, i) -> [(i, e')] -> a i e
Constructs an immutable array from a list of associations. Unlike
array, the same index is allowed to occur multiple times in the list
of associations; an accumulating function is used to combine the
values of elements with the same index.
For example, given a list of values of some index type, hist produces
a histogram of the number of occurrences of each index within a
specified range:
hist :: (Ix a, Num b) => (a,a) -> [a] -> Array a b
hist bnds is = accumArray (+) 0 bnds [(i, 1) | i\<-is, inRange bnds i]
Returns: the array
Argument 0An accumulating function
Argument 1A default element
Argument 2The bounds of the array
Argument 3List of associations
//function
(IArray a e, Ix i) => a i e -> [(i, e)] -> a i e
Takes an array and a list of pairs and returns an array identical to
the left argument except that it has been updated by the associations
in the right argument. For example, if m is a 1-origin, n by n matrix,
then m//[((i,i), 0) | i <- [1..n]] is the same matrix, except with
the diagonal zeroed.
As with the array function, if any two associations in the list have
the same index, the value at that index is implementation-dependent.
(In GHC, the last value specified for that index is used.
Other implementations will also do this for unboxed arrays, but Haskell
98 requires that for Array the value at such indices is bottom.)
For most array types, this operation is O(n) where n is the size
of the array. However, the diffarray package provides an array type
for which this operation has complexity linear in the number of updates.
(IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(i, e')] -> a i e
accum f takes an array and an association list and accumulates pairs
from the list into the array with the accumulating function f. Thus
accumArray can be defined using accum:
accumArray f z b = accum f (array b [(i, z) | i \<- range b])
(IArray a e', IArray a e, Ix i) => (e' -> e) -> a i e' -> a i e
Returns a new array derived from the original array by applying a
function to each of the elements.
(IArray a e, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> a i e
Returns a new array derived from the original array by applying a
function to each of the indices.
(IArray a e, Ix i) => (e -> b -> b) -> b -> a i e -> b
Lazy right-associative fold.
(IArray a e, Ix i) => (b -> e -> b) -> b -> a i e -> b
Strict accumulating left-associative fold.
(IArray a e, Ix i) => (b -> e -> b) -> b -> a i e -> b
Lazy left-associative fold.
(IArray a e, Ix i) => (e -> b -> b) -> b -> a i e -> b
Strict accumulating right-associative fold.
(IArray a e, Ix i, Applicative f) => (e -> f b) -> a i e -> f ()
Map elements to applicative actions, sequence them left-to-right, and
discard the results.
(IArray a e, Ix i, Applicative f) => a i e -> (e -> f b) -> f ()
forArray_ is traverseArray_ with its arguments flipped.
(IArray a e, Ix i, Monad m) => (b -> e -> m b) -> b -> a i e -> m b
Strict accumulating left-associative monadic fold.
(IArray a e, Ix i, Monad m) => (e -> b -> m b) -> b -> a i e -> m b
Strict accumulating right-associative monadic fold.
UArray i e
Arrays with unboxed elements. Instances of IArray are provided
for UArray with certain element types (Int, Float, Char,
etc.; see the UArray class for a full list).
A UArray will generally be more efficient (in terms of both time
and space) than the equivalent Array with the same
element type. However, UArray is strict in its elements - so
don't use UArray if you require the non-strictness that
Array provides.
Because the IArray interface provides operations overloaded on
the type of the array, it should be possible to just change the
array type being used by a program from say Array to UArray to
get the benefits of unboxed arrays (don't forget to import
Data.Array.Unboxed instead of Data.Array).
i -> i -> Int -> ByteArray# -> UArray i e
(MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
STUArray s i e -> ST s (UArray i e)
(MArray (STUArray s) e (ST s), Ix i) => UArray i e -> [(Int, e)] -> ST s (UArray i e)
(MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
(MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
(IArray UArray e, Ix i, Eq e) => UArray i e -> UArray i e -> Bool
(IArray UArray e, Ix i, Ord e) => UArray i e -> UArray i e -> Ordering
(IArray UArray e, Ord e) => UArray Int e -> UArray Int e -> Ordering
(IArray a e, Ix i, Show i, Show e) => Int -> a i e -> ShowS
(IArray a e, Ix i, Read i, Read e) => ReadPrec (a i e)
StablePtr a
a
(Monad m) => MArray a e m
Class of mutable array types.
An array type has the form (a i e) where a is the array type
constructor (kind * -> * -> *), i is the index type (a member of
the class Ix), and e is the element type.
The MArray class is parameterised over both a and e (so that
instances specialised to certain element types can be defined, in the
same way as for IArray), and also over the type of the monad, m,
in which the mutable array will be manipulated.
Ix i => a i e -> m (i, i)
Returns the bounds of the array (lowest,highest).
Ix i => a i e -> m Int
Returns the number of elements in the array.
Ix i => (i, i) -> e -> m (a i e)
Builds a new array, with every element initialised to the supplied
value. The first and second element of the tuple specifies the lowest
and highest index, respectively.
Ix i => (i, i) -> m (a i e)
Builds a new array, with every element initialised to an
undefined value. In a monadic context in which operations must
be deterministic (e.g. the ST monad), the array elements are
initialised to a fixed but undefined value, such as zero.
The first and second element of the tuple specifies the lowest
and highest index, respectively.
Ix i => (i, i) -> m (a i e)
Builds a new array, with every element initialised to an undefined
value. The first and second element of the tuple specifies the lowest
and highest index, respectively.
Ix i => a i e -> Int -> m e
Ix i => a i e -> Int -> e -> m ()
(MArray a e m, Ix i) => (i, i) -> [e] -> m (a i e)
Constructs a mutable array from a list of initial elements.
The list gives the elements of the array in ascending order
beginning with the lowest index. The first and second element
of the tuple specifies the lowest and highest index, respectively.
(MArray a e m, Ix i) => (i, i) -> (i -> m e) -> m (a i e)
Constructs a mutable array using a generator function.
It invokes the generator function in ascending order of the indices.
(MArray a e m, Ix i) => a i e -> i -> m e
Read an element from a mutable array
(MArray a e m, Ix i) => a i e -> i -> e -> m ()
Write an element in a mutable array
(MArray a e m, Ix i) => a i e -> i -> (e -> e) -> m ()
Modify an element in a mutable array
(MArray a e m, Ix i) => a i e -> i -> (e -> e) -> m ()
Modify an element in a mutable array. Strict in the written element.
(MArray a e m, Ix i) => a i e -> m [e]
Return a list of all the elements of a mutable array
(MArray a e m, Ix i) => a i e -> m [(i, e)]
Return a list of all the associations of a mutable array, in
index order.
(MArray a e' m, MArray a e m, Ix i) => (e' -> e) -> a i e' -> m (a i e)
Constructs a new array derived from the original array by applying a
function to each of the elements.
(MArray a e m, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> m (a i e)
Constructs a new array derived from the original array by applying a
function to each of the indices.
(MArray a e m, Ix i) => (b -> e -> b) -> b -> a i e -> m b
Strict accumulating left-associative fold.
(MArray a e m, Ix i) => (e -> b -> b) -> b -> a i e -> m b
Strict accumulating right-associative fold.
(MArray a e m, Ix i) => (b -> e -> m b) -> b -> a i e -> m b
Strict accumulating left-associative monadic fold.
(MArray a e m, Ix i) => (e -> b -> m b) -> b -> a i e -> m b
Strict accumulating right-associative monadic fold.
(MArray a e m, Ix i) => (e -> m b) -> a i e -> m ()
Map elements to monadic actions, sequence them left-to-right, and discard
the results.
(MArray a e m, Ix i) => a i e -> (e -> m b) -> m ()
forMArrayM_ is mapMArrayM_ with its arguments flipped.
STUArray s i e
A mutable array with unboxed elements, that can be manipulated in
the ST monad. The type arguments are as follows:
An STUArray will generally be more efficient (in terms of both time
and space) than the equivalent boxed version (STArray) with the same
element type. However, STUArray is strict in its elements - so
don't use STUArray if you require the non-strictness that
STArray provides.
i -> i -> Int -> (MutableByteArray# s) -> STUArray s i e
Ix i => (i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
Int# -> Int#
Int# -> Int#
Int# -> Int#
Int# -> Int#
Int# -> Int# -> Int#
Int# -> Int#
The index of the word which the given Bool array elements falls within.
Int# -> Word#
Int# -> Word#
(Ix i, MArray a e m, IArray b e) => a i e -> m (b i e)
Converts a mutable array (any instance of MArray) to an
immutable array (any instance of IArray) by taking a complete
copy of it.
STUArray s i e -> ST s (UArray i e)
MutableByteArray# s -> MutableByteArray# s -> CSize -> IO (Ptr a)
(Ix i, MArray a e m, IArray b e) => a i e -> m (b i e)
Converts an mutable array into an immutable array. The
implementation may either simply cast the array from
one type to the other without copying the array, or it
may take a full copy of the array.
Note that because the array is possibly not copied, any subsequent
modifications made to the mutable version of the array may be
shared with the immutable version. It is safe to use, therefore, if
the mutable version is never modified after the freeze operation.
The non-copying implementation is supported between certain pairs
of array types only; one constraint is that the array types must
have identical representations. In GHC, The following pairs of
array types have a non-copying O(1) implementation of
unsafeFreeze. Because the optimised versions are enabled by
specialisations, you will need to compile with optimisation (-O) to
get them.
(Ix i, IArray a e, MArray b e m) => a i e -> m (b i e)
Converts an immutable array (any instance of IArray) into a
mutable array (any instance of MArray) by taking a complete copy
of it.
UArray i e -> ST s (STUArray s i e)
MutableByteArray# s -> ByteArray# -> CSize -> IO (Ptr a)
(Ix i, IArray a e, MArray b e m) => a i e -> m (b i e)
Converts an immutable array into a mutable array. The
implementation may either simply cast the array from
one type to the other without copying the array, or it
may take a full copy of the array.
Note that because the array is possibly not copied, any subsequent
modifications made to the mutable version of the array may be
shared with the immutable version. It is only safe to use,
therefore, if the immutable array is never referenced again in this
thread, and there is no possibility that it can be also referenced
in another thread. If you use an unsafeThawwriteunsafeFreeze
sequence in a multi-threaded setting, then you must ensure that
this sequence is atomic with respect to other threads, or a garbage
collector crash may result (because the write may be writing to a
frozen array).
The non-copying implementation is supported between certain pairs
of array types only; one constraint is that the array types must
have identical representations. In GHC, The following pairs of
array types have a non-copying O(1) implementation of
unsafeThaw. Because the optimised versions are enabled by
specialisations, you will need to compile with optimisation (-O) to
get them.
UArray i e -> ST s (STUArray s i e)
Arr.Array ix e -> IO (IOArray ix e)
Arr.Array ix e -> IO (IOArray ix e)
IOArray ix e -> IO (Arr.Array ix e)
IOArray ix e -> IO (Arr.Array ix e)
STUArray s ix a -> ST s (STUArray s ix b)
Casts an STUArray with one element type into one with a
different element type. All the elements of the resulting array
are undefined (unless you know what you're doing...).
Instances
IArray Arr.Array e
IArray UArray Bool
IArray UArray Char
IArray UArray Int
IArray UArray Word
IArray UArray (Ptr a)
IArray UArray (FunPtr a)
IArray UArray Float
IArray UArray Double
IArray UArray (StablePtr a)
IArray UArray Int8
IArray UArray Int16
IArray UArray Int32
IArray UArray Int64
IArray UArray Word8
IArray UArray Word16
IArray UArray Word32
IArray UArray Word64
(Ix ix, Eq e, IArray UArray e) => Eq (UArray ix e)
(Ix ix, Ord e, IArray UArray e) => Ord (UArray ix e)
(Ix ix, Show ix, Show e, IArray UArray e) => Show (UArray ix e)
(Ix ix, Read ix, Read e, IArray UArray e) => Read (UArray ix e)
MArray IOArray e IO
MArray (STArray s) e (ST s)
MArray (STArray s) e (Lazy.ST s)
Eq (STUArray s i e)
MArray (STUArray s) Bool (ST s)
MArray (STUArray s) Char (ST s)
MArray (STUArray s) Int (ST s)
MArray (STUArray s) Word (ST s)
MArray (STUArray s) (Ptr a) (ST s)
MArray (STUArray s) (FunPtr a) (ST s)
MArray (STUArray s) Float (ST s)
MArray (STUArray s) Double (ST s)
MArray (STUArray s) (StablePtr a) (ST s)
MArray (STUArray s) Int8 (ST s)
MArray (STUArray s) Int16 (ST s)
MArray (STUArray s) Int32 (ST s)
MArray (STUArray s) Int64 (ST s)
MArray (STUArray s) Word8 (ST s)
MArray (STUArray s) Word16 (ST s)
MArray (STUArray s) Word32 (ST s)
MArray (STUArray s) Word64 (ST s)