array-0.1.0.0: Mutable and immutable arraysContentsIndex
Data.Array.Base
Portabilitynon-portable (MPTCs, uses Control.Monad.ST)
Stabilityexperimental
Maintainerlibraries@haskell.org
Description
Basis for IArray and MArray. Not intended for external consumption; use IArray or MArray instead.
Synopsis
class IArray a e where
bounds :: Ix i => a i e -> (i, i)
numElements :: Ix i => a i e -> Int
unsafeArray :: Ix i => (i, i) -> [(Int, e)] -> a i e
unsafeAt :: Ix i => a i e -> Int -> e
unsafeReplace :: Ix i => a i e -> [(Int, e)] -> a i e
unsafeAccum :: Ix i => (e -> e' -> e) -> a i e -> [(Int, e')] -> a i e
unsafeAccumArray :: Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> a i e
safeRangeSize :: Ix i => (i, i) -> Int
safeIndex :: Ix i => (i, i) -> Int -> i -> Int
unsafeReplaceST :: (IArray a e, Ix i) => a i e -> [(Int, e)] -> ST s (STArray s i e)
unsafeAccumST :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(Int, e')] -> ST s (STArray s i e)
unsafeAccumArrayST :: Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (STArray s i e)
array :: (IArray a e, Ix i) => (i, i) -> [(i, e)] -> a i e
listArray :: (IArray a e, Ix i) => (i, i) -> [e] -> a i e
listArrayST :: Ix i => (i, i) -> [e] -> ST s (STArray s i e)
listUArrayST :: (MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [e] -> ST s (STUArray s i e)
type ListUArray e = forall i. Ix i => (i, i) -> [e] -> UArray i e
(!) :: (IArray a e, Ix i) => a i e -> i -> e
indices :: (IArray a e, Ix i) => a i e -> [i]
elems :: (IArray a e, Ix i) => a i e -> [e]
assocs :: (IArray a e, Ix i) => a i e -> [(i, e)]
accumArray :: (IArray a e, Ix i) => (e -> e' -> e) -> e -> (i, i) -> [(i, e')] -> a i e
(//) :: (IArray a e, Ix i) => a i e -> [(i, e)] -> a i e
accum :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(i, e')] -> a i e
amap :: (IArray a e', IArray a e, Ix i) => (e' -> e) -> a i e' -> a i e
ixmap :: (IArray a e, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> a i e
data UArray i e = UArray !i !i !Int ByteArray#
unsafeArrayUArray :: (MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeFreezeSTUArray :: STUArray s i e -> ST s (UArray i e)
unsafeReplaceUArray :: (MArray (STUArray s) e (ST s), Ix i) => UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeAccumUArray :: (MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray :: (MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
eqUArray :: (IArray UArray e, Ix i, Eq e) => UArray i e -> UArray i e -> Bool
cmpUArray :: (IArray UArray e, Ix i, Ord e) => UArray i e -> UArray i e -> Ordering
cmpIntUArray :: (IArray UArray e, Ord e) => UArray Int e -> UArray Int e -> Ordering
showsIArray :: (IArray a e, Ix i, Show i, Show e) => Int -> a i e -> ShowS
arrEleBottom :: a
class Monad m => MArray a e m where
getBounds :: Ix i => a i e -> m (i, i)
getNumElements :: Ix i => a i e -> m Int
newArray :: Ix i => (i, i) -> e -> m (a i e)
newArray_ :: Ix i => (i, i) -> m (a i e)
unsafeNewArray_ :: Ix i => (i, i) -> m (a i e)
unsafeRead :: Ix i => a i e -> Int -> m e
unsafeWrite :: Ix i => a i e -> Int -> e -> m ()
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 ()
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)]
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)
data STUArray s i a = STUArray !i !i !Int (MutableByteArray# s)
unsafeNewArraySTUArray_ :: Ix i => (i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
bOOL_WORD_SCALE :: Int# -> Int#
bOOL_INDEX :: Int# -> Int#
bOOL_NOT_BIT :: Int# -> Word#
freeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e)
freezeSTUArray :: Ix i => STUArray s i e -> ST s (UArray i e)
memcpy_freeze :: MutableByteArray# s -> MutableByteArray# s -> CSize -> IO (Ptr a)
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)
thawSTUArray :: Ix i => UArray i e -> ST s (STUArray s i e)
memcpy_thaw :: MutableByteArray# s -> ByteArray# -> CSize -> IO (Ptr a)
unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e)
unsafeThawSTUArray :: Ix i => UArray i e -> ST s (STUArray s i e)
castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b)
Documentation
class IArray a e where

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.

Methods
bounds :: Ix i => a i e -> (i, i)
Extracts the bounds of an immutable array
numElements :: Ix i => a i e -> Int
unsafeArray :: Ix i => (i, i) -> [(Int, e)] -> a i e
unsafeAt :: Ix i => a i e -> Int -> e
unsafeReplace :: Ix i => a i e -> [(Int, e)] -> a i e
unsafeAccum :: Ix i => (e -> e' -> e) -> a i e -> [(Int, e')] -> a i e
unsafeAccumArray :: Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> a i e
show/hide Instances
IArray Array e
IArray UArray Bool
IArray UArray Bool
IArray UArray Char
IArray UArray Char
IArray UArray Double
IArray UArray Double
IArray UArray Float
IArray UArray Float
IArray UArray Int
IArray UArray Int
IArray UArray Int8
IArray UArray Int8
IArray UArray Int16
IArray UArray Int16
IArray UArray Int32
IArray UArray Int32
IArray UArray Int64
IArray UArray Int64
IArray UArray Word
IArray UArray Word
IArray UArray Word8
IArray UArray Word8
IArray UArray Word16
IArray UArray Word16
IArray UArray Word32
IArray UArray Word32
IArray UArray Word64
IArray UArray Word64
IArray UArray (StablePtr a)
IArray UArray (StablePtr a)
IArray UArray (Ptr a)
IArray UArray (Ptr a)
IArray UArray (FunPtr a)
IArray UArray (FunPtr a)
IArray (IOToDiffArray IOArray) e
IArray (IOToDiffArray IOUArray) Char
IArray (IOToDiffArray IOUArray) Char
IArray (IOToDiffArray IOUArray) Double
IArray (IOToDiffArray IOUArray) Double
IArray (IOToDiffArray IOUArray) Float
IArray (IOToDiffArray IOUArray) Float
IArray (IOToDiffArray IOUArray) Int
IArray (IOToDiffArray IOUArray) Int
IArray (IOToDiffArray IOUArray) Int8
IArray (IOToDiffArray IOUArray) Int8
IArray (IOToDiffArray IOUArray) Int16
IArray (IOToDiffArray IOUArray) Int16
IArray (IOToDiffArray IOUArray) Int32
IArray (IOToDiffArray IOUArray) Int32
IArray (IOToDiffArray IOUArray) Int64
IArray (IOToDiffArray IOUArray) Int64
IArray (IOToDiffArray IOUArray) Word
IArray (IOToDiffArray IOUArray) Word
IArray (IOToDiffArray IOUArray) Word8
IArray (IOToDiffArray IOUArray) Word8
IArray (IOToDiffArray IOUArray) Word16
IArray (IOToDiffArray IOUArray) Word16
IArray (IOToDiffArray IOUArray) Word32
IArray (IOToDiffArray IOUArray) Word32
IArray (IOToDiffArray IOUArray) Word64
IArray (IOToDiffArray IOUArray) Word64
IArray (IOToDiffArray IOUArray) (StablePtr a)
IArray (IOToDiffArray IOUArray) (StablePtr a)
IArray (IOToDiffArray IOUArray) (Ptr a)
IArray (IOToDiffArray IOUArray) (Ptr a)
IArray (IOToDiffArray IOUArray) (FunPtr a)
IArray (IOToDiffArray IOUArray) (FunPtr a)
safeRangeSize :: Ix i => (i, i) -> Int
safeIndex :: Ix i => (i, i) -> Int -> i -> Int
unsafeReplaceST :: (IArray a e, Ix i) => a i e -> [(Int, e)] -> ST s (STArray s i e)
unsafeAccumST :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(Int, e')] -> ST s (STArray s i e)
unsafeAccumArrayST :: Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (STArray s i e)
array
:: (IArray a e, Ix i)
=> (i, i)bounds of the array: (lowest,highest)
-> [(i, e)]list of associations
-> 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 Data.Array.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: Data.Array.Array is a non-strict array type, but all of the Data.Array.Unboxed.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.

listArray :: (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.
listArrayST :: Ix i => (i, i) -> [e] -> ST s (STArray s i e)
listUArrayST :: (MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [e] -> ST s (STUArray s i e)
type ListUArray e = forall i. Ix i => (i, i) -> [e] -> UArray i e
(!) :: (IArray a e, Ix i) => a i e -> i -> e
Returns the element of an immutable array at the specified index.
indices :: (IArray a e, Ix i) => a i e -> [i]
Returns a list of all the valid indices in an array.
elems :: (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.
assocs :: (IArray a e, Ix i) => a i e -> [(i, e)]
Returns the contents of an array as a list of associations.
accumArray
:: (IArray a e, Ix i)
=> e -> e' -> eAn accumulating function
-> eA default element
-> (i, i)The bounds of the array
-> [(i, e')]List of associations
-> a i eReturns: the array

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]
(//) :: (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 Data.Array.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 Data.Array.Diff.DiffArray type provides this operation with complexity linear in the number of updates.

accum :: (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])
amap :: (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.
ixmap :: (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.
data 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 Data.Array.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 Data.Array.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).

Constructors
UArray !i !i !Int ByteArray#
show/hide Instances
unsafeArrayUArray :: (MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeFreezeSTUArray :: STUArray s i e -> ST s (UArray i e)
unsafeReplaceUArray :: (MArray (STUArray s) e (ST s), Ix i) => UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeAccumUArray :: (MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray :: (MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
eqUArray :: (IArray UArray e, Ix i, Eq e) => UArray i e -> UArray i e -> Bool
cmpUArray :: (IArray UArray e, Ix i, Ord e) => UArray i e -> UArray i e -> Ordering
cmpIntUArray :: (IArray UArray e, Ord e) => UArray Int e -> UArray Int e -> Ordering
showsIArray :: (IArray a e, Ix i, Show i, Show e) => Int -> a i e -> ShowS
arrEleBottom :: a
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.

Methods
getBounds :: Ix i => a i e -> m (i, i)
Returns the bounds of the array
getNumElements :: Ix i => a i e -> m Int
Returns the number of elements in 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.
unsafeNewArray_ :: Ix i => (i, i) -> m (a i e)
Builds a new array, with every element initialised to an undefined value.
unsafeRead :: Ix i => a i e -> Int -> m e
unsafeWrite :: Ix i => a i e -> Int -> e -> m ()
show/hide Instances
MArray IOArray e IO
MArray IOArray e IO
MArray IOUArray Bool IO
MArray IOUArray Bool IO
MArray IOUArray Bool IO
MArray IOUArray Char IO
MArray IOUArray Char IO
MArray IOUArray Char IO
MArray IOUArray Double IO
MArray IOUArray Double IO
MArray IOUArray Double IO
MArray IOUArray Float IO
MArray IOUArray Float IO
MArray IOUArray Float IO
MArray IOUArray Int IO
MArray IOUArray Int IO
MArray IOUArray Int IO
MArray IOUArray Int8 IO
MArray IOUArray Int8 IO
MArray IOUArray Int8 IO
MArray IOUArray Int16 IO
MArray IOUArray Int16 IO
MArray IOUArray Int16 IO
MArray IOUArray Int32 IO
MArray IOUArray Int32 IO
MArray IOUArray Int32 IO
MArray IOUArray Int64 IO
MArray IOUArray Int64 IO
MArray IOUArray Int64 IO
MArray IOUArray Word IO
MArray IOUArray Word IO
MArray IOUArray Word IO
MArray IOUArray Word8 IO
MArray IOUArray Word8 IO
MArray IOUArray Word8 IO
MArray IOUArray Word16 IO
MArray IOUArray Word16 IO
MArray IOUArray Word16 IO
MArray IOUArray Word32 IO
MArray IOUArray Word32 IO
MArray IOUArray Word32 IO
MArray IOUArray Word64 IO
MArray IOUArray Word64 IO
MArray IOUArray Word64 IO
Storable e => MArray StorableArray e IO
Storable e => MArray StorableArray e IO
MArray IOUArray (StablePtr a) IO
MArray IOUArray (StablePtr a) IO
MArray IOUArray (StablePtr a) IO
MArray IOUArray (Ptr a) IO
MArray IOUArray (Ptr a) IO
MArray IOUArray (Ptr a) IO
MArray IOUArray (FunPtr a) IO
MArray IOUArray (FunPtr a) IO
MArray IOUArray (FunPtr a) IO
MArray (STArray s) e (ST s)
MArray (STArray s) e (ST s)
MArray (STArray s) e (ST s)
MArray (STArray s) e (ST s)
MArray (STUArray s) Word64 (ST s)
MArray (STUArray s) Word64 (ST s)
MArray (STUArray s) Word64 (ST s)
MArray (STUArray s) Word32 (ST s)
MArray (STUArray s) Word32 (ST s)
MArray (STUArray s) Word32 (ST s)
MArray (STUArray s) Word16 (ST s)
MArray (STUArray s) Word16 (ST s)
MArray (STUArray s) Word16 (ST s)
MArray (STUArray s) Word8 (ST s)
MArray (STUArray s) Word8 (ST s)
MArray (STUArray s) Word8 (ST s)
MArray (STUArray s) Int64 (ST s)
MArray (STUArray s) Int64 (ST s)
MArray (STUArray s) Int64 (ST s)
MArray (STUArray s) Int32 (ST s)
MArray (STUArray s) Int32 (ST s)
MArray (STUArray s) Int32 (ST s)
MArray (STUArray s) Int16 (ST s)
MArray (STUArray s) Int16 (ST s)
MArray (STUArray s) Int16 (ST s)
MArray (STUArray s) Int8 (ST s)
MArray (STUArray s) Int8 (ST s)
MArray (STUArray s) Int8 (ST s)
MArray (STUArray s) Double (ST s)
MArray (STUArray s) Double (ST s)
MArray (STUArray s) Double (ST s)
MArray (STUArray s) Float (ST s)
MArray (STUArray s) Float (ST s)
MArray (STUArray s) Float (ST s)
MArray (STUArray s) Word (ST s)
MArray (STUArray s) Word (ST s)
MArray (STUArray s) Word (ST s)
MArray (STUArray s) Int (ST s)
MArray (STUArray s) Int (ST s)
MArray (STUArray s) Int (ST s)
MArray (STUArray s) Char (ST s)
MArray (STUArray s) Char (ST s)
MArray (STUArray s) Char (ST s)
MArray (STUArray s) Bool (ST s)
MArray (STUArray s) Bool (ST s)
MArray (STUArray s) Bool (ST s)
MArray (STUArray s) (StablePtr a) (ST s)
MArray (STUArray s) (StablePtr a) (ST s)
MArray (STUArray s) (StablePtr a) (ST s)
MArray (STUArray s) (FunPtr a) (ST s)
MArray (STUArray s) (FunPtr a) (ST s)
MArray (STUArray s) (FunPtr a) (ST s)
MArray (STUArray s) (Ptr a) (ST s)
MArray (STUArray s) (Ptr a) (ST s)
MArray (STUArray s) (Ptr a) (ST s)
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.
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
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.
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.
data STUArray s i a

A mutable array with unboxed elements, that can be manipulated in the ST monad. The type arguments are as follows:

  • s: the state variable argument for the ST type
  • i: the index type of the array (should be an instance of Ix)
  • e: the element type of the array. Only certain element types are supported.

An STUArray will generally be more efficient (in terms of both time and space) than the equivalent boxed version (Data.Array.ST.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 Data.Array.ST.STArray provides.

Constructors
STUArray !i !i !Int (MutableByteArray# s)
show/hide Instances
unsafeNewArraySTUArray_ :: Ix i => (i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
bOOL_WORD_SCALE :: Int# -> Int#
bOOL_INDEX :: Int# -> Int#
bOOL_NOT_BIT :: Int# -> Word#
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.
freezeSTUArray :: Ix i => STUArray s i e -> ST s (UArray i e)
memcpy_freeze :: MutableByteArray# s -> MutableByteArray# s -> CSize -> IO (Ptr a)
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)
Converts an immutable array (any instance of IArray) into a mutable array (any instance of MArray) by taking a complete copy of it.
thawSTUArray :: Ix i => UArray i e -> ST s (STUArray s i e)
memcpy_thaw :: MutableByteArray# s -> ByteArray# -> CSize -> IO (Ptr a)
unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e)
unsafeThawSTUArray :: Ix i => UArray i e -> ST s (STUArray s i e)
castSTUArray :: 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...).
Produced by Haddock version 2.2.2