Copyright	(c) Roman Leshchinskiy 2009-2012
License	BSD-style
Maintainer	Roman Leshchinskiy <rl@cse.unsw.edu.au>
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Data.Primitive.Array

Description

Primitive boxed arrays

Synopsis

Documentation

data Array a Source

Boxed arrays

Constructors

Array (Array# a)

Instances

Typeable * a => Data (Array a)
Typeable (* -> *) Array

data MutableArray s a Source

Mutable boxed arrays associated with a primitive state token.

Constructors

MutableArray (MutableArray# s a)

Instances

(Typeable * s, Typeable * a) => Data (MutableArray s a)
Typeable (* -> * -> *) MutableArray

newArray :: PrimMonad m => Int -> a -> m (MutableArray (PrimState m) a) Source

Create a new mutable array of the specified size and initialise all elements with the given value.

readArray :: PrimMonad m => MutableArray (PrimState m) a -> Int -> m a Source

Read a value from the array at the given index.

writeArray :: PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () Source

Write a value to the array at the given index.

indexArray :: Array a -> Int -> a Source

Read a value from the immutable array at the given index.

indexArrayM :: Monad m => Array a -> Int -> m a Source

Monadically read a value from the immutable array at the given index. This allows us to be strict in the array while remaining lazy in the read element which is very useful for collective operations. Suppose we want to copy an array. We could do something like this:

copy marr arr ... = do ...
                       writeArray marr i (indexArray arr i) ...
                       ...

But since primitive arrays are lazy, the calls to indexArray will not be evaluated. Rather, marr will be filled with thunks each of which would retain a reference to arr. This is definitely not what we want!

With indexArrayM, we can instead write

copy marr arr ... = do ...
                       x <- indexArrayM arr i
                       writeArray marr i x
                       ...

Now, indexing is executed immediately although the returned element is still not evaluated.

unsafeFreezeArray :: PrimMonad m => MutableArray (PrimState m) a -> m (Array a) Source

Convert a mutable array to an immutable one without copying. The array should not be modified after the conversion.

unsafeThawArray :: PrimMonad m => Array a -> m (MutableArray (PrimState m) a) Source

Convert an immutable array to an mutable one without copying. The immutable array should not be used after the conversion.

sameMutableArray :: MutableArray s a -> MutableArray s a -> Bool Source

Check whether the two arrays refer to the same memory block.

copyArray Source

Arguments

:: PrimMonad m
=> MutableArray (PrimState m) a	destination array
-> Int	offset into destination array
-> Array a	source array
-> Int	offset into source array
-> Int	number of elements to copy
-> m ()

Copy a slice of an immutable array to a mutable array.

copyMutableArray Source

Arguments

:: PrimMonad m
=> MutableArray (PrimState m) a	destination array
-> Int	offset into destination array
-> MutableArray (PrimState m) a	source array
-> Int	offset into source array
-> Int	number of elements to copy
-> m ()

Copy a slice of a mutable array to another array. The two arrays may not be the same.

cloneArray Source

Arguments

:: Array a	source array
-> Int	offset into destination array
-> Int	number of elements to copy
-> Array a

Return a newly allocated Array with the specified subrange of the provided Array. The provided Array should contain the full subrange specified by the two Ints, but this is not checked.

cloneMutableArray Source

Arguments

:: PrimMonad m
=> MutableArray (PrimState m) a	source array
-> Int	offset into destination array
-> Int	number of elements to copy
-> m (MutableArray (PrimState m) a)

Return a newly allocated MutableArray. with the specified subrange of the provided MutableArray. The provided MutableArray should contain the full subrange specified by the two Ints, but this is not checked.