@@ -223,7 +223,7 @@ import Foreign.C.Types (CSize(..), CInt(..))
223223import Foreign.Ptr (plusPtr, minusPtr, nullPtr)
224224import Streamly.Internal.Data.Unboxed
225225 ( MutableByteArray(..)
226− , Unboxed
226+ , Unbox
227227 , alignment
228228 , castContents
229229 , getMutableByteArray#
@@ -286,7 +286,7 @@ foreign import ccall unsafe "string.h memcmp" c_memcmp
286286-- how many elements of that type will completely fit in those bytes.
287287--
288288{-# INLINE bytesToElemCount #-}
289−bytesToElemCount :: forall a. Unboxed a => a -> Int -> Int
289+bytesToElemCount :: forall a. Unbox a => a -> Int -> Int
290290bytesToElemCount _ n = n `div` SIZE_OF(a)
291291
292292-- XXX we are converting Int to CSize
@@ -333,7 +333,7 @@ memcmp p1 p2 len = do
333333--
334334data Array a =
335335#ifdef DEVBUILD
336− Unboxed a =>
336+ Unbox a =>
337337#endif
338338 -- The array is a range into arrContents. arrContents may be a superset of
339339 -- the slice represented by the array. All offsets are in bytes.
@@ -389,7 +389,7 @@ unpin arr@Array{..} = do
389389--
390390-- /Pre-release/
391391{-# INLINE newArrayWith #-}
392−newArrayWith :: forall m a. (MonadIO m, Unboxed a)
392+newArrayWith :: forall m a. (MonadIO m, Unbox a)
393393 => (Int -> Int -> m (MutableByteArray a)) -> Int -> Int -> m (Array a)
394394newArrayWith alloc alignSize count = do
395395 let size = max (count * SIZE_OF(a)) 0
@@ -403,7 +403,7 @@ newArrayWith alloc alignSize count = do
403403
404404nil ::
405405#ifdef DEVBUILD
406− Unboxed a =>
406+ Unbox a =>
407407#endif
408408 Array a
409409nil = Array Unboxed.nil 0 0 0
@@ -415,7 +415,7 @@ nil = Array Unboxed.nil 0 0 0
415415--
416416-- /Pre-release/
417417{-# INLINE newPinnedBytes #-}
418−newPinnedBytes :: forall m a. (MonadIO m, Unboxed a) => Int -> m (Array a)
418+newPinnedBytes :: forall m a. (MonadIO m, Unbox a) => Int -> m (Array a)
419419newPinnedBytes bytes = do
420420 contents <-
421421 liftIO
@@ -432,7 +432,7 @@ newPinnedBytes bytes = do
432432--
433433-- /Internal/
434434{-# INLINE newAlignedPinned #-}
435−newAlignedPinned :: (MonadIO m, Unboxed a) => Int -> Int -> m (Array a)
435+newAlignedPinned :: (MonadIO m, Unbox a) => Int -> Int -> m (Array a)
436436newAlignedPinned =
437437 newArrayWith (\s a -> liftIO $ Unboxed.newAlignedPinnedBytes s a)
438438
@@ -443,14 +443,14 @@ newAlignedPinned =
443443-- instance of the type.
444444--
445445{-# INLINE newPinned #-}
446−newPinned :: forall m a. (MonadIO m, Unboxed a) => Int -> m (Array a)
446+newPinned :: forall m a. (MonadIO m, Unbox a) => Int -> m (Array a)
447447newPinned = newAlignedPinned (alignment (undefined :: a))
448448
449449-- | Allocates an empty unpinned array that can hold 'count' items. The memory
450450-- of the array is uninitialized.
451451--
452452{-# INLINE new #-}
453−new :: (MonadIO m, Unboxed a) => Int -> m (Array a)
453+new :: (MonadIO m, Unbox a) => Int -> m (Array a)
454454new =
455455 newArrayWith
456456 (\s _ -> liftIO $ Unboxed.newUnpinnedBytes s)
@@ -462,7 +462,7 @@ new =
462462-- /Internal/
463463{-# INLINE withNewArrayUnsafe #-}
464464withNewArrayUnsafe ::
465− (MonadIO m, Unboxed a) => Int -> (Ptr a -> m ()) -> m (Array a)
465+ (MonadIO m, Unbox a) => Int -> (Ptr a -> m ()) -> m (Array a)
466466withNewArrayUnsafe count f = do
467467 arr <- newPinned count
468468 asPtrUnsafe arr
@@ -477,7 +477,7 @@ withNewArrayUnsafe count f = do
477477--
478478-- /Pre-release/
479479{-# INLINE putIndexUnsafe #-}
480−putIndexUnsafe :: forall m a. (MonadIO m, Unboxed a)
480+putIndexUnsafe :: forall m a. (MonadIO m, Unbox a)
481481 => Int -> a -> Array a -> m ()
482482putIndexUnsafe i x Array{..} = do
483483 let index = INDEX_OF(arrStart, i, a)
@@ -496,7 +496,7 @@ invalidIndex label i =
496496-- >>> putIndex ix val arr = Stream.fold (f arr) (Stream.fromPure (ix, val))
497497--
498498{-# INLINE putIndex #-}
499−putIndex :: forall m a. (MonadIO m, Unboxed a) => Int -> a -> Array a -> m ()
499+putIndex :: forall m a. (MonadIO m, Unbox a) => Int -> a -> Array a -> m ()
500500putIndex i x Array{..} = do
501501 let index = INDEX_OF(arrStart,i,a)
502502 if i >= 0 && INDEX_VALID(index,arrEnd,a)
@@ -508,7 +508,7 @@ putIndex i x Array{..} = do
508508--
509509-- /Pre-release/
510510{-# INLINE putIndices #-}
511−putIndices :: forall m a. (MonadIO m, Unboxed a)
511+putIndices :: forall m a. (MonadIO m, Unbox a)
512512 => Array a -> Fold m (Int, a) ()
513513putIndices arr = FL.foldlM' step (return ())
514514
@@ -519,7 +519,7 @@ putIndices arr = FL.foldlM' step (return ())
519519-- | Modify a given index of an array using a modifier function.
520520--
521521-- /Pre-release/
522−modifyIndexUnsafe :: forall m a b. (MonadIO m, Unboxed a) =>
522+modifyIndexUnsafe :: forall m a b. (MonadIO m, Unbox a) =>
523523 Int -> (a -> (a, b)) -> Array a -> m b
524524modifyIndexUnsafe i f Array{..} = liftIO $ do
525525 let index = INDEX_OF(arrStart,i,a)
@@ -532,7 +532,7 @@ modifyIndexUnsafe i f Array{..} = liftIO $ do
532532-- | Modify a given index of an array using a modifier function.
533533--
534534-- /Pre-release/
535−modifyIndex :: forall m a b. (MonadIO m, Unboxed a) =>
535+modifyIndex :: forall m a b. (MonadIO m, Unbox a) =>
536536 Int -> (a -> (a, b)) -> Array a -> m b
537537modifyIndex i f Array{..} = do
538538 let index = INDEX_OF(arrStart,i,a)
@@ -549,7 +549,7 @@ modifyIndex i f Array{..} = do
549549--
550550-- /Pre-release/
551551{-# INLINE modifyIndices #-}
552−modifyIndices :: forall m a . (MonadIO m, Unboxed a)
552+modifyIndices :: forall m a . (MonadIO m, Unbox a)
553553 => (Int -> a -> a) -> Array a -> Fold m Int ()
554554modifyIndices f arr = FL.foldlM' step initial
555555
@@ -564,7 +564,7 @@ modifyIndices f arr = FL.foldlM' step initial
564564-- | Modify each element of an array using the supplied modifier function.
565565--
566566-- /Pre-release/
567−modify :: forall m a. (MonadIO m, Unboxed a)
567+modify :: forall m a. (MonadIO m, Unbox a)
568568 => (a -> a) -> Array a -> m ()
569569modify f Array{..} = liftIO $
570570 go arrStart
@@ -578,7 +578,7 @@ modify f Array{..} = liftIO $
578578 go (INDEX_NEXT(i,a))
579579
580580{-# INLINE swapArrayByteIndices #-}
581−swapArrayByteIndices :: Unboxed a => MutableByteArray a -> Int -> Int -> IO ()
581+swapArrayByteIndices :: Unbox a => MutableByteArray a -> Int -> Int -> IO ()
582582swapArrayByteIndices arrContents i1 i2 = do
583583 r1 <- peekWith arrContents i1
584584 r2 <- peekWith arrContents i2
@@ -591,7 +591,7 @@ swapArrayByteIndices arrContents i1 i2 = do
591591--
592592-- /Pre-release/
593593{-# INLINE unsafeSwapIndices #-}
594−unsafeSwapIndices :: forall m a. (MonadIO m, Unboxed a)
594+unsafeSwapIndices :: forall m a. (MonadIO m, Unbox a)
595595 => Int -> Int -> Array a -> m ()
596596unsafeSwapIndices i1 i2 Array{..} = liftIO $ do
597597 let t1 = INDEX_OF(arrStart,i1,a)
@@ -601,7 +601,7 @@ unsafeSwapIndices i1 i2 Array{..} = liftIO $ do
601601-- | Swap the elements at two indices.
602602--
603603-- /Pre-release/
604−swapIndices :: forall m a. (MonadIO m, Unboxed a)
604+swapIndices :: forall m a. (MonadIO m, Unbox a)
605605 => Int -> Int -> Array a -> m ()
606606swapIndices i1 i2 Array{..} = liftIO $ do
607607 let t1 = INDEX_OF(arrStart,i1,a)
@@ -672,7 +672,7 @@ roundUpToPower2 n =
672672-- case it returns one element's size.
673673--
674674{-# INLINE allocBytesToBytes #-}
675−allocBytesToBytes :: forall a. Unboxed a => a -> Int -> Int
675+allocBytesToBytes :: forall a. Unbox a => a -> Int -> Int
676676allocBytesToBytes _ n = max (arrayPayloadSize n) (SIZE_OF(a))
677677
678678-- | Given an 'Unboxed' type (unused first arg) and real allocation size
@@ -680,7 +680,7 @@ allocBytesToBytes _ n = max (arrayPayloadSize n) (SIZE_OF(a))
680680-- fit in it, returns at least 1.
681681--
682682{-# INLINE allocBytesToElemCount #-}
683−allocBytesToElemCount :: Unboxed a => a -> Int -> Int
683+allocBytesToElemCount :: Unbox a => a -> Int -> Int
684684allocBytesToElemCount x bytes =
685685 let n = bytesToElemCount x (allocBytesToBytes x bytes)
686686 in assert (n >= 1) n
@@ -745,14 +745,14 @@ reallocAligned elemSize alignSize newCapacityInBytes Array{..} = do
745745-- 'largeObjectThreshold' then it is rounded up to the block size (4K).
746746--
747747{-# INLINABLE realloc #-}
748−realloc :: forall m a. (MonadIO m, Unboxed a) => Int -> Array a -> m (Array a)
748+realloc :: forall m a. (MonadIO m, Unbox a) => Int -> Array a -> m (Array a)
749749realloc bytes arr =
750750 liftIO $ reallocAligned (SIZE_OF(a)) (alignment (undefined :: a)) bytes arr
751751
752752-- | @reallocWith label capSizer minIncrBytes array@. The label is used
753753-- in error messages and the capSizer is used to determine the capacity of the
754754-- new array in bytes given the current byte length of the array.
755−reallocWith :: forall m a. (MonadIO m , Unboxed a) =>
755+reallocWith :: forall m a. (MonadIO m , Unbox a) =>
756756 String
757757 -> (Int -> Int)
758758 -> Int
@@ -786,7 +786,7 @@ reallocWith label capSizer minIncrBytes arr = do
786786--
787787-- /Pre-release/
788788{-# INLINE resize #-}
789−resize :: forall m a. (MonadIO m, Unboxed a) =>
789+resize :: forall m a. (MonadIO m, Unbox a) =>
790790 Int -> Array a -> m (Array a)
791791resize nElems arr@Array{..} = do
792792 let req = SIZE_OF(a) * nElems
@@ -800,7 +800,7 @@ resize nElems arr@Array{..} = do
800800--
801801-- /Pre-release/
802802{-# INLINE resizeExp #-}
803−resizeExp :: forall m a. (MonadIO m, Unboxed a) =>
803+resizeExp :: forall m a. (MonadIO m, Unbox a) =>
804804 Int -> Array a -> m (Array a)
805805resizeExp nElems arr@Array{..} = do
806806 let req = roundUpLargeArray (SIZE_OF(a) * nElems)
@@ -822,7 +822,7 @@ resizeExp nElems arr@Array{..} = do
822822--
823823-- /Pre-release/
824824{-# INLINE rightSize #-}
825−rightSize :: forall m a. (MonadIO m, Unboxed a) => Array a -> m (Array a)
825+rightSize :: forall m a. (MonadIO m, Unbox a) => Array a -> m (Array a)
826826rightSize arr@Array{..} = do
827827 assert (arrEnd <= arrBound) (return ())
828828 let start = arrStart
@@ -854,7 +854,7 @@ rightSize arr@Array{..} = do
854854--
855855-- /Internal/
856856{-# INLINE snocNewEnd #-}
857−snocNewEnd :: (MonadIO m, Unboxed a) => Int -> Array a -> a -> m (Array a)
857+snocNewEnd :: (MonadIO m, Unbox a) => Int -> Array a -> a -> m (Array a)
858858snocNewEnd newEnd arr@Array{..} x = liftIO $ do
859859 assert (newEnd <= arrBound) (return ())
860860 pokeWith arrContents arrEnd x
@@ -866,7 +866,7 @@ snocNewEnd newEnd arr@Array{..} x = liftIO $ do
866866--
867867-- /Internal/
868868{-# INLINE snocUnsafe #-}
869−snocUnsafe :: forall m a. (MonadIO m, Unboxed a) =>
869+snocUnsafe :: forall m a. (MonadIO m, Unbox a) =>
870870 Array a -> a -> m (Array a)
871871snocUnsafe arr@Array{..} = snocNewEnd (INDEX_NEXT(arrEnd,a)) arr
872872
@@ -875,7 +875,7 @@ snocUnsafe arr@Array{..} = snocNewEnd (INDEX_NEXT(arrEnd,a)) arr
875875--
876876-- /Internal/
877877{-# INLINE snocMay #-}
878−snocMay :: forall m a. (MonadIO m, Unboxed a) =>
878+snocMay :: forall m a. (MonadIO m, Unbox a) =>
879879 Array a -> a -> m (Maybe (Array a))
880880snocMay arr@Array{..} x = liftIO $ do
881881 let newEnd = INDEX_NEXT(arrEnd,a)
@@ -885,7 +885,7 @@ snocMay arr@Array{..} x = liftIO $ do
885885
886886-- NOINLINE to move it out of the way and not pollute the instruction cache.
887887{-# NOINLINE snocWithRealloc #-}
888−snocWithRealloc :: forall m a. (MonadIO m, Unboxed a) =>
888+snocWithRealloc :: forall m a. (MonadIO m, Unbox a) =>
889889 (Int -> Int)
890890 -> Array a
891891 -> a
@@ -908,7 +908,7 @@ snocWithRealloc sizer arr x = do
908908--
909909-- /Pre-release/
910910{-# INLINE snocWith #-}
911−snocWith :: forall m a. (MonadIO m, Unboxed a) =>
911+snocWith :: forall m a. (MonadIO m, Unbox a) =>
912912 (Int -> Int)
913913 -> Array a
914914 -> a
@@ -930,7 +930,7 @@ snocWith allocSize arr x = liftIO $ do
930930--
931931-- /Pre-release/
932932{-# INLINE snocLinear #-}
933−snocLinear :: forall m a. (MonadIO m, Unboxed a) => Array a -> a -> m (Array a)
933+snocLinear :: forall m a. (MonadIO m, Unbox a) => Array a -> a -> m (Array a)
934934snocLinear = snocWith (+ allocBytesToBytes (undefined :: a) arrayChunkBytes)
935935
936936-- | The array is mutated to append an additional element to it. If there is no
@@ -947,7 +947,7 @@ snocLinear = snocWith (+ allocBytesToBytes (undefined :: a) arrayChunkBytes)
947947-- Performs O(n * log n) copies to grow, but is liberal with memory allocation.
948948--
949949{-# INLINE snoc #-}
950−snoc :: forall m a. (MonadIO m, Unboxed a) => Array a -> a -> m (Array a)
950+snoc :: forall m a. (MonadIO m, Unbox a) => Array a -> a -> m (Array a)
951951snoc = snocWith f
952952
953953 where
@@ -967,7 +967,7 @@ snoc = snocWith f
967967--
968968-- Unsafe because it does not check the bounds of the array.
969969{-# INLINE_NORMAL getIndexUnsafe #-}
970−getIndexUnsafe :: forall m a. (MonadIO m, Unboxed a) => Int -> Array a -> m a
970+getIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Array a -> m a
971971getIndexUnsafe i Array{..} = do
972972 let index = INDEX_OF(arrStart,i,a)
973973 assert (i >= 0 && INDEX_VALID(index,arrEnd,a)) (return ())
@@ -976,7 +976,7 @@ getIndexUnsafe i Array{..} = do
976976-- | /O(1)/ Lookup the element at the given index. Index starts from 0.
977977--
978978{-# INLINE getIndex #-}
979−getIndex :: forall m a. (MonadIO m, Unboxed a) => Int -> Array a -> m a
979+getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> Array a -> m a
980980getIndex i Array{..} = do
981981 let index = INDEX_OF(arrStart,i,a)
982982 if i >= 0 && INDEX_VALID(index,arrEnd,a)
@@ -989,7 +989,7 @@ getIndex i Array{..} = do
989989-- Slightly faster than computing the forward index and using getIndex.
990990--
991991{-# INLINE getIndexRev #-}
992−getIndexRev :: forall m a. (MonadIO m, Unboxed a) => Int -> Array a -> m a
992+getIndexRev :: forall m a. (MonadIO m, Unbox a) => Int -> Array a -> m a
993993getIndexRev i Array{..} = do
994994 let index = RINDEX_OF(arrEnd,i,a)
995995 if i >= 0 && index >= arrStart
@@ -1005,7 +1005,7 @@ data GetIndicesState contents start end st =
10051005--
10061006-- /Pre-release/
10071007{-# INLINE getIndicesD #-}
1008−getIndicesD :: (Monad m, Unboxed a) =>
1008+getIndicesD :: (Monad m, Unbox a) =>
10091009 (forall b. IO b -> m b) -> D.Stream m Int -> Unfold m (Array a) a
10101010getIndicesD liftio (D.Stream stepi sti) = Unfold step inject
10111011
@@ -1025,7 +1025,7 @@ getIndicesD liftio (D.Stream stepi sti) = Unfold step inject
10251025 D.Stop -> return D.Stop
10261026
10271027{-# INLINE getIndices #-}
1028−getIndices :: (MonadIO m, Unboxed a) => Stream m Int -> Unfold m (Array a) a
1028+getIndices :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (Array a) a
10291029getIndices = getIndicesD liftIO . Stream.toStreamD
10301030
10311031-------------------------------------------------------------------------------
@@ -1042,7 +1042,7 @@ getIndices = getIndicesD liftIO . Stream.toStreamD
10421042--
10431043-- /Pre-release/
10441044{-# INLINE getSliceUnsafe #-}
1045−getSliceUnsafe :: forall a. Unboxed a
1045+getSliceUnsafe :: forall a. Unbox a
10461046 => Int -- ^ from index
10471047 -> Int -- ^ length of the slice
10481048 -> Array a
@@ -1061,7 +1061,7 @@ getSliceUnsafe index len (Array contents start e _) =
10611061--
10621062-- /Pre-release/
10631063{-# INLINE getSlice #-}
1064−getSlice :: forall a. Unboxed a =>
1064+getSlice :: forall a. Unbox a =>
10651065 Int -- ^ from index
10661066 -> Int -- ^ length of the slice
10671067 -> Array a
@@ -1089,7 +1089,7 @@ getSlice index len (Array contents start e _) =
10891089-- of cache locality and when you do not want to allocate additional memory.
10901090--
10911091{-# INLINE reverse #-}
1092−reverse :: forall m a. (MonadIO m, Unboxed a) => Array a -> m ()
1092+reverse :: forall m a. (MonadIO m, Unbox a) => Array a -> m ()
10931093reverse Array{..} = liftIO $ do
10941094 let l = arrStart
10951095 h = INDEX_PREV(arrEnd,a)
@@ -1116,7 +1116,7 @@ permute = undefined
11161116--
11171117-- /Pre-release/
11181118{-# INLINE partitionBy #-}
1119−partitionBy :: forall m a. (MonadIO m, Unboxed a)
1119+partitionBy :: forall m a. (MonadIO m, Unbox a)
11201120 => (a -> Bool) -> Array a -> m (Array a, Array a)
11211121partitionBy f arr@Array{..} = liftIO $ do
11221122 if arrStart >= arrEnd
@@ -1238,7 +1238,7 @@ byteLength Array{..} =
12381238-- involves a costly division operation.
12391239--
12401240{-# INLINE length #-}
1241−length :: forall a. Unboxed a => Array a -> Int
1241+length :: forall a. Unbox a => Array a -> Int
12421242length arr =
12431243 let elemSize = SIZE_OF(a)
12441244 blen = byteLength arr
@@ -1282,7 +1282,7 @@ data GroupState s contents start end bound
12821282--
12831283-- /Pre-release/
12841284{-# INLINE_NORMAL arraysOf #-}
1285−arraysOf :: forall m a. (MonadIO m, Unboxed a)
1285+arraysOf :: forall m a. (MonadIO m, Unbox a)
12861286 => Int -> D.Stream m a -> D.Stream m (Array a)
12871287-- XXX the idiomatic implementation leads to large regression in the D.reverse'
12881288-- benchmark. It seems it has difficulty producing optimized code when
@@ -1329,7 +1329,7 @@ arraysOf n (D.Stream step state) =
13291329-- XXX buffer to a list instead?
13301330-- | Buffer the stream into arrays in memory.
13311331{-# INLINE arrayStreamKFromStreamD #-}
1332−arrayStreamKFromStreamD :: forall m a. (MonadIO m, Unboxed a) =>
1332+arrayStreamKFromStreamD :: forall m a. (MonadIO m, Unbox a) =>
13331333 D.Stream m a -> m (K.Stream m (Array a))
13341334arrayStreamKFromStreamD =
13351335 let n = allocBytesToElemCount (undefined :: a) defaultChunkSize
@@ -1350,7 +1350,7 @@ data FlattenState s contents a =
13501350-- We can try this if there are any fusion issues in the unfold.
13511351--
13521352{-# INLINE_NORMAL flattenArrays #-}
1353−flattenArrays :: forall m a. (MonadIO m, Unboxed a)
1353+flattenArrays :: forall m a. (MonadIO m, Unbox a)
13541354 => D.Stream m (Array a) -> D.Stream m a
13551355flattenArrays (D.Stream step state) = D.Stream step' (OuterLoop state)
13561356
@@ -1379,7 +1379,7 @@ flattenArrays (D.Stream step state) = D.Stream step' (OuterLoop state)
13791379-- We can try this if there are any fusion issues in the unfold.
13801380--
13811381{-# INLINE_NORMAL flattenArraysRev #-}
1382−flattenArraysRev :: forall m a. (MonadIO m, Unboxed a)
1382+flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
13831383 => D.Stream m (Array a) -> D.Stream m a
13841384flattenArraysRev (D.Stream step state) = D.Stream step' (OuterLoop state)
13851385
@@ -1417,7 +1417,7 @@ toArrayUnsafe (Array contents start end _) = ArrayUnsafe contents start end
14171417
14181418fromArrayUnsafe ::
14191419#ifdef DEVBUILD
1420− Unboxed a =>
1420+ Unbox a =>
14211421#endif
14221422 ArrayUnsafe a -> Array a
14231423fromArrayUnsafe (ArrayUnsafe contents start end) =
@@ -1425,7 +1425,7 @@ fromArrayUnsafe (ArrayUnsafe contents start end) =
14251425
14261426{-# INLINE_NORMAL producerWith #-}
14271427producerWith ::
1428− forall m a. (Monad m, Unboxed a)
1428+ forall m a. (Monad m, Unbox a)
14291429 => (forall b. IO b -> m b) -> Producer m (Array a) a
14301430producerWith liftio = Producer step (return . toArrayUnsafe) extract
14311431 where
@@ -1446,18 +1446,18 @@ producerWith liftio = Producer step (return . toArrayUnsafe) extract
14461446-- | Resumable unfold of an array.
14471447--
14481448{-# INLINE_NORMAL producer #-}
1449−producer :: forall m a. (MonadIO m, Unboxed a) => Producer m (Array a) a
1449+producer :: forall m a. (MonadIO m, Unbox a) => Producer m (Array a) a
14501450producer = producerWith liftIO
14511451
14521452-- | Unfold an array into a stream.
14531453--
14541454{-# INLINE_NORMAL reader #-}
1455−reader :: forall m a. (MonadIO m, Unboxed a) => Unfold m (Array a) a
1455+reader :: forall m a. (MonadIO m, Unbox a) => Unfold m (Array a) a
14561456reader = Producer.simplify producer
14571457
14581458{-# INLINE_NORMAL readerRevWith #-}
14591459readerRevWith ::
1460− forall m a. (Monad m, Unboxed a)
1460+ forall m a. (Monad m, Unbox a)
14611461 => (forall b. IO b -> m b) -> Unfold m (Array a) a
14621462readerRevWith liftio = Unfold step inject
14631463 where
@@ -1475,7 +1475,7 @@ readerRevWith liftio = Unfold step inject
14751475-- | Unfold an array into a stream in reverse order.
14761476--
14771477{-# INLINE_NORMAL readerRev #-}
1478−readerRev :: forall m a. (MonadIO m, Unboxed a) => Unfold m (Array a) a
1478+readerRev :: forall m a. (MonadIO m, Unbox a) => Unfold m (Array a) a
14791479readerRev = readerRevWith liftIO
14801480
14811481-------------------------------------------------------------------------------
@@ -1486,7 +1486,7 @@ readerRev = readerRevWith liftIO
14861486-- Use foldr/build fusion to fuse with list consumers
14871487-- This can be useful when using the IsList instance
14881488{-# INLINE_LATE toListFB #-}
1489−toListFB :: forall a b. Unboxed a => (a -> b -> b) -> b -> Array a -> b
1489+toListFB :: forall a b. Unbox a => (a -> b -> b) -> b -> Array a -> b
14901490toListFB c n Array{..} = go arrStart
14911491 where
14921492
@@ -1510,7 +1510,7 @@ toListFB c n Array{..} = go arrStart
15101510-- | Convert an 'Array' into a list.
15111511--
15121512{-# INLINE toList #-}
1513−toList :: forall m a. (MonadIO m, Unboxed a) => Array a -> m [a]
1513+toList :: forall m a. (MonadIO m, Unbox a) => Array a -> m [a]
15141514toList Array{..} = liftIO $ go arrStart
15151515 where
15161516
@@ -1521,7 +1521,7 @@ toList Array{..} = liftIO $ go arrStart
15211521
15221522{-# INLINE_NORMAL toStreamDWith #-}
15231523toStreamDWith ::
1524− forall m a. (Monad m, Unboxed a)
1524+ forall m a. (Monad m, Unbox a)
15251525 => (forall b. IO b -> m b) -> Array a -> D.Stream m a
15261526toStreamDWith liftio Array{..} = D.Stream step arrStart
15271527
@@ -1539,12 +1539,12 @@ toStreamDWith liftio Array{..} = D.Stream step arrStart
15391539--
15401540-- We can try this if the unfold has any performance issues.
15411541{-# INLINE_NORMAL toStreamD #-}
1542−toStreamD :: forall m a. (MonadIO m, Unboxed a) => Array a -> D.Stream m a
1542+toStreamD :: forall m a. (MonadIO m, Unbox a) => Array a -> D.Stream m a
15431543toStreamD = toStreamDWith liftIO
15441544
15451545{-# INLINE toStreamKWith #-}
15461546toStreamKWith ::
1547− forall m a. (Monad m, Unboxed a)
1547+ forall m a. (Monad m, Unbox a)
15481548 => (forall b. IO b -> m b) -> Array a -> K.Stream m a
15491549toStreamKWith liftio Array{..} = go arrStart
15501550
@@ -1556,12 +1556,12 @@ toStreamKWith liftio Array{..} = go arrStart
15561556 in liftio elemM `K.consM` go (INDEX_NEXT(p,a))
15571557
15581558{-# INLINE toStreamK #-}
1559−toStreamK :: forall m a. (MonadIO m, Unboxed a) => Array a -> K.Stream m a
1559+toStreamK :: forall m a. (MonadIO m, Unbox a) => Array a -> K.Stream m a
15601560toStreamK = toStreamKWith liftIO
15611561
15621562{-# INLINE_NORMAL toStreamDRevWith #-}
15631563toStreamDRevWith ::
1564− forall m a. (Monad m, Unboxed a)
1564+ forall m a. (Monad m, Unbox a)
15651565 => (forall b. IO b -> m b) -> Array a -> D.Stream m a
15661566toStreamDRevWith liftio Array{..} =
15671567 let p = INDEX_PREV(arrEnd,a)
@@ -1581,12 +1581,12 @@ toStreamDRevWith liftio Array{..} =
15811581--
15821582-- We can try this if the unfold has any perf issues.
15831583{-# INLINE_NORMAL toStreamDRev #-}
1584−toStreamDRev :: forall m a. (MonadIO m, Unboxed a) => Array a -> D.Stream m a
1584+toStreamDRev :: forall m a. (MonadIO m, Unbox a) => Array a -> D.Stream m a
15851585toStreamDRev = toStreamDRevWith liftIO
15861586
15871587{-# INLINE toStreamKRevWith #-}
15881588toStreamKRevWith ::
1589− forall m a. (Monad m, Unboxed a)
1589+ forall m a. (Monad m, Unbox a)
15901590 => (forall b. IO b -> m b) -> Array a -> K.Stream m a
15911591toStreamKRevWith liftio Array {..} =
15921592 let p = INDEX_PREV(arrEnd,a)
@@ -1600,7 +1600,7 @@ toStreamKRevWith liftio Array {..} =
16001600 in liftio elemM `K.consM` go (INDEX_PREV(p,a))
16011601
16021602{-# INLINE toStreamKRev #-}
1603−toStreamKRev :: forall m a. (MonadIO m, Unboxed a) => Array a -> K.Stream m a
1603+toStreamKRev :: forall m a. (MonadIO m, Unbox a) => Array a -> K.Stream m a
16041604toStreamKRev = toStreamKRevWith liftIO
16051605
16061606-------------------------------------------------------------------------------
@@ -1612,12 +1612,12 @@ toStreamKRev = toStreamKRevWith liftIO
16121612--
16131613-- | Strict left fold of an array.
16141614{-# INLINE_NORMAL foldl' #-}
1615−foldl' :: (MonadIO m, Unboxed a) => (b -> a -> b) -> b -> Array a -> m b
1615+foldl' :: (MonadIO m, Unbox a) => (b -> a -> b) -> b -> Array a -> m b
16161616foldl' f z arr = D.foldl' f z $ toStreamD arr
16171617
16181618-- | Right fold of an array.
16191619{-# INLINE_NORMAL foldr #-}
1620−foldr :: (MonadIO m, Unboxed a) => (a -> b -> b) -> b -> Array a -> m b
1620+foldr :: (MonadIO m, Unbox a) => (a -> b -> b) -> b -> Array a -> m b
16211621foldr f z arr = D.foldr f z $ toStreamD arr
16221622
16231623-------------------------------------------------------------------------------
@@ -1641,7 +1641,7 @@ foldr f z arr = D.foldr f z $ toStreamD arr
16411641--
16421642-- /Internal/
16431643{-# INLINE_NORMAL appendNUnsafe #-}
1644−appendNUnsafe :: forall m a. (MonadIO m, Unboxed a) =>
1644+appendNUnsafe :: forall m a. (MonadIO m, Unbox a) =>
16451645 m (Array a)
16461646 -> Int
16471647 -> Fold m a (Array a)
@@ -1673,7 +1673,7 @@ appendNUnsafe action n =
16731673-- >>> appendN initial n = Fold.take n (Array.appendNUnsafe initial n)
16741674--
16751675{-# INLINE_NORMAL appendN #-}
1676−appendN :: forall m a. (MonadIO m, Unboxed a) =>
1676+appendN :: forall m a. (MonadIO m, Unbox a) =>
16771677 m (Array a) -> Int -> Fold m a (Array a)
16781678appendN initial n = FL.take n (appendNUnsafe initial n)
16791679
@@ -1688,7 +1688,7 @@ appendN initial n = FL.take n (appendNUnsafe initial n)
16881688--
16891689-- /Pre-release/
16901690{-# INLINE appendWith #-}
1691−appendWith :: forall m a. (MonadIO m, Unboxed a) =>
1691+appendWith :: forall m a. (MonadIO m, Unbox a) =>
16921692 (Int -> Int) -> m (Array a) -> Fold m a (Array a)
16931693appendWith sizer = FL.foldlM' (snocWith sizer)
16941694
@@ -1701,7 +1701,7 @@ appendWith sizer = FL.foldlM' (snocWith sizer)
17011701-- >>> append = Array.appendWith (* 2)
17021702--
17031703{-# INLINE append #-}
1704−append :: forall m a. (MonadIO m, Unboxed a) =>
1704+append :: forall m a. (MonadIO m, Unbox a) =>
17051705 m (Array a) -> Fold m a (Array a)
17061706append = appendWith (* 2)
17071707
@@ -1715,7 +1715,7 @@ append = appendWith (* 2)
17151715--
17161716-- /Pre-release/
17171717{-# INLINE_NORMAL writeNWithUnsafe #-}
1718−writeNWithUnsafe :: forall m a. (MonadIO m, Unboxed a)
1718+writeNWithUnsafe :: forall m a. (MonadIO m, Unbox a)
17191719 => (Int -> m (Array a)) -> Int -> Fold m a (Array a)
17201720writeNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
17211721
@@ -1737,7 +1737,7 @@ writeNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
17371737-- >>> writeNUnsafe = Array.writeNWithUnsafe Array.newPinned
17381738--
17391739{-# INLINE_NORMAL writeNUnsafe #-}
1740−writeNUnsafe :: forall m a. (MonadIO m, Unboxed a)
1740+writeNUnsafe :: forall m a. (MonadIO m, Unbox a)
17411741 => Int -> Fold m a (Array a)
17421742writeNUnsafe = writeNWithUnsafe newPinned
17431743
@@ -1748,7 +1748,7 @@ writeNUnsafe = writeNWithUnsafe newPinned
17481748-- >>> writeNWith alloc n = Array.appendN (alloc n) n
17491749--
17501750{-# INLINE_NORMAL writeNWith #-}
1751−writeNWith :: forall m a. (MonadIO m, Unboxed a)
1751+writeNWith :: forall m a. (MonadIO m, Unbox a)
17521752 => (Int -> m (Array a)) -> Int -> Fold m a (Array a)
17531753writeNWith alloc n = FL.take n (writeNWithUnsafe alloc n)
17541754
@@ -1760,14 +1760,14 @@ writeNWith alloc n = FL.take n (writeNWithUnsafe alloc n)
17601760-- >>> writeN n = Array.appendN (Array.newPinned n) n
17611761--
17621762{-# INLINE_NORMAL writeN #-}
1763−writeN :: forall m a. (MonadIO m, Unboxed a) => Int -> Fold m a (Array a)
1763+writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
17641764writeN = writeNWith newPinned
17651765
17661766-- | Like writeNWithUnsafe but writes the array in reverse order.
17671767--
17681768-- /Internal/
17691769{-# INLINE_NORMAL writeRevNWithUnsafe #-}
1770−writeRevNWithUnsafe :: forall m a. (MonadIO m, Unboxed a)
1770+writeRevNWithUnsafe :: forall m a. (MonadIO m, Unbox a)
17711771 => (Int -> m (Array a)) -> Int -> Fold m a (Array a)
17721772writeRevNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
17731773
@@ -1788,7 +1788,7 @@ writeRevNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
17881788--
17891789-- /Internal/
17901790{-# INLINE_NORMAL writeRevNWith #-}
1791−writeRevNWith :: forall m a. (MonadIO m, Unboxed a)
1791+writeRevNWith :: forall m a. (MonadIO m, Unbox a)
17921792 => (Int -> m (Array a)) -> Int -> Fold m a (Array a)
17931793writeRevNWith alloc n = FL.take n (writeRevNWithUnsafe alloc n)
17941794
@@ -1796,7 +1796,7 @@ writeRevNWith alloc n = FL.take n (writeRevNWithUnsafe alloc n)
17961796--
17971797-- /Pre-release/
17981798{-# INLINE_NORMAL writeRevN #-}
1799−writeRevN :: forall m a. (MonadIO m, Unboxed a) => Int -> Fold m a (Array a)
1799+writeRevN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
18001800writeRevN = writeRevNWith newPinned
18011801
18021802-- | @writeNAligned align n@ folds a maximum of @n@ elements from the input
@@ -1808,7 +1808,7 @@ writeRevN = writeRevNWith newPinned
18081808-- /Pre-release/
18091809--
18101810{-# INLINE_NORMAL writeNAligned #-}
1811−writeNAligned :: forall m a. (MonadIO m, Unboxed a)
1811+writeNAligned :: forall m a. (MonadIO m, Unbox a)
18121812 => Int -> Int -> Fold m a (Array a)
18131813writeNAligned align = writeNWith (newAlignedPinned align)
18141814
@@ -1826,7 +1826,7 @@ writeNAligned align = writeNWith (newAlignedPinned align)
18261826-- /Unimplemented/
18271827--
18281828{-# INLINE_NORMAL writeChunks #-}
1829−writeChunks :: (MonadIO m, Unboxed a) =>
1829+writeChunks :: (MonadIO m, Unbox a) =>
18301830 Int -> Fold m a (K.Stream n (Array a))
18311831writeChunks n = FL.many (writeN n) FL.toStreamK
18321832
@@ -1859,7 +1859,7 @@ writeChunks n = FL.many (writeN n) FL.toStreamK
18591859--
18601860-- /Pre-release/
18611861{-# INLINE_NORMAL writeWith #-}
1862−writeWith :: forall m a. (MonadIO m, Unboxed a)
1862+writeWith :: forall m a. (MonadIO m, Unbox a)
18631863 => Int -> Fold m a (Array a)
18641864-- writeWith n = FL.rmapM rightSize $ appendWith (* 2) (newPinned n)
18651865writeWith elemCount =
@@ -1897,7 +1897,7 @@ writeWith elemCount =
18971897-- /Caution! Do not use this on infinite streams./
18981898--
18991899{-# INLINE write #-}
1900−write :: forall m a. (MonadIO m, Unboxed a) => Fold m a (Array a)
1900+write :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
19011901write = writeWith (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
19021902
19031903-------------------------------------------------------------------------------
@@ -1909,7 +1909,7 @@ write = writeWith (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
19091909-- >>> fromStreamDN n = StreamD.fold (Array.writeN n)
19101910--
19111911{-# INLINE_NORMAL fromStreamDN #-}
1912−fromStreamDN :: forall m a. (MonadIO m, Unboxed a)
1912+fromStreamDN :: forall m a. (MonadIO m, Unbox a)
19131913 => Int -> D.Stream m a -> m (Array a)
19141914-- fromStreamDN n = D.fold (writeN n)
19151915fromStreamDN limit str = do
@@ -1928,14 +1928,14 @@ fromStreamDN limit str = do
19281928-- array may hold less than N elements.
19291929--
19301930{-# INLINABLE fromListN #-}
1931−fromListN :: (MonadIO m, Unboxed a) => Int -> [a] -> m (Array a)
1931+fromListN :: (MonadIO m, Unbox a) => Int -> [a] -> m (Array a)
19321932fromListN n xs = fromStreamDN n $ D.fromList xs
19331933
19341934-- | Like fromListN but writes the array in reverse order.
19351935--
19361936-- /Pre-release/
19371937{-# INLINE fromListRevN #-}
1938−fromListRevN :: (MonadIO m, Unboxed a) => Int -> [a] -> m (Array a)
1938+fromListRevN :: (MonadIO m, Unbox a) => Int -> [a] -> m (Array a)
19391939fromListRevN n xs = D.fold (writeRevN n) $ D.fromList xs
19401940
19411941-------------------------------------------------------------------------------
@@ -1943,14 +1943,14 @@ fromListRevN n xs = D.fold (writeRevN n) $ D.fromList xs
19431943-------------------------------------------------------------------------------
19441944
19451945{-# INLINE arrayStreamKLength #-}
1946−arrayStreamKLength :: (Monad m, Unboxed a) => K.Stream m (Array a) -> m Int
1946+arrayStreamKLength :: (Monad m, Unbox a) => K.Stream m (Array a) -> m Int
19471947arrayStreamKLength as = K.foldl' (+) 0 (K.map length as)
19481948
19491949-- | Convert an array stream to an array. Note that this requires peak memory
19501950-- that is double the size of the array stream.
19511951--
19521952{-# INLINE fromArrayStreamK #-}
1953−fromArrayStreamK :: (Unboxed a, MonadIO m) =>
1953+fromArrayStreamK :: (Unbox a, MonadIO m) =>
19541954 K.Stream m (Array a) -> m (Array a)
19551955fromArrayStreamK as = do
19561956 len <- arrayStreamKLength as
@@ -1970,13 +1970,13 @@ fromArrayStreamK as = do
19701970-- >>> fromStreamD = StreamD.fold Array.write
19711971--
19721972{-# INLINE fromStreamD #-}
1973−fromStreamD :: (MonadIO m, Unboxed a) => D.Stream m a -> m (Array a)
1973+fromStreamD :: (MonadIO m, Unbox a) => D.Stream m a -> m (Array a)
19741974fromStreamD m = arrayStreamKFromStreamD m >>= fromArrayStreamK
19751975
19761976-- | Create an 'Array' from a list. The list must be of finite size.
19771977--
19781978{-# INLINE fromList #-}
1979−fromList :: (MonadIO m, Unboxed a) => [a] -> m (Array a)
1979+fromList :: (MonadIO m, Unbox a) => [a] -> m (Array a)
19801980fromList xs = fromStreamD $ D.fromList xs
19811981
19821982-- XXX We are materializing the whole list first for getting the length. Check
@@ -1984,7 +1984,7 @@ fromList xs = fromStreamD $ D.fromList xs
19841984
19851985-- | Like 'fromList' but writes the contents of the list in reverse order.
19861986{-# INLINE fromListRev #-}
1987−fromListRev :: (MonadIO m, Unboxed a) => [a] -> m (Array a)
1987+fromListRev :: (MonadIO m, Unbox a) => [a] -> m (Array a)
19881988fromListRev xs = fromListRevN (Prelude.length xs) xs
19891989
19901990-------------------------------------------------------------------------------
@@ -2009,7 +2009,7 @@ putSliceUnsafe src srcStartBytes dst dstStartBytes lenBytes = liftIO $ do
20092009
20102010-- | Copy two arrays into a newly allocated array.
20112011{-# INLINE spliceCopy #-}
2012−spliceCopy :: forall m a. (MonadIO m, Unboxed a) =>
2012+spliceCopy :: forall m a. (MonadIO m, Unbox a) =>
20132013 Array a -> Array a -> m (Array a)
20142014spliceCopy arr1 arr2 = liftIO $ do
20152015 let start1 = arrStart arr1
@@ -2051,7 +2051,7 @@ spliceUnsafe dst src =
20512051--
20522052-- /Pre-release/
20532053{-# INLINE spliceWith #-}
2054−spliceWith :: forall m a. (MonadIO m, Unboxed a) =>
2054+spliceWith :: forall m a. (MonadIO m, Unbox a) =>
20552055 (Int -> Int -> Int) -> Array a -> Array a -> m (Array a)
20562056spliceWith sizer dst@(Array _ start end bound) src = do
20572057{-
@@ -2085,7 +2085,7 @@ spliceWith sizer dst@(Array _ start end bound) src = do
20852085--
20862086-- /Pre-release/
20872087{-# INLINE splice #-}
2088−splice :: (MonadIO m, Unboxed a) => Array a -> Array a -> m (Array a)
2088+splice :: (MonadIO m, Unbox a) => Array a -> Array a -> m (Array a)
20892089splice = spliceWith (+)
20902090
20912091-- | Like 'append' but the growth of the array is exponential. Whenever a new
@@ -2099,7 +2099,7 @@ splice = spliceWith (+)
20992099--
21002100-- /Pre-release/
21012101{-# INLINE spliceExp #-}
2102−spliceExp :: (MonadIO m, Unboxed a) => Array a -> Array a -> m (Array a)
2102+spliceExp :: (MonadIO m, Unbox a) => Array a -> Array a -> m (Array a)
21032103spliceExp = spliceWith (\l1 l2 -> max (l1 * 2) (l1 + l2))
21042104
21052105-------------------------------------------------------------------------------
@@ -2137,7 +2137,7 @@ breakOn sep arr@Array{..} = asPtrUnsafe arr $ \p -> liftIO $ do
21372137-- | Create two slices of an array without copying the original array. The
21382138-- specified index @i@ is the first index of the second slice.
21392139--
2140−splitAt :: forall a. Unboxed a => Int -> Array a -> (Array a, Array a)
2140+splitAt :: forall a. Unbox a => Int -> Array a -> (Array a, Array a)
21412141splitAt i arr@Array{..} =
21422142 let maxIndex = length arr - 1
21432143 in if i < 0
@@ -2189,7 +2189,7 @@ asBytes = castUnsafe
21892189-- type @b@. The length of the array should be a multiple of the size of the
21902190-- target element otherwise 'Nothing' is returned.
21912191--
2192−cast :: forall a b. Unboxed b => Array a -> Maybe (Array b)
2192+cast :: forall a b. Unbox b => Array a -> Maybe (Array b)
21932193cast arr =
21942194 let len = byteLength arr
21952195 r = len `mod` SIZE_OF(b)
@@ -2278,7 +2278,7 @@ cmp arr1 arr2 =
22782278-- NFData
22792279-------------------------------------------------------------------------------
22802280
2281−-- This is an Unboxed array, we cannot have unevaluated data in it so this is
2281+-- This is an Unbox array, we cannot have unevaluated data in it so this is
22822282-- just a no op.
22832283instance NFData (Array a) where
22842284 {-# INLINE rnf #-}
@@ -2292,7 +2292,7 @@ instance NFData1 Array where
22922292--
22932293-- /Pre-release/
22942294{-# INLINE strip #-}
2295−strip :: forall a m. (Unboxed a, MonadIO m) =>
2295+strip :: forall a m. (Unbox a, MonadIO m) =>
22962296 (a -> Bool) -> Array a -> m (Array a)
22972297strip eq arr@Array{..} = liftIO $ do
22982298 st <- getStart arrStart
@@ -2336,7 +2336,7 @@ strip eq arr@Array{..} = liftIO $ do
23362336--
23372337-- /Pre-release/
23382338{-# INLINE bubble #-}
2339−bubble :: (MonadIO m, Unboxed a) => (a -> a -> Ordering) -> Array a -> m ()
2339+bubble :: (MonadIO m, Unbox a) => (a -> a -> Ordering) -> Array a -> m ()
23402340bubble cmp0 arr =
23412341 when (l > 1) $ do
23422342 x <- getIndexUnsafe (l - 1) arr