9706067 · streamly · git.iko.soy

src/Streamly/Prelude.hs+13

compare with master

unifiedsplit

@@ -151,6 +151,9 @@ module Streamly.Prelude

151 -- ** Reordering

152 , reverse

153

154+ -- ** Inserting

155+ , intersperseM

156+

154 -- * Zipping

157 -- * Zipping

155 , zipWith

158 , zipWith

156 , zipWithM

159 , zipWithM

@@ -872,6 +875,16 @@ reverse m = fromStream $ go K.nil (toStream m)

872 yieldk a r = runIt $ go (a `K.cons` rev) r

875 yieldk a r = runIt $ go (a `K.cons` rev) r

873 in K.unStream rest (rstState st) stop single yieldk

876 in K.unStream rest (rstState st) stop single yieldk

874

877

878+------------------------------------------------------------------------------

879+-- Transformation by Inserting

880+------------------------------------------------------------------------------

881+

882+-- | Generate a stream by performing the monadic action inbetween all elements

883+-- of the given stream.

884+{-# INLINE intersperseM #-}

885+intersperseM :: (IsStream t, MonadAsync m) => m a -> t m a -> t m a

886+intersperseM = K.intersperseM

887+

875------------------------------------------------------------------------------

888------------------------------------------------------------------------------

876-- Zipping

889-- Zipping

877------------------------------------------------------------------------------

890------------------------------------------------------------------------------

src/Streamly/Streams/StreamK.hs+19

@@ -117,6 +117,9 @@ module Streamly.Streams.StreamK

117 , mapM

118 , sequence

119

120+ -- ** Inserting

121+ , intersperseM

122+

120 -- ** Map and Filter

123 -- ** Map and Filter

121 , mapMaybe

124 , mapMaybe

122

125

@@ -849,6 +852,22 @@ sequence m = go (toStream m)

849 yieldk ma r = unStream (toStream $ ma |: go r) st stp sng yld

852 yieldk ma r = unStream (toStream $ ma |: go r) st stp sng yld

850 in (unStream m1) (rstState st) stp single yieldk

853 in (unStream m1) (rstState st) stp single yieldk

851

854

855+-------------------------------------------------------------------------------

856+-- Inserting

857+-------------------------------------------------------------------------------

858+

859+{-# INLINE intersperseM #-}

860+intersperseM :: (IsStream t, MonadAsync m) => m a -> t m a -> t m a

861+intersperseM a m = fromStream $ prependingStart (toStream m)

862+ where

863+ prependingStart m1 = Stream $ \st stp sng yld ->

864+ let yieldk i x = unStream (return i |: go x) st stp sng yld

865+ in unStream m1 (rstState st) stp sng yieldk

866+ go m2 = fromStream $ Stream $ \st stp sng yld ->

867+ let single i = unStream (a |: yield i) st stp sng yld

868+ yieldk i x = unStream (a |: return i |: go x) st stp sng yld

869+ in unStream m2 (rstState st) stp single yieldk

870+

852-------------------------------------------------------------------------------

871-------------------------------------------------------------------------------

853-- Map and Filter

872-- Map and Filter

854-------------------------------------------------------------------------------

873-------------------------------------------------------------------------------

test/Prop.hs+6−1

@@ -10,7 +10,7 @@ import Control.Concurrent (MVar, takeMVar, putMVar, newEmptyMVar)

10import Control.Monad (replicateM, replicateM_)

11import Data.IORef (readIORef, modifyIORef, newIORef)

12import Data.List (sort, foldl', scanl', findIndices, findIndex, elemIndices,

13− elemIndex, find)

13+ elemIndex, find, intersperse)

14import Data.Maybe (mapMaybe)

15import GHC.Word (Word8)

16

@@ -351,6 +351,8 @@ transformOps constr desc t eq = do

351 prop (desc ++ " findIndices") $ transform (findIndices odd) $ t . (S.findIndices odd)

352 prop (desc ++ " elemIndices") $ transform (elemIndices 3) $ t . (S.elemIndices 3)

353

354+ prop (desc ++ " intersperseM") $ transform (intersperse 3) $ t . (S.intersperseM (return 3))

355+

354

356

355concurrentOps

357concurrentOps

356 :: IsStream t

358 :: IsStream t

@@ -437,6 +439,9 @@ transformCombineOpsCommon constr desc t eq = do

437 (S.scanlM' (\_ a -> return a) 0)

439 (S.scanlM' (\_ a -> return a) 0)

438 prop (desc ++ " reverse") $ transform reverse t S.reverse

440 prop (desc ++ " reverse") $ transform reverse t S.reverse

439

441

442+ prop (desc ++ " intersperseM") $

443+ transform (intersperse 3) t (S.intersperseM $ return 3)

444+

440transformCombineOpsOrdered

445transformCombineOpsOrdered

441 :: (IsStream t, Semigroup (t IO Int))

446 :: (IsStream t, Semigroup (t IO Int))

442 => ([Int] -> t IO Int)

447 => ([Int] -> t IO Int)