git.iko.soy/streamly
on master help sign in
Rename concatChunks, compactChunks to concat, compact
c3b8dd4Harendra Kumar
core/src/Streamly/Internal/Data/Array/Type.hs+15−15
compare with master
unifiedsplit
@@ -117,8 +117,8 @@ module Streamly.Internal.Data.Array.Type
117
117
118 -- *** Concat
118 -- *** Concat
119 -- | Append the arrays in a stream to form a stream of elements.
119 -- | Append the arrays in a stream to form a stream of elements.
120− , concatChunks
120+ , concat
121− , concatChunksRev
121+ , concatRev
122
122
123 -- *** Compact
123 -- *** Compact
124 -- | Append the arrays in a stream to form a stream of larger arrays.
124 -- | Append the arrays in a stream to form a stream of larger arrays.
@@ -163,7 +163,7 @@ import Streamly.Internal.Data.Unbox (Unbox(..))
163import Streamly.Internal.Data.Unfold.Type (Unfold(..))
163import Streamly.Internal.Data.Unfold.Type (Unfold(..))
164import Text.Read (readPrec)
164import Text.Read (readPrec)
165
165
166−import Prelude hiding (Foldable(..), read, unlines, splitAt)
166+import Prelude hiding (Foldable(..), concat, read, unlines, splitAt)
167
167
168import qualified GHC.Exts as Exts
168import qualified GHC.Exts as Exts
169import qualified Streamly.Internal.Data.MutArray.Type as MA
169import qualified Streamly.Internal.Data.MutArray.Type as MA
@@ -450,35 +450,35 @@ pinnedChunksOf n str = D.map unsafeFreeze $ MA.pinnedChunksOf n str
450
450
451-- | Convert a stream of arrays into a stream of their elements.
451-- | Convert a stream of arrays into a stream of their elements.
452--
452--
453−-- >>> concatChunks = Stream.unfoldMany Array.reader
453+-- >>> concat = Stream.unfoldMany Array.reader
454--
454--
455−{-# INLINE_NORMAL concatChunks #-}
455+{-# INLINE_NORMAL concat #-}
456−concatChunks :: (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a
456+concat :: (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a
457-- XXX this requires MonadIO whereas the unfoldMany version does not
457-- XXX this requires MonadIO whereas the unfoldMany version does not
458−concatChunks = MA.concatChunks . D.map unsafeThaw
458+concat = MA.concat . D.map unsafeThaw
459−-- concatChunks = D.unfoldMany reader
459+-- concat = D.unfoldMany reader
460
460
461{-# DEPRECATED flattenArrays "Please use \"unfoldMany reader\" instead." #-}
461{-# DEPRECATED flattenArrays "Please use \"unfoldMany reader\" instead." #-}
462flattenArrays :: forall m a. (MonadIO m, Unbox a)
462flattenArrays :: forall m a. (MonadIO m, Unbox a)
463 => D.Stream m (Array a) -> D.Stream m a
463 => D.Stream m (Array a) -> D.Stream m a
464−flattenArrays = concatChunks
464+flattenArrays = concat
465
465
466-- | Convert a stream of arrays into a stream of their elements reversing the
466-- | Convert a stream of arrays into a stream of their elements reversing the
467-- contents of each array before flattening.
467-- contents of each array before flattening.
468--
468--
469−-- >>> concatChunksRev = Stream.unfoldMany Array.readerRev
469+-- >>> concatRev = Stream.unfoldMany Array.readerRev
470--
470--
471−{-# INLINE_NORMAL concatChunksRev #-}
471+{-# INLINE_NORMAL concatRev #-}
472−concatChunksRev :: forall m a. (MonadIO m, Unbox a)
472+concatRev :: forall m a. (MonadIO m, Unbox a)
473 => D.Stream m (Array a) -> D.Stream m a
473 => D.Stream m (Array a) -> D.Stream m a
474-- XXX this requires MonadIO whereas the unfoldMany version does not
474-- XXX this requires MonadIO whereas the unfoldMany version does not
475−concatChunksRev = MA.concatChunksRev . D.map unsafeThaw
475+concatRev = MA.concatRev . D.map unsafeThaw
476−-- concatChunksRev = D.unfoldMany readerRev
476+-- concatRev = D.unfoldMany readerRev
477
477
478{-# DEPRECATED flattenArraysRev "Please use \"unfoldMany readerRev\" instead." #-}
478{-# DEPRECATED flattenArraysRev "Please use \"unfoldMany readerRev\" instead." #-}
479flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
479flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
480 => D.Stream m (Array a) -> D.Stream m a
480 => D.Stream m (Array a) -> D.Stream m a
481−flattenArraysRev = concatChunksRev
481+flattenArraysRev = concatRev
482
482
483-- Drops the separator byte
483-- Drops the separator byte
484{-# INLINE breakOn #-}
484{-# INLINE breakOn #-}
core/src/Streamly/Internal/Data/MutArray.hs+6−6
@@ -13,7 +13,7 @@ module Streamly.Internal.Data.MutArray
13 -- * MutArray module
13 -- * MutArray module
14 , sliceIndexerFromLen
14 , sliceIndexerFromLen
15 , slicerFromLen
15 , slicerFromLen
16− , compactChunksLE
16+ , compactLE
17 -- * Unboxed IORef
17 -- * Unboxed IORef
18 , module Streamly.Internal.Data.IORef.Unboxed
18 , module Streamly.Internal.Data.IORef.Unboxed
19
19
@@ -83,10 +83,10 @@ getSlicesFromLen :: forall m a. (Monad m, Unbox a)
83 -> Unfold m (MutArray a) (MutArray a)
83 -> Unfold m (MutArray a) (MutArray a)
84getSlicesFromLen = slicerFromLen
84getSlicesFromLen = slicerFromLen
85
85
86−-- | Scan @compactChunksLE n@ coalesces adjacent arrays in the input stream
86+-- | Scan @compactLE n@ coalesces adjacent arrays in the input stream
87-- only if the combined size would be less than or equal to n.
87-- only if the combined size would be less than or equal to n.
88−{-# INLINE compactChunksLE #-}
88+{-# INLINE compactLE #-}
89−compactChunksLE :: (MonadIO m, Unbox a) =>
89+compactLE :: (MonadIO m, Unbox a) =>
90 Int -> Stream m (MutArray a) -> Stream m (MutArray a)
90 Int -> Stream m (MutArray a) -> Stream m (MutArray a)
91−-- compactLE n = Stream.catRights . Stream.parseManyD (pCompactChunksLE n)
91+-- compactLE n = Stream.catRights . Stream.parseManyD (pCompactLE n)
92−compactChunksLE = rCompactChunksLE
92+compactLE = rCompactLE
core/src/Streamly/Internal/Data/MutArray/Stream.hs+4−4
@@ -69,7 +69,7 @@ import qualified Streamly.Internal.Data.Stream as D
69{-# INLINE packArraysChunksOf #-}
69{-# INLINE packArraysChunksOf #-}
70packArraysChunksOf :: (MonadIO m, Unbox a)
70packArraysChunksOf :: (MonadIO m, Unbox a)
71 => Int -> D.Stream m (MutArray a) -> D.Stream m (MutArray a)
71 => Int -> D.Stream m (MutArray a) -> D.Stream m (MutArray a)
72−packArraysChunksOf = MArray.compactChunksLE
72+packArraysChunksOf = MArray.compactLE
73
73
74-- XXX Remove this once compactLEFold is implemented
74-- XXX Remove this once compactLEFold is implemented
75-- lpackArraysChunksOf = Fold.many compactLEFold
75-- lpackArraysChunksOf = Fold.many compactLEFold
@@ -77,7 +77,7 @@ packArraysChunksOf = MArray.compactChunksLE
77{-# INLINE lpackArraysChunksOf #-}
77{-# INLINE lpackArraysChunksOf #-}
78lpackArraysChunksOf :: (MonadIO m, Unbox a)
78lpackArraysChunksOf :: (MonadIO m, Unbox a)
79 => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
79 => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
80−lpackArraysChunksOf = MArray.lCompactChunksGE
80+lpackArraysChunksOf = MArray.lCompactGE
81
81
82-- XXX Same as compactLE, to be removed once that is implemented.
82-- XXX Same as compactLE, to be removed once that is implemented.
83--
83--
@@ -101,7 +101,7 @@ compact = packArraysChunksOf
101compactLEParserD ::
101compactLEParserD ::
102 forall m a. (MonadIO m, Unbox a)
102 forall m a. (MonadIO m, Unbox a)
103 => Int -> ParserD.Parser (MutArray a) m (MutArray a)
103 => Int -> ParserD.Parser (MutArray a) m (MutArray a)
104−compactLEParserD = MArray.pCompactChunksLE
104+compactLEParserD = MArray.pCompactLE
105
105
106-- | Coalesce adjacent arrays in incoming stream to form bigger arrays of a
106-- | Coalesce adjacent arrays in incoming stream to form bigger arrays of a
107-- minimum specified size. Note that if all the arrays in the stream together
107-- minimum specified size. Note that if all the arrays in the stream together
@@ -114,7 +114,7 @@ compactLEParserD = MArray.pCompactChunksLE
114compactGEFold ::
114compactGEFold ::
115 forall m a. (MonadIO m, Unbox a)
115 forall m a. (MonadIO m, Unbox a)
116 => Int -> FL.Fold m (MutArray a) (MutArray a)
116 => Int -> FL.Fold m (MutArray a) (MutArray a)
117−compactGEFold = MArray.fCompactChunksGE
117+compactGEFold = MArray.fCompactGE
118
118
119-- | Coalesce adjacent arrays in incoming stream to form bigger arrays of a
119-- | Coalesce adjacent arrays in incoming stream to form bigger arrays of a
120-- maximum specified size in bytes.
120-- maximum specified size in bytes.
core/src/Streamly/Internal/Data/MutArray/Type.hs+52−52
@@ -234,18 +234,18 @@ module Streamly.Internal.Data.MutArray.Type
234
234
235 -- *** Concat
235 -- *** Concat
236 -- | 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.
237− , concatChunks
237+ , concat
238− , concatChunksRev
238+ , concatRev
239
239
240 -- *** Compact
240 -- *** Compact
241 -- | 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.
242 , SpliceState (..)
242 , SpliceState (..)
243− , pCompactChunksLE
243+ , pCompactLE
244− , rCompactChunksLE
244+ , rCompactLE
245− , fCompactChunksGE
245+ , fCompactGE
246− , lCompactChunksGE
246+ , lCompactGE
247− , compactChunksGE
247+ , compactGE
248− , compactChunksEQ
248+ , compactEQ
249
249
250 -- ** Utilities
250 -- ** Utilities
251 , roundUpToPower2
251 , roundUpToPower2
@@ -318,7 +318,7 @@ import qualified Streamly.Internal.Data.StreamK.Type as K
318import qualified Prelude
318import qualified Prelude
319
319
320import Prelude hiding
320import Prelude hiding
321− (Foldable(..), read, unlines, splitAt, reverse, truncate)
321+ (Foldable(..), concat, read, unlines, splitAt, reverse, truncate)
322
322
323#include "DocTestDataMutArray.hs"
323#include "DocTestDataMutArray.hs"
324
324
@@ -851,7 +851,7 @@ reallocWith label capSizer minIncrBytes arr = do
851 where
851 where
852
852
853 badSize newSize =
853 badSize newSize =
854− concat
854+ Prelude.concat
855 [ label
855 [ label
856 , ": new array size (in bytes) is less than required size "
856 , ": new array size (in bytes) is less than required size "
857 , show newSize
857 , show newSize
@@ -1465,14 +1465,14 @@ data FlattenState s contents a =
1465
1465
1466-- | Use the "reader" unfold instead.
1466-- | Use the "reader" unfold instead.
1467--
1467--
1468−-- @concatChunks = unfoldMany reader@
1468+-- @concat = unfoldMany reader@
1469--
1469--
1470-- We can try this if there are any fusion issues in the unfold.
1470-- We can try this if there are any fusion issues in the unfold.
1471--
1471--
1472−{-# INLINE_NORMAL concatChunks #-}
1472+{-# INLINE_NORMAL concat #-}
1473−concatChunks :: forall m a. (MonadIO m, Unbox a)
1473+concat :: forall m a. (MonadIO m, Unbox a)
1474 => D.Stream m (MutArray a) -> D.Stream m a
1474 => D.Stream m (MutArray a) -> D.Stream m a
1475−concatChunks (D.Stream step state) = D.Stream step' (OuterLoop state)
1475+concat (D.Stream step state) = D.Stream step' (OuterLoop state)
1476
1476
1477 where
1477 where
1478
1478
@@ -1495,18 +1495,18 @@ concatChunks (D.Stream step state) = D.Stream step' (OuterLoop state)
1495{-# DEPRECATED flattenArrays "Please use \"unfoldMany reader\" instead." #-}
1495{-# DEPRECATED flattenArrays "Please use \"unfoldMany reader\" instead." #-}
1496flattenArrays :: forall m a. (MonadIO m, Unbox a)
1496flattenArrays :: forall m a. (MonadIO m, Unbox a)
1497 => D.Stream m (MutArray a) -> D.Stream m a
1497 => D.Stream m (MutArray a) -> D.Stream m a
1498−flattenArrays = concatChunks
1498+flattenArrays = concat
1499
1499
1500-- | Use the "readerRev" unfold instead.
1500-- | Use the "readerRev" unfold instead.
1501--
1501--
1502−-- @concatChunks = unfoldMany readerRev@
1502+-- @concat = unfoldMany readerRev@
1503--
1503--
1504-- We can try this if there are any fusion issues in the unfold.
1504-- We can try this if there are any fusion issues in the unfold.
1505--
1505--
1506−{-# INLINE_NORMAL concatChunksRev #-}
1506+{-# INLINE_NORMAL concatRev #-}
1507−concatChunksRev :: forall m a. (MonadIO m, Unbox a)
1507+concatRev :: forall m a. (MonadIO m, Unbox a)
1508 => D.Stream m (MutArray a) -> D.Stream m a
1508 => D.Stream m (MutArray a) -> D.Stream m a
1509−concatChunksRev (D.Stream step state) = D.Stream step' (OuterLoop state)
1509+concatRev (D.Stream step state) = D.Stream step' (OuterLoop state)
1510
1510
1511 where
1511 where
1512
1512
@@ -1531,7 +1531,7 @@ concatChunksRev (D.Stream step state) = D.Stream step' (OuterLoop state)
1531{-# DEPRECATED flattenArraysRev "Please use \"unfoldMany readerRev\" instead." #-}
1531{-# DEPRECATED flattenArraysRev "Please use \"unfoldMany readerRev\" instead." #-}
1532flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
1532flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
1533 => D.Stream m (MutArray a) -> D.Stream m a
1533 => D.Stream m (MutArray a) -> D.Stream m a
1534−flattenArraysRev = concatChunksRev
1534+flattenArraysRev = concatRev
1535
1535
1536-------------------------------------------------------------------------------
1536-------------------------------------------------------------------------------
1537-- Unfolds
1537-- Unfolds
@@ -2625,21 +2625,21 @@ byteEq arr1 arr2 = fmap (EQ ==) $ byteCmp arr1 arr2
2625-- Compact
2625-- Compact
2626-------------------------------------------------------------------------------
2626-------------------------------------------------------------------------------
2627
2627
2628−-- | Parser @pCompactChunksLE n@ coalesces adjacent arrays in the input stream
2628+-- | Parser @pCompactLE n@ coalesces adjacent arrays in the input stream
2629-- only if the combined size would be less than or equal to n.
2629-- only if the combined size would be less than or equal to n.
2630--
2630--
2631-- /Internal/
2631-- /Internal/
2632−{-# INLINE_NORMAL pCompactChunksLE #-}
2632+{-# INLINE_NORMAL pCompactLE #-}
2633−pCompactChunksLE ::
2633+pCompactLE ::
2634 forall m a. (MonadIO m, Unbox a)
2634 forall m a. (MonadIO m, Unbox a)
2635 => Int -> Parser (MutArray a) m (MutArray a)
2635 => Int -> Parser (MutArray a) m (MutArray a)
2636−pCompactChunksLE n = Parser step initial extract
2636+pCompactLE n = Parser step initial extract
2637
2637
2638 where
2638 where
2639
2639
2640 nBytes = n * SIZE_OF(a)
2640 nBytes = n * SIZE_OF(a)
2641
2641
2642− functionName = "Streamly.Internal.Data.MutArray.pCompactChunksLE"
2642+ functionName = "Streamly.Internal.Data.MutArray.pCompactLE"
2643
2643
2644 initial =
2644 initial =
2645 return
2645 return
@@ -2683,19 +2683,19 @@ data SpliceState s arr
2683-- immutable array never has additional space so a new array is allocated
2683-- immutable array never has additional space so a new array is allocated
2684-- instead of mutating it.
2684-- instead of mutating it.
2685
2685
2686−-- | Scan @rCompactChunksLE n@ coalesces adjacent arrays in the input stream
2686+-- | Scan @rCompactLE n@ coalesces adjacent arrays in the input stream
2687-- only if the combined size would be less than or equal to n.
2687-- only if the combined size would be less than or equal to n.
2688--
2688--
2689-- /Internal/
2689-- /Internal/
2690−{-# INLINE_NORMAL rCompactChunksLE #-}
2690+{-# INLINE_NORMAL rCompactLE #-}
2691−rCompactChunksLE :: (MonadIO m, Unbox a)
2691+rCompactLE :: (MonadIO m, Unbox a)
2692 => Int -> D.Stream m (MutArray a) -> D.Stream m (MutArray a)
2692 => Int -> D.Stream m (MutArray a) -> D.Stream m (MutArray a)
2693−rCompactChunksLE n (D.Stream step state) =
2693+rCompactLE n (D.Stream step state) =
2694 D.Stream step' (SpliceInitial state)
2694 D.Stream step' (SpliceInitial state)
2695
2695
2696 where
2696 where
2697
2697
2698− functionName = "Streamly.Internal.Data.MutArray.rCompactChunksLE"
2698+ functionName = "Streamly.Internal.Data.MutArray.rCompactLE"
2699
2699
2700 {-# INLINE_LATE step' #-}
2700 {-# INLINE_LATE step' #-}
2701 step' gst (SpliceInitial st) = do
2701 step' gst (SpliceInitial st) = do
@@ -2735,20 +2735,20 @@ rCompactChunksLE n (D.Stream step state) =
2735
2735
2736 step' _ (SpliceYielding arr next) = return $ D.Yield arr next
2736 step' _ (SpliceYielding arr next) = return $ D.Yield arr next
2737
2737
2738−-- | Fold @fCompactChunksGE n@ coalesces adjacent arrays in the input stream
2738+-- | Fold @fCompactGE n@ coalesces adjacent arrays in the input stream
2739-- until the size becomes greater than or equal to n.
2739-- until the size becomes greater than or equal to n.
2740--
2740--
2741−{-# INLINE_NORMAL fCompactChunksGE #-}
2741+{-# INLINE_NORMAL fCompactGE #-}
2742−fCompactChunksGE ::
2742+fCompactGE ::
2743 forall m a. (MonadIO m, Unbox a)
2743 forall m a. (MonadIO m, Unbox a)
2744 => Int -> FL.Fold m (MutArray a) (MutArray a)
2744 => Int -> FL.Fold m (MutArray a) (MutArray a)
2745−fCompactChunksGE n = Fold step initial extract extract
2745+fCompactGE n = Fold step initial extract extract
2746
2746
2747 where
2747 where
2748
2748
2749 nBytes = n * SIZE_OF(a)
2749 nBytes = n * SIZE_OF(a)
2750
2750
2751− functionName = "Streamly.Internal.Data.MutArray.fCompactChunksGE"
2751+ functionName = "Streamly.Internal.Data.MutArray.fCompactGE"
2752
2752
2753 initial =
2753 initial =
2754 return
2754 return
@@ -2779,20 +2779,20 @@ fCompactChunksGE n = Fold step initial extract extract
2779 extract Nothing = return nil
2779 extract Nothing = return nil
2780 extract (Just buf) = return buf
2780 extract (Just buf) = return buf
2781
2781
2782−-- | Like 'compactChunksGE' but for transforming folds instead of stream.
2782+-- | Like 'compactGE' but for transforming folds instead of stream.
2783--
2783--
2784−-- >>> lCompactChunksGE n = Fold.many (MutArray.fCompactChunksGE n)
2784+-- >>> lCompactGE n = Fold.many (MutArray.fCompactGE n)
2785--
2785--
2786−{-# INLINE_NORMAL lCompactChunksGE #-}
2786+{-# INLINE_NORMAL lCompactGE #-}
2787−lCompactChunksGE :: (MonadIO m, Unbox a)
2787+lCompactGE :: (MonadIO m, Unbox a)
2788 => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
2788 => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
2789−-- lCompactChunksGE n = Fold.many (fCompactChunksGE n)
2789+-- lCompactGE n = Fold.many (fCompactGE n)
2790−lCompactChunksGE n (Fold step1 initial1 _ final1) =
2790+lCompactGE n (Fold step1 initial1 _ final1) =
2791 Fold step initial extract final
2791 Fold step initial extract final
2792
2792
2793 where
2793 where
2794
2794
2795− functionName = "Streamly.Internal.Data.MutArray.lCompactChunksGE"
2795+ functionName = "Streamly.Internal.Data.MutArray.lCompactGE"
2796
2796
2797 initial = do
2797 initial = do
2798 when (n <= 0) $
2798 when (n <= 0) $
@@ -2841,7 +2841,7 @@ lCompactChunksGE n (Fold step1 initial1 _ final1) =
2841 --
2841 --
2842 -- extract forces the pending buffer to be sent to the fold which is not
2842 -- extract forces the pending buffer to be sent to the fold which is not
2843 -- what we want.
2843 -- what we want.
2844− extract _ = error "lCompactChunksGE: not designed for scanning"
2844+ extract _ = error "lCompactGE: not designed for scanning"
2845
2845
2846 final (Tuple' Nothing r1) = final1 r1
2846 final (Tuple' Nothing r1) = final1 r1
2847 final (Tuple' (Just buf) r1) = do
2847 final (Tuple' (Just buf) r1) = do
@@ -2850,25 +2850,25 @@ lCompactChunksGE n (Fold step1 initial1 _ final1) =
2850 FL.Partial rr -> final1 rr
2850 FL.Partial rr -> final1 rr
2851 FL.Done _ -> return ()
2851 FL.Done _ -> return ()
2852
2852
2853−-- | @compactChunksGE n stream@ coalesces adjacent arrays in the @stream@ until
2853+-- | @compactGE n stream@ coalesces adjacent arrays in the @stream@ until
2854-- the size becomes greater than or equal to @n@.
2854-- the size becomes greater than or equal to @n@.
2855--
2855--
2856−-- >>> compactChunksGE n = Stream.foldMany (MutArray.fCompactChunksGE n)
2856+-- >>> compactGE n = Stream.foldMany (MutArray.fCompactGE n)
2857--
2857--
2858−{-# INLINE compactChunksGE #-}
2858+{-# INLINE compactGE #-}
2859−compactChunksGE ::
2859+compactGE ::
2860 (MonadIO m, Unbox a)
2860 (MonadIO m, Unbox a)
2861 => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
2861 => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
2862−compactChunksGE n = D.foldMany (fCompactChunksGE n)
2862+compactGE n = D.foldMany (fCompactGE n)
2863
2863
2864−-- | 'compactChunksEQ n' coalesces adajacent arrays in the input stream to
2864+-- | 'compactEQ n' coalesces adajacent arrays in the input stream to
2865-- arrays of exact size @n@.
2865-- arrays of exact size @n@.
2866--
2866--
2867-- /Unimplemented/
2867-- /Unimplemented/
2868−{-# INLINE compactChunksEQ #-}
2868+{-# INLINE compactEQ #-}
2869−compactChunksEQ :: -- (MonadIO m, Unbox a) =>
2869+compactEQ :: -- (MonadIO m, Unbox a) =>
2870 Int -> Stream m (MutArray a) -> Stream m (MutArray a)
2870 Int -> Stream m (MutArray a) -> Stream m (MutArray a)
2871−compactChunksEQ _n = undefined -- D.parseManyD (pCompactChunksEQ n)
2871+compactEQ _n = undefined -- D.parseManyD (pCompactEQ n)
2872
2872
2873-------------------------------------------------------------------------------
2873-------------------------------------------------------------------------------
2874-- In-place mutation algorithms
2874-- In-place mutation algorithms
core/src/Streamly/Internal/Data/Stream/Transform.hs+1−1
@@ -1537,7 +1537,7 @@ reverse m = Stream step Nothing
1537{-# INLINE reverseUnbox #-}
1537{-# INLINE reverseUnbox #-}
1538reverseUnbox :: (MonadIO m, Unbox a) => Stream m a -> Stream m a
1538reverseUnbox :: (MonadIO m, Unbox a) => Stream m a -> Stream m a
1539reverseUnbox =
1539reverseUnbox =
1540− A.concatChunksRev -- unfoldMany A.readerRev
1540+ A.concatRev -- unfoldMany A.readerRev
1541 . fromStreamK
1541 . fromStreamK
1542 . K.reverse
1542 . K.reverse
1543 . toStreamK
1543 . toStreamK
src/Streamly/Internal/Data/Stream/IsStream/Common.hs+1−1
@@ -529,7 +529,7 @@ reverse' :: (IsStream t, MonadIO m, Unbox a) => t m a -> t m a
529-- reverse' s = fromStreamD $ D.reverse' $ toStreamD s
529-- reverse' s = fromStreamD $ D.reverse' $ toStreamD s
530reverse' =
530reverse' =
531 fromStreamD
531 fromStreamD
532− . A.concatChunksRev -- unfoldMany A.readerRev
532+ . A.concatRev -- unfoldMany A.readerRev
533 . D.fromStreamK
533 . D.fromStreamK
534 . K.reverse
534 . K.reverse
535 . D.toStreamK
535 . D.toStreamK