Data.Massiv.Array.Mutable

Documentation

class Manifest r ix e => Mutable r ix e where

Minimal complete definition

msize, unsafeThaw, unsafeFreeze, unsafeNew, unsafeNewZero, unsafeLinearRead, unsafeLinearWrite

Associated Types

data MArray s r ix e :: *

Methods

msize :: MArray s r ix e -> ix

Get the size of a mutable array.

Instances

(Unbox e, Index ix) => Mutable U ix e

Associated Types

data MArray s U ix e :: *

Methods

msize :: MArray s U ix e -> ix

unsafeThaw :: PrimMonad m => Array U ix e -> m (MArray (PrimState m) U ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) U ix e -> m (Array U ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) U ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) U ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) U ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) U ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld U ix e)

unsafeThawA :: Applicative m => Array U ix e -> WorldState -> m (WorldState, MArray RealWorld U ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld U ix e -> WorldState -> m (WorldState, Array U ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld U ix e -> Int -> e -> WorldState -> m WorldState

(Index ix, Storable e) => Mutable S ix e

Associated Types

data MArray s S ix e :: *

Methods

msize :: MArray s S ix e -> ix

unsafeThaw :: PrimMonad m => Array S ix e -> m (MArray (PrimState m) S ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) S ix e -> m (Array S ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) S ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) S ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) S ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) S ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld S ix e)

unsafeThawA :: Applicative m => Array S ix e -> WorldState -> m (WorldState, MArray RealWorld S ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld S ix e -> WorldState -> m (WorldState, Array S ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld S ix e -> Int -> e -> WorldState -> m WorldState

(Index ix, Prim e) => Mutable P ix e

Associated Types

data MArray s P ix e :: *

Methods

msize :: MArray s P ix e -> ix

unsafeThaw :: PrimMonad m => Array P ix e -> m (MArray (PrimState m) P ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) P ix e -> m (Array P ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) P ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) P ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) P ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) P ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld P ix e)

unsafeThawA :: Applicative m => Array P ix e -> WorldState -> m (WorldState, MArray RealWorld P ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld P ix e -> WorldState -> m (WorldState, Array P ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld P ix e -> Int -> e -> WorldState -> m WorldState

(Index ix, NFData e) => Mutable N ix e

Associated Types

data MArray s N ix e :: *

Methods

msize :: MArray s N ix e -> ix

unsafeThaw :: PrimMonad m => Array N ix e -> m (MArray (PrimState m) N ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) N ix e -> m (Array N ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) N ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) N ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) N ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) N ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld N ix e)

unsafeThawA :: Applicative m => Array N ix e -> WorldState -> m (WorldState, MArray RealWorld N ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld N ix e -> WorldState -> m (WorldState, Array N ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld N ix e -> Int -> e -> WorldState -> m WorldState

Index ix => Mutable B ix e

Associated Types

data MArray s B ix e :: *

Methods

msize :: MArray s B ix e -> ix

unsafeThaw :: PrimMonad m => Array B ix e -> m (MArray (PrimState m) B ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) B ix e -> m (Array B ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) B ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) B ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) B ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) B ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld B ix e)

unsafeThawA :: Applicative m => Array B ix e -> WorldState -> m (WorldState, MArray RealWorld B ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld B ix e -> WorldState -> m (WorldState, Array B ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld B ix e -> Int -> e -> WorldState -> m WorldState

msize :: Mutable r ix e => MArray s r ix e -> ix

Get the size of a mutable array.

new :: (Mutable r ix e, PrimMonad m) => ix -> m (MArray (PrimState m) r ix e)

Initialize a new mutable array. Negative size will result in an empty array.

thaw :: (Mutable r ix e, PrimMonad m) => Array r ix e -> m (MArray (PrimState m) r ix e)

O(n) - Yield a mutable copy of the immutable array

freeze :: (Mutable r ix e, PrimMonad m) => Comp -> MArray (PrimState m) r ix e -> m (Array r ix e)

O(n) - Yield an immutable copy of the mutable array

read :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> m (Maybe e)

O(1) - Lookup an element in the mutable array. Return Nothing when index is out of bounds.

read' :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> m e

O(1) - Same as read, but throws an error if index is out of bounds.

write :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> e -> m Bool

O(1) - Write an element into the cell of a mutable array. Returns False when index is out of bounds.

write' :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> e -> m ()

O(1) - Same as write, but throws an error if index is out of bounds.

modify :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> e) -> ix -> m Bool

O(1) - Modify an element in the cell of a mutable array with a supplied function. Returns False when index is out of bounds.

modify' :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> e) -> ix -> m ()

O(1) - Same as modify, but throws an error if index is out of bounds.

swap :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> ix -> m Bool

O(1) - Swap two elements in a mutable array by supplying their indices. Returns False when either one of the indices is out of bounds.

swap' :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> ix -> m ()

O(1) - Same as swap, but throws an error if index is out of bounds.

Computation

data RealWorld :: *

RealWorld is deeply magical. It is primitive, but it is not unlifted (hence ptrArg). We never manipulate values of type RealWorld; it's only used in the type system, to parameterise State#.

computeInto

Arguments

:: (Load r' ix e, Mutable r ix e)

=> MArray RealWorld r ix e

Target Array

-> Array r' ix e

Array to load

-> IO ()

Compute an Array while loading the results into the supplied mutable target array. Sizes of both arrays must agree, otherwise error.

Since: 0.1.3

Generate (experimental)

Functions in this sections can monadically generate manifest arrays using their associated mutable interface. Due to the sequential nature of monads generation is done also sequentially regardless of supplied computation strategy. All of functions here are very much experimental, so please report an issue if you see something not working properly.

Here is a very imperative like for loop that creates an array while performing a side effect for each newly created element:

printSquare :: Int -> IO (Array P Ix1 Int)
printSquare n = forM P (range Seq 0 n) $ i -> do
  let e = i*i
  putStrLn $ "Element at index: " ++ show i ++ " = " ++ show e ++ ";"
  return e

>>> printSquare 5
Element at index: 0 = 0;
Element at index: 1 = 1;
Element at index: 2 = 4;
Element at index: 3 = 9;
Element at index: 4 = 16;
(Array P Seq (5)
  [ 0,1,4,9,16 ])

generateM :: (Monad m, Mutable r ix e) => Comp -> ix -> (ix -> m e) -> m (Array r ix e)

O(n) - Generate an array monadically using it's mutable interface. Computation will be done sequentially, regardless of Comp argument.

Since: 0.1.1

generateLinearM :: (Monad m, Mutable r ix e) => Comp -> ix -> (Int -> m e) -> m (Array r ix e)

O(n) - Same as generateM but using a flat index.

Since: 0.1.1

mapM :: (Monad m, Source r ix e, Mutable r' ix e') => r' -> (e -> m e') -> Array r ix e -> m (Array r' ix e')

O(n) - Map a monadic action over an Array. This operation will force computation sequentially and will result in a manifest Array.

Examples

>>> mapM P (\i -> Just (i*i)) $ range Seq 0 5
Just (Array P Seq (5)
  [ 0,1,4,9,16 ])

Since: 0.1.1

imapM :: (Monad m, Source r ix e, Mutable r' ix e') => r' -> (ix -> e -> m e') -> Array r ix e -> m (Array r' ix e')

O(n) - Map an index aware monadic action over an Array. This operation will force computation sequentially and will result in a manifest Array.

Since: 0.1.1

forM :: (Monad m, Source r ix e, Mutable r' ix e') => r' -> Array r ix e -> (e -> m e') -> m (Array r' ix e')

O(n) - Same as mapM, but with its arguments flipped.

Since: 0.1.1

iforM :: (Monad m, Source r ix e, Mutable r' ix e') => r' -> Array r ix e -> (ix -> e -> m e') -> m (Array r' ix e')

O(n) - Same as imapM, but with its arguments flipped.

Since: 0.1.1

sequenceM :: (Monad m, Source r ix (m e), Mutable r' ix e) => r' -> Array r ix (m e) -> m (Array r' ix e)

O(n) - Sequence monadic actions in a source Array. This operation will force the computation sequentially and will result in a manifest Array.

Since: 0.1.1