Portability  nonportable (uses Data.Array.Base) 

Stability  experimental 
Maintainer  libraries@haskell.org 
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.
 class Monad m => MArray a e m where
 module Data.Ix
 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)
 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 Monad m => MArray a e m whereSource
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.
getBounds :: Ix i => a i e > m (i, i)Source
Returns the bounds of the array
newArray :: Ix i => (i, i) > e > m (a i e)Source
Builds a new array, with every element initialised to the supplied value.
newArray_ :: Ix i => (i, i) > m (a i e)Source
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 Ix
class and operations
module Data.Ix
Constructing mutable arrays
newListArray :: (MArray a e m, Ix i) => (i, i) > [e] > m (a i e)Source
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
writeArray :: (MArray a e m, Ix i) => a i e > i > e > m ()Source
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)Source
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)Source
Constructs a new array derived from the original array by applying a function to each of the indices.
Deconstructing mutable arrays
getElems :: (MArray a e m, Ix i) => a i e > m [e]Source
Return a list of all the elements of a mutable array
getAssocs :: (MArray a e m, Ix i) => a i e > m [(i, e)]Source
Return a list of all the associations of a mutable array, in index order.
Conversions between mutable and immutable arrays
unsafeFreeze :: (Ix i, MArray a e m, IArray b e) => a i e > m (b i e)Source
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 noncopying 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 noncopying O(1) implementation of
unsafeFreeze
. Because the optimised versions are enabled by
specialisations, you will need to compile with optimisation (O) to
get them.

Data.Array.IO.IOUArray
>Data.Array.Unboxed.UArray

Data.Array.ST.STUArray
>Data.Array.Unboxed.UArray

Data.Array.IO.IOArray
>Data.Array.Array

Data.Array.ST.STArray
>Data.Array.Array
unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e > m (b i e)Source
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 multithreaded 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 noncopying 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 noncopying O(1) implementation of
unsafeThaw
. Because the optimised versions are enabled by
specialisations, you will need to compile with optimisation (O) to
get them.

Data.Array.Unboxed.UArray
>Data.Array.IO.IOUArray

Data.Array.Unboxed.UArray
>Data.Array.ST.STUArray

Data.Array.Array
>Data.Array.IO.IOArray

Data.Array.Array
>Data.Array.ST.STArray