|
| Data.Array.MArray | | Portability | non-portable | | Stability | experimental | | Maintainer | libraries@haskell.org |
|
|
|
|
| Contents |
- Class of mutable array types
- Class of array types with bounds
- The Ix class and operations
- Constructing mutable arrays
- Reading and writing mutable arrays
- Derived arrays
- Deconstructing mutable arrays
- Conversions between mutable and immutable arrays
|
|
| Description |
| An overloaded interface to mutable arrays. For array types which can be
used with this interface, see Data.Array.IO, Data.Array.ST,
and Data.Array.Storable.
|
|
| Synopsis |
|
| class (HasBounds a, Monad m) => MArray a e m | | | class HasBounds a | | | module Data.Ix | | | newArray :: (MArray a e m, Ix i) => (i, i) -> e -> m (a i e) | | | newArray_ :: (MArray a e m, Ix i) => (i, i) -> m (a i e) | | | newListArray :: (MArray a e m, Ix i) => (i, i) -> [e] -> m (a i e) | | | readArray :: (MArray a e m, Ix i) => a i e -> i -> m e | | | writeArray :: (MArray a e m, Ix i) => a i e -> i -> e -> m () | | | mapArray :: (MArray a e' m, MArray a e m, Ix i) => (e' -> e) -> a i e' -> m (a i e) | | | mapIndices :: (MArray a e m, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> m (a i e) | | | bounds :: (HasBounds a, Ix i) => a i e -> (i, i) | | | indices :: (HasBounds a, Ix i) => a i e -> [i] | | | getElems :: (MArray a e m, Ix i) => a i e -> m [e] | | | getAssocs :: (MArray a e m, Ix i) => a i e -> m [(i, e)] | | | freeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) | | | unsafeFreeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) | | | thaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) | | | unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) |
|
|
|
| Class of mutable array types |
|
| class (HasBounds 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.
| | | Instances | |
|
|
| Class of array types with bounds |
|
| class HasBounds a |
| Class of array types with bounds | | | Instances | |
|
|
| The Ix class and operations |
|
| module Data.Ix |
|
| Constructing mutable arrays |
|
| newArray :: (MArray a e m, Ix i) => (i, i) -> e -> m (a i e) |
| Builds a new array, with every element initialised to the supplied
value. |
|
| newArray_ :: (MArray a e m, Ix i) => (i, i) -> m (a i e) |
| Builds a new array, with every element initialised to undefined. |
|
| newListArray :: (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. |
|
| Reading and writing mutable arrays |
|
| readArray :: (MArray a e m, Ix i) => a i e -> i -> m e |
| Read an element from a mutable array |
|
| writeArray :: (MArray a e m, Ix i) => a i e -> i -> e -> m () |
| Write an element in a mutable array |
|
| Derived arrays |
|
| mapArray :: (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. |
|
| mapIndices :: (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. |
|
| Deconstructing mutable arrays |
|
| bounds :: (HasBounds a, Ix i) => a i e -> (i, i) |
| Extracts the bounds of an array |
|
| indices :: (HasBounds a, Ix i) => a i e -> [i] |
| Returns a list of all the valid indices in an array. |
|
| getElems :: (MArray a e m, Ix i) => a i e -> m [e] |
| Return a list of all the elements of a mutable array |
|
| getAssocs :: (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. |
|
| Conversions between mutable and immutable arrays |
|
| freeze :: (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. |
|
| unsafeFreeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) |
| Converts a mutable array to an immutable array without taking a
copy. This function is "unsafe" because if any further
modifications are made to the original mutable array then they will
be shared with the immutable version. It is safe to use,
therefore, if the mutable version is never modified after the
freeze operation. |
|
| thaw :: (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. |
|
| unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) |
| Converts an immutable array into a mutable array without taking
a copy. This function is "unsafe" because any subsequent
modifications made to the mutable version of the array will be
shared with the immutable version. It is safe to use, therefore, if
the immutable version is never referenced again. |
|
| Produced by Haddock version 0.4 |
