Streamly.Internal.Data.Array.Prim.Pinned.Mut.Type

Documentation

data Array a

Constructors

Array (MutableByteArray# RealWorld)

Construction

newArray :: forall m a. (MonadIO m, Prim a) => Int -> m (Array a)

Allocate an array that is pinned and can hold count items. The memory of the array is uninitialized.

Note that this is internal routine, the reference to this array cannot be given out until the array has been written to and frozen.

newAlignedArray :: forall m a. (MonadIO m, Prim a) => Int -> Int -> m (Array a)

Allocate a new array aligned to the specified alignment and using pinned memory.

unsafeWriteIndex

Arguments

:: (MonadIO m, Prim a)

=> Array a

array

-> Int

index

-> a

element

-> m ()

spliceTwo :: (MonadIO m, Prim a) => Array a -> Array a -> m (Array a)

unsafeCopy

Arguments

:: forall m a. (MonadIO m, Prim a)

=> Array 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 range of the first array to the specified region in the second array. Both arrays must fully contain the specified ranges, but this is not checked. The regions are allowed to overlap, although this is only possible when the same array is provided as both the source and the destination.

fromListM :: (MonadIO m, Prim a) => [a] -> m (Array a)

fromListNM :: (MonadIO m, Prim a) => Int -> [a] -> m (Array a)

fromStreamDN :: (MonadIO m, Prim a) => Int -> Stream m a -> m (Array a)

fromStreamD :: (MonadIO m, Prim a) => Stream m a -> m (Array a)

Streams of arrays

fromStreamDArraysOf :: (MonadIO m, Prim a) => Int -> Stream m a -> Stream m (Array a)

fromStreamArraysOf n stream groups the input stream into a stream of arrays of size n.

packArraysChunksOf :: (MonadIO m, Prim a) => Int -> Stream m (Array a) -> Stream m (Array a)

Coalesce adjacent arrays in incoming stream to form bigger arrays of a maximum specified size in bytes. Note that if a single array is bigger than the specified size we do not split it to fit. When we coalesce multiple arrays if the size would exceed the specified size we do not coalesce therefore the actual array size may be less than the specified chunk size.

Pre-release

lpackArraysChunksOf :: (MonadIO m, Prim a) => Int -> Fold m (Array a) () -> Fold m (Array a) ()

Elimination

unsafeReadIndex :: (MonadIO m, Prim a) => Array a -> Int -> m a

length :: forall m a. (MonadIO m, Prim a) => Array a -> m Int

byteLength :: MonadIO m => Array a -> m Int

writeN :: (MonadIO m, Prim a) => Int -> Fold m a (Array a)

writeN n folds a maximum of n elements from the input stream to an Array.

Pre-release

data ArrayUnsafe a

Constructors

ArrayUnsafe !(Array a) !Int

writeNUnsafe :: (MonadIO m, Prim a) => Int -> Fold m a (Array a)

Like writeN but does not check the array bounds when writing. The fold driver must not call the step function more than n times otherwise it will corrupt the memory and crash. This function exists mainly because any conditional in the step function blocks fusion causing 10x performance slowdown.

Pre-release

writeNAligned :: (MonadIO m, Prim a) => Int -> Int -> Fold m a (Array a)

write :: (MonadIO m, Prim a) => Fold m a (Array a)

Fold the whole input to a single array.

Caution! Do not use this on infinite streams.

Pre-release

Utilities

resizeArray

Arguments

:: (MonadIO m, Prim a)

=> Array a

-> Int

new size

-> m (Array a)

Resize (pinned) mutable byte array to new specified size (in elem count). The returned array is either the original array resized in-place or, if not possible, a newly allocated (pinned) array (with the original content copied over).

shrinkArray

Arguments

:: forall m a. (MonadIO m, Prim a)

=> Array a

-> Int

new size

-> m ()

touchArray :: Array a -> IO ()

withArrayAsPtr :: Array a -> (Ptr a -> IO b) -> IO b