git.iko.soy/streamly
on master help sign in
Rename intersperse ops (#2210)
c01c7e2Ranjeet Ranjan
core/src/Streamly/Internal/Console/Stdio.hs+2−2
compare with master
unifiedsplit
@@ -52,7 +52,7 @@ import Streamly.Internal.Data.Unfold (Unfold)
52import Streamly.Internal.Data.Fold (Fold)
52import Streamly.Internal.Data.Fold (Fold)
53
53
54import qualified Streamly.Internal.Data.Array as Array
54import qualified Streamly.Internal.Data.Array as Array
55−import qualified Streamly.Internal.Data.Stream as Stream (intersperseSuffix)
55+import qualified Streamly.Internal.Data.Stream as Stream (intersperseMSuffix)
56import qualified Streamly.Internal.Data.Unfold as Unfold
56import qualified Streamly.Internal.Data.Unfold as Unfold
57import qualified Streamly.Internal.FileSystem.Handle as Handle
57import qualified Streamly.Internal.FileSystem.Handle as Handle
58import qualified Streamly.Internal.Unicode.Stream as Unicode
58import qualified Streamly.Internal.Unicode.Stream as Unicode
@@ -223,5 +223,5 @@ putStrings = putStringsWith Unicode.encodeUtf8
223putStringsLn :: MonadIO m => Stream m String -> m ()
223putStringsLn :: MonadIO m => Stream m String -> m ()
224putStringsLn =
224putStringsLn =
225 putChunks
225 putChunks
226− . Stream.intersperseSuffix (return $ Array.fromList [10])
226+ . Stream.intersperseMSuffix (return $ Array.fromList [10])
227 . Unicode.encodeStrings Unicode.encodeUtf8
227 . Unicode.encodeStrings Unicode.encodeUtf8
core/src/Streamly/Internal/Data/Stream/Bottom.hs+1−1
@@ -495,7 +495,7 @@ findIndices p m = fromStreamD $ D.findIndices p (toStreamD m)
495-- Transformation by Inserting
495-- Transformation by Inserting
496------------------------------------------------------------------------------
496------------------------------------------------------------------------------
497
497
498−-- intersperseM = intersperseBySpan 1
498+-- intersperseM = intersperseMWith 1
499
499
500-- | Insert an effect and its output before consuming an element of a stream
500-- | Insert an effect and its output before consuming an element of a stream
501-- except the first one.
501-- except the first one.
core/src/Streamly/Internal/Data/Stream/Expand.hs+4−4
@@ -550,10 +550,10 @@ gintercalateSuffix unf1 str1 unf2 str2 =
550
550
551-- > intercalateSuffix unf seed str = gintercalateSuffix unf str unf (repeatM seed)
551-- > intercalateSuffix unf seed str = gintercalateSuffix unf str unf (repeatM seed)
552
552
553−-- | 'intersperseSuffix' followed by unfold and concat.
553+-- | 'intersperseMSuffix' followed by unfold and concat.
554--
554--
555−-- >>> intercalateSuffix u a = Stream.unfoldMany u . Stream.intersperseSuffix a
555+-- >>> intercalateSuffix u a = Stream.unfoldMany u . Stream.intersperseMSuffix a
556−-- >>> intersperseSuffix = Stream.intercalateSuffix Unfold.identity
556+-- >>> intersperseMSuffix = Stream.intercalateSuffix Unfold.identity
557-- >>> unlines = Stream.intercalateSuffix Unfold.fromList "\n"
557-- >>> unlines = Stream.intercalateSuffix Unfold.fromList "\n"
558--
558--
559-- >>> input = Stream.fromList ["abc", "def", "ghi"]
559-- >>> input = Stream.fromList ["abc", "def", "ghi"]
@@ -564,7 +564,7 @@ gintercalateSuffix unf1 str1 unf2 str2 =
564intercalateSuffix :: Monad m
564intercalateSuffix :: Monad m
565 => Unfold m b c -> b -> Stream m b -> Stream m c
565 => Unfold m b c -> b -> Stream m b -> Stream m c
566intercalateSuffix unf seed str = fromStreamD $ D.unfoldMany unf
566intercalateSuffix unf seed str = fromStreamD $ D.unfoldMany unf
567− $ D.intersperseSuffix (return seed) (toStreamD str)
567+ $ D.intersperseMSuffix (return seed) (toStreamD str)
568
568
569------------------------------------------------------------------------------
569------------------------------------------------------------------------------
570-- Combine N Streams - concatMap
570-- Combine N Streams - concatMap
core/src/Streamly/Internal/Data/Stream/StreamD/Transform.hs+12−12
@@ -85,12 +85,12 @@ module Streamly.Internal.Data.Stream.StreamD.Transform
85 , insertBy
85 , insertBy
86 , intersperse
86 , intersperse
87 , intersperseM
87 , intersperseM
88− , intersperseSuffix
88+ , intersperseMSuffix
89− , intersperseSuffixBySpan
89+ , intersperseMSuffixWith
90
90
91 -- * Inserting Side Effects
91 -- * Inserting Side Effects
92 , intersperseM_
92 , intersperseM_
93− , intersperseSuffix_
93+ , intersperseMSuffix_
94
94
95 -- * Reordering
95 -- * Reordering
96 -- | Produce strictly the same set but reordered.
96 -- | Produce strictly the same set but reordered.
@@ -846,9 +846,9 @@ data SuffixState s a
846 | SuffixSuffix s
846 | SuffixSuffix s
847 | SuffixYield a (SuffixState s a)
847 | SuffixYield a (SuffixState s a)
848
848
849−{-# INLINE_NORMAL intersperseSuffix #-}
849+{-# INLINE_NORMAL intersperseMSuffix #-}
850−intersperseSuffix :: forall m a. Monad m => m a -> Stream m a -> Stream m a
850+intersperseMSuffix :: forall m a. Monad m => m a -> Stream m a -> Stream m a
851−intersperseSuffix action (Stream step state) = Stream step' (SuffixElem state)
851+intersperseMSuffix action (Stream step state) = Stream step' (SuffixElem state)
852 where
852 where
853 {-# INLINE_LATE step' #-}
853 {-# INLINE_LATE step' #-}
854 step' gst (SuffixElem st) = do
854 step' gst (SuffixElem st) = do
@@ -863,9 +863,9 @@ intersperseSuffix action (Stream step state) = Stream step' (SuffixElem state)
863
863
864 step' _ (SuffixYield x next) = return $ Yield x next
864 step' _ (SuffixYield x next) = return $ Yield x next
865
865
866−{-# INLINE_NORMAL intersperseSuffix_ #-}
866+{-# INLINE_NORMAL intersperseMSuffix_ #-}
867−intersperseSuffix_ :: Monad m => m b -> Stream m a -> Stream m a
867+intersperseMSuffix_ :: Monad m => m b -> Stream m a -> Stream m a
868−intersperseSuffix_ m (Stream step1 state1) = Stream step (Left state1)
868+intersperseMSuffix_ m (Stream step1 state1) = Stream step (Left state1)
869 where
869 where
870 {-# INLINE_LATE step #-}
870 {-# INLINE_LATE step #-}
871 step gst (Left st) = do
871 step gst (Left st) = do
@@ -885,10 +885,10 @@ data SuffixSpanState s a
885 | SuffixSpanStop
885 | SuffixSpanStop
886
886
887-- | intersperse after every n items
887-- | intersperse after every n items
888−{-# INLINE_NORMAL intersperseSuffixBySpan #-}
888+{-# INLINE_NORMAL intersperseMSuffixWith #-}
889−intersperseSuffixBySpan :: forall m a. Monad m
889+intersperseMSuffixWith :: forall m a. Monad m
890 => Int -> m a -> Stream m a -> Stream m a
890 => Int -> m a -> Stream m a -> Stream m a
891−intersperseSuffixBySpan n action (Stream step state) =
891+intersperseMSuffixWith n action (Stream step state) =
892 Stream step' (SuffixSpanElem state n)
892 Stream step' (SuffixSpanElem state n)
893 where
893 where
894 {-# INLINE_LATE step' #-}
894 {-# INLINE_LATE step' #-}
core/src/Streamly/Internal/Data/Stream/Transform.hs+33−33
@@ -101,10 +101,10 @@ module Streamly.Internal.Data.Stream.Transform
101 -- Element agnostic (Opposite of sampling)
101 -- Element agnostic (Opposite of sampling)
102 , intersperse
102 , intersperse
103 , intersperseM -- XXX naming
103 , intersperseM -- XXX naming
104− , intersperseBySpan
104+ , intersperseMWith
105
105
106− , intersperseSuffix
106+ , intersperseMSuffix
107− , intersperseSuffixBySpan
107+ , intersperseMSuffixWith
108
108
109 -- , interspersePrefix
109 -- , interspersePrefix
110 -- , interspersePrefixBySpan
110 -- , interspersePrefixBySpan
@@ -112,9 +112,9 @@ module Streamly.Internal.Data.Stream.Transform
112 -- * Inserting Side Effects/Time
112 -- * Inserting Side Effects/Time
113 , intersperseM_ -- XXX naming
113 , intersperseM_ -- XXX naming
114 , delay
114 , delay
115− , intersperseSuffix_
115+ , intersperseMSuffix_
116 , delayPost
116 , delayPost
117− , interspersePrefix_
117+ , intersperseMPrefix_
118 , delayPre
118 , delayPre
119
119
120 -- * Element Aware Insertion
120 -- * Element Aware Insertion
@@ -325,7 +325,7 @@ trace f = mapM (\x -> void (f x) >> return x)
325-- "got here"
325-- "got here"
326-- "got here"
326-- "got here"
327--
327--
328−-- Same as 'interspersePrefix_' but always serial.
328+-- Same as 'intersperseMPrefix_' but always serial.
329--
329--
330-- See also: 'trace'
330-- See also: 'trace'
331--
331--
@@ -680,72 +680,72 @@ intersperseM_ m = fromStreamD . D.intersperseM_ m . toStreamD
680-- elements.
680-- elements.
681--
681--
682-- >> input = Stream.fromList "hello"
682-- >> input = Stream.fromList "hello"
683−-- >> Stream.fold Fold.toList $ Stream.intersperseBySpan 2 (return ',') input
683+-- >> Stream.fold Fold.toList $ Stream.intersperseMWith 2 (return ',') input
684-- "he,ll,o"
684-- "he,ll,o"
685--
685--
686-- /Unimplemented/
686-- /Unimplemented/
687−{-# INLINE intersperseBySpan #-}
687+{-# INLINE intersperseMWith #-}
688−intersperseBySpan :: -- Monad m =>
688+intersperseMWith :: -- Monad m =>
689 Int -> m a -> Stream m a -> Stream m a
689 Int -> m a -> Stream m a -> Stream m a
690−intersperseBySpan _n _f _xs = undefined
690+intersperseMWith _n _f _xs = undefined
691
691
692-- | Insert an effect and its output after consuming an element of a stream.
692-- | Insert an effect and its output after consuming an element of a stream.
693--
693--
694-- >>> input = Stream.fromList "hello"
694-- >>> input = Stream.fromList "hello"
695−-- >>> Stream.fold Fold.toList $ Stream.trace putChar $ Stream.intersperseSuffix (putChar '.' >> return ',') input
695+-- >>> Stream.fold Fold.toList $ Stream.trace putChar $ Stream.intersperseMSuffix (putChar '.' >> return ',') input
696-- h.,e.,l.,l.,o.,"h,e,l,l,o,"
696-- h.,e.,l.,l.,o.,"h,e,l,l,o,"
697--
697--
698-- /Pre-release/
698-- /Pre-release/
699−{-# INLINE intersperseSuffix #-}
699+{-# INLINE intersperseMSuffix #-}
700−intersperseSuffix :: Monad m => m a -> Stream m a -> Stream m a
700+intersperseMSuffix :: Monad m => m a -> Stream m a -> Stream m a
701−intersperseSuffix m = fromStreamD . D.intersperseSuffix m . toStreamD
701+intersperseMSuffix m = fromStreamD . D.intersperseMSuffix m . toStreamD
702
702
703-- | Insert a side effect after consuming an element of a stream.
703-- | Insert a side effect after consuming an element of a stream.
704--
704--
705-- >>> input = Stream.fromList "hello"
705-- >>> input = Stream.fromList "hello"
706−-- >>> Stream.fold Fold.toList $ Stream.intersperseSuffix_ (threadDelay 1000000) input
706+-- >>> Stream.fold Fold.toList $ Stream.intersperseMSuffix_ (threadDelay 1000000) input
707-- "hello"
707-- "hello"
708--
708--
709-- /Pre-release/
709-- /Pre-release/
710--
710--
711−{-# INLINE intersperseSuffix_ #-}
711+{-# INLINE intersperseMSuffix_ #-}
712−intersperseSuffix_ :: Monad m => m b -> Stream m a -> Stream m a
712+intersperseMSuffix_ :: Monad m => m b -> Stream m a -> Stream m a
713−intersperseSuffix_ m = fromStreamD . D.intersperseSuffix_ m . toStreamD
713+intersperseMSuffix_ m = fromStreamD . D.intersperseMSuffix_ m . toStreamD
714
714
715-- XXX Use an offset argument, like tapOffsetEvery
715-- XXX Use an offset argument, like tapOffsetEvery
716
716
717−-- | Like 'intersperseSuffix' but intersperses an effectful action into the
717+-- | Like 'intersperseMSuffix' but intersperses an effectful action into the
718-- input stream after every @n@ elements and after the last element.
718-- input stream after every @n@ elements and after the last element.
719--
719--
720-- >>> input = Stream.fromList "hello"
720-- >>> input = Stream.fromList "hello"
721−-- >>> Stream.fold Fold.toList $ Stream.intersperseSuffixBySpan 2 (return ',') input
721+-- >>> Stream.fold Fold.toList $ Stream.intersperseMSuffixWith 2 (return ',') input
722-- "he,ll,o,"
722-- "he,ll,o,"
723--
723--
724-- /Pre-release/
724-- /Pre-release/
725--
725--
726−{-# INLINE intersperseSuffixBySpan #-}
726+{-# INLINE intersperseMSuffixWith #-}
727−intersperseSuffixBySpan :: Monad m
727+intersperseMSuffixWith :: Monad m
728 => Int -> m a -> Stream m a -> Stream m a
728 => Int -> m a -> Stream m a -> Stream m a
729−intersperseSuffixBySpan n eff =
729+intersperseMSuffixWith n eff =
730− fromStreamD . D.intersperseSuffixBySpan n eff . toStreamD
730+ fromStreamD . D.intersperseMSuffixWith n eff . toStreamD
731
731
732-- | Insert a side effect before consuming an element of a stream.
732-- | Insert a side effect before consuming an element of a stream.
733--
733--
734-- Definition:
734-- Definition:
735--
735--
736−-- >>> interspersePrefix_ m = Stream.mapM (\x -> void m >> return x)
736+-- >>> intersperseMPrefix_ m = Stream.mapM (\x -> void m >> return x)
737--
737--
738-- >>> input = Stream.fromList "hello"
738-- >>> input = Stream.fromList "hello"
739−-- >>> Stream.fold Fold.toList $ Stream.trace putChar $ Stream.interspersePrefix_ (putChar '.' >> return ',') input
739+-- >>> Stream.fold Fold.toList $ Stream.trace putChar $ Stream.intersperseMPrefix_ (putChar '.' >> return ',') input
740-- .h.e.l.l.o"hello"
740-- .h.e.l.l.o"hello"
741--
741--
742-- Same as 'trace_'.
742-- Same as 'trace_'.
743--
743--
744-- /Pre-release/
744-- /Pre-release/
745--
745--
746−{-# INLINE interspersePrefix_ #-}
746+{-# INLINE intersperseMPrefix_ #-}
747−interspersePrefix_ :: Monad m => m b -> Stream m a -> Stream m a
747+intersperseMPrefix_ :: Monad m => m b -> Stream m a -> Stream m a
748−interspersePrefix_ m = mapM (\x -> void m >> return x)
748+intersperseMPrefix_ m = mapM (\x -> void m >> return x)
749
749
750------------------------------------------------------------------------------
750------------------------------------------------------------------------------
751-- Inserting Time
751-- Inserting Time
@@ -783,7 +783,7 @@ delay = intersperseM_ . sleep
783-- Definition:
783-- Definition:
784--
784--
785-- >>> sleep n = liftIO $ threadDelay $ round $ n * 1000000
785-- >>> sleep n = liftIO $ threadDelay $ round $ n * 1000000
786−-- >>> delayPost = Stream.intersperseSuffix_ . sleep
786+-- >>> delayPost = Stream.intersperseMSuffix_ . sleep
787--
787--
788-- Example:
788-- Example:
789--
789--
@@ -797,7 +797,7 @@ delay = intersperseM_ . sleep
797--
797--
798{-# INLINE delayPost #-}
798{-# INLINE delayPost #-}
799delayPost :: MonadIO m => Double -> Stream m a -> Stream m a
799delayPost :: MonadIO m => Double -> Stream m a -> Stream m a
800−delayPost = intersperseSuffix_ . sleep
800+delayPost n = intersperseMSuffix_ $ liftIO $ threadDelay $ round $ n * 1000000
801
801
802-- | Introduce a delay of specified seconds before consuming an element of a
802-- | Introduce a delay of specified seconds before consuming an element of a
803-- stream.
803-- stream.
@@ -805,7 +805,7 @@ delayPost = intersperseSuffix_ . sleep
805-- Definition:
805-- Definition:
806--
806--
807-- >>> sleep n = liftIO $ threadDelay $ round $ n * 1000000
807-- >>> sleep n = liftIO $ threadDelay $ round $ n * 1000000
808−-- >>> delayPre = Stream.interspersePrefix_ . sleep
808+-- >>> delayPre = Stream.intersperseMPrefix_. sleep
809--
809--
810-- Example:
810-- Example:
811--
811--
@@ -819,7 +819,7 @@ delayPost = intersperseSuffix_ . sleep
819--
819--
820{-# INLINE delayPre #-}
820{-# INLINE delayPre #-}
821delayPre :: MonadIO m => Double -> Stream m a -> Stream m a
821delayPre :: MonadIO m => Double -> Stream m a -> Stream m a
822−delayPre = interspersePrefix_ . sleep
822+delayPre = intersperseMPrefix_. sleep
823
823
824------------------------------------------------------------------------------
824------------------------------------------------------------------------------
825-- Reorder in sequence
825-- Reorder in sequence
src/Streamly/Internal/Data/Stream/IsStream/Common.hs+1−1
@@ -438,7 +438,7 @@ findIndices p m = fromStreamD $ D.findIndices p (toStreamD m)
438-- Transformation by Inserting
438-- Transformation by Inserting
439------------------------------------------------------------------------------
439------------------------------------------------------------------------------
440
440
441−-- intersperseM = intersperseBySpan 1
441+-- intersperseM = intersperseMWith 1
442
442
443-- | Insert an effect and its output before consuming an element of a stream
443-- | Insert an effect and its output before consuming an element of a stream
444-- except the first one.
444-- except the first one.
src/Streamly/Internal/Data/Stream/IsStream/Expand.hs+5−5
@@ -182,7 +182,7 @@ import qualified Streamly.Internal.Data.Stream.StreamD as D
182 (append, interleave, interleaveSuffix, interleaveInfix, interleaveMin
182 (append, interleave, interleaveSuffix, interleaveInfix, interleaveMin
183 , roundRobin, mergeByM, unfoldMany, unfoldManyInterleave, intersperse
183 , roundRobin, mergeByM, unfoldMany, unfoldManyInterleave, intersperse
184 , unfoldManyRoundRobin, interpose, interposeSuffix, gintercalate
184 , unfoldManyRoundRobin, interpose, interposeSuffix, gintercalate
185− , gintercalateSuffix, intersperseSuffix)
185+ , gintercalateSuffix, intersperseMSuffix)
186import qualified Streamly.Internal.Data.Stream.StreamK as K (mergeBy, mergeByM)
186import qualified Streamly.Internal.Data.Stream.StreamK as K (mergeBy, mergeByM)
187import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
187import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
188 (interleave, serial, concatPairsWith)
188 (interleave, serial, concatPairsWith)
@@ -935,10 +935,10 @@ gintercalateSuffix unf1 str1 unf2 str2 =
935
935
936-- > intercalateSuffix unf seed str = gintercalateSuffix unf str unf (repeatM seed)
936-- > intercalateSuffix unf seed str = gintercalateSuffix unf str unf (repeatM seed)
937--
937--
938−-- | 'intersperseSuffix' followed by unfold and concat.
938+-- | 'intersperseMSuffix' followed by unfold and concat.
939--
939--
940−-- > intercalateSuffix unf a str = unfoldMany unf $ intersperseSuffix a str
940+-- > intercalateSuffix unf a str = unfoldMany unf $ intersperseMSuffix a str
941−-- > intersperseSuffix = intercalateSuffix (Unfold.function id)
941+-- > intersperseMSuffix = intercalateSuffix (Unfold.function id)
942-- > unlines = intercalateSuffix Unfold.fromList "\n"
942-- > unlines = intercalateSuffix Unfold.fromList "\n"
943--
943--
944-- >>> Stream.toList $ Stream.intercalateSuffix Unfold.fromList "\n" $ Stream.fromList ["abc", "def", "ghi"]
944-- >>> Stream.toList $ Stream.intercalateSuffix Unfold.fromList "\n" $ Stream.fromList ["abc", "def", "ghi"]
@@ -949,7 +949,7 @@ gintercalateSuffix unf1 str1 unf2 str2 =
949intercalateSuffix :: (IsStream t, Monad m)
949intercalateSuffix :: (IsStream t, Monad m)
950 => Unfold m b c -> b -> t m b -> t m c
950 => Unfold m b c -> b -> t m b -> t m c
951intercalateSuffix unf seed str = fromStreamD $ D.unfoldMany unf
951intercalateSuffix unf seed str = fromStreamD $ D.unfoldMany unf
952− $ D.intersperseSuffix (return seed) (toStreamD str)
952+ $ D.intersperseMSuffix (return seed) (toStreamD str)
953
953
954------------------------------------------------------------------------------
954------------------------------------------------------------------------------
955-- Combine N Streams - concatMap
955-- Combine N Streams - concatMap
src/Streamly/Internal/Data/Stream/IsStream/Transform.hs+31−31
@@ -109,10 +109,10 @@ module Streamly.Internal.Data.Stream.IsStream.Transform {-# DEPRECATED "Please u
109 -- Element agnostic (Opposite of sampling)
109 -- Element agnostic (Opposite of sampling)
110 , intersperse
110 , intersperse
111 , intersperseM -- XXX naming
111 , intersperseM -- XXX naming
112− , intersperseBySpan
112+ , intersperseMWith
113
113
114− , intersperseSuffix
114+ , intersperseMSuffix
115− , intersperseSuffixBySpan
115+ , intersperseMSuffixWith
116 , interjectSuffix
116 , interjectSuffix
117
117
118 -- , interspersePrefix
118 -- , interspersePrefix
@@ -121,9 +121,9 @@ module Streamly.Internal.Data.Stream.IsStream.Transform {-# DEPRECATED "Please u
121 -- * Inserting Side Effects/Time
121 -- * Inserting Side Effects/Time
122 , intersperseM_ -- XXX naming
122 , intersperseM_ -- XXX naming
123 , delay
123 , delay
124− , intersperseSuffix_
124+ , intersperseMSuffix_
125 , delayPost
125 , delayPost
126− , interspersePrefix_
126+ , intersperseMPrefix_
127 , delayPre
127 , delayPre
128
128
129 -- * Element Aware Insertion
129 -- * Element Aware Insertion
@@ -261,8 +261,8 @@ import qualified Streamly.Internal.Data.Stream.StreamD as D
261 , scanMany, postscanOnce, scanlx', scanlM', scanl', postscanl', prescanl'
261 , scanMany, postscanOnce, scanlx', scanlM', scanl', postscanl', prescanl'
262 , prescanlM', scanl1M', scanl1', filter, filterM, uniq, deleteBy, takeWhileM
262 , prescanlM', scanl1M', scanl1', filter, filterM, uniq, deleteBy, takeWhileM
263 , dropWhile, dropWhileM, insertBy, intersperse
263 , dropWhile, dropWhileM, insertBy, intersperse
264− , intersperseM_, intersperseSuffix, intersperseSuffix_
264+ , intersperseM_, intersperseMSuffix, intersperseMSuffix_
265− , intersperseSuffixBySpan, indexed, indexedR, rollingMap, rollingMapM
265+ , intersperseMSuffixWith, indexed, indexedR, rollingMap, rollingMapM
266 , rollingMap2, mapMaybe, mapMaybeM)
266 , rollingMap2, mapMaybe, mapMaybeM)
267import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
267import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
268 (foldrS, foldrSShared, mapMWith)
268 (foldrS, foldrSShared, mapMWith)
@@ -610,7 +610,7 @@ trace f = mapM (\x -> void (f x) >> return x)
610--
610--
611-- @
611-- @
612--
612--
613−-- Same as 'interspersePrefix_' but always serial.
613+-- Same as 'intersperseMPrefix_' but always serial.
614--
614--
615-- See also: 'trace'
615-- See also: 'trace'
616--
616--
@@ -1165,60 +1165,60 @@ intersperseM_ m = fromStreamD . D.intersperseM_ m . toStreamD
1165-- elements.
1165-- elements.
1166--
1166--
1167-- @
1167-- @
1168−-- > Stream.toList $ Stream.intersperseBySpan 2 (return ',') $ Stream.fromList "hello"
1168+-- > Stream.toList $ Stream.intersperseMWith 2 (return ',') $ Stream.fromList "hello"
1169-- "he,ll,o"
1169-- "he,ll,o"
1170--
1170--
1171-- @
1171-- @
1172--
1172--
1173-- /Unimplemented/
1173-- /Unimplemented/
1174−{-# INLINE intersperseBySpan #-}
1174+{-# INLINE intersperseMWith #-}
1175−intersperseBySpan :: -- IsStream t =>
1175+intersperseMWith :: -- IsStream t =>
1176 Int -> m a -> t m a -> t m a
1176 Int -> m a -> t m a -> t m a
1177−intersperseBySpan _n _f _xs = undefined
1177+intersperseMWith _n _f _xs = undefined
1178
1178
1179-- | Insert an effect and its output after consuming an element of a stream.
1179-- | Insert an effect and its output after consuming an element of a stream.
1180--
1180--
1181−-- >>> Stream.toList $ Stream.trace putChar $ intersperseSuffix (putChar '.' >> return ',') $ Stream.fromList "hello"
1181+-- >>> Stream.toList $ Stream.trace putChar $ intersperseMSuffix (putChar '.' >> return ',') $ Stream.fromList "hello"
1182-- h.,e.,l.,l.,o.,"h,e,l,l,o,"
1182-- h.,e.,l.,l.,o.,"h,e,l,l,o,"
1183--
1183--
1184-- /Pre-release/
1184-- /Pre-release/
1185−{-# INLINE intersperseSuffix #-}
1185+{-# INLINE intersperseMSuffix #-}
1186−intersperseSuffix :: (IsStream t, Monad m) => m a -> t m a -> t m a
1186+intersperseMSuffix :: (IsStream t, Monad m) => m a -> t m a -> t m a
1187−intersperseSuffix m = fromStreamD . D.intersperseSuffix m . toStreamD
1187+intersperseMSuffix m = fromStreamD . D.intersperseMSuffix m . toStreamD
1188
1188
1189-- | Insert a side effect after consuming an element of a stream.
1189-- | Insert a side effect after consuming an element of a stream.
1190--
1190--
1191-- @
1191-- @
1192−-- >>> Stream.mapM_ putChar $ Stream.intersperseSuffix_ (threadDelay 1000000) $ Stream.fromList "hello"
1192+-- >>> Stream.mapM_ putChar $ Stream.intersperseMSuffix_ (threadDelay 1000000) $ Stream.fromList "hello"
1193-- hello
1193-- hello
1194--
1194--
1195-- @
1195-- @
1196--
1196--
1197-- /Pre-release/
1197-- /Pre-release/
1198--
1198--
1199−{-# INLINE intersperseSuffix_ #-}
1199+{-# INLINE intersperseMSuffix_ #-}
1200−intersperseSuffix_ :: (IsStream t, Monad m) => m b -> t m a -> t m a
1200+intersperseMSuffix_ :: (IsStream t, Monad m) => m b -> t m a -> t m a
1201−intersperseSuffix_ m = fromStreamD . D.intersperseSuffix_ m . toStreamD
1201+intersperseMSuffix_ m = fromStreamD . D.intersperseMSuffix_ m . toStreamD
1202
1202
1203-- XXX Use an offset argument, like tapOffsetEvery
1203-- XXX Use an offset argument, like tapOffsetEvery
1204--
1204--
1205−-- | Like 'intersperseSuffix' but intersperses an effectful action into the
1205+-- | Like 'intersperseMSuffix' but intersperses an effectful action into the
1206-- input stream after every @n@ elements and after the last element.
1206-- input stream after every @n@ elements and after the last element.
1207--
1207--
1208−-- >>> Stream.toList $ Stream.intersperseSuffixBySpan 2 (return ',') $ Stream.fromList "hello"
1208+-- >>> Stream.toList $ Stream.intersperseMSuffixWith 2 (return ',') $ Stream.fromList "hello"
1209-- "he,ll,o,"
1209-- "he,ll,o,"
1210--
1210--
1211-- /Pre-release/
1211-- /Pre-release/
1212--
1212--
1213−{-# INLINE intersperseSuffixBySpan #-}
1213+{-# INLINE intersperseMSuffixWith #-}
1214−intersperseSuffixBySpan :: (IsStream t, Monad m)
1214+intersperseMSuffixWith :: (IsStream t, Monad m)
1215 => Int -> m a -> t m a -> t m a
1215 => Int -> m a -> t m a -> t m a
1216−intersperseSuffixBySpan n eff =
1216+intersperseMSuffixWith n eff =
1217− fromStreamD . D.intersperseSuffixBySpan n eff . toStreamD
1217+ fromStreamD . D.intersperseMSuffixWith n eff . toStreamD
1218
1218
1219-- | Insert a side effect before consuming an element of a stream.
1219-- | Insert a side effect before consuming an element of a stream.
1220--
1220--
1221−-- >>> Stream.toList $ Stream.trace putChar $ Stream.interspersePrefix_ (putChar '.' >> return ',') $ Stream.fromList "hello"
1221+-- >>> Stream.toList $ Stream.trace putChar $ Stream.intersperseMPrefix_ (putChar '.' >> return ',') $ Stream.fromList "hello"
1222-- .h.e.l.l.o"hello"
1222-- .h.e.l.l.o"hello"
1223--
1223--
1224-- Same as 'trace_' but may be concurrent.
1224-- Same as 'trace_' but may be concurrent.
@@ -1227,9 +1227,9 @@ intersperseSuffixBySpan n eff =
1227--
1227--
1228-- /Pre-release/
1228-- /Pre-release/
1229--
1229--
1230−{-# INLINE interspersePrefix_ #-}
1230+{-# INLINE intersperseMPrefix_ #-}
1231−interspersePrefix_ :: (IsStream t, MonadAsync m) => m b -> t m a -> t m a
1231+intersperseMPrefix_ :: (IsStream t, MonadAsync m) => m b -> t m a -> t m a
1232−interspersePrefix_ m = mapM (\x -> void m >> return x)
1232+intersperseMPrefix_ m = mapM (\x -> void m >> return x)
1233
1233
1234------------------------------------------------------------------------------
1234------------------------------------------------------------------------------
1235-- Inserting Time
1235-- Inserting Time
@@ -1265,7 +1265,7 @@ delay n = intersperseM_ $ liftIO $ threadDelay $ round $ n * 1000000
1265--
1265--
1266{-# INLINE delayPost #-}
1266{-# INLINE delayPost #-}
1267delayPost :: (IsStream t, MonadIO m) => Double -> t m a -> t m a
1267delayPost :: (IsStream t, MonadIO m) => Double -> t m a -> t m a
1268−delayPost n = intersperseSuffix_ $ liftIO $ threadDelay $ round $ n * 1000000
1268+delayPost n = intersperseMSuffix_ $ liftIO $ threadDelay $ round $ n * 1000000
1269
1269
1270-- Note: delay must be serial, that's why 'trace_' is used.
1270-- Note: delay must be serial, that's why 'trace_' is used.
1271--
1271--