Streamly.Internal.Data.Array.Type

See notes in Streamly.Internal.Data.Array.Mut.Type

Documentation

We can use an Unbox constraint in the Array type and the constraint can be automatically provided to a function that pattern matches on the Array type. However, it has huge performance cost, so we do not use it. Investigate a GHC improvement possiblity.

data Array a

Constructors

Array

Fields

• arrContents :: !MutableByteArray
• arrStart :: !Int
• arrEnd :: !Int

Instances

a ~ Char => IsString (Array a)

Defined in Streamly.Internal.Data.Array.Type

Methods

fromString :: String -> Array a

Unbox a => Monoid (Array a)

Defined in Streamly.Internal.Data.Array.Type

Methods

mempty :: Array a

mappend :: Array a -> Array a -> Array a

mconcat :: [Array a] -> Array a

Unbox a => Semigroup (Array a)

Defined in Streamly.Internal.Data.Array.Type

Methods

(<>) :: Array a -> Array a -> Array a

sconcat :: NonEmpty (Array a) -> Array a

stimes :: Integral b => b -> Array a -> Array a

Unbox a => IsList (Array a)

Defined in Streamly.Internal.Data.Array.Type

Associated Types

type Item (Array a)

Methods

fromList :: [Item (Array a)] -> Array a

fromListN :: Int -> [Item (Array a)] -> Array a

toList :: Array a -> [Item (Array a)]

(Unbox a, Read a, Show a) => Read (Array a)

Defined in Streamly.Internal.Data.Array.Type

Methods

readsPrec :: Int -> ReadS (Array a)

readList :: ReadS [Array a]

readPrec :: ReadPrec (Array a)

readListPrec :: ReadPrec [Array a]

(Show a, Unbox a) => Show (Array a)

Defined in Streamly.Internal.Data.Array.Type

Methods

showsPrec :: Int -> Array a -> ShowS

show :: Array a -> String

showList :: [Array a] -> ShowS

(Unbox a, Eq a) => Eq (Array a)

Defined in Streamly.Internal.Data.Array.Type

Methods

(==) :: Array a -> Array a -> Bool

(/=) :: Array a -> Array a -> Bool

(Unbox a, Ord a) => Ord (Array a)

Defined in Streamly.Internal.Data.Array.Type

Methods

compare :: Array a -> Array a -> Ordering

(<) :: Array a -> Array a -> Bool

(<=) :: Array a -> Array a -> Bool

(>) :: Array a -> Array a -> Bool

(>=) :: Array a -> Array a -> Bool

max :: Array a -> Array a -> Array a

min :: Array a -> Array a -> Array a

type Item (Array a)

Defined in Streamly.Internal.Data.Array.Type

type Item (Array a) = a

asPtrUnsafe :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

Use an Array a as Ptr a.

See asPtrUnsafe in the Mutable array module for more details.

Unsafe

Pre-release

Freezing and Thawing

unsafeFreeze :: MutArray a -> Array a

Makes an immutable array using the underlying memory of the mutable array.

Please make sure that there are no other references to the mutable array lying around, so that it is never used after freezing it using unsafeFreeze. If the underlying array is mutated, the immutable promise is lost.

Pre-release

unsafeFreezeWithShrink :: Unbox a => MutArray a -> Array a

Similar to unsafeFreeze but uses rightSize on the mutable array first.

unsafeThaw :: Array a -> MutArray a

Makes a mutable array using the underlying memory of the immutable array.

Please make sure that there are no other references to the immutable array lying around, so that it is never used after thawing it using unsafeThaw. If the resulting array is mutated, any references to the older immutable array are mutated as well.

Pre-release

Pinning and Unpinning

pin :: Array a -> IO (Array a)

unpin :: Array a -> IO (Array a)

Construction

splice :: (MonadIO m, Unbox a) => Array a -> Array a -> m (Array a)

fromList :: Unbox a => [a] -> Array a

Create an Array from a list. The list must be of finite size.

fromListN :: Unbox a => Int -> [a] -> Array a

Create an Array from the first N elements of a list. The array is allocated to size N, if the list terminates before N elements then the array may hold less than N elements.

fromListRev :: Unbox a => [a] -> Array a

Create an Array from a list in reverse order. The list must be of finite size.

Pre-release

fromListRevN :: Unbox a => Int -> [a] -> Array a

Create an Array from the first N elements of a list in reverse order. The array is allocated to size N, if the list terminates before N elements then the array may hold less than N elements.

Pre-release

fromStreamDN :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> m (Array a)

fromStreamD :: forall m a. (MonadIO m, Unbox a) => Stream m a -> m (Array a)

Split

breakOn :: MonadIO m => Word8 -> Array Word8 -> m (Array Word8, Maybe (Array Word8))

Elimination

unsafeIndexIO :: forall a. Unbox a => Int -> Array a -> IO a

Return element at the specified index without checking the bounds.

Unsafe because it does not check the bounds of the array.

unsafeIndex :: forall a. Unbox a => Int -> Array a -> a

Return element at the specified index without checking the bounds.

byteLength :: Array a -> Int

O(1) Get the byte length of the array.

length :: Unbox a => Array a -> Int

O(1) Get the length of the array i.e. the number of elements in the array.

foldl' :: forall a b. Unbox a => (b -> a -> b) -> b -> Array a -> b

foldr :: Unbox a => (a -> b -> b) -> b -> Array a -> b

splitAt :: Unbox a => Int -> Array a -> (Array a, Array a)

Create two slices of an array without copying the original array. The specified index i is the first index of the second slice.

toStreamD :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a

toStreamDRev :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a

toStreamK :: forall m a. (Monad m, Unbox a) => Array a -> StreamK m a

toStreamKRev :: forall m a. (Monad m, Unbox a) => Array a -> StreamK m a

toStream :: (Monad m, Unbox a) => Array a -> Stream m a

Deprecated: Please use read instead.

Same as read

toStreamRev :: (Monad m, Unbox a) => Array a -> Stream m a

Deprecated: Please use readRev instead.

Same as readRev

read :: (Monad m, Unbox a) => Array a -> Stream m a

Convert an Array into a stream.

Pre-release

readRev :: (Monad m, Unbox a) => Array a -> Stream m a

Convert an Array into a stream in reverse order.

Pre-release

readerRev :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a

Unfold an array into a stream in reverse order.

toList :: Unbox a => Array a -> [a]

Convert an Array into a list.

Folds

writeWith :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)

writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)

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

writeNUnsafe :: forall m a. (MonadIO m, Unbox 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.

data ArrayUnsafe a

Constructors

ArrayUnsafe !MutableByteArray !Int !Int

writeNAligned :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> Fold m a (Array a)

writeNAligned alignment n folds a maximum of n elements from the input stream to an Array aligned to the given size.

Pre-release

write :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)

Fold the whole input to a single array.

Caution! Do not use this on infinite streams.

Streams of arrays

chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)

chunksOf n stream groups the elements in the input stream into arrays of n elements each.

Same as the following but may be more efficient:

>>> chunksOf n = Stream.foldMany (Array.writeN n)

Pre-release

bufferChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))

flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a

Use the "read" unfold instead.

flattenArrays = unfoldMany read

We can try this if there are any fusion issues in the unfold.

flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a

Use the "readRev" unfold instead.

flattenArrays = unfoldMany readRev

We can try this if there are any fusion issues in the unfold.