@@ -40,22 +40,22 @@ module Streamly.Internal.Data.MutArray.Type
41 -- ** Casting
41 -- ** Casting
43− , castUnsafe -- XXX unsafeCast
43+ , castUnsafe
45− , unsafePinnedAsPtr
45+ , asPtrUnsafe
46− , unsafeAsPtr
46+ , asUnpinnedPtrUnsafe
48 -- ** Construction
48 -- ** Construction
51 -- *** New
51 -- *** New
52 -- | New arrays are always empty arrays with some reserve capacity to
52 -- | New arrays are always empty arrays with some reserve capacity to
53 -- extend the length without reallocating.
53 -- extend the length without reallocating.
55− , newArrayWith -- emptyAlignedWith
55+ , newArrayWith
56− , pinnedEmptyOf
56+ , pinnedNew
57− , pinnedNewAligned -- XXX not required
58+ , pinnedNewAligned
58− -- , new -- uninitialized array of specified length
60 -- *** Cloning
60 -- *** Cloning
@@ -63,25 +63,27 @@ module Streamly.Internal.Data.MutArray.Type
64 -- *** Slicing
64 -- *** Slicing
65 -- | Get a subarray without copying
65 -- | Get a subarray without copying
66− , getSliceUnsafe -- XXX unsafeGetSlice
66+ , getSliceUnsafe
67 , getSlice
67 , getSlice
68 , splitAt -- XXX should be able to express using getSlice
68 , splitAt -- XXX should be able to express using getSlice
71 -- *** Stream Folds
71 -- *** Stream Folds
72 , ArrayUnsafe (..)
72 , ArrayUnsafe (..)
73− , unsafeCreateOfWith
73+ , writeNWithUnsafe
74− , unsafeCreateOf
74+ , writeNWith
75− , unsafePinnedCreateOf
75+ , writeNUnsafe
76− , pinnedCreateOf
76+ , pinnedWriteNUnsafe
77− , createOfWith
77+ , writeN
78− , createOf
78+ , pinnedWriteN
79− , revCreateOf
79+ , pinnedWriteNAligned
81− , pinnedCreate
81+ , writeWith
82− , createWith
82+ , write
83− , create
83+ , pinnedWrite
86 -- *** From containers
88 -- *** From containers
87 , fromListN
89 , fromListN
@@ -97,11 +99,11 @@ module Streamly.Internal.Data.MutArray.Type
97 , fromByteStr#
99 , fromByteStr#
98 , fromPtrN
100 , fromPtrN
99 , fromChunksK
101 , fromChunksK
100− , fromChunksRealloced -- fromSmallChunks
102+ , fromChunksRealloced
102 -- ** Random writes
104 -- ** Random writes
103 , putIndex
105 , putIndex
104− , putIndexUnsafe -- XXX unsafePutIndex
106+ , putIndexUnsafe
105 , putIndices
107 , putIndices
106 -- , putFromThenTo
108 -- , putFromThenTo
107 -- , putFrom -- start writing at the given position
109 -- , putFrom -- start writing at the given position
@@ -109,7 +111,7 @@ module Streamly.Internal.Data.MutArray.Type
109 -- , putFromTo
111 -- , putFromTo
110 -- , putFromRev
112 -- , putFromRev
111 -- , putUptoRev
113 -- , putUptoRev
112− , modifyIndexUnsafe -- XXX unsafeModifyIndex
114+ , modifyIndexUnsafe
113 , modifyIndex
115 , modifyIndex
114 , modifyIndices
116 , modifyIndices
@@ -120,11 +122,11 @@ module Streamly.Internal.Data.MutArray.Type
121 -- *** Indexing
123 -- *** Indexing
122 , getIndex
124 , getIndex
123− , getIndexUnsafe -- XXX unsafeGetIndex
125+ , getIndexUnsafe
126+ , getIndices -- XXX indexReader
127+ , getIndicesWith -- XXX indexReaderWith
124 -- , getFromThenTo
128 -- , getFromThenTo
125− , getIndexRev -- getRevIndex?
129+ , getIndexRev
129 -- *** To Streams
131 -- *** To Streams
@@ -162,9 +164,9 @@ module Streamly.Internal.Data.MutArray.Type
162 , blockSize
164 , blockSize
163 , arrayChunkBytes
165 , arrayChunkBytes
164 , allocBytesToElemCount
166 , allocBytesToElemCount
165− , realloc -- this is "resize"
167+ , realloc
167− , growExp
169+ , resizeExp
168 , rightSize
170 , rightSize
170 -- ** Folding
172 -- ** Folding
@@ -193,34 +195,24 @@ module Streamly.Internal.Data.MutArray.Type
194 , snocLinear
196 , snocLinear
195 , snocMay
197 , snocMay
196− , snocUnsafe -- XXX unsafeSnoc
198+ , snocUnsafe
198 -- *** Appending streams
200 -- *** Appending streams
199− , unsafeAppendN
201+ , writeAppendNUnsafe
200− , appendN
202+ , writeAppendN
201− , appendWith
203+ , writeAppendWith
202− , append
204+ , writeAppend
204 -- *** Appending arrays
206 -- *** Appending arrays
205 , spliceCopy
207 , spliceCopy
206 , spliceWith
208 , spliceWith
208 , spliceExp
210 , spliceExp
209− , spliceUnsafe -- XXX unsafeSplice
211+ , spliceUnsafe
210 -- , putSlice
212 -- , putSlice
211 -- , appendSlice
213 -- , appendSlice
212 -- , appendSliceFrom
214 -- , appendSliceFrom
214− -- ** Serialization using Unbox
217− , pokeSkipUnsafe -- unsafePokeSkip
219− -- ** Deserialization using Unbox
221− , peekUnconsUnsafe -- unsafePeekUncons
222− , peekSkipUnsafe -- unsafePeekSkip
224 -- Arrays of arrays
216 -- Arrays of arrays
225 -- We can add dimensionality parameter to the array type to get
217 -- We can add dimensionality parameter to the array type to get
226 -- multidimensional arrays. Multidimensional arrays would just be a
218 -- multidimensional arrays. Multidimensional arrays would just be a
@@ -242,23 +234,18 @@ module Streamly.Internal.Data.MutArray.Type
243 -- *** Concat
235 -- *** Concat
244 -- | Append the arrays in a stream to form a stream of elements.
236 -- | Append the arrays in a stream to form a stream of elements.
245− , concatWith
237+ , concatChunks
246− , concatRevWith
238+ , concatChunksRev
250 -- *** Compact
240 -- *** Compact
251 -- | Append the arrays in a stream to form a stream of larger arrays.
241 -- | Append the arrays in a stream to form a stream of larger arrays.
252 , SpliceState (..)
242 , SpliceState (..)
253− , pCompactLE
243+ , pCompactChunksLE
254− , pPinnedCompactLE
244+ , rCompactChunksLE
255− , compactLeAs
245+ , fCompactChunksGE
256− , fCompactGE
246+ , lCompactChunksGE
257− , fPinnedCompactGE
247+ , compactChunksGE
258− , lCompactGE
248+ , compactChunksEQ
263 -- ** Utilities
250 -- ** Utilities
264 , roundUpToPower2
251 , roundUpToPower2
@@ -267,7 +254,6 @@ module Streamly.Internal.Data.MutArray.Type
267 , c_memchr
254 , c_memchr
269 -- * Deprecated
256 -- * Deprecated
271 , writeChunks
257 , writeChunks
272 , flattenArrays
258 , flattenArrays
273 , flattenArraysRev
259 , flattenArraysRev
@@ -275,29 +261,6 @@ module Streamly.Internal.Data.MutArray.Type
275 , fromStreamDN
261 , fromStreamDN
276 , fromStreamD
262 , fromStreamD
286− , writeAppendNUnsafe
293− , pinnedWriteNUnsafe
296− , pinnedWriteNAligned -- XXX not required
@@ -353,7 +316,7 @@ import qualified Streamly.Internal.Data.StreamK.Type as K
353import qualified Prelude
316import qualified Prelude
355import Prelude hiding
318import Prelude hiding
356− (Foldable(..), concat, read, unlines, splitAt, reverse, truncate)
319+ (Foldable(..), read, unlines, splitAt, reverse, truncate)
358#include "DocTestDataMutArray.hs"
321#include "DocTestDataMutArray.hs"
@@ -479,8 +442,6 @@ isPinned MutArray{..} = Unboxed.isPinned arrContents
479-- we need more than that. See stg_pinnedNewAlignedByteArrayzh and
442-- we need more than that. See stg_pinnedNewAlignedByteArrayzh and
480-- allocatePinned in GHC source.
443-- allocatePinned in GHC source.
482−-- XXX Rename to emptyAlignedWith, alignSize should be first arg.
484-- | @newArrayWith allocator alignment count@ allocates a new array of zero
445-- | @newArrayWith allocator alignment count@ allocates a new array of zero
485-- length and with a capacity to hold @count@ elements, using @allocator
446-- length and with a capacity to hold @count@ elements, using @allocator
486-- size alignment@ as the memory allocator function.
447-- size alignment@ as the memory allocator function.
@@ -504,25 +465,12 @@ newArrayWith alloc alignSize count = do
504 , arrBound = size
465 , arrBound = size
507−-- For arrays "nil" sounds a bit odd. empty is better. The only problem with
508−-- empty is that it is also used by the Alternative type class. But assuming we
509−-- will mostly import the Array module qualified this should be fine.
511−-- | Create an empty array.
517−empty = MutArray Unboxed.empty 0 0 0
519−{-# DEPRECATED nil "Please use empty instead." #-}
521#ifdef DEVBUILD
469#ifdef DEVBUILD
522 Unbox a =>
470 Unbox a =>
524 MutArray a
472 MutArray a
525−nil = empty
473+nil = MutArray Unboxed.nil 0 0 0
527{-# INLINE newBytesAs #-}
475{-# INLINE newBytesAs #-}
528newBytesAs :: MonadIO m =>
476newBytesAs :: MonadIO m =>
@@ -539,13 +487,12 @@ newBytesAs ps bytes = do
539 , arrBound = bytes
487 , arrBound = bytes
542−-- | Allocates a pinned empty array that with a reserved capacity of bytes.
490+-- | Allocates a pinned empty array that can hold 'count' items. The memory of
543−-- The memory of the array is uninitialized and the allocation is aligned as
491+-- the array is uninitialized and the allocation is aligned as per the
544−-- per the 'Unboxed' instance of the type.
492+-- 'Unboxed' instance of the type.
546-- /Pre-release/
494-- /Pre-release/
547{-# INLINE pinnedNewBytes #-}
495{-# INLINE pinnedNewBytes #-}
548−{-# DEPRECATED pinnedNewBytes "Please use pinnedEmptyOf with appropriate calculation" #-}
549pinnedNewBytes :: MonadIO m =>
496pinnedNewBytes :: MonadIO m =>
550#ifdef DEVBUILD
497#ifdef DEVBUILD
551 Unbox a =>
498 Unbox a =>
@@ -570,31 +517,21 @@ newAs ps =
570 (error "new: alignment is not used in unpinned arrays.")
517 (error "new: alignment is not used in unpinned arrays.")
572-- XXX can unaligned allocation be more efficient when alignment is not needed?
519-- XXX can unaligned allocation be more efficient when alignment is not needed?
574−-- | Allocates a pinned array of zero length but growable to the specified
521+-- | Allocates an empty pinned array that can hold 'count' items. The memory of
575−-- capacity without reallocation.
522+-- the array is uninitialized and the allocation is aligned as per the 'Unboxed'
576−{-# INLINE pinnedEmptyOf #-}
523+-- instance of the type.
577−pinnedEmptyOf :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
524+--
578−pinnedEmptyOf = newAs Pinned
580−-- XXX Deprecate in major
581−-- {-# DEPRECATED pinnedNew "Please use pinnedEmptyOf instead." #-}
582{-# INLINE pinnedNew #-}
525{-# INLINE pinnedNew #-}
583pinnedNew :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
526pinnedNew :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
584−pinnedNew = pinnedEmptyOf
527+pinnedNew = newAs Pinned
586−-- | Allocates an unpinned array of zero length but growable to the specified
529+-- | Allocates an empty unpinned array that can hold 'count' items. The memory
587−-- capacity without reallocation.
530+-- of the array is uninitialized.
589−{-# INLINE emptyOf #-}
590−emptyOf :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
591−emptyOf = newAs Unpinned
593−-- XXX Deprecate in major
594−-- {-# DEPRECATED new "Please use emptyOf instead." #-}
595{-# INLINE new #-}
532{-# INLINE new #-}
596new :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
533new :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
597−new = emptyOf
534+new = newAs Unpinned
599-------------------------------------------------------------------------------
536-------------------------------------------------------------------------------
600-- Random writes
537-- Random writes
@@ -642,7 +579,7 @@ putIndices arr = FL.foldlM' step (return ())
645− step () (i, x) = putIndex i arr x
582+ step () (i, x) = liftIO (putIndex i arr x)
647-- | Modify a given index of an array using a modifier function.
584-- | Modify a given index of an array using a modifier function.
@@ -838,19 +775,22 @@ arrayChunkBytes = 1024
838roundDownTo :: Int -> Int -> Int
775roundDownTo :: Int -> Int -> Int
839roundDownTo elemSize size = size - (size `mod` elemSize)
776roundDownTo elemSize size = size - (size `mod` elemSize)
778+-- XXX See if resizing can be implemented by reading the old array as a stream
779+-- and then using writeN to the new array.
841-- NOTE: we are passing elemSize explicitly to avoid an Unboxed constraint.
781-- NOTE: we are passing elemSize explicitly to avoid an Unboxed constraint.
842-- Since this is not inlined Unboxed consrraint leads to dictionary passing
782-- Since this is not inlined Unboxed consrraint leads to dictionary passing
843-- which complicates some inspection tests.
783-- which complicates some inspection tests.
845−{-# NOINLINE reallocExplicitAs #-}
785+{-# NOINLINE reallocExplicit #-}
846−reallocExplicitAs :: PinnedState -> Int -> Int -> MutArray a -> IO (MutArray a)
786+reallocExplicit :: Int -> Int -> MutArray a -> IO (MutArray a)
847−reallocExplicitAs ps elemSize newCapacityInBytes MutArray{..} = do
787+reallocExplicit elemSize newCapacityInBytes MutArray{..} = do
848 assertM(arrEnd <= arrBound)
788 assertM(arrEnd <= arrBound)
850 -- Allocate new array
790 -- Allocate new array
851 let newCapMaxInBytes = roundUpLargeArray newCapacityInBytes
791 let newCapMaxInBytes = roundUpLargeArray newCapacityInBytes
852 contents <-
792 contents <-
853− if ps == Pinned
793+ if Unboxed.isPinned arrContents
854 then Unboxed.pinnedNew newCapMaxInBytes
794 then Unboxed.pinnedNew newCapMaxInBytes
855 else Unboxed.new newCapMaxInBytes
795 else Unboxed.new newCapMaxInBytes
856 let !(MutByteArray mbarrFrom#) = arrContents
796 let !(MutByteArray mbarrFrom#) = arrContents
@@ -875,10 +815,6 @@ reallocExplicitAs ps elemSize newCapacityInBytes MutArray{..} = do
875 , arrBound = newCapInBytes
815 , arrBound = newCapInBytes
878−-- XXX Should these be called reallocBytes etc?
879−-- XXX We may also need reallocAs to allocate as pinned/unpinned explicitly. In
880−-- fact clone/pinnedClone can be implemented using reallocAs.
882-- | @realloc newCapacity array@ reallocates the array to the specified
818-- | @realloc newCapacity array@ reallocates the array to the specified
883-- capacity in bytes.
819-- capacity in bytes.
@@ -890,12 +826,7 @@ reallocExplicitAs ps elemSize newCapacityInBytes MutArray{..} = do
890-- If the original array is pinned, the newly allocated array is also pinned.
826-- If the original array is pinned, the newly allocated array is also pinned.
891{-# INLINABLE realloc #-}
827{-# INLINABLE realloc #-}
892realloc :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
828realloc :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
898− in liftIO $ reallocExplicitAs ps (SIZE_OF(a)) bytes arr
829+realloc bytes arr = liftIO $ reallocExplicit (SIZE_OF(a)) bytes arr
900-- | @reallocWith label capSizer minIncrBytes array@. The label is used
831-- | @reallocWith label capSizer minIncrBytes array@. The label is used
901-- in error messages and the capSizer is used to determine the capacity of the
832-- in error messages and the capSizer is used to determine the capacity of the
@@ -918,14 +849,14 @@ reallocWith label capSizer minIncrBytes arr = do
920 badSize newSize =
851 badSize newSize =
921− Prelude.concat
852+ concat
923 , ": new array size (in bytes) is less than required size "
854 , ": new array size (in bytes) is less than required size "
924 , show newSize
855 , show newSize
925 , ". Please check the sizing function passed."
856 , ". Please check the sizing function passed."
928−-- | @grow newCapacity array@ changes the total capacity of the array so that
859+-- | @resize newCapacity array@ changes the total capacity of the array so that
929-- it is enough to hold the specified number of elements. Nothing is done if
860-- it is enough to hold the specified number of elements. Nothing is done if
930-- the specified capacity is less than the length of the array.
861-- the specified capacity is less than the length of the array.
@@ -933,46 +864,34 @@ reallocWith label capSizer minIncrBytes arr = do
933-- the block size (4K).
864-- the block size (4K).
935-- /Pre-release/
866-- /Pre-release/
936−{-# INLINE grow #-}
867+{-# INLINE resize #-}
937−grow :: forall m a. (MonadIO m, Unbox a) =>
868+resize :: forall m a. (MonadIO m, Unbox a) =>
938 Int -> MutArray a -> m (MutArray a)
869 Int -> MutArray a -> m (MutArray a)
939−grow nElems arr@MutArray{..} = do
870+resize nElems arr@MutArray{..} = do
940 let req = SIZE_OF(a) * nElems
871 let req = SIZE_OF(a) * nElems
941− cap = arrBound - arrStart
872+ len = arrEnd - arrStart
942− if req < cap
873+ if req < len
943 then return arr
874 then return arr
944 else realloc req arr
875 else realloc req arr
946−{-# DEPRECATED resize "Please use grow instead." #-}
947−{-# INLINE resize #-}
948−resize :: forall m a. (MonadIO m, Unbox a) =>
949− Int -> MutArray a -> m (MutArray a)
952−-- | Like 'grow' but if the requested byte capacity is more than
877+-- | Like 'resize' but if the byte capacity is more than 'largeObjectThreshold'
953−-- 'largeObjectThreshold' then it is rounded up to the closest power of 2.
878+-- then it is rounded up to the closest power of 2.
955-- /Pre-release/
880-- /Pre-release/
956−{-# INLINE growExp #-}
881+{-# INLINE resizeExp #-}
957−growExp :: forall m a. (MonadIO m, Unbox a) =>
882+resizeExp :: forall m a. (MonadIO m, Unbox a) =>
958 Int -> MutArray a -> m (MutArray a)
883 Int -> MutArray a -> m (MutArray a)
959−growExp nElems arr@MutArray{..} = do
884+resizeExp nElems arr@MutArray{..} = do
960 let req = roundUpLargeArray (SIZE_OF(a) * nElems)
885 let req = roundUpLargeArray (SIZE_OF(a) * nElems)
962 if req > largeObjectThreshold
887 if req > largeObjectThreshold
963 then roundUpToPower2 req
888 then roundUpToPower2 req
965− cap = arrBound - arrStart
890+ len = arrEnd - arrStart
966− if req1 < cap
891+ if req1 < len
967 then return arr
892 then return arr
968 else realloc req1 arr
893 else realloc req1 arr
970−{-# DEPRECATED resizeExp "Please use growExp instead." #-}
971−{-# INLINE resizeExp #-}
972−resizeExp :: forall m a. (MonadIO m, Unbox a) =>
973− Int -> MutArray a -> m (MutArray a)
976-- | Resize the allocated memory to drop any reserved free space at the end of
895-- | Resize the allocated memory to drop any reserved free space at the end of
977-- the array and reallocate it to reduce wastage.
896-- the array and reallocate it to reduce wastage.
@@ -1037,7 +956,7 @@ snocUnsafe arr@MutArray{..} = snocNewEnd (INDEX_NEXT(arrEnd,a)) arr
1037{-# INLINE snocMay #-}
956{-# INLINE snocMay #-}
1038snocMay :: forall m a. (MonadIO m, Unbox a) =>
957snocMay :: forall m a. (MonadIO m, Unbox a) =>
1039 MutArray a -> a -> m (Maybe (MutArray a))
958 MutArray a -> a -> m (Maybe (MutArray a))
1040−snocMay arr@MutArray{..} x = do
959+snocMay arr@MutArray{..} x = liftIO $ do
1041 let newEnd = INDEX_NEXT(arrEnd,a)
960 let newEnd = INDEX_NEXT(arrEnd,a)
1042 if newEnd <= arrBound
961 if newEnd <= arrBound
1043 then Just <$> snocNewEnd newEnd arr x
962 then Just <$> snocNewEnd newEnd arr x
@@ -1051,7 +970,7 @@ snocWithRealloc :: forall m a. (MonadIO m, Unbox a) =>
1052 -> m (MutArray a)
971 -> m (MutArray a)
1053snocWithRealloc sizer arr x = do
972snocWithRealloc sizer arr x = do
1054− arr1 <- reallocWith "snocWith" sizer (SIZE_OF(a)) arr
973+ arr1 <- liftIO $ reallocWith "snocWith" sizer (SIZE_OF(a)) arr
1055 snocUnsafe arr1 x
974 snocUnsafe arr1 x
1057-- | @snocWith sizer arr elem@ mutates @arr@ to append @elem@. The length of
976-- | @snocWith sizer arr elem@ mutates @arr@ to append @elem@. The length of
@@ -1073,7 +992,7 @@ snocWith :: forall m a. (MonadIO m, Unbox a) =>
1073 -> MutArray a
992 -> MutArray a
1075 -> m (MutArray a)
994 -> m (MutArray a)
1076−snocWith allocSize arr x = do
995+snocWith allocSize arr x = liftIO $ do
1077 let newEnd = INDEX_NEXT(arrEnd arr,a)
996 let newEnd = INDEX_NEXT(arrEnd arr,a)
1078 if newEnd <= arrBound arr
997 if newEnd <= arrBound arr
1079 then snocNewEnd newEnd arr x
998 then snocNewEnd newEnd arr x
@@ -1117,126 +1036,6 @@ snoc = snocWith f
1117 then oldSize * 2
1036 then oldSize * 2
1118 else roundUpToPower2 oldSize * 2
1037 else roundUpToPower2 oldSize * 2
1120−-------------------------------------------------------------------------------
1121−-- Serialization/Deserialization
1122−-------------------------------------------------------------------------------
1124−{-# INLINE pokeNewEnd #-}
1125−pokeNewEnd :: (MonadIO m, Unbox a) =>
1126− Int -> MutArray Word8 -> a -> m (MutArray Word8)
1127−pokeNewEnd newEnd arr@MutArray{..} x = liftIO $ do
1128− assert (newEnd <= arrBound) (return ())
1129− liftIO $ pokeAt arrEnd arrContents x
1130− return $ arr {arrEnd = newEnd}
1132−-- | Really really unsafe, unboxes a Haskell type and appends the resulting
1133−-- bytes to the byte array, may cause silent data corruption or if you are
1134−-- lucky a segfault if the array does not have enough space to append the
1138−{-# INLINE pokeAppendUnsafe #-}
1139−pokeAppendUnsafe :: forall m a. (MonadIO m, Unbox a) =>
1140− MutArray Word8 -> a -> m (MutArray Word8)
1141−pokeAppendUnsafe arr@MutArray{..} = pokeNewEnd (arrEnd + SIZE_OF(a)) arr
1143−-- | Skip the specified number of bytes in the array. The data in the skipped
1144−-- region remains uninitialzed.
1145−{-# INLINE pokeSkipUnsafe #-}
1146−pokeSkipUnsafe :: Int -> MutArray Word8 -> MutArray Word8
1147−pokeSkipUnsafe n arr@MutArray{..} = do
1148− let newEnd = arrEnd + n
1149− in assert (newEnd <= arrBound) (arr {arrEnd = newEnd})
1151−-- | Like 'pokeAppend' but does not grow the array when pre-allocated array
1152−-- capacity becomes full.
1155−{-# INLINE pokeAppendMay #-}
1156−pokeAppendMay :: forall m a. (MonadIO m, Unbox a) =>
1157− MutArray Word8 -> a -> m (Maybe (MutArray Word8))
1158−pokeAppendMay arr@MutArray{..} x = liftIO $ do
1159− let newEnd = arrEnd + SIZE_OF(a)
1160− if newEnd <= arrBound
1161− then Just <$> pokeNewEnd newEnd arr x
1162− else return Nothing
1164−{-# NOINLINE pokeWithRealloc #-}
1165−pokeWithRealloc :: forall m a. (MonadIO m, Unbox a) =>
1169− -> m (MutArray Word8)
1170−pokeWithRealloc sizer arr x = do
1171− arr1 <- liftIO $ reallocWith "pokeWithRealloc" sizer (SIZE_OF(a)) arr
1172− pokeAppendUnsafe arr1 x
1174−{-# INLINE pokeAppendWith #-}
1175−pokeAppendWith :: forall m a. (MonadIO m, Unbox a) =>
1179− -> m (MutArray Word8)
1180−pokeAppendWith allocSize arr x = liftIO $ do
1181− let newEnd = arrEnd arr + SIZE_OF(a)
1182− if newEnd <= arrBound arr
1183− then pokeNewEnd newEnd arr x
1184− else pokeWithRealloc allocSize arr x
1186−-- | Unbox a Haskell type and append the resulting bytes to a mutable byte
1187−-- array. The array is grown exponentially when more space is needed.
1191−-- >>> pokeAppend arr x = MutArray.castUnsafe <$> MutArray.snoc (MutArray.castUnsafe arr) x
1193−{-# INLINE pokeAppend #-}
1194−pokeAppend :: forall m a. (MonadIO m, Unbox a) =>
1195− MutArray Word8 -> a -> m (MutArray Word8)
1196−pokeAppend = pokeAppendWith f
1201− if isPower2 oldSize
1203− else roundUpToPower2 oldSize * 2
1205−-- | Really really unsafe, create a Haskell value from an unboxed byte array,
1206−-- does not check if the array is big enough, may return garbage or if you are
1207−-- lucky may cause a segfault.
1210−{-# INLINE peekUnconsUnsafe #-}
1211−peekUnconsUnsafe :: forall m a. (MonadIO m, Unbox a) =>
1212− MutArray Word8 -> m (a, MutArray Word8)
1213−peekUnconsUnsafe MutArray{..} = do
1214− let start1 = arrStart + SIZE_OF(a)
1215− assert (start1 <= arrEnd) (return ())
1217− r <- peekAt arrStart arrContents
1218− return (r, MutArray arrContents start1 arrEnd arrBound)
1220−-- | Discard the specified number of bytes in the array.
1221−{-# INLINE peekSkipUnsafe #-}
1222−peekSkipUnsafe :: Int -> MutArray Word8 -> MutArray Word8
1223−peekSkipUnsafe n MutArray{..} =
1224− let start1 = arrStart + n
1225− in assert (start1 <= arrEnd) (MutArray arrContents start1 arrEnd arrBound)
1227−-- | Create a Haskell value from its unboxed representation from the head of a
1228−-- byte array, return the value and the remaining array.
1229−{-# INLINE peekUncons #-}
1230−peekUncons :: forall m a. (MonadIO m, Unbox a) =>
1231− MutArray Word8 -> m (Maybe a, MutArray Word8)
1232−peekUncons arr@MutArray{..} = do
1233− let start1 = arrStart + SIZE_OF(a)
1235− then return (Nothing, arr)
1237− r <- peekAt arrStart arrContents
1238− return (Just r, MutArray arrContents start1 arrEnd arrBound)
1240-------------------------------------------------------------------------------
1039-------------------------------------------------------------------------------
1241-- Random reads
1040-- Random reads
1242-------------------------------------------------------------------------------
1041-------------------------------------------------------------------------------
@@ -1279,10 +1078,10 @@ getIndexRev i MutArray{..} = do
1279data GetIndicesState contents start end st =
1078data GetIndicesState contents start end st =
1280 GetIndicesState contents start end st
1079 GetIndicesState contents start end st
1282−{-# INLINE indexReaderWith #-}
1081+{-# INLINE getIndicesWith #-}
1283−indexReaderWith :: (Monad m, Unbox a) =>
1082+getIndicesWith :: (Monad m, Unbox a) =>
1284 (forall b. IO b -> m b) -> D.Stream m Int -> Unfold m (MutArray a) a
1083 (forall b. IO b -> m b) -> D.Stream m Int -> Unfold m (MutArray a) a
1285−indexReaderWith liftio (D.Stream stepi sti) = Unfold step inject
1084+getIndicesWith liftio (D.Stream stepi sti) = Unfold step inject
@@ -1301,26 +1100,14 @@ indexReaderWith liftio (D.Stream stepi sti) = Unfold step inject
1301 D.Skip s -> return $ D.Skip (GetIndicesState contents start end s)
1100 D.Skip s -> return $ D.Skip (GetIndicesState contents start end s)
1302 D.Stop -> return D.Stop
1101 D.Stop -> return D.Stop
1304−{-# DEPRECATED getIndicesWith "Please use indexReaderWith instead." #-}
1305−{-# INLINE getIndicesWith #-}
1306−getIndicesWith :: (Monad m, Unbox a) =>
1307− (forall b. IO b -> m b) -> D.Stream m Int -> Unfold m (MutArray a) a
1308−getIndicesWith = indexReaderWith
1310-- | Given an unfold that generates array indices, read the elements on those
1103-- | Given an unfold that generates array indices, read the elements on those
1311-- indices from the supplied MutArray. An error is thrown if an index is out of
1104-- indices from the supplied MutArray. An error is thrown if an index is out of
1312-- bounds.
1105-- bounds.
1314-- /Pre-release/
1107-- /Pre-release/
1315−{-# INLINE indexReader #-}
1316−indexReader :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a
1317−indexReader = indexReaderWith liftIO
1319−-- XXX DO NOT REMOVE, change the signature to use Stream instead of unfold
1320−{-# DEPRECATED getIndices "Please use indexReader instead." #-}
1321{-# INLINE getIndices #-}
1108{-# INLINE getIndices #-}
1322getIndices :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a
1109getIndices :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a
1323−getIndices = indexReader
1110+getIndices = getIndicesWith liftIO
1325-------------------------------------------------------------------------------
1112-------------------------------------------------------------------------------
1326-- Subarrays
1113-- Subarrays
@@ -1615,7 +1402,7 @@ chunksOfAs ps n (D.Stream step state) =
1616-- Same as the following but may be more efficient:
1403-- Same as the following but may be more efficient:
1618−-- >>> chunksOf n = Stream.foldMany (MutArray.createOf n)
1405+-- >>> chunksOf n = Stream.foldMany (MutArray.writeN n)
1620-- /Pre-release/
1407-- /Pre-release/
1621{-# INLINE_NORMAL chunksOf #-}
1408{-# INLINE_NORMAL chunksOf #-}
@@ -1624,14 +1411,14 @@ chunksOf :: forall m a. (MonadIO m, Unbox a)
1624-- XXX the idiomatic implementation leads to large regression in the D.reverse'
1411-- XXX the idiomatic implementation leads to large regression in the D.reverse'
1625-- benchmark. It seems it has difficulty producing optimized code when
1412-- benchmark. It seems it has difficulty producing optimized code when
1626-- converting to StreamK. Investigate GHC optimizations.
1413-- converting to StreamK. Investigate GHC optimizations.
1627−-- chunksOf n = D.foldMany (createOf n)
1414+-- chunksOf n = D.foldMany (writeN n)
1628chunksOf = chunksOfAs Unpinned
1415chunksOf = chunksOfAs Unpinned
1630-- | Like 'chunksOf' but creates pinned arrays.
1417-- | Like 'chunksOf' but creates pinned arrays.
1631{-# INLINE_NORMAL pinnedChunksOf #-}
1418{-# INLINE_NORMAL pinnedChunksOf #-}
1632pinnedChunksOf :: forall m a. (MonadIO m, Unbox a)
1419pinnedChunksOf :: forall m a. (MonadIO m, Unbox a)
1633 => Int -> D.Stream m a -> D.Stream m (MutArray a)
1420 => Int -> D.Stream m a -> D.Stream m (MutArray a)
1634−-- pinnedChunksOf n = D.foldMany (pinnedCreateOf n)
1421+-- pinnedChunksOf n = D.foldMany (pinnedWriteN n)
1635pinnedChunksOf = chunksOfAs Pinned
1422pinnedChunksOf = chunksOfAs Pinned
1637-- | When we are buffering a stream of unknown size into an array we do not
1424-- | When we are buffering a stream of unknown size into an array we do not
@@ -1664,10 +1451,16 @@ data FlattenState s contents a =
1664 OuterLoop s
1451 OuterLoop s
1665 | InnerLoop s contents !Int !Int
1452 | InnerLoop s contents !Int !Int
1454+-- | Use the "reader" unfold instead.
1456+-- @concatChunks = unfoldMany reader@
1458+-- We can try this if there are any fusion issues in the unfold.
1667−{-# INLINE_NORMAL concatWith #-}
1460+{-# INLINE_NORMAL concatChunks #-}
1668−concatWith :: forall m a. (Monad m, Unbox a)
1461+concatChunks :: forall m a. (MonadIO m, Unbox a)
1669− => (forall b. IO b -> m b) -> D.Stream m (MutArray a) -> D.Stream m a
1462+ => D.Stream m (MutArray a) -> D.Stream m a
1670−concatWith liftio (D.Stream step state) = D.Stream step' (OuterLoop state)
1463+concatChunks (D.Stream step state) = D.Stream step' (OuterLoop state)
@@ -1684,30 +1477,24 @@ concatWith liftio (D.Stream step state) = D.Stream step' (OuterLoop state)
1684 return $ D.Skip $ OuterLoop st
1477 return $ D.Skip $ OuterLoop st
1686 step' _ (InnerLoop st contents p end) = do
1479 step' _ (InnerLoop st contents p end) = do
1687− x <- liftio $ peekAt p contents
1480+ x <- liftIO $ peekAt p contents
1688 return $ D.Yield x (InnerLoop st contents (INDEX_NEXT(p,a)) end)
1481 return $ D.Yield x (InnerLoop st contents (INDEX_NEXT(p,a)) end)
1483+{-# DEPRECATED flattenArrays "Please use \"unfoldMany reader\" instead." #-}
1484+flattenArrays :: forall m a. (MonadIO m, Unbox a)
1485+ => D.Stream m (MutArray a) -> D.Stream m a
1486+flattenArrays = concatChunks
1690−-- | Use the "reader" unfold instead.
1488+-- | Use the "readerRev" unfold instead.
1692−-- @concat = unfoldMany reader@
1490+-- @concatChunks = unfoldMany readerRev@
1694-- We can try this if there are any fusion issues in the unfold.
1492-- We can try this if there are any fusion issues in the unfold.
1696−{-# INLINE_NORMAL concat #-}
1494+{-# INLINE_NORMAL concatChunksRev #-}
1697−concat :: forall m a. (MonadIO m, Unbox a)
1495+concatChunksRev :: forall m a. (MonadIO m, Unbox a)
1698 => D.Stream m (MutArray a) -> D.Stream m a
1496 => D.Stream m (MutArray a) -> D.Stream m a
1699−concat = concatWith liftIO
1701−{-# DEPRECATED flattenArrays "Please use \"unfoldMany reader\" instead." #-}
1702−{-# INLINE flattenArrays #-}
1703−flattenArrays :: forall m a. (MonadIO m, Unbox a)
1704− => D.Stream m (MutArray a) -> D.Stream m a
1705−flattenArrays = concat
1707−{-# INLINE_NORMAL concatRevWith #-}
1708−concatRevWith :: forall m a. (Monad m, Unbox a)
1709− => (forall b. IO b -> m b) -> D.Stream m (MutArray a) -> D.Stream m a
1710−concatRevWith liftio (D.Stream step state) = D.Stream step' (OuterLoop state)
1497+concatChunksRev (D.Stream step state) = D.Stream step' (OuterLoop state)
@@ -1725,26 +1512,14 @@ concatRevWith liftio (D.Stream step state) = D.Stream step' (OuterLoop state)
1725 return $ D.Skip $ OuterLoop st
1512 return $ D.Skip $ OuterLoop st
1727 step' _ (InnerLoop st contents p start) = do
1514 step' _ (InnerLoop st contents p start) = do
1728− x <- liftio $ peekAt p contents
1515+ x <- liftIO $ peekAt p contents
1729 let cur = INDEX_PREV(p,a)
1516 let cur = INDEX_PREV(p,a)
1730 return $ D.Yield x (InnerLoop st contents cur start)
1517 return $ D.Yield x (InnerLoop st contents cur start)
1732−-- | Use the "readerRev" unfold instead.
1734−-- @concat = unfoldMany readerRev@
1736−-- We can try this if there are any fusion issues in the unfold.
1738−{-# INLINE_NORMAL concatRev #-}
1739−concatRev :: forall m a. (MonadIO m, Unbox a)
1740− => D.Stream m (MutArray a) -> D.Stream m a
1741−concatRev = concatRevWith liftIO
1743{-# DEPRECATED flattenArraysRev "Please use \"unfoldMany readerRev\" instead." #-}
1519{-# DEPRECATED flattenArraysRev "Please use \"unfoldMany readerRev\" instead." #-}
1744−{-# INLINE flattenArraysRev #-}
1745flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
1520flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
1746 => D.Stream m (MutArray a) -> D.Stream m a
1521 => D.Stream m (MutArray a) -> D.Stream m a
1747−flattenArraysRev = concatRev
1522+flattenArraysRev = concatChunksRev
1749-------------------------------------------------------------------------------
1524-------------------------------------------------------------------------------
1750-- Unfolds
1525-- Unfolds
@@ -1973,7 +1748,7 @@ foldr f z arr = D.foldr f z $ read arr
1974-- XXX Keep the bound intact to not lose any free space? Perf impact?
1749-- XXX Keep the bound intact to not lose any free space? Perf impact?
1976−-- | @unsafeAppendN n arr@ appends up to @n@ input items to the supplied
1751+-- | @writeAppendNUnsafe n arr@ appends up to @n@ input items to the supplied
1977-- array.
1752-- array.
1979-- Unsafe: Do not drive the fold beyond @n@ elements, it will lead to memory
1754-- Unsafe: Do not drive the fold beyond @n@ elements, it will lead to memory
@@ -1982,12 +1757,13 @@ foldr f z arr = D.foldr f z $ read arr
1982-- Any free space left in the array after appending @n@ elements is lost.
1757-- Any free space left in the array after appending @n@ elements is lost.
1984-- /Internal/
1759-- /Internal/
1985−{-# INLINE_NORMAL unsafeAppendN #-}
1760+{-# INLINE_NORMAL writeAppendNUnsafe #-}
1986−unsafeAppendN :: forall m a. (MonadIO m, Unbox a) =>
1761+writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) =>
1988 -> m (MutArray a)
1763 -> m (MutArray a)
1989 -> Fold m a (MutArray a)
1764 -> Fold m a (MutArray a)
1765+writeAppendNUnsafe n action =
1990−unsafeAppendN n action = fmap fromArrayUnsafe $ FL.foldlM' step initial
1766+ fmap fromArrayUnsafe $ FL.foldlM' step initial
@@ -2000,7 +1776,7 @@ unsafeAppendN n action = fmap fromArrayUnsafe $ FL.foldlM' step initial
2000 -- otherwise we lose that space.
1776 -- otherwise we lose that space.
2002 if free < needed
1778 if free < needed
2003− then noinline reallocWith "unsafeAppendN" (+ needed) needed arr
1779+ then noinline reallocWith "writeAppendNUnsafeWith" (+ needed) needed arr
2004 else return arr
1780 else return arr
2005 return $ toArrayUnsafe arr1
1781 return $ toArrayUnsafe arr1
@@ -2008,51 +1784,30 @@ unsafeAppendN n action = fmap fromArrayUnsafe $ FL.foldlM' step initial
2008 liftIO $ pokeAt end contents x
1784 liftIO $ pokeAt end contents x
2009 return $ ArrayUnsafe contents start (INDEX_NEXT(end,a))
1785 return $ ArrayUnsafe contents start (INDEX_NEXT(end,a))
2011−{-# DEPRECATED writeAppendNUnsafe "Please use unsafeAppendN instead." #-}
2012−{-# INLINE writeAppendNUnsafe #-}
2013−writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) =>
2016− -> Fold m a (MutArray a)
2017−writeAppendNUnsafe = unsafeAppendN
2019-- | Append @n@ elements to an existing array. Any free space left in the array
1787-- | Append @n@ elements to an existing array. Any free space left in the array
2020-- after appending @n@ elements is lost.
1788-- after appending @n@ elements is lost.
2022−-- >>> appendN n initial = Fold.take n (MutArray.unsafeAppendN n initial)
1790+-- >>> writeAppendN n initial = Fold.take n (MutArray.writeAppendNUnsafe n initial)
2024−{-# INLINE_NORMAL appendN #-}
1792+{-# INLINE_NORMAL writeAppendN #-}
2025−appendN :: forall m a. (MonadIO m, Unbox a) =>
2026− Int -> m (MutArray a) -> Fold m a (MutArray a)
2027−appendN n initial = FL.take n (unsafeAppendN n initial)
2029−-- XXX Deprecate in major
2030−-- {-# DEPRECATED writeAppendN "Please use appendN instead." #-}
2031−{-# INLINE writeAppendN #-}
2032writeAppendN :: forall m a. (MonadIO m, Unbox a) =>
1793writeAppendN :: forall m a. (MonadIO m, Unbox a) =>
2033 Int -> m (MutArray a) -> Fold m a (MutArray a)
1794 Int -> m (MutArray a) -> Fold m a (MutArray a)
2034−writeAppendN = appendN
1795+writeAppendN n initial = FL.take n (writeAppendNUnsafe n initial)
2036−-- | @appendWith realloc action@ mutates the array generated by @action@ to
1797+-- | @writeAppendWith realloc action@ mutates the array generated by @action@ to
2037-- append the input stream. If there is no reserved space available in the
1798-- append the input stream. If there is no reserved space available in the
2038-- array it is reallocated to a size in bytes determined by @realloc oldSize@,
1799-- array it is reallocated to a size in bytes determined by @realloc oldSize@,
2039-- where @oldSize@ is the current size of the array in bytes.
1800-- where @oldSize@ is the current size of the array in bytes.
2041-- Note that the returned array may be a mutated version of original array.
1802-- Note that the returned array may be a mutated version of original array.
2043−-- >>> appendWith sizer = Fold.foldlM' (MutArray.snocWith sizer)
1804+-- >>> writeAppendWith sizer = Fold.foldlM' (MutArray.snocWith sizer)
2045-- /Pre-release/
1806-- /Pre-release/
2046−{-# INLINE appendWith #-}
2047−appendWith :: forall m a. (MonadIO m, Unbox a) =>
2048− (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)
2049−appendWith sizer = FL.foldlM' (snocWith sizer)
2051−{-# DEPRECATED writeAppendWith "Please use appendWith instead." #-}
2052{-# INLINE writeAppendWith #-}
1807{-# INLINE writeAppendWith #-}
2053writeAppendWith :: forall m a. (MonadIO m, Unbox a) =>
1808writeAppendWith :: forall m a. (MonadIO m, Unbox a) =>
2054 (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)
1809 (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)
2055−writeAppendWith = appendWith
1810+writeAppendWith sizer = FL.foldlM' (snocWith sizer)
2057-- | @append action@ mutates the array generated by @action@ to append the
1812-- | @append action@ mutates the array generated by @action@ to append the
2058-- input stream. If there is no reserved space available in the array it is
1813-- input stream. If there is no reserved space available in the array it is
@@ -2060,33 +1815,26 @@ writeAppendWith = appendWith
2061-- Note that the returned array may be a mutated version of original array.
1816-- Note that the returned array may be a mutated version of original array.
2063−-- >>> append = MutArray.appendWith (* 2)
1818+-- >>> writeAppend = MutArray.writeAppendWith (* 2)
2065−{-# INLINE append #-}
2066−append :: forall m a. (MonadIO m, Unbox a) =>
2067− m (MutArray a) -> Fold m a (MutArray a)
2068−append = appendWith (* 2)
2070−-- XXX Deprecate in major
2071−-- {-# DEPRECATED writeAppend "Please use append instead." #-}
2072{-# INLINE writeAppend #-}
1820{-# INLINE writeAppend #-}
2073writeAppend :: forall m a. (MonadIO m, Unbox a) =>
1821writeAppend :: forall m a. (MonadIO m, Unbox a) =>
2074 m (MutArray a) -> Fold m a (MutArray a)
1822 m (MutArray a) -> Fold m a (MutArray a)
2075−writeAppend = append
1823+writeAppend = writeAppendWith (* 2)
2077-- XXX We can carry bound as well in the state to make sure we do not lose the
1825-- XXX We can carry bound as well in the state to make sure we do not lose the
2078-- remaining capacity. Need to check perf impact.
1826-- remaining capacity. Need to check perf impact.
2080−-- | Like 'unsafeCreateOf' but takes a new array allocator @alloc size@
1828+-- | Like 'writeNUnsafe' but takes a new array allocator @alloc size@ function
2081−-- function as argument.
1829+-- as argument.
2083−-- >>> unsafeCreateOfWith alloc n = MutArray.unsafeAppendN (alloc n) n
1831+-- >>> writeNWithUnsafe alloc n = MutArray.writeAppendNUnsafe (alloc n) n
2085-- /Pre-release/
1833-- /Pre-release/
2086−{-# INLINE_NORMAL unsafeCreateOfWith #-}
1834+{-# INLINE_NORMAL writeNWithUnsafe #-}
2087−unsafeCreateOfWith :: forall m a. (MonadIO m, Unbox a)
1835+writeNWithUnsafe :: forall m a. (MonadIO m, Unbox a)
2088 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
1836 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2089−unsafeCreateOfWith alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
1837+writeNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
@@ -2097,64 +1845,40 @@ unsafeCreateOfWith alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
2098 $ ArrayUnsafe contents start (INDEX_NEXT(end,a))
1846 $ ArrayUnsafe contents start (INDEX_NEXT(end,a))
2100−{-# DEPRECATED writeNWithUnsafe "Please use unsafeCreateOfWith instead." #-}
2101−{-# INLINE writeNWithUnsafe #-}
2102−writeNWithUnsafe :: forall m a. (MonadIO m, Unbox a)
2103− => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2104−writeNWithUnsafe = unsafeCreateOfWith
2106{-# INLINE_NORMAL writeNUnsafeAs #-}
1848{-# INLINE_NORMAL writeNUnsafeAs #-}
2107writeNUnsafeAs :: forall m a. (MonadIO m, Unbox a)
1849writeNUnsafeAs :: forall m a. (MonadIO m, Unbox a)
2108 => PinnedState -> Int -> Fold m a (MutArray a)
1850 => PinnedState -> Int -> Fold m a (MutArray a)
2109−writeNUnsafeAs ps = unsafeCreateOfWith (newAs ps)
1851+writeNUnsafeAs ps = writeNWithUnsafe (newAs ps)
2111−-- | Like 'createOf' but does not check the array bounds when writing. The fold
1853+-- | Like 'writeN' but does not check the array bounds when writing. The fold
2112-- driver must not call the step function more than 'n' times otherwise it will
1854-- driver must not call the step function more than 'n' times otherwise it will
2113-- corrupt the memory and crash. This function exists mainly because any
1855-- corrupt the memory and crash. This function exists mainly because any
2114-- conditional in the step function blocks fusion causing 10x performance
1856-- conditional in the step function blocks fusion causing 10x performance
2115-- slowdown.
1857-- slowdown.
2117−-- >>> unsafeCreateOf = MutArray.unsafeCreateOfWith MutArray.emptyOf
1859+-- >>> writeNUnsafe = MutArray.writeNWithUnsafe MutArray.new
2119−{-# INLINE_NORMAL unsafeCreateOf #-}
2120−unsafeCreateOf :: forall m a. (MonadIO m, Unbox a)
2121− => Int -> Fold m a (MutArray a)
2122−unsafeCreateOf = writeNUnsafeAs Unpinned
2124−{-# DEPRECATED writeNUnsafe "Please use unsafeCreateOf instead." #-}
2125−{-# INLINE writeNUnsafe #-}
1861+{-# INLINE_NORMAL writeNUnsafe #-}
2126writeNUnsafe :: forall m a. (MonadIO m, Unbox a)
1862writeNUnsafe :: forall m a. (MonadIO m, Unbox a)
2127 => Int -> Fold m a (MutArray a)
1863 => Int -> Fold m a (MutArray a)
2128−writeNUnsafe = unsafeCreateOf
1864+writeNUnsafe = writeNUnsafeAs Unpinned
2130−-- | Like 'unsafeCreateOf' but creates a pinned array.
1866+-- | Like 'writeNUnsafe' but creates a pinned array.
2131−{-# INLINE_NORMAL unsafePinnedCreateOf #-}
2132−unsafePinnedCreateOf :: forall m a. (MonadIO m, Unbox a)
2133− => Int -> Fold m a (MutArray a)
2134−unsafePinnedCreateOf = writeNUnsafeAs Pinned
2136−{-# DEPRECATED pinnedWriteNUnsafe "Please use unsafePinnedCreateOf instead." #-}
2137−{-# INLINE pinnedWriteNUnsafe #-}
1867+{-# INLINE_NORMAL pinnedWriteNUnsafe #-}
2138pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a)
1868pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a)
2139 => Int -> Fold m a (MutArray a)
1869 => Int -> Fold m a (MutArray a)
2140−pinnedWriteNUnsafe = unsafePinnedCreateOf
1870+pinnedWriteNUnsafe = writeNUnsafeAs Pinned
2142−-- | @createOfWith alloc n@ folds a maximum of @n@ elements into an array
1872+-- | @writeNWith alloc n@ folds a maximum of @n@ elements into an array
2143-- allocated using the @alloc@ function.
1873-- allocated using the @alloc@ function.
2145−-- >>> createOfWith alloc n = Fold.take n (MutArray.unsafeCreateOfWith alloc n)
1875+-- >>> writeNWith alloc n = Fold.take n (MutArray.writeNWithUnsafe alloc n)
2146−-- >>> createOfWith alloc n = MutArray.appendN (alloc n) n
1876+-- >>> writeNWith alloc n = MutArray.writeAppendN (alloc n) n
2148−{-# INLINE_NORMAL createOfWith #-}
1878+{-# INLINE_NORMAL writeNWith #-}
2149−createOfWith :: forall m a. (MonadIO m, Unbox a)
2150− => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2151−createOfWith alloc n = FL.take n (unsafeCreateOfWith alloc n)
2153−-- {-# DEPRECATED writeNWith "Please use createOfWith instead." #-}
2154−{-# INLINE writeNWith #-}
2155writeNWith :: forall m a. (MonadIO m, Unbox a)
1879writeNWith :: forall m a. (MonadIO m, Unbox a)
2156 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
1880 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2157−writeNWith = createOfWith
1881+writeNWith alloc n = FL.take n (writeNWithUnsafe alloc n)
2159{-# INLINE_NORMAL writeNAs #-}
1883{-# INLINE_NORMAL writeNAs #-}
2160writeNAs ::
1884writeNAs ::
@@ -2162,42 +1886,28 @@ writeNAs ::
2162 => PinnedState
1886 => PinnedState
2164 -> Fold m a (MutArray a)
1888 -> Fold m a (MutArray a)
2165−writeNAs ps = createOfWith (newAs ps)
1889+writeNAs ps = writeNWith (newAs ps)
2167−-- | @createOf n@ folds a maximum of @n@ elements from the input stream to an
1891+-- | @writeN n@ folds a maximum of @n@ elements from the input stream to an
2168-- 'MutArray'.
1892-- 'MutArray'.
2170−-- >>> createOf = MutArray.createOfWith MutArray.new
1894+-- >>> writeN = MutArray.writeNWith MutArray.new
2171−-- >>> createOf n = Fold.take n (MutArray.unsafeCreateOf n)
1895+-- >>> writeN n = Fold.take n (MutArray.writeNUnsafe n)
2172−-- >>> createOf n = MutArray.appendN n (MutArray.emptyOf n)
1896+-- >>> writeN n = MutArray.writeAppendN n (MutArray.new n)
2174−{-# INLINE_NORMAL createOf #-}
1898+{-# INLINE_NORMAL writeN #-}
2175−createOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2176−createOf = writeNAs Unpinned
2178−-- XXX Deprecate in major
2179−-- {-# DEPRECATED writeN "Please use createOf instead." #-}
2180−{-# INLINE writeN #-}
2181writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
1899writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2182−writeN = createOf
1900+writeN = writeNAs Unpinned
2184−-- | Like 'createOf' but creates a pinned array.
1902+-- | Like 'writeN' but creates a pinned array.
2185−{-# INLINE_NORMAL pinnedCreateOf #-}
2187− forall m a. (MonadIO m, Unbox a)
2189− -> Fold m a (MutArray a)
2190−pinnedCreateOf = writeNAs Pinned
2192−{-# DEPRECATED pinnedWriteN "Please use pinnedCreateOf instead." #-}
2193−{-# INLINE pinnedWriteN #-}
1903+{-# INLINE_NORMAL pinnedWriteN #-}
2194pinnedWriteN ::
1904pinnedWriteN ::
2195 forall m a. (MonadIO m, Unbox a)
1905 forall m a. (MonadIO m, Unbox a)
2197 -> Fold m a (MutArray a)
1907 -> Fold m a (MutArray a)
2198−pinnedWriteN = pinnedCreateOf
1908+pinnedWriteN = writeNAs Pinned
2200−-- | Like unsafeCreateOfWith but writes the array in reverse order.
1910+-- | Like writeNWithUnsafe but writes the array in reverse order.
2202-- /Internal/
1912-- /Internal/
2203{-# INLINE_NORMAL writeRevNWithUnsafe #-}
1913{-# INLINE_NORMAL writeRevNWithUnsafe #-}
@@ -2218,7 +1928,7 @@ writeRevNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
2219 $ ArrayUnsafe contents ptr end
1929 $ ArrayUnsafe contents ptr end
2221−-- | Like createOfWith but writes the array in reverse order.
1931+-- | Like writeNWith but writes the array in reverse order.
2223-- /Internal/
1933-- /Internal/
2224{-# INLINE_NORMAL writeRevNWith #-}
1934{-# INLINE_NORMAL writeRevNWith #-}
@@ -2226,36 +1936,31 @@ writeRevNWith :: forall m a. (MonadIO m, Unbox a)
2226 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
1936 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2227writeRevNWith alloc n = FL.take n (writeRevNWithUnsafe alloc n)
1937writeRevNWith alloc n = FL.take n (writeRevNWithUnsafe alloc n)
2229−-- | Like 'createOf' but writes the array in reverse order.
1939+-- | Like writeN but writes the array in reverse order.
2231-- /Pre-release/
1941-- /Pre-release/
2232−{-# INLINE_NORMAL revCreateOf #-}
1942+{-# INLINE_NORMAL writeRevN #-}
2233−revCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2234−revCreateOf = writeRevNWith new
2236−{-# DEPRECATED writeRevN "Please use revCreateOf instead." #-}
2237−{-# INLINE writeRevN #-}
2238writeRevN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
1943writeRevN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2239−writeRevN = revCreateOf
1944+writeRevN = writeRevNWith new
2241-- | @pinnedWriteNAligned align n@ folds a maximum of @n@ elements from the
1946-- | @pinnedWriteNAligned align n@ folds a maximum of @n@ elements from the
2242-- input stream to a 'MutArray' aligned to the given size.
1947-- input stream to a 'MutArray' aligned to the given size.
2244−-- >>> pinnedWriteNAligned align = MutArray.createOfWith (MutArray.pinnedNewAligned align)
1949+-- >>> pinnedWriteNAligned align = MutArray.writeNWith (MutArray.pinnedNewAligned align)
2245−-- >>> pinnedWriteNAligned align n = MutArray.appendN n (MutArray.pinnedNewAligned align n)
1950+-- >>> pinnedWriteNAligned align n = MutArray.writeAppendN n (MutArray.pinnedNewAligned align n)
2247-- /Pre-release/
1952-- /Pre-release/
2249{-# INLINE_NORMAL pinnedWriteNAligned #-}
1954{-# INLINE_NORMAL pinnedWriteNAligned #-}
2250pinnedWriteNAligned :: forall m a. (MonadIO m, Unbox a)
1955pinnedWriteNAligned :: forall m a. (MonadIO m, Unbox a)
2251 => Int -> Int -> Fold m a (MutArray a)
1956 => Int -> Int -> Fold m a (MutArray a)
2252−pinnedWriteNAligned align = createOfWith (pinnedNewAligned align)
1957+pinnedWriteNAligned align = writeNWith (pinnedNewAligned align)
2254-- XXX Buffer to a list instead?
1959-- XXX Buffer to a list instead?
2256-- | Buffer a stream into a stream of arrays.
1961-- | Buffer a stream into a stream of arrays.
2258−-- >>> buildChunks n = Fold.many (MutArray.createOf n) Fold.toStreamK
1963+-- >>> buildChunks n = Fold.many (MutArray.writeN n) Fold.toStreamK
2260-- Breaking an array into an array stream can be useful to consume a large
1965-- Breaking an array into an array stream can be useful to consume a large
2261-- array sequentially such that memory of the array is released incrementatlly.
1966-- array sequentially such that memory of the array is released incrementatlly.
@@ -2267,10 +1972,9 @@ pinnedWriteNAligned align = createOfWith (pinnedNewAligned align)
2267{-# INLINE_NORMAL buildChunks #-}
1972{-# INLINE_NORMAL buildChunks #-}
2268buildChunks :: (MonadIO m, Unbox a) =>
1973buildChunks :: (MonadIO m, Unbox a) =>
2269 Int -> Fold m a (StreamK n (MutArray a))
1974 Int -> Fold m a (StreamK n (MutArray a))
2270−buildChunks n = FL.many (createOf n) FL.toStreamK
1975+buildChunks n = FL.many (writeN n) FL.toStreamK
2272{-# DEPRECATED writeChunks "Please use buildChunks instead." #-}
1977{-# DEPRECATED writeChunks "Please use buildChunks instead." #-}
2273−{-# INLINE writeChunks #-}
2274writeChunks :: (MonadIO m, Unbox a) =>
1978writeChunks :: (MonadIO m, Unbox a) =>
2275 Int -> Fold m a (StreamK n (MutArray a))
1979 Int -> Fold m a (StreamK n (MutArray a))
2276writeChunks = buildChunks
1980writeChunks = buildChunks
@@ -2278,29 +1982,29 @@ writeChunks = buildChunks
2278{-# INLINE_NORMAL writeWithAs #-}
1982{-# INLINE_NORMAL writeWithAs #-}
2279writeWithAs :: forall m a. (MonadIO m, Unbox a)
1983writeWithAs :: forall m a. (MonadIO m, Unbox a)
2280 => PinnedState -> Int -> Fold m a (MutArray a)
1984 => PinnedState -> Int -> Fold m a (MutArray a)
2281−-- writeWithAs ps n = FL.rmapM rightSize $ appendWith (* 2) (newAs ps n)
1985+-- writeWithAs ps n = FL.rmapM rightSize $ writeAppendWith (* 2) (newAs ps n)
2282writeWithAs ps elemCount =
1986writeWithAs ps elemCount =
2283 FL.rmapM extract $ FL.foldlM' step initial
1987 FL.rmapM extract $ FL.foldlM' step initial
2287 initial = do
1991 initial = do
2288− when (elemCount < 0) $ error "createWith: elemCount is negative"
1992+ when (elemCount < 0) $ error "writeWith: elemCount is negative"
2289− newAs ps elemCount
1993+ liftIO $ newAs ps elemCount
2291 step arr@(MutArray _ start end bound) x
1995 step arr@(MutArray _ start end bound) x
2292 | INDEX_NEXT(end,a) > bound = do
1996 | INDEX_NEXT(end,a) > bound = do
2293 let oldSize = end - start
1997 let oldSize = end - start
2294 newSize = max (oldSize * 2) 1
1998 newSize = max (oldSize * 2) 1
2295− arr1 <- liftIO $ reallocExplicitAs ps (SIZE_OF(a)) newSize arr
1999+ arr1 <- liftIO $ reallocExplicit (SIZE_OF(a)) newSize arr
2296 snocUnsafe arr1 x
2000 snocUnsafe arr1 x
2297 step arr x = snocUnsafe arr x
2001 step arr x = snocUnsafe arr x
2299 extract = liftIO . rightSize
2003 extract = liftIO . rightSize
2301−-- XXX Compare createWith with fromStreamD which uses an array of streams
2005+-- XXX Compare writeWith with fromStreamD which uses an array of streams
2302-- implementation. We can write this using buildChunks above if that is faster.
2006-- implementation. We can write this using buildChunks above if that is faster.
2303−-- If createWith is faster then we should use that to implement
2007+-- If writeWith is faster then we should use that to implement
2304-- fromStreamD.
2008-- fromStreamD.
2306-- XXX The realloc based implementation needs to make one extra copy if we use
2010-- XXX The realloc based implementation needs to make one extra copy if we use
@@ -2315,56 +2019,39 @@ writeWithAs ps elemCount =
2315-- XXX check if GHC's memory allocator is efficient enough. We can try the C
2019-- XXX check if GHC's memory allocator is efficient enough. We can try the C
2316-- malloc to compare against.
2020-- malloc to compare against.
2318−-- | @createWith minCount@ folds the whole input to a single array. The array
2022+-- | @writeWith minCount@ folds the whole input to a single array. The array
2319-- starts at a size big enough to hold minCount elements, the size is doubled
2023-- starts at a size big enough to hold minCount elements, the size is doubled
2320-- every time the array needs to be grown.
2024-- every time the array needs to be grown.
2322-- /Caution! Do not use this on infinite streams./
2026-- /Caution! Do not use this on infinite streams./
2324−-- >>> f n = MutArray.appendWith (* 2) (MutArray.emptyOf n)
2028+-- >>> f n = MutArray.writeAppendWith (* 2) (MutArray.new n)
2325−-- >>> createWith n = Fold.rmapM MutArray.rightSize (f n)
2029+-- >>> writeWith n = Fold.rmapM MutArray.rightSize (f n)
2326−-- >>> createWith n = Fold.rmapM MutArray.fromChunksK (MutArray.buildChunks n)
2030+-- >>> writeWith n = Fold.rmapM MutArray.fromChunksK (MutArray.buildChunks n)
2328-- /Pre-release/
2032-- /Pre-release/
2329−{-# INLINE_NORMAL createWith #-}
2033+{-# INLINE_NORMAL writeWith #-}
2330−createWith :: forall m a. (MonadIO m, Unbox a)
2331− => Int -> Fold m a (MutArray a)
2332−-- createWith n = FL.rmapM rightSize $ appendWith (* 2) (emptyOf n)
2333−createWith = writeWithAs Unpinned
2335−{-# DEPRECATED writeWith "Please use createWith instead." #-}
2336−{-# INLINE writeWith #-}
2337writeWith :: forall m a. (MonadIO m, Unbox a)
2034writeWith :: forall m a. (MonadIO m, Unbox a)
2338 => Int -> Fold m a (MutArray a)
2035 => Int -> Fold m a (MutArray a)
2339−writeWith = createWith
2036+-- writeWith n = FL.rmapM rightSize $ writeAppendWith (* 2) (new n)
2037+writeWith = writeWithAs Unpinned
2341-- | Fold the whole input to a single array.
2039-- | Fold the whole input to a single array.
2343−-- Same as 'createWith' using an initial array size of 'arrayChunkBytes' bytes
2041+-- Same as 'writeWith' using an initial array size of 'arrayChunkBytes' bytes
2344-- rounded up to the element size.
2042-- rounded up to the element size.
2346-- /Caution! Do not use this on infinite streams./
2044-- /Caution! Do not use this on infinite streams./
2348−{-# INLINE create #-}
2349−create :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2350−create = createWith (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
2352−-- XXX Deprecate in major
2353−-- {-# DEPRECATED write "Please use create instead." #-}
2354{-# INLINE write #-}
2046{-# INLINE write #-}
2355write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2047write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2358−-- | Like 'create' but creates a pinned array.
2359−{-# INLINE pinnedCreate #-}
2360−pinnedCreate :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2362− writeWithAs Pinned (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
2048+write = writeWith (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
2364−{-# DEPRECATED pinnedWrite "Please use pinnedCreate instead." #-}
2050+-- | Like 'write' but creates a pinned array.
2365{-# INLINE pinnedWrite #-}
2051{-# INLINE pinnedWrite #-}
2366pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2052pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2367−pinnedWrite = pinnedCreate
2053+pinnedWrite =
2054+ writeWithAs Pinned (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
2369-------------------------------------------------------------------------------
2056-------------------------------------------------------------------------------
2370-- construct from streams, known size
2057-- construct from streams, known size
@@ -2374,7 +2061,7 @@ pinnedWrite = pinnedCreate
2374fromStreamDNAs :: forall m a. (MonadIO m, Unbox a)
2061fromStreamDNAs :: forall m a. (MonadIO m, Unbox a)
2375 => PinnedState -> Int -> D.Stream m a -> m (MutArray a)
2062 => PinnedState -> Int -> D.Stream m a -> m (MutArray a)
2376fromStreamDNAs ps limit str = do
2063fromStreamDNAs ps limit str = do
2377− (arr :: MutArray a) <- newAs ps limit
2064+ (arr :: MutArray a) <- liftIO $ newAs ps limit
2378 end <- D.foldlM' (fwrite (arrContents arr)) (return $ arrEnd arr) $ D.take limit str
2065 end <- D.foldlM' (fwrite (arrContents arr)) (return $ arrEnd arr) $ D.take limit str
2379 return $ arr {arrEnd = end}
2066 return $ arr {arrEnd = end}
@@ -2384,18 +2071,17 @@ fromStreamDNAs ps limit str = do
2384 liftIO $ pokeAt ptr arrContents x
2071 liftIO $ pokeAt ptr arrContents x
2385 return $ INDEX_NEXT(ptr,a)
2072 return $ INDEX_NEXT(ptr,a)
2387−-- | Use the 'createOf' fold instead.
2074+-- | Use the 'writeN' fold instead.
2389−-- >>> fromStreamN n = Stream.fold (MutArray.createOf n)
2076+-- >>> fromStreamN n = Stream.fold (MutArray.writeN n)
2391{-# INLINE_NORMAL fromStreamN #-}
2078{-# INLINE_NORMAL fromStreamN #-}
2392fromStreamN :: forall m a. (MonadIO m, Unbox a)
2079fromStreamN :: forall m a. (MonadIO m, Unbox a)
2393 => Int -> D.Stream m a -> m (MutArray a)
2080 => Int -> D.Stream m a -> m (MutArray a)
2394−-- fromStreamDN n = D.fold (createOf n)
2081+-- fromStreamDN n = D.fold (writeN n)
2395fromStreamN = fromStreamDNAs Unpinned
2082fromStreamN = fromStreamDNAs Unpinned
2397{-# DEPRECATED fromStreamDN "Please use fromStreamN instead." #-}
2084{-# DEPRECATED fromStreamDN "Please use fromStreamN instead." #-}
2398−{-# INLINE fromStreamDN #-}
2399fromStreamDN :: forall m a. (MonadIO m, Unbox a)
2085fromStreamDN :: forall m a. (MonadIO m, Unbox a)
2400 => Int -> D.Stream m a -> m (MutArray a)
2086 => Int -> D.Stream m a -> m (MutArray a)
2401fromStreamDN = fromStreamN
2087fromStreamDN = fromStreamN
@@ -2418,20 +2104,20 @@ pinnedFromListN n xs = fromStreamDNAs Pinned n $ D.fromList xs
2418-- /Pre-release/
2104-- /Pre-release/
2419{-# INLINE fromListRevN #-}
2105{-# INLINE fromListRevN #-}
2420fromListRevN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
2106fromListRevN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
2421−fromListRevN n xs = D.fold (revCreateOf n) $ D.fromList xs
2107+fromListRevN n xs = D.fold (writeRevN n) $ D.fromList xs
2423-- | Convert a pure stream in Identity monad to a mutable array.
2109-- | Convert a pure stream in Identity monad to a mutable array.
2424{-# INLINABLE fromPureStreamN #-}
2110{-# INLINABLE fromPureStreamN #-}
2425fromPureStreamN :: (MonadIO m, Unbox a) =>
2111fromPureStreamN :: (MonadIO m, Unbox a) =>
2426 Int -> Stream Identity a -> m (MutArray a)
2112 Int -> Stream Identity a -> m (MutArray a)
2427fromPureStreamN n xs =
2113fromPureStreamN n xs =
2428− D.fold (createOf n) $ D.morphInner (return . runIdentity) xs
2114+ liftIO $ D.fold (writeN n) $ D.morphInner (return . runIdentity) xs
2430-- | Convert a pure stream in Identity monad to a mutable array.
2116-- | Convert a pure stream in Identity monad to a mutable array.
2431{-# INLINABLE fromPureStream #-}
2117{-# INLINABLE fromPureStream #-}
2432fromPureStream :: (MonadIO m, Unbox a) => Stream Identity a -> m (MutArray a)
2118fromPureStream :: (MonadIO m, Unbox a) => Stream Identity a -> m (MutArray a)
2433fromPureStream xs =
2119fromPureStream xs =
2434− D.fold create $ D.morphInner (return . runIdentity) xs
2120+ liftIO $ D.fold write $ D.morphInner (return . runIdentity) xs
2436{-# INLINABLE fromPtrN #-}
2122{-# INLINABLE fromPtrN #-}
2437fromPtrN :: MonadIO m => Int -> Ptr Word8 -> m (MutArray Word8)
2123fromPtrN :: MonadIO m => Int -> Ptr Word8 -> m (MutArray Word8)
@@ -2440,7 +2126,7 @@ fromPtrN len addr = do
2440 -- XXX We can implement a stream copy in a similar way by streaming Word64
2126 -- XXX We can implement a stream copy in a similar way by streaming Word64
2441 -- first and then remaining Word8.
2127 -- first and then remaining Word8.
2442 arr <- new len
2128 arr <- new len
2443− _ <- unsafeAsPtr arr
2129+ _ <- asUnpinnedPtrUnsafe arr
2444 (\ptr -> liftIO $ c_memcpy ptr addr (fromIntegral len))
2130 (\ptr -> liftIO $ c_memcpy ptr addr (fromIntegral len))
2445 return (arr {arrEnd = len})
2131 return (arr {arrEnd = len})
@@ -2456,7 +2142,7 @@ fromByteStr# addr = do
2456 len <- liftIO $ c_strlen (Ptr addr)
2142 len <- liftIO $ c_strlen (Ptr addr)
2457 let lenInt = fromIntegral len
2143 let lenInt = fromIntegral len
2458 arr <- new lenInt
2144 arr <- new lenInt
2459− _ <- unsafeAsPtr arr (\ptr -> liftIO $ c_memcpy ptr (Ptr addr) len)
2145+ _ <- asUnpinnedPtrUnsafe arr (\ptr -> liftIO $ c_memcpy ptr (Ptr addr) len)
2460 return (arr {arrEnd = lenInt})
2146 return (arr {arrEnd = lenInt})
2462-------------------------------------------------------------------------------
2148-------------------------------------------------------------------------------
@@ -2477,7 +2163,7 @@ fromChunksRealloced s = do
2477 arr <- D.foldlM' spliceExp (pure a) strm
2163 arr <- D.foldlM' spliceExp (pure a) strm
2478 -- Reallocation is exponential so there may be 50% empty space in
2164 -- Reallocation is exponential so there may be 50% empty space in
2479 -- worst case. One more reallocation to reclaim the space.
2165 -- worst case. One more reallocation to reclaim the space.
2480− rightSize arr
2166+ liftIO $ rightSize arr
2481 Nothing -> pure nil
2167 Nothing -> pure nil
2483-------------------------------------------------------------------------------
2169-------------------------------------------------------------------------------
@@ -2515,7 +2201,6 @@ fromChunksK :: (Unbox a, MonadIO m) =>
2515fromChunksK = fromChunkskAs Unpinned
2201fromChunksK = fromChunkskAs Unpinned
2517{-# DEPRECATED fromArrayStreamK "Please use fromChunksK instead." #-}
2203{-# DEPRECATED fromArrayStreamK "Please use fromChunksK instead." #-}
2518−{-# INLINE fromArrayStreamK #-}
2519fromArrayStreamK :: (Unbox a, MonadIO m) =>
2204fromArrayStreamK :: (Unbox a, MonadIO m) =>
2520 StreamK m (MutArray a) -> m (MutArray a)
2205 StreamK m (MutArray a) -> m (MutArray a)
2521fromArrayStreamK = fromChunksK
2206fromArrayStreamK = fromChunksK
@@ -2527,7 +2212,7 @@ fromStreamDAs ps m =
2527 arrayStreamKFromStreamDAs Unpinned m >>= fromChunkskAs ps
2212 arrayStreamKFromStreamDAs Unpinned m >>= fromChunkskAs ps
2529-- | Create an 'Array' from a stream. This is useful when we want to create a
2214-- | Create an 'Array' from a stream. This is useful when we want to create a
2530−-- single array from a stream of unknown size. 'createOf' is at least twice
2215+-- single array from a stream of unknown size. 'writeN' is at least twice
2531-- as efficient when the size is already known.
2216-- as efficient when the size is already known.
2533-- Note that if the input stream is too large memory allocation for the array
2218-- Note that if the input stream is too large memory allocation for the array
@@ -2539,19 +2224,19 @@ fromStreamDAs ps m =
2539fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a)
2224fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a)
2540fromStream = fromStreamDAs Unpinned
2225fromStream = fromStreamDAs Unpinned
2542−-- fromStream (Stream m) = P.fold create m
2227+-- fromStream (Stream m) = P.fold write m
2543-- CAUTION: a very large number (millions) of arrays can degrade performance
2228-- CAUTION: a very large number (millions) of arrays can degrade performance
2544-- due to GC overhead because we need to buffer the arrays before we flatten
2229-- due to GC overhead because we need to buffer the arrays before we flatten
2545-- all the arrays.
2230-- all the arrays.
2547−-- XXX Compare if this is faster or "fold create".
2232+-- XXX Compare if this is faster or "fold write".
2549-- | We could take the approach of doubling the memory allocation on each
2234-- | We could take the approach of doubling the memory allocation on each
2550-- overflow. This would result in more or less the same amount of copying as in
2235-- overflow. This would result in more or less the same amount of copying as in
2551-- the chunking approach. However, if we have to shrink in the end then it may
2236-- the chunking approach. However, if we have to shrink in the end then it may
2552-- result in an extra copy of the entire data.
2237-- result in an extra copy of the entire data.
2554−-- >>> fromStreamD = StreamD.fold MutArray.create
2239+-- >>> fromStreamD = StreamD.fold MutArray.write
2556{-# INLINE fromStreamD #-}
2241{-# INLINE fromStreamD #-}
2557{-# DEPRECATED fromStreamD "Please use fromStream instead." #-}
2242{-# DEPRECATED fromStreamD "Please use fromStream instead." #-}
@@ -2581,10 +2266,6 @@ fromListRev xs = fromListRevN (Prelude.length xs) xs
2581-- Cloning
2266-- Cloning
2582-------------------------------------------------------------------------------
2267-------------------------------------------------------------------------------
2584−-- Arrays are aligned on 64-bit boundaries. The fastest way to copy an array is
2585−-- to unsafeCast it to Word64, read it, write it to Word64 array and unsafeCast
2586−-- it again. We can use SIMD read/write as well.
2588{-# INLINE cloneAs #-}
2269{-# INLINE cloneAs #-}
2589cloneAs ::
2270cloneAs ::
2590 ( MonadIO m
2271 ( MonadIO m
@@ -2594,7 +2275,7 @@ cloneAs ::
2595 => PinnedState -> MutArray a -> m (MutArray a)
2276 => PinnedState -> MutArray a -> m (MutArray a)
2596cloneAs ps src =
2277cloneAs ps src =
2597− do
2278+ liftIO $ do
2598 let startSrc = arrStart src
2279 let startSrc = arrStart src
2599 srcLen = arrEnd src - startSrc
2280 srcLen = arrEnd src - startSrc
2600 newArrContents <-
2281 newArrContents <-
@@ -2633,16 +2314,17 @@ spliceCopy :: forall m a. MonadIO m =>
2633 Unbox a =>
2314 Unbox a =>
2635 MutArray a -> MutArray a -> m (MutArray a)
2316 MutArray a -> MutArray a -> m (MutArray a)
2636−spliceCopy arr1 arr2 = do
2317+spliceCopy arr1 arr2 = liftIO $ do
2637 let start1 = arrStart arr1
2318 let start1 = arrStart arr1
2638 start2 = arrStart arr2
2319 start2 = arrStart arr2
2639 len1 = arrEnd arr1 - start1
2320 len1 = arrEnd arr1 - start1
2640 len2 = arrEnd arr2 - start2
2321 len2 = arrEnd arr2 - start2
2641− let len = len1 + len2
2322+ let newLen = len1 + len2
2642 newArrContents <-
2323 newArrContents <-
2643 if Unboxed.isPinned (arrContents arr1)
2324 if Unboxed.isPinned (arrContents arr1)
2644− then liftIO $ Unboxed.pinnedNew len
2325+ then Unboxed.pinnedNew newLen
2645− else liftIO $ Unboxed.new len
2326+ else Unboxed.new newLen
2327+ let len = len1 + len2
2646 putSliceUnsafe (arrContents arr1) start1 newArrContents 0 len1
2328 putSliceUnsafe (arrContents arr1) start1 newArrContents 0 len1
2647 putSliceUnsafe (arrContents arr2) start2 newArrContents len1 len2
2329 putSliceUnsafe (arrContents arr2) start2 newArrContents len1 len2
2648 return $ MutArray newArrContents 0 len len
2330 return $ MutArray newArrContents 0 len len
@@ -2654,7 +2336,7 @@ spliceCopy arr1 arr2 = do
2654spliceUnsafe :: MonadIO m =>
2336spliceUnsafe :: MonadIO m =>
2655 MutArray a -> MutArray a -> m (MutArray a)
2337 MutArray a -> MutArray a -> m (MutArray a)
2656spliceUnsafe dst src =
2338spliceUnsafe dst src =
2657− do
2339+ liftIO $ do
2658 let startSrc = arrStart src
2340 let startSrc = arrStart src
2659 srcLen = arrEnd src - startSrc
2341 srcLen = arrEnd src - startSrc
2660 endDst = arrEnd dst
2342 endDst = arrEnd dst
@@ -2676,7 +2358,7 @@ spliceWith :: forall m a. (MonadIO m, Unbox a) =>
2676 (Int -> Int -> Int) -> MutArray a -> MutArray a -> m (MutArray a)
2358 (Int -> Int -> Int) -> MutArray a -> MutArray a -> m (MutArray a)
2677spliceWith sizer dst@(MutArray _ start end bound) src = do
2359spliceWith sizer dst@(MutArray _ start end bound) src = do
2679− let f = appendWith (`sizer` byteLength src) (return dst)
2361+ let f = writeAppendWith (`sizer` byteLength src) (return dst)
2680 in D.fold f (toStreamD src)
2362 in D.fold f (toStreamD src)
2682 assert (end <= bound) (return ())
2364 assert (end <= bound) (return ())
@@ -2692,7 +2374,7 @@ spliceWith sizer dst@(MutArray _ start end bound) src = do
2692 $ "splice: newSize is less than the total size "
2374 $ "splice: newSize is less than the total size "
2693 ++ "of arrays being appended. Please check the "
2375 ++ "of arrays being appended. Please check the "
2694 ++ "sizer function passed."
2376 ++ "sizer function passed."
2695− realloc newSizeInBytes dst
2377+ liftIO $ realloc newSizeInBytes dst
2696 else return dst
2378 else return dst
2697 spliceUnsafe dst1 src
2379 spliceUnsafe dst1 src
@@ -2744,7 +2426,7 @@ splitOn predicate arr =
2744{-# INLINE breakOn #-}
2426{-# INLINE breakOn #-}
2745breakOn :: MonadIO m
2427breakOn :: MonadIO m
2746 => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8))
2428 => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8))
2747−breakOn sep arr@MutArray{..} = unsafeAsPtr arr $ \p -> liftIO $ do
2429+breakOn sep arr@MutArray{..} = asUnpinnedPtrUnsafe arr $ \p -> liftIO $ do
2748 -- XXX We do not need memchr here, we can use a Haskell equivalent.
2430 -- XXX We do not need memchr here, we can use a Haskell equivalent.
2749 -- Need efficient stream based primitives that work on Word64.
2431 -- Need efficient stream based primitives that work on Word64.
2750 loc <- c_memchr p sep (fromIntegral $ byteLength arr)
2432 loc <- c_memchr p sep (fromIntegral $ byteLength arr)
@@ -2767,41 +2449,33 @@ breakOn sep arr@MutArray{..} = unsafeAsPtr arr $ \p -> liftIO $ do
2770−-- | Like 'splitAt' but does not check whether the index is valid.
2772−{-# INLINE unsafeSplitAt #-}
2773−unsafeSplitAt :: forall a. Unbox a =>
2774− Int -> MutArray a -> (MutArray a, MutArray a)
2775−unsafeSplitAt i MutArray{..} =
2776− let off = i * SIZE_OF(a)
2779− { arrContents = arrContents
2780− , arrStart = arrStart
2785− { arrContents = arrContents
2788− , arrBound = arrBound
2792-- | Create two slices of an array without copying the original array. The
2452-- | Create two slices of an array without copying the original array. The
2793-- specified index @i@ is the first index of the second slice.
2453-- specified index @i@ is the first index of the second slice.
2795{-# INLINE splitAt #-}
2455{-# INLINE splitAt #-}
2796splitAt :: forall a. Unbox a => Int -> MutArray a -> (MutArray a, MutArray a)
2456splitAt :: forall a. Unbox a => Int -> MutArray a -> (MutArray a, MutArray a)
2797−splitAt i arr =
2457+splitAt i arr@MutArray{..} =
2798 let maxIndex = length arr - 1
2458 let maxIndex = length arr - 1
2799 in if i < 0
2459 in if i < 0
2800 then error "sliceAt: negative array index"
2460 then error "sliceAt: negative array index"
2801 else if i > maxIndex
2461 else if i > maxIndex
2802 then error $ "sliceAt: specified array index " ++ show i
2462 then error $ "sliceAt: specified array index " ++ show i
2803 ++ " is beyond the maximum index " ++ show maxIndex
2463 ++ " is beyond the maximum index " ++ show maxIndex
2804− else unsafeSplitAt i arr
2464+ else let off = i * SIZE_OF(a)
2467+ { arrContents = arrContents
2468+ , arrStart = arrStart
2473+ { arrContents = arrContents
2476+ , arrBound = arrBound
2806-------------------------------------------------------------------------------
2480-------------------------------------------------------------------------------
2807-- Casting
2481-- Casting
@@ -2851,13 +2525,9 @@ cast arr =
2851-- guarantees that unsafe calls will be performed in the calling thread. Making
2525-- guarantees that unsafe calls will be performed in the calling thread. Making
2852-- it safe to pass heap-allocated objects to unsafe functions.
2526-- it safe to pass heap-allocated objects to unsafe functions.
2854−-- XXX Should we just name it asPtr, the unsafety is implicit for any pointer
2528+-- Should we just name it asPtr, the unsafety is implicit for any pointer
2855-- operations. And we are safe from Haskell perspective because we will be
2529-- operations. And we are safe from Haskell perspective because we will be
2856-- pinning the memory.
2530-- pinning the memory.
2858−-- XXX we cannot pass the length of the ptr here as in some cases it may not be
2859−-- available e.g. a null terminated C string. However, we can create another
2860−-- flavor of the API e.g. asPtrN.
2862-- | Use a @MutArray a@ as @Ptr a@. This is useful when we want to pass an
2532-- | Use a @MutArray a@ as @Ptr a@. This is useful when we want to pass an
2863-- array as a pointer to some operating system call or to a "safe" FFI call.
2533-- array as a pointer to some operating system call or to a "safe" FFI call.
@@ -2875,21 +2545,16 @@ cast arr =
2876-- /Pre-release/
2546-- /Pre-release/
2878−{-# INLINE unsafePinnedAsPtr #-}
2879−unsafePinnedAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2880−unsafePinnedAsPtr arr f =
2881− Unboxed.unsafePinnedAsPtr
2882− (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))
2884−{-# DEPRECATED asPtrUnsafe "Please use unsafePinnedAsPtr instead." #-}
2885{-# INLINE asPtrUnsafe #-}
2548{-# INLINE asPtrUnsafe #-}
2886asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2549asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2887−asPtrUnsafe = unsafePinnedAsPtr
2550+asPtrUnsafe arr f =
2551+ Unboxed.asPtrUnsafe
2552+ (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))
2889−{-# INLINE unsafeAsPtr #-}
2554+{-# INLINE asUnpinnedPtrUnsafe #-}
2890−unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2555+asUnpinnedPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2891−unsafeAsPtr arr f =
2556+asUnpinnedPtrUnsafe arr f =
2892− Unboxed.unsafeAsPtr
2557+ Unboxed.asUnpinnedPtrUnsafe
2893 (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))
2558 (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))
2895-------------------------------------------------------------------------------
2560-------------------------------------------------------------------------------
@@ -2907,26 +2572,28 @@ unsafeAsPtr arr f =
2907-- /Pre-release/
2572-- /Pre-release/
2908{-# INLINE byteCmp #-}
2573{-# INLINE byteCmp #-}
2909byteCmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering
2574byteCmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering
2910−byteCmp arr1 arr2 = do
2575+byteCmp arr1 arr2 =
2911− let marr1 = getMutableByteArray# (arrContents arr1)
2578+ let marr1 = getMutableByteArray# (arrContents arr1)
2912− marr2 = getMutableByteArray# (arrContents arr2)
2579+ marr2 = getMutableByteArray# (arrContents arr2)
2913− !(I# st1#) = arrStart arr1
2580+ !(I# st1#) = arrStart arr1
2914− !(I# st2#) = arrStart arr2
2581+ !(I# st2#) = arrStart arr2
2915− !(I# len#) = byteLength arr1
2582+ !(I# len#) = byteLength arr1
2916− case compare (byteLength arr1) (byteLength arr2) of
2583+ case compare (byteLength arr1) (byteLength arr2) of
2917− EQ -> do
2584+ EQ -> do
2918− r <- liftIO $ IO $ \s# ->
2585+ r <- liftIO $ IO $ \s# ->
2919− let res =
2586+ let res =
2921− (compareByteArrays#
2588+ (compareByteArrays#
2922− (unsafeCoerce# marr1)
2589+ (unsafeCoerce# marr1)
2924− (unsafeCoerce# marr2)
2591+ (unsafeCoerce# marr2)
2927− in (# s#, res #)
2594+ in (# s#, res #)
2928− return $ compare r 0
2595+ return $ compare r 0
2929− x -> return x
2596+ x -> return x
2931{-# INLINE cmp #-}
2598{-# INLINE cmp #-}
2932{-# DEPRECATED cmp "Please use byteCmp instead." #-}
2599{-# DEPRECATED cmp "Please use byteCmp instead." #-}
@@ -2946,48 +2613,46 @@ byteEq arr1 arr2 = fmap (EQ ==) $ byteCmp arr1 arr2
2946-- Compact
2613-- Compact
2947-------------------------------------------------------------------------------
2614-------------------------------------------------------------------------------
2949−-- Note: LE versions avoid an extra copy compared to GE. LE parser trades
2616+-- | Parser @pCompactChunksLE n@ coalesces adjacent arrays in the input stream
2950−-- backtracking one array in lieu of avoiding a copy. However, LE and GE both
2617+-- only if the combined size would be less than or equal to n.
2951−-- can leave some memory unused. They can split the last array to fit it
2618+--
2952−-- exactly in the space.
2619+-- /Internal/
2954−{-# INLINE_NORMAL pCompactLeAs #-}
2620+{-# INLINE_NORMAL pCompactChunksLE #-}
2955−pCompactLeAs ::
2621+pCompactChunksLE ::
2956 forall m a. (MonadIO m, Unbox a)
2622 forall m a. (MonadIO m, Unbox a)
2957− => PinnedState -> Int -> Parser (MutArray a) m (MutArray a)
2623+ => Int -> Parser (MutArray a) m (MutArray a)
2958−pCompactLeAs ps maxElems = Parser step initial extract
2624+pCompactChunksLE n = Parser step initial extract
2962− maxBytes = maxElems * SIZE_OF(a)
2628+ nBytes = n * SIZE_OF(a)
2964− functionName = "Streamly.Internal.Data.MutArray.pCompactLE"
2630+ functionName = "Streamly.Internal.Data.MutArray.pCompactChunksLE"
2966 initial =
2632 initial =
2968− $ if maxElems <= 0
2634+ $ if n <= 0
2969 then error
2635 then error
2970 $ functionName
2636 $ functionName
2971 ++ ": the size of arrays ["
2637 ++ ": the size of arrays ["
2972− ++ show maxElems ++ "] must be a natural number"
2638+ ++ show n ++ "] must be a natural number"
2973 else Parser.IPartial Nothing
2639 else Parser.IPartial Nothing
2975 step Nothing arr =
2641 step Nothing arr =
2977 $ let len = byteLength arr
2643 $ let len = byteLength arr
2978− in if len >= maxBytes
2644+ in if len >= nBytes
2979 then Parser.Done 0 arr
2645 then Parser.Done 0 arr
2980 else Parser.Partial 0 (Just arr)
2646 else Parser.Partial 0 (Just arr)
2981− -- XXX Split the last array to use the space more compactly.
2982 step (Just buf) arr =
2647 step (Just buf) arr =
2983 let len = byteLength buf + byteLength arr
2648 let len = byteLength buf + byteLength arr
2984− in if len > maxBytes
2649+ in if len > nBytes
2985 then return $ Parser.Done 1 buf
2650 then return $ Parser.Done 1 buf
2652+ -- XXX check this in the Nothing case
2988− if byteCapacity buf < maxBytes
2654+ if byteCapacity buf < nBytes
2989− then liftIO $ reallocExplicitAs
2655+ then liftIO $ realloc nBytes buf
2990− ps (SIZE_OF(a)) maxBytes buf
2991 else return buf
2656 else return buf
2992 buf2 <- spliceUnsafe buf1 arr
2657 buf2 <- spliceUnsafe buf1 arr
2993 return $ Parser.Partial 0 (Just buf2)
2658 return $ Parser.Partial 0 (Just buf2)
@@ -2995,30 +2660,6 @@ pCompactLeAs ps maxElems = Parser step initial extract
2995 extract Nothing = return $ Parser.Done 0 nil
2660 extract Nothing = return $ Parser.Done 0 nil
2996 extract (Just buf) = return $ Parser.Done 0 buf
2661 extract (Just buf) = return $ Parser.Done 0 buf
2998−-- | Parser @pCompactLE maxElems@ coalesces adjacent arrays in the input stream
2999−-- only if the combined size would be less than or equal to @maxElems@
3000−-- elements. Note that it won't split an array if the original array is already
3001−-- larger than maxElems.
3003−-- @maxElems@ must be greater than 0.
3005−-- Generates unpinned arrays irrespective of the pinning status of input
3009−{-# INLINE pCompactLE #-}
3011− forall m a. (MonadIO m, Unbox a)
3012− => Int -> Parser (MutArray a) m (MutArray a)
3013−pCompactLE = pCompactLeAs Unpinned
3015−-- | Pinned version of 'pCompactLE'.
3016−{-# INLINE pPinnedCompactLE #-}
3018− forall m a. (MonadIO m, Unbox a)
3019− => Int -> Parser (MutArray a) m (MutArray a)
3020−pPinnedCompactLE = pCompactLeAs Pinned
3022data SpliceState s arr
2663data SpliceState s arr
3023 = SpliceInitial s
2664 = SpliceInitial s
3024 | SpliceBuffering s arr
2665 | SpliceBuffering s arr
@@ -3030,47 +2671,48 @@ data SpliceState s arr
3030-- immutable array never has additional space so a new array is allocated
2671-- immutable array never has additional space so a new array is allocated
3031-- instead of mutating it.
2672-- instead of mutating it.
2674+-- | Scan @rCompactChunksLE n@ coalesces adjacent arrays in the input stream
2675+-- only if the combined size would be less than or equal to n.
3033−{-# INLINE_NORMAL compactLeAs #-}
2678+{-# INLINE_NORMAL rCompactChunksLE #-}
3034−compactLeAs :: forall m a. (MonadIO m, Unbox a)
2679+rCompactChunksLE :: (MonadIO m, Unbox a)
3035− => PinnedState -> Int -> D.Stream m (MutArray a) -> D.Stream m (MutArray a)
2680+ => Int -> D.Stream m (MutArray a) -> D.Stream m (MutArray a)
3036−compactLeAs ps maxElems (D.Stream step state) =
2681+rCompactChunksLE n (D.Stream step state) =
3037 D.Stream step' (SpliceInitial state)
2682 D.Stream step' (SpliceInitial state)
3041− maxBytes = maxElems * SIZE_OF(a)
3043− functionName = "Streamly.Internal.Data.MutArray.rCompactLE"
2686+ functionName = "Streamly.Internal.Data.MutArray.rCompactChunksLE"
3045 {-# INLINE_LATE step' #-}
2688 {-# INLINE_LATE step' #-}
3046 step' gst (SpliceInitial st) = do
2689 step' gst (SpliceInitial st) = do
3047− when (maxElems <= 0) $
2690+ when (n <= 0) $
3048 -- XXX we can pass the module string from the higher level API
2691 -- XXX we can pass the module string from the higher level API
3049− error $ functionName ++ ": the size of arrays [" ++ show maxElems
2692+ error $ functionName ++ ": the size of arrays [" ++ show n
3050 ++ "] must be a natural number"
2693 ++ "] must be a natural number"
3051 r <- step gst st
2694 r <- step gst st
3052 case r of
2695 case r of
3053 D.Yield arr s -> return $
2696 D.Yield arr s -> return $
3054 let len = byteLength arr
2697 let len = byteLength arr
3055− in if len >= maxBytes
2698+ in if len >= n
3056 then D.Skip (SpliceYielding arr (SpliceInitial s))
2699 then D.Skip (SpliceYielding arr (SpliceInitial s))
3057 else D.Skip (SpliceBuffering s arr)
2700 else D.Skip (SpliceBuffering s arr)
3058 D.Skip s -> return $ D.Skip (SpliceInitial s)
2701 D.Skip s -> return $ D.Skip (SpliceInitial s)
3059 D.Stop -> return D.Stop
2702 D.Stop -> return D.Stop
3061− -- XXX Split the last array to use the space more compactly.
3062 step' gst (SpliceBuffering st buf) = do
2704 step' gst (SpliceBuffering st buf) = do
3063 r <- step gst st
2705 r <- step gst st
3064 case r of
2706 case r of
3065 D.Yield arr s -> do
2707 D.Yield arr s -> do
3066 let len = byteLength buf + byteLength arr
2708 let len = byteLength buf + byteLength arr
3067− if len > maxBytes
2709+ if len > n
3068 then return $
2710 then return $
3069 D.Skip (SpliceYielding buf (SpliceBuffering s arr))
2711 D.Skip (SpliceYielding buf (SpliceBuffering s arr))
2713+ -- XXX check this in the SpliceInitial case
3071− buf1 <- if byteCapacity buf < maxBytes
2714+ buf1 <- if byteCapacity buf < n
3072− then liftIO $ reallocExplicitAs
2715+ then liftIO $ realloc n buf
3073− ps (SIZE_OF(a)) maxBytes buf
3074 else return buf
2716 else return buf
3075 buf2 <- spliceUnsafe buf1 arr
2717 buf2 <- spliceUnsafe buf1 arr
3076 return $ D.Skip (SpliceBuffering s buf2)
2718 return $ D.Skip (SpliceBuffering s buf2)
@@ -3081,124 +2723,113 @@ compactLeAs ps maxElems (D.Stream step state) =
3082 step' _ (SpliceYielding arr next) = return $ D.Yield arr next
2724 step' _ (SpliceYielding arr next) = return $ D.Yield arr next
3084−
2726+-- | Fold @fCompactChunksGE n@ coalesces adjacent arrays in the input stream
2727+-- until the size becomes greater than or equal to n.
3085−{-# INLINE_NORMAL fCompactGeAs #-}
2729+{-# INLINE_NORMAL fCompactChunksGE #-}
3086−fCompactGeAs ::
2730+fCompactChunksGE ::
3087 forall m a. (MonadIO m, Unbox a)
2731 forall m a. (MonadIO m, Unbox a)
3088− => PinnedState -> Int -> FL.Fold m (MutArray a) (MutArray a)
2732+ => Int -> FL.Fold m (MutArray a) (MutArray a)
3089−fCompactGeAs ps minElems = Fold step initial extract extract
2733+fCompactChunksGE n = Fold step initial extract extract
3093− minBytes = minElems * SIZE_OF(a)
2737+ nBytes = n * SIZE_OF(a)
3095− functionName = "Streamly.Internal.Data.MutArray.fCompactGE"
2739+ functionName = "Streamly.Internal.Data.MutArray.fCompactChunksGE"
3097 initial =
2741 initial =
3099− $ if minElems < 0
2743+ $ if n < 0
3100 then error
2744 then error
3101 $ functionName
2745 $ functionName
3102 ++ ": the size of arrays ["
2746 ++ ": the size of arrays ["
3103− ++ show minElems ++ "] must be a natural number"
2747+ ++ show n ++ "] must be a natural number"
3104 else FL.Partial Nothing
2748 else FL.Partial Nothing
3106 step Nothing arr =
2750 step Nothing arr =
3108 $ let len = byteLength arr
2752 $ let len = byteLength arr
3109− in if len >= minBytes
2753+ in if len >= nBytes
3110 then FL.Done arr
2754 then FL.Done arr
3111 else FL.Partial (Just arr)
2755 else FL.Partial (Just arr)
3112− -- XXX Buffer arrays as a list to avoid copy and reallocations
3113 step (Just buf) arr = do
2756 step (Just buf) arr = do
3114 let len = byteLength buf + byteLength arr
2757 let len = byteLength buf + byteLength arr
3116 if byteCapacity buf < len
2759 if byteCapacity buf < len
3117− then liftIO $ reallocExplicitAs
2760+ then liftIO $ realloc (max len nBytes) buf
3118− ps (SIZE_OF(a)) (max minBytes len) buf
3119 else return buf
2761 else return buf
3120 buf2 <- spliceUnsafe buf1 arr
2762 buf2 <- spliceUnsafe buf1 arr
3121− if len >= minBytes
2763+ if len >= n
3122 then return $ FL.Done buf2
2764 then return $ FL.Done buf2
3123 else return $ FL.Partial (Just buf2)
2765 else return $ FL.Partial (Just buf2)
3125 extract Nothing = return nil
2767 extract Nothing = return nil
3126 extract (Just buf) = return buf
2768 extract (Just buf) = return buf
3128−-- | Fold @fCompactGE minElems@ coalesces adjacent arrays in the input stream
2770+-- | Like 'compactChunksGE' but for transforming folds instead of stream.
3129−-- until the size becomes greater than or equal to @minElems@.
3131−-- Generates unpinned arrays irrespective of the pinning status of input
2772+-- >>> lCompactChunksGE n = Fold.many (MutArray.fCompactChunksGE n)
3133−{-# INLINE fCompactGE #-}
3135− forall m a. (MonadIO m, Unbox a)
3136− => Int -> FL.Fold m (MutArray a) (MutArray a)
3137−fCompactGE = fCompactGeAs Unpinned
3139−-- | Pinned version of 'fCompactGE'.
3140−{-# INLINE fPinnedCompactGE #-}
3142− forall m a. (MonadIO m, Unbox a)
3143− => Int -> FL.Fold m (MutArray a) (MutArray a)
3144−fPinnedCompactGE = fCompactGeAs Pinned
3146−{-# INLINE_NORMAL lCompactGeAs #-}
2774+{-# INLINE_NORMAL lCompactChunksGE #-}
3147−lCompactGeAs :: forall m a. (MonadIO m, Unbox a)
2775+lCompactChunksGE :: (MonadIO m, Unbox a)
3148− => PinnedState -> Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
2776+ => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
3149−-- The fold version turns out to be a little bit slower.
2777+-- lCompactChunksGE n = Fold.many (fCompactChunksGE n)
3150−-- lCompactGeAs ps n = FL.many (fCompactGeAs ps n)
3151−lCompactGeAs ps minElems (Fold step1 initial1 _ final1) =
2778+lCompactChunksGE n (Fold step1 initial1 _ final1) =
3152 Fold step initial extract final
2779 Fold step initial extract final
3156− minBytes = minElems * SIZE_OF(a)
3158− functionName = "Streamly.Internal.Data.MutArray.lCompactGE"
2783+ functionName = "Streamly.Internal.Data.MutArray.lCompactChunksGE"
3160 initial = do
2785 initial = do
3161− when (minElems <= 0) $
2786+ when (n <= 0) $
3162 -- XXX we can pass the module string from the higher level API
2787 -- XXX we can pass the module string from the higher level API
3163 error $ functionName ++ ": the size of arrays ["
2788 error $ functionName ++ ": the size of arrays ["
3164− ++ show minElems ++ "] must be a natural number"
2789+ ++ show n ++ "] must be a natural number"
3166 r <- initial1
2791 r <- initial1
3167 return $ first (Tuple' Nothing) r
2792 return $ first (Tuple' Nothing) r
3169− {-# INLINE runInner #-}
2794+ step (Tuple' Nothing r1) arr =
3170− runInner len acc buf =
2795+ let len = byteLength arr
2800+ FL.Done _ -> return $ FL.Done ()
2804+ return $ first (Tuple' Nothing) res
2805+ else return $ FL.Partial $ Tuple' (Just arr) r1
2807+ step (Tuple' (Just buf) r1) arr = do
2808+ let len = byteLength buf + byteLength arr
2809+ buf1 <- if byteCapacity buf < len
2810+ then liftIO $ realloc (max n len) buf
2812+ buf2 <- spliceUnsafe buf1 arr
2814+ -- XXX this is common in both the equations of step
3171− if len >= minBytes
2815+ if len >= n
3173− r <- step1 acc buf
2817+ r <- step1 r1 buf2
3174 case r of
2818 case r of
3175 FL.Done _ -> return $ FL.Done ()
2819 FL.Done _ -> return $ FL.Done ()
3176 FL.Partial s -> do
2820 FL.Partial s -> do
3177 _ <- final1 s
2821 _ <- final1 s
3178 res <- initial1
2822 res <- initial1
3179 return $ first (Tuple' Nothing) res
2823 return $ first (Tuple' Nothing) res
3180− else return $ FL.Partial $ Tuple' (Just buf) acc
2824+ else return $ FL.Partial $ Tuple' (Just buf2) r1
3182− step (Tuple' Nothing r1) arr =
3183− runInner (byteLength arr) r1 arr
3185− -- XXX Buffer arrays as a list to avoid copy and reallocations
3186− step (Tuple' (Just buf) r1) arr = do
3187− let len = byteLength buf + byteLength arr
3188− buf1 <- if byteCapacity buf < len
3189− then liftIO $ reallocExplicitAs
3190− ps (SIZE_OF(a)) (max minBytes len) buf
3192− buf2 <- spliceUnsafe buf1 arr
3193− runInner len r1 buf2
3195 -- XXX Several folds do extract >=> final, therefore, we need to make final
2826 -- XXX Several folds do extract >=> final, therefore, we need to make final
3196− -- return "m b" rather than using extract post it if we want extract to be
2827+ -- return "m b" rather than using extract post it if we want extract to be
3197 -- partial.
2828 -- partial.
3199 -- extract forces the pending buffer to be sent to the fold which is not
2830 -- extract forces the pending buffer to be sent to the fold which is not
3200 -- what we want.
2831 -- what we want.
3201− extract _ = error "lCompactGE: not designed for scanning"
2832+ extract _ = error "lCompactChunksGE: not designed for scanning"
3203 final (Tuple' Nothing r1) = final1 r1
2834 final (Tuple' Nothing r1) = final1 r1
3204 final (Tuple' (Just buf) r1) = do
2835 final (Tuple' (Just buf) r1) = do
@@ -3207,42 +2838,25 @@ lCompactGeAs ps minElems (Fold step1 initial1 _ final1) =
3207 FL.Partial rr -> final1 rr
2838 FL.Partial rr -> final1 rr
3208 FL.Done _ -> return ()
2839 FL.Done _ -> return ()
3210−-- | Like 'compactGE' but for transforming folds instead of stream.
3212−-- >>> lCompactGE n = Fold.many (MutArray.fCompactGE n)
3214−-- Generates unpinned arrays irrespective of the pinning status of input
3216−{-# INLINE lCompactGE #-}
3217−lCompactGE :: forall m a. (MonadIO m, Unbox a)
3218− => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
3219−lCompactGE = lCompactGeAs Unpinned
3221−-- | Pinned version of 'lCompactGE'.
3222−{-# INLINE lPinnedCompactGE #-}
3223−lPinnedCompactGE :: forall m a. (MonadIO m, Unbox a)
3224− => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
3225−lPinnedCompactGE = lCompactGeAs Pinned
3227−-- | @compactGE n stream@ coalesces adjacent arrays in the @stream@ until
2841+-- | @compactChunksGE n stream@ coalesces adjacent arrays in the @stream@ until
3228-- the size becomes greater than or equal to @n@.
2842-- the size becomes greater than or equal to @n@.
3230−-- >>> compactGE n = Stream.foldMany (MutArray.fCompactGE n)
2844+-- >>> compactChunksGE n = Stream.foldMany (MutArray.fCompactChunksGE n)
3232−{-# INLINE compactGE #-}
2846+{-# INLINE compactChunksGE #-}
3233−compactGE ::
2847+compactChunksGE ::
3234 (MonadIO m, Unbox a)
2848 (MonadIO m, Unbox a)
3235 => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
2849 => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
3236−compactGE n = D.foldMany (fCompactGE n)
2850+compactChunksGE n = D.foldMany (fCompactChunksGE n)
3238−-- | 'compactEQ n' coalesces adajacent arrays in the input stream to
2852+-- | 'compactChunksEQ n' coalesces adajacent arrays in the input stream to
3239-- arrays of exact size @n@.
2853-- arrays of exact size @n@.
3241-- /Unimplemented/
2855-- /Unimplemented/
3242−{-# INLINE compactEQ #-}
2856+{-# INLINE compactChunksEQ #-}
3243−compactEQ :: -- (MonadIO m, Unbox a) =>
2857+compactChunksEQ :: -- (MonadIO m, Unbox a) =>
3244 Int -> Stream m (MutArray a) -> Stream m (MutArray a)
2858 Int -> Stream m (MutArray a) -> Stream m (MutArray a)
3245−compactEQ _n = undefined -- D.parseManyD (pCompactEQ n)
2859+compactChunksEQ _n = undefined -- D.parseManyD (pCompactChunksEQ n)
3247-------------------------------------------------------------------------------
2861-------------------------------------------------------------------------------
3248-- In-place mutation algorithms
2862-- In-place mutation algorithms