array-0.5.1.0: Mutable and immutable arrays

Copyright | (c) The University of Glasgow 2001
License | BSD-style (see the file libraries/base/LICENSE)
Maintainer | libraries@haskell.org
Stability | experimental
Portability | non-portable (uses Data.Array.Base)
Safe Haskell | None
Language | Haskell2010

Data.Array.MArray

Contents

- Class of mutable array types
- 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 Monad m => MArray a e m where
  - getBounds :: Ix i => a i e -> m (i, i)
  - newArray :: Ix i => (i, i) -> e -> m (a i e)
  - newArray_ :: Ix i => (i, i) -> m (a i e)
- 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)
- thaw :: (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 where

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.

Minimal complete definition

getBounds, getNumElements, unsafeRead, unsafeWrite

Methods

getBounds :: Ix i => a i e -> m (i, i)

Returns the bounds of the array

newArray :: Ix i => (i, i) -> e -> m (a i e)

Builds a new array, with every element initialised to the supplied value.

newArray_ :: 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.

Instances

MArray IOArray e IO |
MArray IOUArray Bool IO |
MArray IOUArray Char IO |
MArray IOUArray Double IO |
MArray IOUArray Float IO |
MArray IOUArray Int IO |
MArray IOUArray Int8 IO |
MArray IOUArray Int16 IO |
MArray IOUArray Int32 IO |
MArray IOUArray Int64 IO |
MArray IOUArray Word IO |
MArray IOUArray Word8 IO |
MArray IOUArray Word16 IO |
MArray IOUArray Word32 IO |
MArray IOUArray Word64 IO |
Storable e => MArray StorableArray e IO |
MArray IOUArray (StablePtr a) IO |
MArray IOUArray (Ptr a) IO |
MArray IOUArray (FunPtr a) IO |
MArray (STArray s) e (ST s) |
MArray (STArray s) e (ST s) |
MArray (STUArray s) Word64 (ST s) |
MArray (STUArray s) Word32 (ST s) |
MArray (STUArray s) Word16 (ST s) |
MArray (STUArray s) Word8 (ST s) |
MArray (STUArray s) Int64 (ST s) |
MArray (STUArray s) Int32 (ST s) |
MArray (STUArray s) Int16 (ST s) |
MArray (STUArray s) Int8 (ST s) |
MArray (STUArray s) Double (ST s) |
MArray (STUArray s) Float (ST s) |
MArray (STUArray s) Word (ST s) |
MArray (STUArray s) Int (ST s) |
MArray (STUArray s) Char (ST s) |
MArray (STUArray s) Bool (ST s) |
MArray (STUArray s) (StablePtr a) (ST s) |
MArray (STUArray s) (FunPtr a) (ST s) |
MArray (STUArray s) (Ptr a) (ST s) |

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

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

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.

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.