git.iko.soy/streamly
on master help sign in
Change the order of foldStream arguments
0a2755aHarendra Kumar
src/Streamly/Prelude.hs+5−5
compare with master
unifiedsplit
@@ -896,7 +896,7 @@ each = K.fromFoldable
896fromHandle :: (IsStream t, MonadIO m) => IO.Handle -> t m String
896fromHandle :: (IsStream t, MonadIO m) => IO.Handle -> t m String
897fromHandle h = go
897fromHandle h = go
898 where
898 where
899− go = K.mkStream $ \_ stp _ yld -> do
899+ go = K.mkStream $ \_ yld _ stp -> do
900 eof <- liftIO $ IO.hIsEOF h
900 eof <- liftIO $ IO.hIsEOF h
901 if eof
901 if eof
902 then stp
902 then stp
@@ -1449,7 +1449,7 @@ toHandle h m = go m
1449 let stop = return ()
1449 let stop = return ()
1450 single a = liftIO (IO.hPutStrLn h a)
1450 single a = liftIO (IO.hPutStrLn h a)
1451 yieldk a r = liftIO (IO.hPutStrLn h a) >> go r
1451 yieldk a r = liftIO (IO.hPutStrLn h a) >> go r
1452− in K.foldStream defState stop single yieldk m1
1452+ in K.foldStream defState yieldk single stop m1
1453
1453
1454------------------------------------------------------------------------------
1454------------------------------------------------------------------------------
1455-- Transformation by Folding (Scans)
1455-- Transformation by Folding (Scans)
@@ -1770,12 +1770,12 @@ mapMaybeMSerial f m = fromStreamD $ D.mapMaybeM f $ toStreamD m
1770reverse :: (IsStream t) => t m a -> t m a
1770reverse :: (IsStream t) => t m a -> t m a
1771reverse m = go K.nil m
1771reverse m = go K.nil m
1772 where
1772 where
1773− go rev rest = K.mkStream $ \st stp sng yld ->
1773+ go rev rest = K.mkStream $ \st yld sng stp ->
1774− let runIt x = K.foldStream st stp sng yld x
1774+ let runIt x = K.foldStream st yld sng stp x
1775 stop = runIt rev
1775 stop = runIt rev
1776 single a = runIt $ a `K.cons` rev
1776 single a = runIt $ a `K.cons` rev
1777 yieldk a r = runIt $ go (a `K.cons` rev) r
1777 yieldk a r = runIt $ go (a `K.cons` rev) r
1778− in K.foldStream st stop single yieldk rest
1778+ in K.foldStream st yieldk single stop rest
1779
1779
1780------------------------------------------------------------------------------
1780------------------------------------------------------------------------------
1781-- Transformation by Inserting
1781-- Transformation by Inserting
src/Streamly/Streams/Ahead.hs+16−12
@@ -298,9 +298,10 @@ processHeap q heap st sv winfo entry sno stopping = loopHeap sno entry
298 let stop = do
298 let stop = do
299 liftIO (incrementYieldLimit sv)
299 liftIO (incrementYieldLimit sv)
300 nextHeap seqNo
300 nextHeap seqNo
301− foldStreamSVar sv st stop
301+ foldStreamSVar sv st
302− (singleStreamFromHeap seqNo)
303 (yieldStreamFromHeap seqNo)
302 (yieldStreamFromHeap seqNo)
303+ (singleStreamFromHeap seqNo)
304+ stop
304 r
305 r
305 else liftIO $ do
306 else liftIO $ do
306 let ent = Entry seqNo (AheadEntryStream r)
307 let ent = Entry seqNo (AheadEntryStream r)
@@ -349,9 +350,10 @@ processWithoutToken q heap st sv winfo m seqNo = do
349 -- we stop.
350 -- we stop.
350 toHeap AheadEntryNull
351 toHeap AheadEntryNull
351
352
352− foldStreamSVar sv st stop
353+ foldStreamSVar sv st
353− (toHeap . AheadEntryPure)
354 (\a r -> toHeap $ AheadEntryStream $ K.cons a r)
354 (\a r -> toHeap $ AheadEntryStream $ K.cons a r)
355+ (toHeap . AheadEntryPure)
356+ stop
355 m
357 m
356
358
357 where
359 where
@@ -410,7 +412,7 @@ processWithToken q heap st sv winfo action sno = do
410 liftIO (incrementYieldLimit sv)
412 liftIO (incrementYieldLimit sv)
411 loopWithToken (sno + 1)
413 loopWithToken (sno + 1)
412
414
413− foldStreamSVar sv st stop (singleOutput sno) (yieldOutput sno) action
415+ foldStreamSVar sv st (yieldOutput sno) (singleOutput sno) stop action
414
416
415 where
417 where
416
418
@@ -433,9 +435,10 @@ processWithToken q heap st sv winfo action sno = do
433 let stop = do
435 let stop = do
434 liftIO (incrementYieldLimit sv)
436 liftIO (incrementYieldLimit sv)
435 loopWithToken (seqNo + 1)
437 loopWithToken (seqNo + 1)
436− foldStreamSVar sv st stop
438+ foldStreamSVar sv st
437− (singleOutput seqNo)
438 (yieldOutput seqNo)
439 (yieldOutput seqNo)
440+ (singleOutput seqNo)
441+ stop
439 r
442 r
440 else do
443 else do
441 let ent = Entry seqNo (AheadEntryStream r)
444 let ent = Entry seqNo (AheadEntryStream r)
@@ -463,9 +466,10 @@ processWithToken q heap st sv winfo action sno = do
463 let stop = do
466 let stop = do
464 liftIO (incrementYieldLimit sv)
467 liftIO (incrementYieldLimit sv)
465 loopWithToken (seqNo + 1)
468 loopWithToken (seqNo + 1)
466− foldStreamSVar sv st stop
469+ foldStreamSVar sv st
467− (singleOutput seqNo)
468 (yieldOutput seqNo)
470 (yieldOutput seqNo)
471+ (singleOutput seqNo)
472+ stop
469 m
473 m
470 else
474 else
471 -- To avoid a race when another thread puts something
475 -- To avoid a race when another thread puts something
@@ -684,11 +688,11 @@ aheadbind
684aheadbind m f = go m
688aheadbind m f = go m
685 where
689 where
686 go g =
690 go g =
687− mkStream $ \st stp sng yld ->
691+ mkStream $ \st yld sng stp ->
688− let foldShared = foldStreamShared st stp sng yld
692+ let foldShared = foldStreamShared st yld sng stp
689 single a = foldShared $ unShare (f a)
693 single a = foldShared $ unShare (f a)
690 yieldk a r = foldShared $ unShare (f a) `ahead` go r
694 yieldk a r = foldShared $ unShare (f a) `ahead` go r
691− in foldStream (adaptState st) stp single yieldk g
695+ in foldStream (adaptState st) yieldk single stp g
692
696
693instance MonadAsync m => Monad (AheadT m) where
697instance MonadAsync m => Monad (AheadT m) where
694 return = pure
698 return = pure
src/Streamly/Streams/Async.hs+8−8
@@ -84,7 +84,7 @@ workLoopLIFO q st sv winfo = run
84 work <- dequeue
84 work <- dequeue
85 case work of
85 case work of
86 Nothing -> liftIO $ sendStop sv winfo
86 Nothing -> liftIO $ sendStop sv winfo
87− Just m -> foldStreamSVar sv st run single yieldk m
87+ Just m -> foldStreamSVar sv st yieldk single run m
88
88
89 single a = do
89 single a = do
90 res <- liftIO $ sendYield sv winfo (ChildYield a)
90 res <- liftIO $ sendYield sv winfo (ChildYield a)
@@ -93,7 +93,7 @@ workLoopLIFO q st sv winfo = run
93 yieldk a r = do
93 yieldk a r = do
94 res <- liftIO $ sendYield sv winfo (ChildYield a)
94 res <- liftIO $ sendYield sv winfo (ChildYield a)
95 if res
95 if res
96− then foldStreamSVar sv st run single yieldk r
96+ then foldStreamSVar sv st yieldk single run r
97 else liftIO $ do
97 else liftIO $ do
98 enqueueLIFO sv q r
98 enqueueLIFO sv q r
99 sendStop sv winfo
99 sendStop sv winfo
@@ -134,7 +134,7 @@ workLoopLIFOLimited q st sv winfo = run
134 if yieldLimitOk
134 if yieldLimitOk
135 then do
135 then do
136 let stop = liftIO (incrementYieldLimit sv) >> run
136 let stop = liftIO (incrementYieldLimit sv) >> run
137− foldStreamSVar sv st stop single yieldk m
137+ foldStreamSVar sv st yieldk single stop m
138 -- Avoid any side effects, undo the yield limit decrement if we
138 -- Avoid any side effects, undo the yield limit decrement if we
139 -- never yielded anything.
139 -- never yielded anything.
140 else liftIO $ do
140 else liftIO $ do
@@ -153,7 +153,7 @@ workLoopLIFOLimited q st sv winfo = run
153 yieldLimitOk <- liftIO $ decrementYieldLimit sv
153 yieldLimitOk <- liftIO $ decrementYieldLimit sv
154 let stop = liftIO (incrementYieldLimit sv) >> run
154 let stop = liftIO (incrementYieldLimit sv) >> run
155 if res && yieldLimitOk
155 if res && yieldLimitOk
156− then foldStreamSVar sv st stop single yieldk r
156+ then foldStreamSVar sv st yieldk single stop r
157 else liftIO $ do
157 else liftIO $ do
158 incrementYieldLimit sv
158 incrementYieldLimit sv
159 enqueueLIFO sv q r
159 enqueueLIFO sv q r
@@ -185,7 +185,7 @@ workLoopFIFO q st sv winfo = run
185 work <- liftIO $ tryPopR q
185 work <- liftIO $ tryPopR q
186 case work of
186 case work of
187 Nothing -> liftIO $ sendStop sv winfo
187 Nothing -> liftIO $ sendStop sv winfo
188− Just m -> foldStreamSVar sv st run single yieldk m
188+ Just m -> foldStreamSVar sv st yieldk single run m
189
189
190 single a = do
190 single a = do
191 res <- liftIO $ sendYield sv winfo (ChildYield a)
191 res <- liftIO $ sendYield sv winfo (ChildYield a)
@@ -194,7 +194,7 @@ workLoopFIFO q st sv winfo = run
194 yieldk a r = do
194 yieldk a r = do
195 res <- liftIO $ sendYield sv winfo (ChildYield a)
195 res <- liftIO $ sendYield sv winfo (ChildYield a)
196 if res
196 if res
197− then foldStreamSVar sv st run single yieldk r
197+ then foldStreamSVar sv st yieldk single run r
198 else liftIO $ do
198 else liftIO $ do
199 enqueueFIFO sv q r
199 enqueueFIFO sv q r
200 sendStop sv winfo
200 sendStop sv winfo
@@ -220,7 +220,7 @@ workLoopFIFOLimited q st sv winfo = run
220 if yieldLimitOk
220 if yieldLimitOk
221 then do
221 then do
222 let stop = liftIO (incrementYieldLimit sv) >> run
222 let stop = liftIO (incrementYieldLimit sv) >> run
223− foldStreamSVar sv st stop single yieldk m
223+ foldStreamSVar sv st yieldk single stop m
224 else liftIO $ do
224 else liftIO $ do
225 enqueueFIFO sv q m
225 enqueueFIFO sv q m
226 incrementYieldLimit sv
226 incrementYieldLimit sv
@@ -235,7 +235,7 @@ workLoopFIFOLimited q st sv winfo = run
235 yieldLimitOk <- liftIO $ decrementYieldLimit sv
235 yieldLimitOk <- liftIO $ decrementYieldLimit sv
236 let stop = liftIO (incrementYieldLimit sv) >> run
236 let stop = liftIO (incrementYieldLimit sv) >> run
237 if res && yieldLimitOk
237 if res && yieldLimitOk
238− then foldStreamSVar sv st stop single yieldk r
238+ then foldStreamSVar sv st yieldk single stop r
239 else liftIO $ do
239 else liftIO $ do
240 incrementYieldLimit sv
240 incrementYieldLimit sv
241 enqueueFIFO sv q r
241 enqueueFIFO sv q r
src/Streamly/Streams/Parallel.hs+8−8
@@ -63,7 +63,7 @@ import qualified Streamly.Streams.StreamK as K
63runOne
63runOne
64 :: MonadIO m
64 :: MonadIO m
65 => State Stream m a -> Stream m a -> Maybe WorkerInfo -> m ()
65 => State Stream m a -> Stream m a -> Maybe WorkerInfo -> m ()
66−runOne st m winfo = foldStreamShared st stop single yieldk m
66+runOne st m winfo = foldStreamShared st yieldk single stop m
67
67
68 where
68 where
69
69
@@ -89,21 +89,21 @@ runOne st m winfo = foldStreamShared st stop single yieldk m
89
89
90{-# NOINLINE forkSVarPar #-}
90{-# NOINLINE forkSVarPar #-}
91forkSVarPar :: (IsStream t, MonadAsync m) => t m a -> t m a -> t m a
91forkSVarPar :: (IsStream t, MonadAsync m) => t m a -> t m a -> t m a
92−forkSVarPar m r = mkStream $ \st stp sng yld -> do
92+forkSVarPar m r = mkStream $ \st yld sng stp -> do
93 sv <- newParallelVar st
93 sv <- newParallelVar st
94 pushWorkerPar sv (runOne st{streamVar = Just sv} $ toStream m)
94 pushWorkerPar sv (runOne st{streamVar = Just sv} $ toStream m)
95 pushWorkerPar sv (runOne st{streamVar = Just sv} $ toStream r)
95 pushWorkerPar sv (runOne st{streamVar = Just sv} $ toStream r)
96− foldStream st stp sng yld (fromSVar sv)
96+ foldStream st yld sng stp (fromSVar sv)
97
97
98{-# INLINE joinStreamVarPar #-}
98{-# INLINE joinStreamVarPar #-}
99joinStreamVarPar :: (IsStream t, MonadAsync m)
99joinStreamVarPar :: (IsStream t, MonadAsync m)
100 => SVarStyle -> t m a -> t m a -> t m a
100 => SVarStyle -> t m a -> t m a -> t m a
101−joinStreamVarPar style m1 m2 = mkStream $ \st stp sng yld ->
101+joinStreamVarPar style m1 m2 = mkStream $ \st yld sng stp ->
102 case streamVar st of
102 case streamVar st of
103 Just sv | svarStyle sv == style -> do
103 Just sv | svarStyle sv == style -> do
104 pushWorkerPar sv (runOne st $ toStream m1)
104 pushWorkerPar sv (runOne st $ toStream m1)
105− foldStreamShared st stp sng yld m2
105+ foldStreamShared st yld sng stp m2
106− _ -> foldStreamShared st stp sng yld (forkSVarPar m1 m2)
106+ _ -> foldStreamShared st yld sng stp (forkSVarPar m1 m2)
107
107
108-- | XXX we can implement it more efficienty by directly implementing instead
108-- | XXX we can implement it more efficienty by directly implementing instead
109-- of combining streams using parallel.
109-- of combining streams using parallel.
@@ -135,10 +135,10 @@ mkParallel m = do
135
135
136{-# INLINE applyWith #-}
136{-# INLINE applyWith #-}
137applyWith :: (IsStream t, MonadAsync m) => (t m a -> t m b) -> t m a -> t m b
137applyWith :: (IsStream t, MonadAsync m) => (t m a -> t m b) -> t m a -> t m b
138−applyWith f m = mkStream $ \st stp sng yld -> do
138+applyWith f m = mkStream $ \st yld sng stp -> do
139 sv <- newParallelVar (adaptState st)
139 sv <- newParallelVar (adaptState st)
140 pushWorkerPar sv (runOne st{streamVar = Just sv} (toStream m))
140 pushWorkerPar sv (runOne st{streamVar = Just sv} (toStream m))
141− foldStream st stp sng yld $ f $ fromSVar sv
141+ foldStream st yld sng stp $ f $ fromSVar sv
142
142
143------------------------------------------------------------------------------
143------------------------------------------------------------------------------
144-- Stream runner concurrent function application
144-- Stream runner concurrent function application
src/Streamly/Streams/SVar.hs+9−9
@@ -38,12 +38,12 @@ printSVar sv how = do
38-- | Pull a stream from an SVar.
38-- | Pull a stream from an SVar.
39{-# NOINLINE fromStreamVar #-}
39{-# NOINLINE fromStreamVar #-}
40fromStreamVar :: MonadAsync m => SVar Stream m a -> Stream m a
40fromStreamVar :: MonadAsync m => SVar Stream m a -> Stream m a
41−fromStreamVar sv = mkStream $ \st stp sng yld -> do
41+fromStreamVar sv = mkStream $ \st yld sng stp -> do
42 list <- readOutputQ sv
42 list <- readOutputQ sv
43 -- Reversing the output is important to guarantee that we process the
43 -- Reversing the output is important to guarantee that we process the
44 -- outputs in the same order as they were generated by the constituent
44 -- outputs in the same order as they were generated by the constituent
45 -- streams.
45 -- streams.
46− foldStream st stp sng yld $ processEvents $ reverse list
46+ foldStream st yld sng stp $ processEvents $ reverse list
47
47
48 where
48 where
49
49
@@ -55,36 +55,36 @@ fromStreamVar sv = mkStream $ \st stp sng yld -> do
55 stp
55 stp
56
56
57 {-# INLINE processEvents #-}
57 {-# INLINE processEvents #-}
58− processEvents [] = mkStream $ \st stp sng yld -> do
58+ processEvents [] = mkStream $ \st yld sng stp -> do
59 done <- postProcess sv
59 done <- postProcess sv
60 if done
60 if done
61 then allDone stp
61 then allDone stp
62− else foldStream st stp sng yld $ fromStreamVar sv
62+ else foldStream st yld sng stp $ fromStreamVar sv
63
63
64− processEvents (ev : es) = mkStream $ \st stp sng yld -> do
64+ processEvents (ev : es) = mkStream $ \st yld sng stp -> do
65 let rest = processEvents es
65 let rest = processEvents es
66 case ev of
66 case ev of
67 ChildYield a -> yld a rest
67 ChildYield a -> yld a rest
68 ChildStop tid e -> do
68 ChildStop tid e -> do
69 accountThread sv tid
69 accountThread sv tid
70 case e of
70 case e of
71− Nothing -> foldStream st stp sng yld rest
71+ Nothing -> foldStream st yld sng stp rest
72 Just ex ->
72 Just ex ->
73 case fromException ex of
73 case fromException ex of
74 Just ThreadAbort ->
74 Just ThreadAbort ->
75− foldStream st stp sng yld rest
75+ foldStream st yld sng stp rest
76 Nothing -> liftIO (cleanupSVar sv) >> throwM ex
76 Nothing -> liftIO (cleanupSVar sv) >> throwM ex
77
77
78{-# INLINE fromSVar #-}
78{-# INLINE fromSVar #-}
79fromSVar :: (MonadAsync m, IsStream t) => SVar Stream m a -> t m a
79fromSVar :: (MonadAsync m, IsStream t) => SVar Stream m a -> t m a
80fromSVar sv =
80fromSVar sv =
81− mkStream $ \st stp sng yld -> do
81+ mkStream $ \st yld sng stp -> do
82 ref <- liftIO $ newIORef ()
82 ref <- liftIO $ newIORef ()
83 _ <- liftIO $ mkWeakIORef ref hook
83 _ <- liftIO $ mkWeakIORef ref hook
84 -- We pass a copy of sv to fromStreamVar, so that we know that it has
84 -- We pass a copy of sv to fromStreamVar, so that we know that it has
85 -- no other references, when that copy gets garbage collected "ref"
85 -- no other references, when that copy gets garbage collected "ref"
86 -- will get garbage collected and our hook will be called.
86 -- will get garbage collected and our hook will be called.
87− foldStreamShared st stp sng yld $
87+ foldStreamShared st yld sng stp $
88 fromStream $ fromStreamVar sv{svarRef = Just ref}
88 fromStream $ fromStreamVar sv{svarRef = Just ref}
89 where
89 where
90
90
src/Streamly/Streams/Serial.hs+9−9
@@ -174,11 +174,11 @@ instance IsStream SerialT where
174--
174--
175instance Monad m => Monad (SerialT m) where
175instance Monad m => Monad (SerialT m) where
176 return = pure
176 return = pure
177− m >>= f = mkStream $ \st stp sng yld ->
177+ m >>= f = mkStream $ \st yld sng stp ->
178− let run x = foldStream st stp sng yld x
178+ let run x = foldStream st yld sng stp x
179 single a = run $ f a
179 single a = run $ f a
180 yieldk a r = run $ f a <> (r >>= f)
180 yieldk a r = run $ f a <> (r >>= f)
181− in foldStream (adaptState st) stp single yieldk m
181+ in foldStream (adaptState st) yieldk single stp m
182
182
183------------------------------------------------------------------------------
183------------------------------------------------------------------------------
184-- Other instances
184-- Other instances
@@ -300,11 +300,11 @@ instance IsStream WSerialT where
300-- @since 0.2.0
300-- @since 0.2.0
301{-# INLINE wSerial #-}
301{-# INLINE wSerial #-}
302wSerial :: IsStream t => t m a -> t m a -> t m a
302wSerial :: IsStream t => t m a -> t m a -> t m a
303−wSerial m1 m2 = mkStream $ \st stp sng yld -> do
303+wSerial m1 m2 = mkStream $ \st yld sng stp -> do
304− let stop = foldStream st stp sng yld m2
304+ let stop = foldStream st yld sng stp m2
305 single a = yld a m2
305 single a = yld a m2
306 yieldk a r = yld a (wSerial m2 r)
306 yieldk a r = yld a (wSerial m2 r)
307− foldStream st stop single yieldk m1
307+ foldStream st yieldk single stop m1
308
308
309instance Semigroup (WSerialT m a) where
309instance Semigroup (WSerialT m a) where
310 (<>) = wSerial
310 (<>) = wSerial
@@ -337,11 +337,11 @@ instance Monoid (WSerialT m a) where
337--
337--
338instance Monad m => Monad (WSerialT m) where
338instance Monad m => Monad (WSerialT m) where
339 return = pure
339 return = pure
340− m >>= f = mkStream $ \st stp sng yld ->
340+ m >>= f = mkStream $ \st yld sng stp ->
341− let run x = foldStream st stp sng yld x
341+ let run x = foldStream st yld sng stp x
342 single a = run $ f a
342 single a = run $ f a
343 yieldk a r = run $ f a <> (r >>= f)
343 yieldk a r = run $ f a <> (r >>= f)
344− in foldStream (adaptState st) stp single yieldk m
344+ in foldStream (adaptState st) yieldk single stp m
345
345
346------------------------------------------------------------------------------
346------------------------------------------------------------------------------
347-- Other instances
347-- Other instances
src/Streamly/Streams/StreamD.hs+3−3
@@ -483,7 +483,7 @@ fromStreamK = Stream step
483 let stop = return Stop
483 let stop = return Stop
484 single a = return $ Yield a K.nil
484 single a = return $ Yield a K.nil
485 yieldk a r = return $ Yield a r
485 yieldk a r = return $ Yield a r
486− in K.foldStreamShared gst stop single yieldk m1
486+ in K.foldStreamShared gst yieldk single stop m1
487
487
488{-# INLINE toStreamD #-}
488{-# INLINE toStreamD #-}
489toStreamD :: (K.IsStream t, Monad m) => t m a -> Stream m a
489toStreamD :: (K.IsStream t, Monad m) => t m a -> Stream m a
@@ -882,11 +882,11 @@ toList = foldr (:) []
882toStreamK :: Monad m => Stream m a -> K.Stream m a
882toStreamK :: Monad m => Stream m a -> K.Stream m a
883toStreamK (Stream step state) = go state
883toStreamK (Stream step state) = go state
884 where
884 where
885− go st = K.mkStream $ \gst stp sng yld -> do
885+ go st = K.mkStream $ \gst yld sng stp -> do
886 r <- step gst st
886 r <- step gst st
887 case r of
887 case r of
888 Yield x s -> yld x (go s)
888 Yield x s -> yld x (go s)
889− Skip s -> K.foldStreamShared gst stp sng yld $ go s
889+ Skip s -> K.foldStreamShared gst yld sng stp $ go s
890 Stop -> stp
890 Stop -> stp
891
891
892#ifndef DISABLE_FUSION
892#ifndef DISABLE_FUSION
src/Streamly/Streams/StreamK.hs+98−99
@@ -174,8 +174,8 @@ import Streamly.Streams.StreamKType
174-- | Detach a stream from an SVar
174-- | Detach a stream from an SVar
175{-# INLINE unShare #-}
175{-# INLINE unShare #-}
176unShare :: IsStream t => t m a -> t m a
176unShare :: IsStream t => t m a -> t m a
177−unShare x = mkStream $ \st stp sng yld ->
177+unShare x = mkStream $ \st yld sng stp ->
178− foldStream st stp sng yld x
178+ foldStream st yld sng stp x
179
179
180------------------------------------------------------------------------------
180------------------------------------------------------------------------------
181-- Construction
181-- Construction
@@ -196,7 +196,7 @@ infixr 5 `cons`
196--
196--
197-- @since 0.1.0
197-- @since 0.1.0
198cons :: IsStream t => a -> t m a -> t m a
198cons :: IsStream t => a -> t m a -> t m a
199−cons a r = mkStream $ \_ _ _ yld -> yld a r
199+cons a r = mkStream $ \_ yld _ _ -> yld a r
200
200
201infixr 5 .:
201infixr 5 .:
202
202
@@ -221,7 +221,7 @@ uncons m =
221 let stop = return Nothing
221 let stop = return Nothing
222 single a = return (Just (a, nil))
222 single a = return (Just (a, nil))
223 yieldk a r = return (Just (a, r))
223 yieldk a r = return (Just (a, r))
224− in foldStream defState stop single yieldk m
224+ in foldStream defState yieldk single stop m
225
225
226-------------------------------------------------------------------------------
226-------------------------------------------------------------------------------
227-- Generation
227-- Generation
@@ -231,7 +231,7 @@ uncons m =
231unfoldr :: IsStream t => (b -> Maybe (a, b)) -> b -> t m a
231unfoldr :: IsStream t => (b -> Maybe (a, b)) -> b -> t m a
232unfoldr step = go
232unfoldr step = go
233 where
233 where
234− go s = mkStream $ \_ stp _ yld ->
234+ go s = mkStream $ \_ yld _ stp ->
235 case step s of
235 case step s of
236 Nothing -> stp
236 Nothing -> stp
237 Just (a, b) -> yld a (go b)
237 Just (a, b) -> yld a (go b)
@@ -240,12 +240,12 @@ unfoldr step = go
240unfoldrM :: (IsStream t, MonadAsync m) => (b -> m (Maybe (a, b))) -> b -> t m a
240unfoldrM :: (IsStream t, MonadAsync m) => (b -> m (Maybe (a, b))) -> b -> t m a
241unfoldrM step = go
241unfoldrM step = go
242 where
242 where
243− go s = mkStream $ \st stp sng yld -> do
243+ go s = mkStream $ \st yld sng stp -> do
244 mayb <- step s
244 mayb <- step s
245 case mayb of
245 case mayb of
246 Nothing -> stp
246 Nothing -> stp
247 Just (a, b) ->
247 Just (a, b) ->
248− foldStreamShared st stp sng yld $ return a |: go b
248+ foldStreamShared st yld sng stp $ return a |: go b
249
249
250-------------------------------------------------------------------------------
250-------------------------------------------------------------------------------
251-- Special generation
251-- Special generation
@@ -320,7 +320,7 @@ foldr step acc m = go m
320 let stop = return acc
320 let stop = return acc
321 single a = return (step a acc)
321 single a = return (step a acc)
322 yieldk a r = go r >>= \b -> return (step a b)
322 yieldk a r = go r >>= \b -> return (step a b)
323− in foldStream defState stop single yieldk m1
323+ in foldStream defState yieldk single stop m1
324
324
325-- | Lazy right fold with a monadic step function.
325-- | Lazy right fold with a monadic step function.
326{-# INLINE foldrM #-}
326{-# INLINE foldrM #-}
@@ -331,7 +331,7 @@ foldrM step acc m = go m
331 let stop = return acc
331 let stop = return acc
332 single a = step a acc
332 single a = step a acc
333 yieldk a r = go r >>= step a
333 yieldk a r = go r >>= step a
334− in foldStream defState stop single yieldk m1
334+ in foldStream defState yieldk single stop m1
335
335
336{-# INLINE foldr1 #-}
336{-# INLINE foldr1 #-}
337foldr1 :: (IsStream t, Monad m) => (a -> a -> a) -> t m a -> m (Maybe a)
337foldr1 :: (IsStream t, Monad m) => (a -> a -> a) -> t m a -> m (Maybe a)
@@ -345,7 +345,7 @@ foldr1 step m = do
345 let stp = return p
345 let stp = return p
346 single a = return $ step a p
346 single a = return $ step a p
347 yieldk a r = fmap (step p) (go a r)
347 yieldk a r = fmap (step p) (go a r)
348− in foldStream defState stp single yieldk m1
348+ in foldStream defState yieldk single stp m1
349
349
350-- | Strict left fold with an extraction function. Like the standard strict
350-- | Strict left fold with an extraction function. Like the standard strict
351-- left fold, but applies a user supplied extraction function (the third
351-- left fold, but applies a user supplied extraction function (the third
@@ -372,13 +372,13 @@ foldx step begin done m = get $ go m begin
372 -- that cannot be tail call optimized. Unfolding recursion explicitly via
372 -- that cannot be tail call optimized. Unfolding recursion explicitly via
373 -- continuations is much more efficient.
373 -- continuations is much more efficient.
374 go :: t m a -> x -> t m x
374 go :: t m a -> x -> t m x
375− go m1 !acc = mkStream $ \_ _ sng yld ->
375+ go m1 !acc = mkStream $ \_ yld sng _ ->
376 let stop = sng acc
376 let stop = sng acc
377 single a = sng $ step acc a
377 single a = sng $ step acc a
378 -- XXX this is foldNonEmptyStream
378 -- XXX this is foldNonEmptyStream
379− yieldk a r = foldStream defState undefined sng yld $
379+ yieldk a r = foldStream defState yld sng undefined $
380 go r (step acc a)
380 go r (step acc a)
381− in foldStream defState stop single yieldk m1
381+ in foldStream defState yieldk single stop m1
382
382
383-- | Strict left associative fold.
383-- | Strict left associative fold.
384{-# INLINE foldl' #-}
384{-# INLINE foldl' #-}
@@ -395,7 +395,7 @@ foldxM step begin done m = go begin m
395 let stop = acc >>= done
395 let stop = acc >>= done
396 single a = acc >>= \b -> step b a >>= done
396 single a = acc >>= \b -> step b a >>= done
397 yieldk a r = acc >>= \b -> step b a >>= \x -> go (return x) r
397 yieldk a r = acc >>= \b -> step b a >>= \x -> go (return x) r
398− in foldStream defState stop single yieldk m1
398+ in foldStream defState yieldk single stop m1
399
399
400-- | Like 'foldl'' but with a monadic step function.
400-- | Like 'foldl'' but with a monadic step function.
401foldlM' :: (IsStream t, Monad m) => (b -> a -> m b) -> b -> t m a -> m b
401foldlM' :: (IsStream t, Monad m) => (b -> a -> m b) -> b -> t m a -> m b
@@ -413,7 +413,7 @@ runStream = go
413 let stop = return ()
413 let stop = return ()
414 single _ = return ()
414 single _ = return ()
415 yieldk _ r = go r
415 yieldk _ r = go r
416− in foldStream defState stop single yieldk m1
416+ in foldStream defState yieldk single stop m1
417
417
418{-# INLINE null #-}
418{-# INLINE null #-}
419null :: (IsStream t, Monad m) => t m a -> m Bool
419null :: (IsStream t, Monad m) => t m a -> m Bool
@@ -421,7 +421,7 @@ null m =
421 let stop = return True
421 let stop = return True
422 single _ = return False
422 single _ = return False
423 yieldk _ _ = return False
423 yieldk _ _ = return False
424− in foldStream defState stop single yieldk m
424+ in foldStream defState yieldk single stop m
425
425
426{-# INLINE head #-}
426{-# INLINE head #-}
427head :: (IsStream t, Monad m) => t m a -> m (Maybe a)
427head :: (IsStream t, Monad m) => t m a -> m (Maybe a)
@@ -429,7 +429,7 @@ head m =
429 let stop = return Nothing
429 let stop = return Nothing
430 single a = return (Just a)
430 single a = return (Just a)
431 yieldk a _ = return (Just a)
431 yieldk a _ = return (Just a)
432− in foldStream defState stop single yieldk m
432+ in foldStream defState yieldk single stop m
433
433
434{-# INLINE tail #-}
434{-# INLINE tail #-}
435tail :: (IsStream t, Monad m) => t m a -> m (Maybe (t m a))
435tail :: (IsStream t, Monad m) => t m a -> m (Maybe (t m a))
@@ -437,7 +437,7 @@ tail m =
437 let stop = return Nothing
437 let stop = return Nothing
438 single _ = return $ Just nil
438 single _ = return $ Just nil
439 yieldk _ r = return $ Just r
439 yieldk _ r = return $ Just r
440− in foldStream defState stop single yieldk m
440+ in foldStream defState yieldk single stop m
441
441
442{-# INLINE init #-}
442{-# INLINE init #-}
443init :: (IsStream t, Monad m) => t m a -> m (Maybe (t m a))
443init :: (IsStream t, Monad m) => t m a -> m (Maybe (t m a))
@@ -448,10 +448,10 @@ init m = go1 m
448 case r of
448 case r of
449 Nothing -> return Nothing
449 Nothing -> return Nothing
450 Just (h, t) -> return . Just $ go h t
450 Just (h, t) -> return . Just $ go h t
451− go p m1 = mkStream $ \_ stp sng yld ->
451+ go p m1 = mkStream $ \_ yld sng stp ->
452 let single _ = sng p
452 let single _ = sng p
453 yieldk a x = yld p $ go a x
453 yieldk a x = yld p $ go a x
454− in foldStream defState stp single yieldk m1
454+ in foldStream defState yieldk single stp m1
455
455
456{-# INLINE elem #-}
456{-# INLINE elem #-}
457elem :: (IsStream t, Monad m, Eq a) => a -> t m a -> m Bool
457elem :: (IsStream t, Monad m, Eq a) => a -> t m a -> m Bool
@@ -461,7 +461,7 @@ elem e m = go m
461 let stop = return False
461 let stop = return False
462 single a = return (a == e)
462 single a = return (a == e)
463 yieldk a r = if a == e then return True else go r
463 yieldk a r = if a == e then return True else go r
464− in foldStream defState stop single yieldk m1
464+ in foldStream defState yieldk single stop m1
465
465
466{-# INLINE notElem #-}
466{-# INLINE notElem #-}
467notElem :: (IsStream t, Monad m, Eq a) => a -> t m a -> m Bool
467notElem :: (IsStream t, Monad m, Eq a) => a -> t m a -> m Bool
@@ -471,7 +471,7 @@ notElem e m = go m
471 let stop = return True
471 let stop = return True
472 single a = return (a /= e)
472 single a = return (a /= e)
473 yieldk a r = if a == e then return False else go r
473 yieldk a r = if a == e then return False else go r
474− in foldStream defState stop single yieldk m1
474+ in foldStream defState yieldk single stop m1
475
475
476all :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m Bool
476all :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m Bool
477all p m = go m
477all p m = go m
@@ -481,7 +481,7 @@ all p m = go m
481 | otherwise = return False
481 | otherwise = return False
482 yieldk a r | p a = go r
482 yieldk a r | p a = go r
483 | otherwise = return False
483 | otherwise = return False
484− in foldStream defState (return True) single yieldk m1
484+ in foldStream defState yieldk single (return True) m1
485
485
486any :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m Bool
486any :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m Bool
487any p m = go m
487any p m = go m
@@ -491,7 +491,7 @@ any p m = go m
491 | otherwise = return False
491 | otherwise = return False
492 yieldk a r | p a = return True
492 yieldk a r | p a = return True
493 | otherwise = go r
493 | otherwise = go r
494− in foldStream defState (return False) single yieldk m1
494+ in foldStream defState yieldk single (return False) m1
495
495
496-- | Extract the last element of the stream, if any.
496-- | Extract the last element of the stream, if any.
497{-# INLINE last #-}
497{-# INLINE last #-}
@@ -506,7 +506,7 @@ minimum m = go Nothing m
506 let stop = return Nothing
506 let stop = return Nothing
507 single a = return (Just a)
507 single a = return (Just a)
508 yieldk a r = go (Just a) r
508 yieldk a r = go (Just a) r
509− in foldStream defState stop single yieldk m1
509+ in foldStream defState yieldk single stop m1
510
510
511 go (Just res) m1 =
511 go (Just res) m1 =
512 let stop = return (Just res)
512 let stop = return (Just res)
@@ -518,7 +518,7 @@ minimum m = go Nothing m
518 if res <= a
518 if res <= a
519 then go (Just res) r
519 then go (Just res) r
520 else go (Just a) r
520 else go (Just a) r
521− in foldStream defState stop single yieldk m1
521+ in foldStream defState yieldk single stop m1
522
522
523{-# INLINE minimumBy #-}
523{-# INLINE minimumBy #-}
524minimumBy
524minimumBy
@@ -530,7 +530,7 @@ minimumBy cmp m = go Nothing m
530 let stop = return Nothing
530 let stop = return Nothing
531 single a = return (Just a)
531 single a = return (Just a)
532 yieldk a r = go (Just a) r
532 yieldk a r = go (Just a) r
533− in foldStream defState stop single yieldk m1
533+ in foldStream defState yieldk single stop m1
534
534
535 go (Just res) m1 =
535 go (Just res) m1 =
536 let stop = return (Just res)
536 let stop = return (Just res)
@@ -540,7 +540,7 @@ minimumBy cmp m = go Nothing m
540 yieldk a r = case cmp res a of
540 yieldk a r = case cmp res a of
541 GT -> go (Just a) r
541 GT -> go (Just a) r
542 _ -> go (Just res) r
542 _ -> go (Just res) r
543− in foldStream defState stop single yieldk m1
543+ in foldStream defState yieldk single stop m1
544
544
545{-# INLINE maximum #-}
545{-# INLINE maximum #-}
546maximum :: (IsStream t, Monad m, Ord a) => t m a -> m (Maybe a)
546maximum :: (IsStream t, Monad m, Ord a) => t m a -> m (Maybe a)
@@ -550,7 +550,7 @@ maximum m = go Nothing m
550 let stop = return Nothing
550 let stop = return Nothing
551 single a = return (Just a)
551 single a = return (Just a)
552 yieldk a r = go (Just a) r
552 yieldk a r = go (Just a) r
553− in foldStream defState stop single yieldk m1
553+ in foldStream defState yieldk single stop m1
554
554
555 go (Just res) m1 =
555 go (Just res) m1 =
556 let stop = return (Just res)
556 let stop = return (Just res)
@@ -562,7 +562,7 @@ maximum m = go Nothing m
562 if res <= a
562 if res <= a
563 then go (Just a) r
563 then go (Just a) r
564 else go (Just res) r
564 else go (Just res) r
565− in foldStream defState stop single yieldk m1
565+ in foldStream defState yieldk single stop m1
566
566
567{-# INLINE maximumBy #-}
567{-# INLINE maximumBy #-}
568maximumBy :: (IsStream t, Monad m) => (a -> a -> Ordering) -> t m a -> m (Maybe a)
568maximumBy :: (IsStream t, Monad m) => (a -> a -> Ordering) -> t m a -> m (Maybe a)
@@ -572,7 +572,7 @@ maximumBy cmp m = go Nothing m
572 let stop = return Nothing
572 let stop = return Nothing
573 single a = return (Just a)
573 single a = return (Just a)
574 yieldk a r = go (Just a) r
574 yieldk a r = go (Just a) r
575− in foldStream defState stop single yieldk m1
575+ in foldStream defState yieldk single stop m1
576
576
577 go (Just res) m1 =
577 go (Just res) m1 =
578 let stop = return (Just res)
578 let stop = return (Just res)
@@ -582,7 +582,7 @@ maximumBy cmp m = go Nothing m
582 yieldk a r = case cmp res a of
582 yieldk a r = case cmp res a of
583 GT -> go (Just res) r
583 GT -> go (Just res) r
584 _ -> go (Just a) r
584 _ -> go (Just a) r
585− in foldStream defState stop single yieldk m1
585+ in foldStream defState yieldk single stop m1
586
586
587{-# INLINE (!!) #-}
587{-# INLINE (!!) #-}
588(!!) :: (IsStream t, Monad m) => t m a -> Int -> m (Maybe a)
588(!!) :: (IsStream t, Monad m) => t m a -> Int -> m (Maybe a)
@@ -594,7 +594,7 @@ m !! i = go i m
594 yieldk a x | n < 0 = return Nothing
594 yieldk a x | n < 0 = return Nothing
595 | n == 0 = return $ Just a
595 | n == 0 = return $ Just a
596 | otherwise = go (n - 1) x
596 | otherwise = go (n - 1) x
597− in foldStream defState (return Nothing) single yieldk m1
597+ in foldStream defState yieldk single (return Nothing) m1
598
598
599{-# INLINE lookup #-}
599{-# INLINE lookup #-}
600lookup :: (IsStream t, Monad m, Eq a) => a -> t m (a, b) -> m (Maybe b)
600lookup :: (IsStream t, Monad m, Eq a) => a -> t m (a, b) -> m (Maybe b)
@@ -605,7 +605,7 @@ lookup e m = go m
605 | otherwise = return Nothing
605 | otherwise = return Nothing
606 yieldk (a, b) x | a == e = return $ Just b
606 yieldk (a, b) x | a == e = return $ Just b
607 | otherwise = go x
607 | otherwise = go x
608− in foldStream defState (return Nothing) single yieldk m1
608+ in foldStream defState yieldk single (return Nothing) m1
609
609
610{-# INLINE findM #-}
610{-# INLINE findM #-}
611findM :: (IsStream t, Monad m) => (a -> m Bool) -> t m a -> m (Maybe a)
611findM :: (IsStream t, Monad m) => (a -> m Bool) -> t m a -> m (Maybe a)
@@ -618,7 +618,7 @@ findM p m = go m
618 yieldk a x = do
618 yieldk a x = do
619 b <- p a
619 b <- p a
620 if b then return $ Just a else go x
620 if b then return $ Just a else go x
621− in foldStream defState (return Nothing) single yieldk m1
621+ in foldStream defState yieldk single (return Nothing) m1
622
622
623{-# INLINE find #-}
623{-# INLINE find #-}
624find :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m (Maybe a)
624find :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m (Maybe a)
@@ -628,13 +628,13 @@ find p = findM (return . p)
628findIndices :: IsStream t => (a -> Bool) -> t m a -> t m Int
628findIndices :: IsStream t => (a -> Bool) -> t m a -> t m Int
629findIndices p = go 0
629findIndices p = go 0
630 where
630 where
631− go offset m1 = mkStream $ \st stp sng yld ->
631+ go offset m1 = mkStream $ \st yld sng stp ->
632 let single a | p a = sng offset
632 let single a | p a = sng offset
633 | otherwise = stp
633 | otherwise = stp
634 yieldk a x | p a = yld offset $ go (offset + 1) x
634 yieldk a x | p a = yld offset $ go (offset + 1) x
635− | otherwise = foldStream (adaptState st) stp sng yld $
635+ | otherwise = foldStream (adaptState st) yld sng stp $
636 go (offset + 1) x
636 go (offset + 1) x
637− in foldStream (adaptState st) stp single yieldk m1
637+ in foldStream (adaptState st) yieldk single stp m1
638
638
639------------------------------------------------------------------------------
639------------------------------------------------------------------------------
640-- Map and Fold
640-- Map and Fold
@@ -649,7 +649,7 @@ mapM_ f m = go m
649 let stop = return ()
649 let stop = return ()
650 single a = void (f a)
650 single a = void (f a)
651 yieldk a r = f a >> go r
651 yieldk a r = f a >> go r
652− in foldStream defState stop single yieldk m1
652+ in foldStream defState yieldk single stop m1
653
653
654------------------------------------------------------------------------------
654------------------------------------------------------------------------------
655-- Converting folds
655-- Converting folds
@@ -672,12 +672,12 @@ scanx :: IsStream t => (x -> a -> x) -> x -> (x -> b) -> t m a -> t m b
672scanx step begin done m =
672scanx step begin done m =
673 cons (done begin) $ go m begin
673 cons (done begin) $ go m begin
674 where
674 where
675− go m1 !acc = mkStream $ \st stp sng yld ->
675+ go m1 !acc = mkStream $ \st yld sng stp ->
676 let single a = sng (done $ step acc a)
676 let single a = sng (done $ step acc a)
677 yieldk a r =
677 yieldk a r =
678 let s = step acc a
678 let s = step acc a
679 in yld (done s) (go r s)
679 in yld (done s) (go r s)
680− in foldStream (adaptState st) stp single yieldk m1
680+ in foldStream (adaptState st) yieldk single stp m1
681
681
682{-# INLINE scanl' #-}
682{-# INLINE scanl' #-}
683scanl' :: IsStream t => (b -> a -> b) -> b -> t m a -> t m b
683scanl' :: IsStream t => (b -> a -> b) -> b -> t m a -> t m b
@@ -691,56 +691,55 @@ scanl' step begin = scanx step begin id
691filter :: IsStream t => (a -> Bool) -> t m a -> t m a
691filter :: IsStream t => (a -> Bool) -> t m a -> t m a
692filter p m = go m
692filter p m = go m
693 where
693 where
694− go m1 = mkStream $ \st stp sng yld ->
694+ go m1 = mkStream $ \st yld sng stp ->
695 let single a | p a = sng a
695 let single a | p a = sng a
696 | otherwise = stp
696 | otherwise = stp
697 yieldk a r | p a = yld a (go r)
697 yieldk a r | p a = yld a (go r)
698− | otherwise = foldStream st stp single yieldk r
698+ | otherwise = foldStream st yieldk single stp r
699− in foldStream st stp single yieldk m1
699+ in foldStream st yieldk single stp m1
700
700
701{-# INLINE take #-}
701{-# INLINE take #-}
702take :: IsStream t => Int -> t m a -> t m a
702take :: IsStream t => Int -> t m a -> t m a
703take n m = go n m
703take n m = go n m
704 where
704 where
705− go n1 m1 = mkStream $ \st stp sng yld ->
705+ go n1 m1 = mkStream $ \st yld sng stp ->
706 let yieldk a r = yld a (go (n1 - 1) r)
706 let yieldk a r = yld a (go (n1 - 1) r)
707 in if n1 <= 0
707 in if n1 <= 0
708 then stp
708 then stp
709− else foldStream st stp sng yieldk m1
709+ else foldStream st yieldk sng stp m1
710
710
711{-# INLINE takeWhile #-}
711{-# INLINE takeWhile #-}
712takeWhile :: IsStream t => (a -> Bool) -> t m a -> t m a
712takeWhile :: IsStream t => (a -> Bool) -> t m a -> t m a
713takeWhile p m = go m
713takeWhile p m = go m
714 where
714 where
715− go m1 = mkStream $ \st stp sng yld ->
715+ go m1 = mkStream $ \st yld sng stp ->
716 let single a | p a = sng a
716 let single a | p a = sng a
717 | otherwise = stp
717 | otherwise = stp
718 yieldk a r | p a = yld a (go r)
718 yieldk a r | p a = yld a (go r)
719 | otherwise = stp
719 | otherwise = stp
720− in foldStream st stp single yieldk m1
720+ in foldStream st yieldk single stp m1
721
721
722drop :: IsStream t => Int -> t m a -> t m a
722drop :: IsStream t => Int -> t m a -> t m a
723−drop n m = mkStream $ \st stp sng yld ->
723+drop n m = go n m
724− foldStream st stp sng yld $ go n m
725 where
724 where
726− go n1 m1 = mkStream $ \st stp sng yld ->
725+ go n1 m1 = mkStream $ \st yld sng stp ->
727 let single _ = stp
726 let single _ = stp
728− yieldk _ r = foldStream st stp sng yld $ go (n1 - 1) r
727+ yieldk _ r = foldStream st yld sng stp $ go (n1 - 1) r
729 -- Somehow "<=" check performs better than a ">"
728 -- Somehow "<=" check performs better than a ">"
730 in if n1 <= 0
729 in if n1 <= 0
731− then foldStream st stp sng yld m1
730+ then foldStream st yld sng stp m1
732− else foldStream st stp single yieldk m1
731+ else foldStream st yieldk single stp m1
733
732
734{-# INLINE dropWhile #-}
733{-# INLINE dropWhile #-}
735dropWhile :: IsStream t => (a -> Bool) -> t m a -> t m a
734dropWhile :: IsStream t => (a -> Bool) -> t m a -> t m a
736dropWhile p m = go m
735dropWhile p m = go m
737 where
736 where
738− go m1 = mkStream $ \st stp sng yld ->
737+ go m1 = mkStream $ \st yld sng stp ->
739 let single a | p a = stp
738 let single a | p a = stp
740 | otherwise = sng a
739 | otherwise = sng a
741− yieldk a r | p a = foldStream st stp single yieldk r
740+ yieldk a r | p a = foldStream st yieldk single stp r
742 | otherwise = yld a r
741 | otherwise = yld a r
743− in foldStream st stp single yieldk m1
742+ in foldStream st yieldk single stp m1
744
743
745-------------------------------------------------------------------------------
744-------------------------------------------------------------------------------
746-- Mapping
745-- Mapping
@@ -752,10 +751,10 @@ dropWhile p m = go m
752mapM :: (IsStream t, MonadAsync m) => (a -> m b) -> t m a -> t m b
751mapM :: (IsStream t, MonadAsync m) => (a -> m b) -> t m a -> t m b
753mapM f m = go m
752mapM f m = go m
754 where
753 where
755− go m1 = mkStream $ \st stp sng yld ->
754+ go m1 = mkStream $ \st yld sng stp ->
756 let single a = f a >>= sng
755 let single a = f a >>= sng
757− yieldk a r = foldStreamShared st stp sng yld $ f a |: go r
756+ yieldk a r = foldStreamShared st yld sng stp $ f a |: go r
758− in foldStream (adaptState st) stp single yieldk m1
757+ in foldStream (adaptState st) yieldk single stp m1
759
758
760-- Be careful when modifying this, this uses a consM (|:) deliberately to allow
759-- Be careful when modifying this, this uses a consM (|:) deliberately to allow
761-- other stream types to overload it.
760-- other stream types to overload it.
@@ -763,10 +762,10 @@ mapM f m = go m
763sequence :: (IsStream t, MonadAsync m) => t m (m a) -> t m a
762sequence :: (IsStream t, MonadAsync m) => t m (m a) -> t m a
764sequence m = go m
763sequence m = go m
765 where
764 where
766− go m1 = mkStream $ \st stp sng yld ->
765+ go m1 = mkStream $ \st yld sng stp ->
767 let single ma = ma >>= sng
766 let single ma = ma >>= sng
768− yieldk ma r = foldStreamShared st stp sng yld $ ma |: go r
767+ yieldk ma r = foldStreamShared st yld sng stp $ ma |: go r
769− in foldStream (adaptState st) stp single yieldk m1
768+ in foldStream (adaptState st) yieldk single stp m1
770
769
771-------------------------------------------------------------------------------
770-------------------------------------------------------------------------------
772-- Inserting
771-- Inserting
@@ -776,19 +775,19 @@ sequence m = go m
776intersperseM :: (IsStream t, MonadAsync m) => m a -> t m a -> t m a
775intersperseM :: (IsStream t, MonadAsync m) => m a -> t m a -> t m a
777intersperseM a m = prependingStart m
776intersperseM a m = prependingStart m
778 where
777 where
779− prependingStart m1 = mkStream $ \st stp sng yld ->
778+ prependingStart m1 = mkStream $ \st yld sng stp ->
780− let yieldk i x = foldStreamShared st stp sng yld $ return i |: go x
779+ let yieldk i x = foldStreamShared st yld sng stp $ return i |: go x
781− in foldStream st stp sng yieldk m1
780+ in foldStream st yieldk sng stp m1
782− go m2 = mkStream $ \st stp sng yld ->
781+ go m2 = mkStream $ \st yld sng stp ->
783− let single i = foldStreamShared st stp sng yld $ a |: yield i
782+ let single i = foldStreamShared st yld sng stp $ a |: yield i
784− yieldk i x = foldStreamShared st stp sng yld $ a |: return i |: go x
783+ yieldk i x = foldStreamShared st yld sng stp $ a |: return i |: go x
785− in foldStream st stp single yieldk m2
784+ in foldStream st yieldk single stp m2
786
785
787{-# INLINE insertBy #-}
786{-# INLINE insertBy #-}
788insertBy :: IsStream t => (a -> a -> Ordering) -> a -> t m a -> t m a
787insertBy :: IsStream t => (a -> a -> Ordering) -> a -> t m a -> t m a
789insertBy cmp x m = go m
788insertBy cmp x m = go m
790 where
789 where
791− go m1 = mkStream $ \st _ _ yld ->
790+ go m1 = mkStream $ \st yld _ _ ->
792 let single a = case cmp x a of
791 let single a = case cmp x a of
793 GT -> yld a (yield x)
792 GT -> yld a (yield x)
794 _ -> yld x (yield a)
793 _ -> yld x (yield a)
@@ -796,7 +795,7 @@ insertBy cmp x m = go m
796 yieldk a r = case cmp x a of
795 yieldk a r = case cmp x a of
797 GT -> yld a (go r)
796 GT -> yld a (go r)
798 _ -> yld x (a `cons` r)
797 _ -> yld x (a `cons` r)
799− in foldStream st stop single yieldk m1
798+ in foldStream st yieldk single stop m1
800
799
801------------------------------------------------------------------------------
800------------------------------------------------------------------------------
802-- Deleting
801-- Deleting
@@ -806,12 +805,12 @@ insertBy cmp x m = go m
806deleteBy :: IsStream t => (a -> a -> Bool) -> a -> t m a -> t m a
805deleteBy :: IsStream t => (a -> a -> Bool) -> a -> t m a -> t m a
807deleteBy eq x m = go m
806deleteBy eq x m = go m
808 where
807 where
809− go m1 = mkStream $ \st stp sng yld ->
808+ go m1 = mkStream $ \st yld sng stp ->
810 let single a = if eq x a then stp else sng a
809 let single a = if eq x a then stp else sng a
811 yieldk a r = if eq x a
810 yieldk a r = if eq x a
812− then foldStream st stp sng yld r
811+ then foldStream st yld sng stp r
813 else yld a (go r)
812 else yld a (go r)
814− in foldStream st stp single yieldk m1
813+ in foldStream st yieldk single stp m1
815
814
816-------------------------------------------------------------------------------
815-------------------------------------------------------------------------------
817-- Map and Filter
816-- Map and Filter
@@ -821,14 +820,14 @@ deleteBy eq x m = go m
821mapMaybe :: IsStream t => (a -> Maybe b) -> t m a -> t m b
820mapMaybe :: IsStream t => (a -> Maybe b) -> t m a -> t m b
822mapMaybe f m = go m
821mapMaybe f m = go m
823 where
822 where
824− go m1 = mkStream $ \st stp sng yld ->
823+ go m1 = mkStream $ \st yld sng stp ->
825 let single a = case f a of
824 let single a = case f a of
826 Just b -> sng b
825 Just b -> sng b
827 Nothing -> stp
826 Nothing -> stp
828 yieldk a r = case f a of
827 yieldk a r = case f a of
829 Just b -> yld b $ go r
828 Just b -> yld b $ go r
830− Nothing -> foldStream (adaptState st) stp single yieldk r
829+ Nothing -> foldStream (adaptState st) yieldk single stp r
831− in foldStream (adaptState st) stp single yieldk m1
830+ in foldStream (adaptState st) yieldk single stp m1
832
831
833------------------------------------------------------------------------------
832------------------------------------------------------------------------------
834-- Serial Zipping
833-- Serial Zipping
@@ -841,14 +840,14 @@ mapMaybe f m = go m
841zipWith :: IsStream t => (a -> b -> c) -> t m a -> t m b -> t m c
840zipWith :: IsStream t => (a -> b -> c) -> t m a -> t m b -> t m c
842zipWith f = go
841zipWith f = go
843 where
842 where
844− go mx my = mkStream $ \st stp sng yld -> do
843+ go mx my = mkStream $ \st yld sng stp -> do
845 let merge a ra =
844 let merge a ra =
846 let single2 b = sng (f a b)
845 let single2 b = sng (f a b)
847 yield2 b rb = yld (f a b) (go ra rb)
846 yield2 b rb = yld (f a b) (go ra rb)
848− in foldStream (adaptState st) stp single2 yield2 my
847+ in foldStream (adaptState st) yield2 single2 stp my
849 let single1 a = merge a nil
848 let single1 a = merge a nil
850 yield1 = merge
849 yield1 = merge
851− foldStream (adaptState st) stp single1 yield1 mx
850+ foldStream (adaptState st) yield1 single1 stp mx
852
851
853-- | Zip two streams serially using a monadic zipping function.
852-- | Zip two streams serially using a monadic zipping function.
854--
853--
@@ -856,15 +855,15 @@ zipWith f = go
856zipWithM :: (IsStream t, Monad m) => (a -> b -> m c) -> t m a -> t m b -> t m c
855zipWithM :: (IsStream t, Monad m) => (a -> b -> m c) -> t m a -> t m b -> t m c
857zipWithM f m1 m2 = go m1 m2
856zipWithM f m1 m2 = go m1 m2
858 where
857 where
859− go mx my = mkStream $ \st stp sng yld -> do
858+ go mx my = mkStream $ \st yld sng stp -> do
860 let merge a ra =
859 let merge a ra =
861− let runIt x = foldStream st stp sng yld x
860+ let runIt x = foldStream st yld sng stp x
862 single2 b = f a b >>= sng
861 single2 b = f a b >>= sng
863 yield2 b rb = f a b >>= \x -> runIt (x `cons` go ra rb)
862 yield2 b rb = f a b >>= \x -> runIt (x `cons` go ra rb)
864− in foldStream (adaptState st) stp single2 yield2 my
863+ in foldStream (adaptState st) yield2 single2 stp my
865 let single1 a = merge a nil
864 let single1 a = merge a nil
866 yield1 = merge
865 yield1 = merge
867− foldStream (adaptState st) stp single1 yield1 mx
866+ foldStream (adaptState st) yield1 single1 stp mx
868
867
869------------------------------------------------------------------------------
868------------------------------------------------------------------------------
870-- Merging
869-- Merging
@@ -876,9 +875,9 @@ mergeByM
876 => (a -> a -> m Ordering) -> t m a -> t m a -> t m a
875 => (a -> a -> m Ordering) -> t m a -> t m a -> t m a
877mergeByM cmp = go
876mergeByM cmp = go
878 where
877 where
879− go mx my = mkStream $ \st stp sng yld -> do
878+ go mx my = mkStream $ \st yld sng stp -> do
880 let mergeWithY a ra =
879 let mergeWithY a ra =
881− let stop2 = foldStream st stp sng yld mx
880+ let stop2 = foldStream st yld sng stp mx
882 single2 b = do
881 single2 b = do
883 r <- cmp a b
882 r <- cmp a b
884 case r of
883 case r of
@@ -889,11 +888,11 @@ mergeByM cmp = go
889 case r of
888 case r of
890 GT -> yld b (go (a `cons` ra) rb)
889 GT -> yld b (go (a `cons` ra) rb)
891 _ -> yld a (go ra (b `cons` rb))
890 _ -> yld a (go ra (b `cons` rb))
892− in foldStream st stop2 single2 yield2 my
891+ in foldStream st yield2 single2 stop2 my
893− let stopX = foldStream st stp sng yld my
892+ let stopX = foldStream st yld sng stp my
894 singleX a = mergeWithY a nil
893 singleX a = mergeWithY a nil
895 yieldX = mergeWithY
894 yieldX = mergeWithY
896− foldStream st stopX singleX yieldX mx
895+ foldStream st yieldX singleX stopX mx
897
896
898{-# INLINABLE mergeBy #-}
897{-# INLINABLE mergeBy #-}
899mergeBy
898mergeBy
@@ -918,7 +917,7 @@ the m = do
918 | otherwise = return Nothing
917 | otherwise = return Nothing
919 yieldk a r | h == a = go h r
918 yieldk a r | h == a = go h r
920 | otherwise = return Nothing
919 | otherwise = return Nothing
921− in foldStream defState (return $ Just h) single yieldk m1
920+ in foldStream defState yieldk single (return $ Just h) m1
922
921
923-------------------------------------------------------------------------------
922-------------------------------------------------------------------------------
924-- Bind utility
923-- Bind utility
@@ -934,20 +933,20 @@ bindWith
934bindWith par m1 f = go m1
933bindWith par m1 f = go m1
935 where
934 where
936 go m =
935 go m =
937− mkStream $ \st stp sng yld ->
936+ mkStream $ \st yld sng stp ->
938− let foldShared = foldStreamShared st stp sng yld
937+ let foldShared = foldStreamShared st yld sng stp
939 single a = foldShared $ unShare (f a)
938 single a = foldShared $ unShare (f a)
940 yieldk a r = foldShared $ unShare (f a) `par` go r
939 yieldk a r = foldShared $ unShare (f a) `par` go r
941− in foldStream (adaptState st) stp single yieldk m
940+ in foldStream (adaptState st) yieldk single stp m
942
941
943------------------------------------------------------------------------------
942------------------------------------------------------------------------------
944-- Alternative & MonadPlus
943-- Alternative & MonadPlus
945------------------------------------------------------------------------------
944------------------------------------------------------------------------------
946
945
947_alt :: Stream m a -> Stream m a -> Stream m a
946_alt :: Stream m a -> Stream m a -> Stream m a
948−_alt m1 m2 = mkStream $ \st stp sng yld ->
947+_alt m1 m2 = mkStream $ \st yld sng stp ->
949− let stop = foldStream st stp sng yld m2
948+ let stop = foldStream st yld sng stp m2
950− in foldStream st stop sng yld m1
949+ in foldStream st yld sng stop m1
951
950
952------------------------------------------------------------------------------
951------------------------------------------------------------------------------
953-- MonadReader
952-- MonadReader
@@ -955,10 +954,10 @@ _alt m1 m2 = mkStream $ \st stp sng yld ->
955
954
956withLocal :: MonadReader r m => (r -> r) -> Stream m a -> Stream m a
955withLocal :: MonadReader r m => (r -> r) -> Stream m a -> Stream m a
957withLocal f m =
956withLocal f m =
958− mkStream $ \st stp sng yld ->
957+ mkStream $ \st yld sng stp ->
959 let single = local f . sng
958 let single = local f . sng
960 yieldk a r = local f $ yld a (withLocal f r)
959 yieldk a r = local f $ yld a (withLocal f r)
961− in foldStream st (local f stp) single yieldk m
960+ in foldStream st yieldk single (local f stp) m
962
961
963------------------------------------------------------------------------------
962------------------------------------------------------------------------------
964-- MonadError
963-- MonadError
src/Streamly/Streams/StreamKType.hs+27−30
@@ -90,9 +90,9 @@ import Streamly.SVar
90newtype Stream m a =
90newtype Stream m a =
91 MkStream (forall r.
91 MkStream (forall r.
92 State Stream m a -- state
92 State Stream m a -- state
93− -> m r -- stop
94− -> (a -> m r) -- singleton
95 -> (a -> Stream m a -> m r) -- yield
93 -> (a -> Stream m a -> m r) -- yield
94+ -> (a -> m r) -- singleton
95+ -> m r -- stop
96 -> m r
96 -> m r
97 )
97 )
98
98
@@ -182,21 +182,18 @@ adapt = fromStream . toStream
182-- Currently we always use "SVar Stream" and therefore a different State type
182-- Currently we always use "SVar Stream" and therefore a different State type
183-- parameterized by that stream.
183-- parameterized by that stream.
184--
184--
185−-- XXX change the order of arguments to match the standard fold function
186−-- convention i.e. st yield single stop.
187−--
188-- | Build a stream from an 'SVar', a stop continuation, a singleton stream
185-- | Build a stream from an 'SVar', a stop continuation, a singleton stream
189-- continuation and a yield continuation.
186-- continuation and a yield continuation.
190mkStream:: IsStream t
187mkStream:: IsStream t
191 => (forall r. State Stream m a
188 => (forall r. State Stream m a
192− -> m r
193− -> (a -> m r)
194 -> (a -> t m a -> m r)
189 -> (a -> t m a -> m r)
190+ -> (a -> m r)
191+ -> m r
195 -> m r)
192 -> m r)
196 -> t m a
193 -> t m a
197−mkStream k = fromStream $ MkStream $ \st stp sng yld ->
194+mkStream k = fromStream $ MkStream $ \st yld sng stp ->
198 let yieldk a r = yld a (toStream r)
195 let yieldk a r = yld a (toStream r)
199− in k st stp sng yieldk
196+ in k st yieldk sng stp
200
197
201-- | A terminal function that has no continuation to follow.
198-- | A terminal function that has no continuation to follow.
202type StopK m = forall r. m r -> m r
199type StopK m = forall r. m r -> m r
@@ -212,7 +209,7 @@ _wrapM m = \k -> m >>= k
212
209
213-- | Make an empty stream from a stop function.
210-- | Make an empty stream from a stop function.
214fromStopK :: IsStream t => StopK m -> t m a
211fromStopK :: IsStream t => StopK m -> t m a
215−fromStopK k = mkStream $ \_ stp _ _ -> k stp
212+fromStopK k = mkStream $ \_ _ _ stp -> k stp
216
213
217-- | Make a singleton stream from a yield function.
214-- | Make a singleton stream from a yield function.
218fromYieldK :: IsStream t => YieldK m a -> t m a
215fromYieldK :: IsStream t => YieldK m a -> t m a
@@ -220,7 +217,7 @@ fromYieldK k = mkStream $ \_ _ sng _ -> k sng
220
217
221-- | Add a yield function at the head of the stream.
218-- | Add a yield function at the head of the stream.
222consK :: IsStream t => YieldK m a -> t m a -> t m a
219consK :: IsStream t => YieldK m a -> t m a -> t m a
223−consK k r = mkStream $ \_ _ _ yld -> k (\x -> yld x r)
220+consK k r = mkStream $ \_ yld _ _ -> k (\x -> yld x r)
224
221
225-- XXX Build a stream from a repeating callback function.
222-- XXX Build a stream from a repeating callback function.
226
223
@@ -235,15 +232,15 @@ consK k r = mkStream $ \_ _ _ yld -> k (\x -> yld x r)
235foldStreamShared
232foldStreamShared
236 :: IsStream t
233 :: IsStream t
237 => State Stream m a
234 => State Stream m a
238− -> m r
239− -> (a -> m r)
240 -> (a -> t m a -> m r)
235 -> (a -> t m a -> m r)
236+ -> (a -> m r)
237+ -> m r
241 -> t m a
238 -> t m a
242 -> m r
239 -> m r
243−foldStreamShared st stp sng yld m =
240+foldStreamShared st yld sng stp m =
244 let yieldk a x = yld a (fromStream x)
241 let yieldk a x = yld a (fromStream x)
245 MkStream k = toStream m
242 MkStream k = toStream m
246− in k st stp sng yieldk
243+ in k st yieldk sng stp
247
244
248-- | Fold a stream by providing a State, stop continuation, a singleton
245-- | Fold a stream by providing a State, stop continuation, a singleton
249-- continuation and a yield continuation. The stream will not use the SVar
246-- continuation and a yield continuation. The stream will not use the SVar
@@ -252,15 +249,15 @@ foldStreamShared st stp sng yld m =
252foldStream
249foldStream
253 :: IsStream t
250 :: IsStream t
254 => State Stream m a
251 => State Stream m a
255− -> m r
256− -> (a -> m r)
257 -> (a -> t m a -> m r)
252 -> (a -> t m a -> m r)
253+ -> (a -> m r)
254+ -> m r
258 -> t m a
255 -> t m a
259 -> m r
256 -> m r
260−foldStream st stp sng yld m =
257+foldStream st yld sng stp m =
261 let yieldk a x = yld a (fromStream x)
258 let yieldk a x = yld a (fromStream x)
262 MkStream k = toStream m
259 MkStream k = toStream m
263− in k (adaptState st) stp sng yieldk
260+ in k (adaptState st) yieldk sng stp
264
261
265-- Run the stream using a run function associated with the SVar that runs the
262-- Run the stream using a run function associated with the SVar that runs the
266-- streams with a captured snapshot of the monadic state.
263-- streams with a captured snapshot of the monadic state.
@@ -269,14 +266,14 @@ foldStreamSVar
269 :: (IsStream t, MonadIO m)
266 :: (IsStream t, MonadIO m)
270 => SVar Stream m a
267 => SVar Stream m a
271 -> State Stream m a -- state
268 -> State Stream m a -- state
272− -> m r -- stop
273− -> (a -> m r) -- singleton
274 -> (a -> t m a -> m r) -- yield
269 -> (a -> t m a -> m r) -- yield
270+ -> (a -> m r) -- singleton
271+ -> m r -- stop
275 -> t m a
272 -> t m a
276 -> m ()
273 -> m ()
277−foldStreamSVar sv st stp sng yld m =
274+foldStreamSVar sv st yld sng stp m =
278 let mrun = runInIO $ svarMrun sv
275 let mrun = runInIO $ svarMrun sv
279− in void $ liftIO $ mrun $ foldStreamShared st stp sng yld m
276+ in void $ liftIO $ mrun $ foldStreamShared st yld sng stp m
280
277
281-------------------------------------------------------------------------------
278-------------------------------------------------------------------------------
282-- Instances
279-- Instances
@@ -284,7 +281,7 @@ foldStreamSVar sv st stp sng yld m =
284
281
285{-# INLINE consMSerial #-}
282{-# INLINE consMSerial #-}
286consMSerial :: (IsStream t, Monad m) => m a -> t m a -> t m a
283consMSerial :: (IsStream t, Monad m) => m a -> t m a -> t m a
287−consMSerial m r = mkStream $ \_ _ _ yld -> m >>= \a -> yld a r
284+consMSerial m r = mkStream $ \_ yld _ _ -> m >>= \a -> yld a r
288
285
289-------------------------------------------------------------------------------
286-------------------------------------------------------------------------------
290-- IsStream Stream
287-- IsStream Stream
@@ -317,11 +314,11 @@ instance IsStream Stream where
317serial :: IsStream t => t m a -> t m a -> t m a
314serial :: IsStream t => t m a -> t m a -> t m a
318serial m1 m2 = go m1
315serial m1 m2 = go m1
319 where
316 where
320− go m = mkStream $ \st stp sng yld ->
317+ go m = mkStream $ \st yld sng stp ->
321− let stop = foldStream st stp sng yld m2
318+ let stop = foldStream st yld sng stp m2
322 single a = yld a m2
319 single a = yld a m2
323 yieldk a r = yld a (go r)
320 yieldk a r = yld a (go r)
324− in foldStream st stop single yieldk m
321+ in foldStream st yieldk single stop m
325
322
326instance Semigroup (Stream m a) where
323instance Semigroup (Stream m a) where
327 (<>) = serial
324 (<>) = serial
@@ -339,7 +336,7 @@ instance Semigroup (Stream m a) where
339--
336--
340-- @since 0.1.0
337-- @since 0.1.0
341nil :: IsStream t => t m a
338nil :: IsStream t => t m a
342−nil = mkStream $ \_ stp _ _ -> stp
339+nil = mkStream $ \_ _ _ stp -> stp
343
340
344instance Monoid (Stream m a) where
341instance Monoid (Stream m a) where
345 mempty = nil
342 mempty = nil
@@ -352,10 +349,10 @@ instance Monoid (Stream m a) where
352
349
353{-# INLINE map #-}
350{-# INLINE map #-}
354map :: (IsStream t, Monad m) => (a -> b) -> t m a -> t m b
351map :: (IsStream t, Monad m) => (a -> b) -> t m a -> t m b
355−map f m = mkStream $ \st stp sng yld ->
352+map f m = mkStream $ \st yld sng stp ->
356 let single = sng . f
353 let single = sng . f
357 yieldk a r = yld (f a) (map f r)
354 yieldk a r = yld (f a) (map f r)
358− in foldStream (adaptState st) stp single yieldk m
355+ in foldStream (adaptState st) yieldk single stp m
359
356
360instance Monad m => Functor (Stream m) where
357instance Monad m => Functor (Stream m) where
361 fmap = map
358 fmap = map