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 arrays of boxed values.
Synopsis
- data Array a = Array {
- array# :: Array# a
- data MutableArray s a = MutableArray {
- marray# :: MutableArray# s a
- newArray :: PrimMonad m => Int -> a -> m (MutableArray (PrimState m) a)
- readArray :: PrimMonad m => MutableArray (PrimState m) a -> Int -> m a
- writeArray :: PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m ()
- indexArray :: Array a -> Int -> a
- indexArrayM :: Monad m => Array a -> Int -> m a
- indexArray## :: Array a -> Int -> (# a #)
- freezeArray :: PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> m (Array a)
- thawArray :: PrimMonad m => Array a -> Int -> Int -> m (MutableArray (PrimState m) a)
- runArray :: (forall s. ST s (MutableArray s a)) -> Array a
- unsafeFreezeArray :: PrimMonad m => MutableArray (PrimState m) a -> m (Array a)
- unsafeThawArray :: PrimMonad m => Array a -> m (MutableArray (PrimState m) a)
- sameMutableArray :: MutableArray s a -> MutableArray s a -> Bool
- copyArray :: PrimMonad m => MutableArray (PrimState m) a -> Int -> Array a -> Int -> Int -> m ()
- copyMutableArray :: PrimMonad m => MutableArray (PrimState m) a -> Int -> MutableArray (PrimState m) a -> Int -> Int -> m ()
- cloneArray :: Array a -> Int -> Int -> Array a
- cloneMutableArray :: PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> m (MutableArray (PrimState m) a)
- sizeofArray :: Array a -> Int
- sizeofMutableArray :: MutableArray s a -> Int
- fromListN :: IsList l => Int -> [Item l] -> l
- fromList :: IsList l => [Item l] -> l
- mapArray' :: (a -> b) -> Array a -> Array b
- traverseArrayP :: PrimMonad m => (a -> m b) -> Array a -> m (Array b)
Documentation
Boxed arrays
Instances
Monad Array # | |
Functor Array # | |
MonadFix Array # | |
Defined in Data.Primitive.Array | |
MonadFail Array # | |
Defined in Data.Primitive.Array | |
Applicative Array # | |
Foldable Array # | |
Defined in Data.Primitive.Array Methods fold :: Monoid m => Array m -> m foldMap :: Monoid m => (a -> m) -> Array a -> m foldMap' :: Monoid m => (a -> m) -> Array a -> m foldr :: (a -> b -> b) -> b -> Array a -> b foldr' :: (a -> b -> b) -> b -> Array a -> b foldl :: (b -> a -> b) -> b -> Array a -> b foldl' :: (b -> a -> b) -> b -> Array a -> b foldr1 :: (a -> a -> a) -> Array a -> a foldl1 :: (a -> a -> a) -> Array a -> a elem :: Eq a => a -> Array a -> Bool maximum :: Ord a => Array a -> a | |
Traversable Array # | |
MonadPlus Array # | |
Alternative Array # | |
Eq1 Array # | Since: 0.6.4.0 |
Defined in Data.Primitive.Array | |
MonadZip Array # | |
Ord1 Array # | Since: 0.6.4.0 |
Defined in Data.Primitive.Array Methods liftCompare :: (a -> b -> Ordering) -> Array a -> Array b -> Ordering | |
Read1 Array # | Since: 0.6.4.0 |
Defined in Data.Primitive.Array Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Array a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Array a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Array a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Array a] | |
Show1 Array # | Since: 0.6.4.0 |
Defined in Data.Primitive.Array Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Array a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Array a] -> ShowS | |
IsList (Array a) # | |
Eq a => Eq (Array a) # | |
Data a => Data (Array a) # | |
Defined in Data.Primitive.Array Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Array a -> c (Array a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array a) dataTypeOf :: Array a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Array a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a)) gmapT :: (forall b. Data b => b -> b) -> Array a -> Array a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array a -> r gmapQ :: (forall d. Data d => d -> u) -> Array a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Array a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array a -> m (Array a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a -> m (Array a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a -> m (Array a) | |
Ord a => Ord (Array a) # | Lexicographic ordering. Subject to change between major versions. |
Read a => Read (Array a) # | |
Defined in Data.Primitive.Array | |
Show a => Show (Array a) # | |
Semigroup (Array a) # | Since: 0.6.3.0 |
Monoid (Array a) # | |
type Item (Array a) # | |
Defined in Data.Primitive.Array type Item (Array a) = a |
data MutableArray s a #
Mutable boxed arrays associated with a primitive state token.
Constructors
MutableArray | |
Fields
|
Instances
Eq (MutableArray s a) # | |
Defined in Data.Primitive.Array Methods (==) :: MutableArray s a -> MutableArray s a -> Bool (/=) :: MutableArray s a -> MutableArray s a -> Bool | |
(Typeable s, Typeable a) => Data (MutableArray s a) # | |
Defined in Data.Primitive.Array Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MutableArray s a -> c (MutableArray s a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MutableArray s a) toConstr :: MutableArray s a -> Constr dataTypeOf :: MutableArray s a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MutableArray s a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MutableArray s a)) gmapT :: (forall b. Data b => b -> b) -> MutableArray s a -> MutableArray s a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MutableArray s a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MutableArray s a -> r gmapQ :: (forall d. Data d => d -> u) -> MutableArray s a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> MutableArray s a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> MutableArray s a -> m (MutableArray s a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MutableArray s a -> m (MutableArray s a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MutableArray s a -> m (MutableArray s a) |
newArray :: PrimMonad m => Int -> a -> m (MutableArray (PrimState m) a) #
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 #
Read a value from the array at the given index.
writeArray :: PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () #
Write a value to the array at the given index.
indexArray :: Array a -> Int -> a #
Read a value from the immutable array at the given index.
indexArrayM :: Monad m => Array a -> Int -> m a #
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.
indexArray## :: Array a -> Int -> (# a #) #
Read a value from the immutable array at the given index, returning the result in an unboxed unary tuple. This is currently used to implement folds.
Arguments
:: PrimMonad m | |
=> MutableArray (PrimState m) a | source |
-> Int | offset |
-> Int | length |
-> m (Array a) |
Create an immutable copy of a slice of an array.
This operation makes a copy of the specified section, so it is safe to continue using the mutable array afterward.
Arguments
:: PrimMonad m | |
=> Array a | source |
-> Int | offset |
-> Int | length |
-> m (MutableArray (PrimState m) a) |
Create a mutable array from a slice of an immutable array.
This operation makes a copy of the specified slice, so it is safe to use the immutable array afterward.
runArray :: (forall s. ST s (MutableArray s a)) -> Array a #
unsafeFreezeArray :: PrimMonad m => MutableArray (PrimState m) a -> m (Array a) #
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) #
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 #
Check whether the two arrays refer to the same memory block.
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.
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 must not be the same when using this library with GHC versions 7.6 and older. In GHC 7.8 and newer, overlapping arrays will behave correctly.
Note: The order of arguments is different from that of copyMutableArray#
. The primop
has the source first while this wrapper has the destination first.
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.
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.
sizeofArray :: Array a -> Int #
sizeofMutableArray :: MutableArray s a -> Int #
traverseArrayP :: PrimMonad m => (a -> m b) -> Array a -> m (Array b) #