git.iko.soy/streamly
on master help sign in
Change the order of foldStream arguments

To make it consistent with regular fold function conventions.

commit0a2755a48c69a9022aa12a528b9693ad7a530933 authorHarendra Kumar <harendra.kumar@gmail.com> dateWed 26 Dec 2018, 16:31 (8 years ago) parent90844f9
9 files changed+183−183
compare with master
unifiedsplit
src/Streamly/Prelude.hs+5−5 src/Streamly/Streams/Ahead.hs+16−12 src/Streamly/Streams/Async.hs+8−8 src/Streamly/Streams/Parallel.hs+8−8 src/Streamly/Streams/SVar.hs+9−9 src/Streamly/Streams/Serial.hs+9−9 src/Streamly/Streams/StreamD.hs+3−3 src/Streamly/Streams/StreamK.hs+98−99 src/Streamly/Streams/StreamKType.hs+27−30
src/Streamly/Prelude.hs+5−5
@@ -896,7 +896,7 @@ each = K.fromFoldable
896896fromHandle :: (IsStream t, MonadIO m) => IO.Handle -> t m String
897897fromHandle h = go
898898 where
899− go = K.mkStream $ \_ stp _ yld -> do
899+ go = K.mkStream $ \_ yld _ stp -> do
900900 eof <- liftIO $ IO.hIsEOF h
901901 if eof
902902 then stp
@@ -1449,7 +1449,7 @@ toHandle h m = go m
14491449 let stop = return ()
14501450 single a = liftIO (IO.hPutStrLn h a)
14511451 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
14531453
14541454------------------------------------------------------------------------------
14551455-- Transformation by Folding (Scans)
@@ -1770,12 +1770,12 @@ mapMaybeMSerial f m = fromStreamD $ D.mapMaybeM f $ toStreamD m
17701770reverse :: (IsStream t) => t m a -> t m a
17711771reverse m = go K.nil m
17721772 where
1773− go rev rest = K.mkStream $ \st stp sng yld ->
1774− let runIt x = K.foldStream st stp sng yld x
1773+ go rev rest = K.mkStream $ \st yld sng stp ->
1774+ let runIt x = K.foldStream st yld sng stp x
17751775 stop = runIt rev
17761776 single a = runIt $ a `K.cons` rev
17771777 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
17791779
17801780------------------------------------------------------------------------------
17811781-- 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
298298 let stop = do
299299 liftIO (incrementYieldLimit sv)
300300 nextHeap seqNo
301− foldStreamSVar sv st stop
302− (singleStreamFromHeap seqNo)
301+ foldStreamSVar sv st
303302 (yieldStreamFromHeap seqNo)
303+ (singleStreamFromHeap seqNo)
304+ stop
304305 r
305306 else liftIO $ do
306307 let ent = Entry seqNo (AheadEntryStream r)
@@ -349,9 +350,10 @@ processWithoutToken q heap st sv winfo m seqNo = do
349350 -- we stop.
350351 toHeap AheadEntryNull
351352
352− foldStreamSVar sv st stop
353− (toHeap . AheadEntryPure)
353+ foldStreamSVar sv st
354354 (\a r -> toHeap $ AheadEntryStream $ K.cons a r)
355+ (toHeap . AheadEntryPure)
356+ stop
355357 m
356358
357359 where
@@ -410,7 +412,7 @@ processWithToken q heap st sv winfo action sno = do
410412 liftIO (incrementYieldLimit sv)
411413 loopWithToken (sno + 1)
412414
413− foldStreamSVar sv st stop (singleOutput sno) (yieldOutput sno) action
415+ foldStreamSVar sv st (yieldOutput sno) (singleOutput sno) stop action
414416
415417 where
416418
@@ -433,9 +435,10 @@ processWithToken q heap st sv winfo action sno = do
433435 let stop = do
434436 liftIO (incrementYieldLimit sv)
435437 loopWithToken (seqNo + 1)
436− foldStreamSVar sv st stop
437− (singleOutput seqNo)
438+ foldStreamSVar sv st
438439 (yieldOutput seqNo)
440+ (singleOutput seqNo)
441+ stop
439442 r
440443 else do
441444 let ent = Entry seqNo (AheadEntryStream r)
@@ -463,9 +466,10 @@ processWithToken q heap st sv winfo action sno = do
463466 let stop = do
464467 liftIO (incrementYieldLimit sv)
465468 loopWithToken (seqNo + 1)
466− foldStreamSVar sv st stop
467− (singleOutput seqNo)
469+ foldStreamSVar sv st
468470 (yieldOutput seqNo)
471+ (singleOutput seqNo)
472+ stop
469473 m
470474 else
471475 -- To avoid a race when another thread puts something
@@ -684,11 +688,11 @@ aheadbind
684688aheadbind m f = go m
685689 where
686690 go g =
687− mkStream $ \st stp sng yld ->
688− let foldShared = foldStreamShared st stp sng yld
691+ mkStream $ \st yld sng stp ->
692+ let foldShared = foldStreamShared st yld sng stp
689693 single a = foldShared $ unShare (f a)
690694 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
692696
693697instance MonadAsync m => Monad (AheadT m) where
694698 return = pure
src/Streamly/Streams/Async.hs+8−8
@@ -84,7 +84,7 @@ workLoopLIFO q st sv winfo = run
8484 work <- dequeue
8585 case work of
8686 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
8888
8989 single a = do
9090 res <- liftIO $ sendYield sv winfo (ChildYield a)
@@ -93,7 +93,7 @@ workLoopLIFO q st sv winfo = run
9393 yieldk a r = do
9494 res <- liftIO $ sendYield sv winfo (ChildYield a)
9595 if res
96− then foldStreamSVar sv st run single yieldk r
96+ then foldStreamSVar sv st yieldk single run r
9797 else liftIO $ do
9898 enqueueLIFO sv q r
9999 sendStop sv winfo
@@ -134,7 +134,7 @@ workLoopLIFOLimited q st sv winfo = run
134134 if yieldLimitOk
135135 then do
136136 let stop = liftIO (incrementYieldLimit sv) >> run
137− foldStreamSVar sv st stop single yieldk m
137+ foldStreamSVar sv st yieldk single stop m
138138 -- Avoid any side effects, undo the yield limit decrement if we
139139 -- never yielded anything.
140140 else liftIO $ do
@@ -153,7 +153,7 @@ workLoopLIFOLimited q st sv winfo = run
153153 yieldLimitOk <- liftIO $ decrementYieldLimit sv
154154 let stop = liftIO (incrementYieldLimit sv) >> run
155155 if res && yieldLimitOk
156− then foldStreamSVar sv st stop single yieldk r
156+ then foldStreamSVar sv st yieldk single stop r
157157 else liftIO $ do
158158 incrementYieldLimit sv
159159 enqueueLIFO sv q r
@@ -185,7 +185,7 @@ workLoopFIFO q st sv winfo = run
185185 work <- liftIO $ tryPopR q
186186 case work of
187187 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
189189
190190 single a = do
191191 res <- liftIO $ sendYield sv winfo (ChildYield a)
@@ -194,7 +194,7 @@ workLoopFIFO q st sv winfo = run
194194 yieldk a r = do
195195 res <- liftIO $ sendYield sv winfo (ChildYield a)
196196 if res
197− then foldStreamSVar sv st run single yieldk r
197+ then foldStreamSVar sv st yieldk single run r
198198 else liftIO $ do
199199 enqueueFIFO sv q r
200200 sendStop sv winfo
@@ -220,7 +220,7 @@ workLoopFIFOLimited q st sv winfo = run
220220 if yieldLimitOk
221221 then do
222222 let stop = liftIO (incrementYieldLimit sv) >> run
223− foldStreamSVar sv st stop single yieldk m
223+ foldStreamSVar sv st yieldk single stop m
224224 else liftIO $ do
225225 enqueueFIFO sv q m
226226 incrementYieldLimit sv
@@ -235,7 +235,7 @@ workLoopFIFOLimited q st sv winfo = run
235235 yieldLimitOk <- liftIO $ decrementYieldLimit sv
236236 let stop = liftIO (incrementYieldLimit sv) >> run
237237 if res && yieldLimitOk
238− then foldStreamSVar sv st stop single yieldk r
238+ then foldStreamSVar sv st yieldk single stop r
239239 else liftIO $ do
240240 incrementYieldLimit sv
241241 enqueueFIFO sv q r
src/Streamly/Streams/Parallel.hs+8−8
@@ -63,7 +63,7 @@ import qualified Streamly.Streams.StreamK as K
6363runOne
6464 :: MonadIO m
6565 => 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
6767
6868 where
6969
@@ -89,21 +89,21 @@ runOne st m winfo = foldStreamShared st stop single yieldk m
8989
9090{-# NOINLINE forkSVarPar #-}
9191forkSVarPar :: (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
9393 sv <- newParallelVar st
9494 pushWorkerPar sv (runOne st{streamVar = Just sv} $ toStream m)
9595 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)
9797
9898{-# INLINE joinStreamVarPar #-}
9999joinStreamVarPar :: (IsStream t, MonadAsync m)
100100 => 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 ->
102102 case streamVar st of
103103 Just sv | svarStyle sv == style -> do
104104 pushWorkerPar sv (runOne st $ toStream m1)
105− foldStreamShared st stp sng yld m2
106− _ -> foldStreamShared st stp sng yld (forkSVarPar m1 m2)
105+ foldStreamShared st yld sng stp m2
106+ _ -> foldStreamShared st yld sng stp (forkSVarPar m1 m2)
107107
108108-- | XXX we can implement it more efficienty by directly implementing instead
109109-- of combining streams using parallel.
@@ -135,10 +135,10 @@ mkParallel m = do
135135
136136{-# INLINE applyWith #-}
137137applyWith :: (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
139139 sv <- newParallelVar (adaptState st)
140140 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
142142
143143------------------------------------------------------------------------------
144144-- Stream runner concurrent function application
src/Streamly/Streams/SVar.hs+9−9
@@ -38,12 +38,12 @@ printSVar sv how = do
3838-- | Pull a stream from an SVar.
3939{-# NOINLINE fromStreamVar #-}
4040fromStreamVar :: 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
4242 list <- readOutputQ sv
4343 -- Reversing the output is important to guarantee that we process the
4444 -- outputs in the same order as they were generated by the constituent
4545 -- streams.
46− foldStream st stp sng yld $ processEvents $ reverse list
46+ foldStream st yld sng stp $ processEvents $ reverse list
4747
4848 where
4949
@@ -55,36 +55,36 @@ fromStreamVar sv = mkStream $ \st stp sng yld -> do
5555 stp
5656
5757 {-# INLINE processEvents #-}
58− processEvents [] = mkStream $ \st stp sng yld -> do
58+ processEvents [] = mkStream $ \st yld sng stp -> do
5959 done <- postProcess sv
6060 if done
6161 then allDone stp
62− else foldStream st stp sng yld $ fromStreamVar sv
62+ else foldStream st yld sng stp $ fromStreamVar sv
6363
64− processEvents (ev : es) = mkStream $ \st stp sng yld -> do
64+ processEvents (ev : es) = mkStream $ \st yld sng stp -> do
6565 let rest = processEvents es
6666 case ev of
6767 ChildYield a -> yld a rest
6868 ChildStop tid e -> do
6969 accountThread sv tid
7070 case e of
71− Nothing -> foldStream st stp sng yld rest
71+ Nothing -> foldStream st yld sng stp rest
7272 Just ex ->
7373 case fromException ex of
7474 Just ThreadAbort ->
75− foldStream st stp sng yld rest
75+ foldStream st yld sng stp rest
7676 Nothing -> liftIO (cleanupSVar sv) >> throwM ex
7777
7878{-# INLINE fromSVar #-}
7979fromSVar :: (MonadAsync m, IsStream t) => SVar Stream m a -> t m a
8080fromSVar sv =
81− mkStream $ \st stp sng yld -> do
81+ mkStream $ \st yld sng stp -> do
8282 ref <- liftIO $ newIORef ()
8383 _ <- liftIO $ mkWeakIORef ref hook
8484 -- We pass a copy of sv to fromStreamVar, so that we know that it has
8585 -- no other references, when that copy gets garbage collected "ref"
8686 -- will get garbage collected and our hook will be called.
87− foldStreamShared st stp sng yld $
87+ foldStreamShared st yld sng stp $
8888 fromStream $ fromStreamVar sv{svarRef = Just ref}
8989 where
9090
src/Streamly/Streams/Serial.hs+9−9
@@ -174,11 +174,11 @@ instance IsStream SerialT where
174174--
175175instance Monad m => Monad (SerialT m) where
176176 return = pure
177− m >>= f = mkStream $ \st stp sng yld ->
178− let run x = foldStream st stp sng yld x
177+ m >>= f = mkStream $ \st yld sng stp ->
178+ let run x = foldStream st yld sng stp x
179179 single a = run $ f a
180180 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
182182
183183------------------------------------------------------------------------------
184184-- Other instances
@@ -300,11 +300,11 @@ instance IsStream WSerialT where
300300-- @since 0.2.0
301301{-# INLINE wSerial #-}
302302wSerial :: IsStream t => t m a -> t m a -> t m a
303−wSerial m1 m2 = mkStream $ \st stp sng yld -> do
304− let stop = foldStream st stp sng yld m2
303+wSerial m1 m2 = mkStream $ \st yld sng stp -> do
304+ let stop = foldStream st yld sng stp m2
305305 single a = yld a m2
306306 yieldk a r = yld a (wSerial m2 r)
307− foldStream st stop single yieldk m1
307+ foldStream st yieldk single stop m1
308308
309309instance Semigroup (WSerialT m a) where
310310 (<>) = wSerial
@@ -337,11 +337,11 @@ instance Monoid (WSerialT m a) where
337337--
338338instance Monad m => Monad (WSerialT m) where
339339 return = pure
340− m >>= f = mkStream $ \st stp sng yld ->
341− let run x = foldStream st stp sng yld x
340+ m >>= f = mkStream $ \st yld sng stp ->
341+ let run x = foldStream st yld sng stp x
342342 single a = run $ f a
343343 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
345345
346346------------------------------------------------------------------------------
347347-- Other instances
src/Streamly/Streams/StreamD.hs+3−3
@@ -483,7 +483,7 @@ fromStreamK = Stream step
483483 let stop = return Stop
484484 single a = return $ Yield a K.nil
485485 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
487487
488488{-# INLINE toStreamD #-}
489489toStreamD :: (K.IsStream t, Monad m) => t m a -> Stream m a
@@ -882,11 +882,11 @@ toList = foldr (:) []
882882toStreamK :: Monad m => Stream m a -> K.Stream m a
883883toStreamK (Stream step state) = go state
884884 where
885− go st = K.mkStream $ \gst stp sng yld -> do
885+ go st = K.mkStream $ \gst yld sng stp -> do
886886 r <- step gst st
887887 case r of
888888 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
890890 Stop -> stp
891891
892892#ifndef DISABLE_FUSION
src/Streamly/Streams/StreamK.hs+98−99
@@ -174,8 +174,8 @@ import Streamly.Streams.StreamKType
174174-- | Detach a stream from an SVar
175175{-# INLINE unShare #-}
176176unShare :: IsStream t => t m a -> t m a
177−unShare x = mkStream $ \st stp sng yld ->
178− foldStream st stp sng yld x
177+unShare x = mkStream $ \st yld sng stp ->
178+ foldStream st yld sng stp x
179179
180180------------------------------------------------------------------------------
181181-- Construction
@@ -196,7 +196,7 @@ infixr 5 `cons`
196196--
197197-- @since 0.1.0
198198cons :: 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
200200
201201infixr 5 .:
202202
@@ -221,7 +221,7 @@ uncons m =
221221 let stop = return Nothing
222222 single a = return (Just (a, nil))
223223 yieldk a r = return (Just (a, r))
224− in foldStream defState stop single yieldk m
224+ in foldStream defState yieldk single stop m
225225
226226-------------------------------------------------------------------------------
227227-- Generation
@@ -231,7 +231,7 @@ uncons m =
231231unfoldr :: IsStream t => (b -> Maybe (a, b)) -> b -> t m a
232232unfoldr step = go
233233 where
234− go s = mkStream $ \_ stp _ yld ->
234+ go s = mkStream $ \_ yld _ stp ->
235235 case step s of
236236 Nothing -> stp
237237 Just (a, b) -> yld a (go b)
@@ -240,12 +240,12 @@ unfoldr step = go
240240unfoldrM :: (IsStream t, MonadAsync m) => (b -> m (Maybe (a, b))) -> b -> t m a
241241unfoldrM step = go
242242 where
243− go s = mkStream $ \st stp sng yld -> do
243+ go s = mkStream $ \st yld sng stp -> do
244244 mayb <- step s
245245 case mayb of
246246 Nothing -> stp
247247 Just (a, b) ->
248− foldStreamShared st stp sng yld $ return a |: go b
248+ foldStreamShared st yld sng stp $ return a |: go b
249249
250250-------------------------------------------------------------------------------
251251-- Special generation
@@ -320,7 +320,7 @@ foldr step acc m = go m
320320 let stop = return acc
321321 single a = return (step a acc)
322322 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
324324
325325-- | Lazy right fold with a monadic step function.
326326{-# INLINE foldrM #-}
@@ -331,7 +331,7 @@ foldrM step acc m = go m
331331 let stop = return acc
332332 single a = step a acc
333333 yieldk a r = go r >>= step a
334− in foldStream defState stop single yieldk m1
334+ in foldStream defState yieldk single stop m1
335335
336336{-# INLINE foldr1 #-}
337337foldr1 :: (IsStream t, Monad m) => (a -> a -> a) -> t m a -> m (Maybe a)
@@ -345,7 +345,7 @@ foldr1 step m = do
345345 let stp = return p
346346 single a = return $ step a p
347347 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
349349
350350-- | Strict left fold with an extraction function. Like the standard strict
351351-- left fold, but applies a user supplied extraction function (the third
@@ -372,13 +372,13 @@ foldx step begin done m = get $ go m begin
372372 -- that cannot be tail call optimized. Unfolding recursion explicitly via
373373 -- continuations is much more efficient.
374374 go :: t m a -> x -> t m x
375− go m1 !acc = mkStream $ \_ _ sng yld ->
375+ go m1 !acc = mkStream $ \_ yld sng _ ->
376376 let stop = sng acc
377377 single a = sng $ step acc a
378378 -- XXX this is foldNonEmptyStream
379− yieldk a r = foldStream defState undefined sng yld $
379+ yieldk a r = foldStream defState yld sng undefined $
380380 go r (step acc a)
381− in foldStream defState stop single yieldk m1
381+ in foldStream defState yieldk single stop m1
382382
383383-- | Strict left associative fold.
384384{-# INLINE foldl' #-}
@@ -395,7 +395,7 @@ foldxM step begin done m = go begin m
395395 let stop = acc >>= done
396396 single a = acc >>= \b -> step b a >>= done
397397 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
399399
400400-- | Like 'foldl'' but with a monadic step function.
401401foldlM' :: (IsStream t, Monad m) => (b -> a -> m b) -> b -> t m a -> m b
@@ -413,7 +413,7 @@ runStream = go
413413 let stop = return ()
414414 single _ = return ()
415415 yieldk _ r = go r
416− in foldStream defState stop single yieldk m1
416+ in foldStream defState yieldk single stop m1
417417
418418{-# INLINE null #-}
419419null :: (IsStream t, Monad m) => t m a -> m Bool
@@ -421,7 +421,7 @@ null m =
421421 let stop = return True
422422 single _ = return False
423423 yieldk _ _ = return False
424− in foldStream defState stop single yieldk m
424+ in foldStream defState yieldk single stop m
425425
426426{-# INLINE head #-}
427427head :: (IsStream t, Monad m) => t m a -> m (Maybe a)
@@ -429,7 +429,7 @@ head m =
429429 let stop = return Nothing
430430 single a = return (Just a)
431431 yieldk a _ = return (Just a)
432− in foldStream defState stop single yieldk m
432+ in foldStream defState yieldk single stop m
433433
434434{-# INLINE tail #-}
435435tail :: (IsStream t, Monad m) => t m a -> m (Maybe (t m a))
@@ -437,7 +437,7 @@ tail m =
437437 let stop = return Nothing
438438 single _ = return $ Just nil
439439 yieldk _ r = return $ Just r
440− in foldStream defState stop single yieldk m
440+ in foldStream defState yieldk single stop m
441441
442442{-# INLINE init #-}
443443init :: (IsStream t, Monad m) => t m a -> m (Maybe (t m a))
@@ -448,10 +448,10 @@ init m = go1 m
448448 case r of
449449 Nothing -> return Nothing
450450 Just (h, t) -> return . Just $ go h t
451− go p m1 = mkStream $ \_ stp sng yld ->
451+ go p m1 = mkStream $ \_ yld sng stp ->
452452 let single _ = sng p
453453 yieldk a x = yld p $ go a x
454− in foldStream defState stp single yieldk m1
454+ in foldStream defState yieldk single stp m1
455455
456456{-# INLINE elem #-}
457457elem :: (IsStream t, Monad m, Eq a) => a -> t m a -> m Bool
@@ -461,7 +461,7 @@ elem e m = go m
461461 let stop = return False
462462 single a = return (a == e)
463463 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
465465
466466{-# INLINE notElem #-}
467467notElem :: (IsStream t, Monad m, Eq a) => a -> t m a -> m Bool
@@ -471,7 +471,7 @@ notElem e m = go m
471471 let stop = return True
472472 single a = return (a /= e)
473473 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
475475
476476all :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m Bool
477477all p m = go m
@@ -481,7 +481,7 @@ all p m = go m
481481 | otherwise = return False
482482 yieldk a r | p a = go r
483483 | otherwise = return False
484− in foldStream defState (return True) single yieldk m1
484+ in foldStream defState yieldk single (return True) m1
485485
486486any :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m Bool
487487any p m = go m
@@ -491,7 +491,7 @@ any p m = go m
491491 | otherwise = return False
492492 yieldk a r | p a = return True
493493 | otherwise = go r
494− in foldStream defState (return False) single yieldk m1
494+ in foldStream defState yieldk single (return False) m1
495495
496496-- | Extract the last element of the stream, if any.
497497{-# INLINE last #-}
@@ -506,7 +506,7 @@ minimum m = go Nothing m
506506 let stop = return Nothing
507507 single a = return (Just a)
508508 yieldk a r = go (Just a) r
509− in foldStream defState stop single yieldk m1
509+ in foldStream defState yieldk single stop m1
510510
511511 go (Just res) m1 =
512512 let stop = return (Just res)
@@ -518,7 +518,7 @@ minimum m = go Nothing m
518518 if res <= a
519519 then go (Just res) r
520520 else go (Just a) r
521− in foldStream defState stop single yieldk m1
521+ in foldStream defState yieldk single stop m1
522522
523523{-# INLINE minimumBy #-}
524524minimumBy
@@ -530,7 +530,7 @@ minimumBy cmp m = go Nothing m
530530 let stop = return Nothing
531531 single a = return (Just a)
532532 yieldk a r = go (Just a) r
533− in foldStream defState stop single yieldk m1
533+ in foldStream defState yieldk single stop m1
534534
535535 go (Just res) m1 =
536536 let stop = return (Just res)
@@ -540,7 +540,7 @@ minimumBy cmp m = go Nothing m
540540 yieldk a r = case cmp res a of
541541 GT -> go (Just a) r
542542 _ -> go (Just res) r
543− in foldStream defState stop single yieldk m1
543+ in foldStream defState yieldk single stop m1
544544
545545{-# INLINE maximum #-}
546546maximum :: (IsStream t, Monad m, Ord a) => t m a -> m (Maybe a)
@@ -550,7 +550,7 @@ maximum m = go Nothing m
550550 let stop = return Nothing
551551 single a = return (Just a)
552552 yieldk a r = go (Just a) r
553− in foldStream defState stop single yieldk m1
553+ in foldStream defState yieldk single stop m1
554554
555555 go (Just res) m1 =
556556 let stop = return (Just res)
@@ -562,7 +562,7 @@ maximum m = go Nothing m
562562 if res <= a
563563 then go (Just a) r
564564 else go (Just res) r
565− in foldStream defState stop single yieldk m1
565+ in foldStream defState yieldk single stop m1
566566
567567{-# INLINE maximumBy #-}
568568maximumBy :: (IsStream t, Monad m) => (a -> a -> Ordering) -> t m a -> m (Maybe a)
@@ -572,7 +572,7 @@ maximumBy cmp m = go Nothing m
572572 let stop = return Nothing
573573 single a = return (Just a)
574574 yieldk a r = go (Just a) r
575− in foldStream defState stop single yieldk m1
575+ in foldStream defState yieldk single stop m1
576576
577577 go (Just res) m1 =
578578 let stop = return (Just res)
@@ -582,7 +582,7 @@ maximumBy cmp m = go Nothing m
582582 yieldk a r = case cmp res a of
583583 GT -> go (Just res) r
584584 _ -> go (Just a) r
585− in foldStream defState stop single yieldk m1
585+ in foldStream defState yieldk single stop m1
586586
587587{-# INLINE (!!) #-}
588588(!!) :: (IsStream t, Monad m) => t m a -> Int -> m (Maybe a)
@@ -594,7 +594,7 @@ m !! i = go i m
594594 yieldk a x | n < 0 = return Nothing
595595 | n == 0 = return $ Just a
596596 | otherwise = go (n - 1) x
597− in foldStream defState (return Nothing) single yieldk m1
597+ in foldStream defState yieldk single (return Nothing) m1
598598
599599{-# INLINE lookup #-}
600600lookup :: (IsStream t, Monad m, Eq a) => a -> t m (a, b) -> m (Maybe b)
@@ -605,7 +605,7 @@ lookup e m = go m
605605 | otherwise = return Nothing
606606 yieldk (a, b) x | a == e = return $ Just b
607607 | otherwise = go x
608− in foldStream defState (return Nothing) single yieldk m1
608+ in foldStream defState yieldk single (return Nothing) m1
609609
610610{-# INLINE findM #-}
611611findM :: (IsStream t, Monad m) => (a -> m Bool) -> t m a -> m (Maybe a)
@@ -618,7 +618,7 @@ findM p m = go m
618618 yieldk a x = do
619619 b <- p a
620620 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
622622
623623{-# INLINE find #-}
624624find :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m (Maybe a)
@@ -628,13 +628,13 @@ find p = findM (return . p)
628628findIndices :: IsStream t => (a -> Bool) -> t m a -> t m Int
629629findIndices p = go 0
630630 where
631− go offset m1 = mkStream $ \st stp sng yld ->
631+ go offset m1 = mkStream $ \st yld sng stp ->
632632 let single a | p a = sng offset
633633 | otherwise = stp
634634 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 $
636636 go (offset + 1) x
637− in foldStream (adaptState st) stp single yieldk m1
637+ in foldStream (adaptState st) yieldk single stp m1
638638
639639------------------------------------------------------------------------------
640640-- Map and Fold
@@ -649,7 +649,7 @@ mapM_ f m = go m
649649 let stop = return ()
650650 single a = void (f a)
651651 yieldk a r = f a >> go r
652− in foldStream defState stop single yieldk m1
652+ in foldStream defState yieldk single stop m1
653653
654654------------------------------------------------------------------------------
655655-- Converting folds
@@ -672,12 +672,12 @@ scanx :: IsStream t => (x -> a -> x) -> x -> (x -> b) -> t m a -> t m b
672672scanx step begin done m =
673673 cons (done begin) $ go m begin
674674 where
675− go m1 !acc = mkStream $ \st stp sng yld ->
675+ go m1 !acc = mkStream $ \st yld sng stp ->
676676 let single a = sng (done $ step acc a)
677677 yieldk a r =
678678 let s = step acc a
679679 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
681681
682682{-# INLINE scanl' #-}
683683scanl' :: IsStream t => (b -> a -> b) -> b -> t m a -> t m b
@@ -691,56 +691,55 @@ scanl' step begin = scanx step begin id
691691filter :: IsStream t => (a -> Bool) -> t m a -> t m a
692692filter p m = go m
693693 where
694− go m1 = mkStream $ \st stp sng yld ->
694+ go m1 = mkStream $ \st yld sng stp ->
695695 let single a | p a = sng a
696696 | otherwise = stp
697697 yieldk a r | p a = yld a (go r)
698− | otherwise = foldStream st stp single yieldk r
699− in foldStream st stp single yieldk m1
698+ | otherwise = foldStream st yieldk single stp r
699+ in foldStream st yieldk single stp m1
700700
701701{-# INLINE take #-}
702702take :: IsStream t => Int -> t m a -> t m a
703703take n m = go n m
704704 where
705− go n1 m1 = mkStream $ \st stp sng yld ->
705+ go n1 m1 = mkStream $ \st yld sng stp ->
706706 let yieldk a r = yld a (go (n1 - 1) r)
707707 in if n1 <= 0
708708 then stp
709− else foldStream st stp sng yieldk m1
709+ else foldStream st yieldk sng stp m1
710710
711711{-# INLINE takeWhile #-}
712712takeWhile :: IsStream t => (a -> Bool) -> t m a -> t m a
713713takeWhile p m = go m
714714 where
715− go m1 = mkStream $ \st stp sng yld ->
715+ go m1 = mkStream $ \st yld sng stp ->
716716 let single a | p a = sng a
717717 | otherwise = stp
718718 yieldk a r | p a = yld a (go r)
719719 | otherwise = stp
720− in foldStream st stp single yieldk m1
720+ in foldStream st yieldk single stp m1
721721
722722drop :: IsStream t => Int -> t m a -> t m a
723−drop n m = mkStream $ \st stp sng yld ->
724− foldStream st stp sng yld $ go n m
723+drop n m = go n m
725724 where
726− go n1 m1 = mkStream $ \st stp sng yld ->
725+ go n1 m1 = mkStream $ \st yld sng stp ->
727726 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
729728 -- Somehow "<=" check performs better than a ">"
730729 in if n1 <= 0
731− then foldStream st stp sng yld m1
732− else foldStream st stp single yieldk m1
730+ then foldStream st yld sng stp m1
731+ else foldStream st yieldk single stp m1
733732
734733{-# INLINE dropWhile #-}
735734dropWhile :: IsStream t => (a -> Bool) -> t m a -> t m a
736735dropWhile p m = go m
737736 where
738− go m1 = mkStream $ \st stp sng yld ->
737+ go m1 = mkStream $ \st yld sng stp ->
739738 let single a | p a = stp
740739 | 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
742741 | otherwise = yld a r
743− in foldStream st stp single yieldk m1
742+ in foldStream st yieldk single stp m1
744743
745744-------------------------------------------------------------------------------
746745-- Mapping
@@ -752,10 +751,10 @@ dropWhile p m = go m
752751mapM :: (IsStream t, MonadAsync m) => (a -> m b) -> t m a -> t m b
753752mapM f m = go m
754753 where
755− go m1 = mkStream $ \st stp sng yld ->
754+ go m1 = mkStream $ \st yld sng stp ->
756755 let single a = f a >>= sng
757− yieldk a r = foldStreamShared st stp sng yld $ f a |: go r
758− in foldStream (adaptState st) stp single yieldk m1
756+ yieldk a r = foldStreamShared st yld sng stp $ f a |: go r
757+ in foldStream (adaptState st) yieldk single stp m1
759758
760759-- Be careful when modifying this, this uses a consM (|:) deliberately to allow
761760-- other stream types to overload it.
@@ -763,10 +762,10 @@ mapM f m = go m
763762sequence :: (IsStream t, MonadAsync m) => t m (m a) -> t m a
764763sequence m = go m
765764 where
766− go m1 = mkStream $ \st stp sng yld ->
765+ go m1 = mkStream $ \st yld sng stp ->
767766 let single ma = ma >>= sng
768− yieldk ma r = foldStreamShared st stp sng yld $ ma |: go r
769− in foldStream (adaptState st) stp single yieldk m1
767+ yieldk ma r = foldStreamShared st yld sng stp $ ma |: go r
768+ in foldStream (adaptState st) yieldk single stp m1
770769
771770-------------------------------------------------------------------------------
772771-- Inserting
@@ -776,19 +775,19 @@ sequence m = go m
776775intersperseM :: (IsStream t, MonadAsync m) => m a -> t m a -> t m a
777776intersperseM a m = prependingStart m
778777 where
779− prependingStart m1 = mkStream $ \st stp sng yld ->
780− let yieldk i x = foldStreamShared st stp sng yld $ return i |: go x
781− in foldStream st stp sng yieldk m1
782− go m2 = mkStream $ \st stp sng yld ->
783− let single i = foldStreamShared st stp sng yld $ a |: yield i
784− yieldk i x = foldStreamShared st stp sng yld $ a |: return i |: go x
785− in foldStream st stp single yieldk m2
778+ prependingStart m1 = mkStream $ \st yld sng stp ->
779+ let yieldk i x = foldStreamShared st yld sng stp $ return i |: go x
780+ in foldStream st yieldk sng stp m1
781+ go m2 = mkStream $ \st yld sng stp ->
782+ let single i = foldStreamShared st yld sng stp $ a |: yield i
783+ yieldk i x = foldStreamShared st yld sng stp $ a |: return i |: go x
784+ in foldStream st yieldk single stp m2
786785
787786{-# INLINE insertBy #-}
788787insertBy :: IsStream t => (a -> a -> Ordering) -> a -> t m a -> t m a
789788insertBy cmp x m = go m
790789 where
791− go m1 = mkStream $ \st _ _ yld ->
790+ go m1 = mkStream $ \st yld _ _ ->
792791 let single a = case cmp x a of
793792 GT -> yld a (yield x)
794793 _ -> yld x (yield a)
@@ -796,7 +795,7 @@ insertBy cmp x m = go m
796795 yieldk a r = case cmp x a of
797796 GT -> yld a (go r)
798797 _ -> yld x (a `cons` r)
799− in foldStream st stop single yieldk m1
798+ in foldStream st yieldk single stop m1
800799
801800------------------------------------------------------------------------------
802801-- Deleting
@@ -806,12 +805,12 @@ insertBy cmp x m = go m
806805deleteBy :: IsStream t => (a -> a -> Bool) -> a -> t m a -> t m a
807806deleteBy eq x m = go m
808807 where
809− go m1 = mkStream $ \st stp sng yld ->
808+ go m1 = mkStream $ \st yld sng stp ->
810809 let single a = if eq x a then stp else sng a
811810 yieldk a r = if eq x a
812− then foldStream st stp sng yld r
811+ then foldStream st yld sng stp r
813812 else yld a (go r)
814− in foldStream st stp single yieldk m1
813+ in foldStream st yieldk single stp m1
815814
816815-------------------------------------------------------------------------------
817816-- Map and Filter
@@ -821,14 +820,14 @@ deleteBy eq x m = go m
821820mapMaybe :: IsStream t => (a -> Maybe b) -> t m a -> t m b
822821mapMaybe f m = go m
823822 where
824− go m1 = mkStream $ \st stp sng yld ->
823+ go m1 = mkStream $ \st yld sng stp ->
825824 let single a = case f a of
826825 Just b -> sng b
827826 Nothing -> stp
828827 yieldk a r = case f a of
829828 Just b -> yld b $ go r
830− Nothing -> foldStream (adaptState st) stp single yieldk r
831− in foldStream (adaptState st) stp single yieldk m1
829+ Nothing -> foldStream (adaptState st) yieldk single stp r
830+ in foldStream (adaptState st) yieldk single stp m1
832831
833832------------------------------------------------------------------------------
834833-- Serial Zipping
@@ -841,14 +840,14 @@ mapMaybe f m = go m
841840zipWith :: IsStream t => (a -> b -> c) -> t m a -> t m b -> t m c
842841zipWith f = go
843842 where
844− go mx my = mkStream $ \st stp sng yld -> do
843+ go mx my = mkStream $ \st yld sng stp -> do
845844 let merge a ra =
846845 let single2 b = sng (f a b)
847846 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
849848 let single1 a = merge a nil
850849 yield1 = merge
851− foldStream (adaptState st) stp single1 yield1 mx
850+ foldStream (adaptState st) yield1 single1 stp mx
852851
853852-- | Zip two streams serially using a monadic zipping function.
854853--
@@ -856,15 +855,15 @@ zipWith f = go
856855zipWithM :: (IsStream t, Monad m) => (a -> b -> m c) -> t m a -> t m b -> t m c
857856zipWithM f m1 m2 = go m1 m2
858857 where
859− go mx my = mkStream $ \st stp sng yld -> do
858+ go mx my = mkStream $ \st yld sng stp -> do
860859 let merge a ra =
861− let runIt x = foldStream st stp sng yld x
860+ let runIt x = foldStream st yld sng stp x
862861 single2 b = f a b >>= sng
863862 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
865864 let single1 a = merge a nil
866865 yield1 = merge
867− foldStream (adaptState st) stp single1 yield1 mx
866+ foldStream (adaptState st) yield1 single1 stp mx
868867
869868------------------------------------------------------------------------------
870869-- Merging
@@ -876,9 +875,9 @@ mergeByM
876875 => (a -> a -> m Ordering) -> t m a -> t m a -> t m a
877876mergeByM cmp = go
878877 where
879− go mx my = mkStream $ \st stp sng yld -> do
878+ go mx my = mkStream $ \st yld sng stp -> do
880879 let mergeWithY a ra =
881− let stop2 = foldStream st stp sng yld mx
880+ let stop2 = foldStream st yld sng stp mx
882881 single2 b = do
883882 r <- cmp a b
884883 case r of
@@ -889,11 +888,11 @@ mergeByM cmp = go
889888 case r of
890889 GT -> yld b (go (a `cons` ra) rb)
891890 _ -> yld a (go ra (b `cons` rb))
892− in foldStream st stop2 single2 yield2 my
893− let stopX = foldStream st stp sng yld my
891+ in foldStream st yield2 single2 stop2 my
892+ let stopX = foldStream st yld sng stp my
894893 singleX a = mergeWithY a nil
895894 yieldX = mergeWithY
896− foldStream st stopX singleX yieldX mx
895+ foldStream st yieldX singleX stopX mx
897896
898897{-# INLINABLE mergeBy #-}
899898mergeBy
@@ -918,7 +917,7 @@ the m = do
918917 | otherwise = return Nothing
919918 yieldk a r | h == a = go h r
920919 | otherwise = return Nothing
921− in foldStream defState (return $ Just h) single yieldk m1
920+ in foldStream defState yieldk single (return $ Just h) m1
922921
923922-------------------------------------------------------------------------------
924923-- Bind utility
@@ -934,20 +933,20 @@ bindWith
934933bindWith par m1 f = go m1
935934 where
936935 go m =
937− mkStream $ \st stp sng yld ->
938− let foldShared = foldStreamShared st stp sng yld
936+ mkStream $ \st yld sng stp ->
937+ let foldShared = foldStreamShared st yld sng stp
939938 single a = foldShared $ unShare (f a)
940939 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
942941
943942------------------------------------------------------------------------------
944943-- Alternative & MonadPlus
945944------------------------------------------------------------------------------
946945
947946_alt :: Stream m a -> Stream m a -> Stream m a
948−_alt m1 m2 = mkStream $ \st stp sng yld ->
949− let stop = foldStream st stp sng yld m2
950− in foldStream st stop sng yld m1
947+_alt m1 m2 = mkStream $ \st yld sng stp ->
948+ let stop = foldStream st yld sng stp m2
949+ in foldStream st yld sng stop m1
951950
952951------------------------------------------------------------------------------
953952-- MonadReader
@@ -955,10 +954,10 @@ _alt m1 m2 = mkStream $ \st stp sng yld ->
955954
956955withLocal :: MonadReader r m => (r -> r) -> Stream m a -> Stream m a
957956withLocal f m =
958− mkStream $ \st stp sng yld ->
957+ mkStream $ \st yld sng stp ->
959958 let single = local f . sng
960959 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
962961
963962------------------------------------------------------------------------------
964963-- MonadError
src/Streamly/Streams/StreamKType.hs+27−30
@@ -90,9 +90,9 @@ import Streamly.SVar
9090newtype Stream m a =
9191 MkStream (forall r.
9292 State Stream m a -- state
93− -> m r -- stop
94− -> (a -> m r) -- singleton
9593 -> (a -> Stream m a -> m r) -- yield
94+ -> (a -> m r) -- singleton
95+ -> m r -- stop
9696 -> m r
9797 )
9898
@@ -182,21 +182,18 @@ adapt = fromStream . toStream
182182-- Currently we always use "SVar Stream" and therefore a different State type
183183-- parameterized by that stream.
184184--
185−-- XXX change the order of arguments to match the standard fold function
186−-- convention i.e. st yield single stop.
187−--
188185-- | Build a stream from an 'SVar', a stop continuation, a singleton stream
189186-- continuation and a yield continuation.
190187mkStream:: IsStream t
191188 => (forall r. State Stream m a
192− -> m r
193− -> (a -> m r)
194189 -> (a -> t m a -> m r)
190+ -> (a -> m r)
191+ -> m r
195192 -> m r)
196193 -> t m a
197−mkStream k = fromStream $ MkStream $ \st stp sng yld ->
194+mkStream k = fromStream $ MkStream $ \st yld sng stp ->
198195 let yieldk a r = yld a (toStream r)
199− in k st stp sng yieldk
196+ in k st yieldk sng stp
200197
201198-- | A terminal function that has no continuation to follow.
202199type StopK m = forall r. m r -> m r
@@ -212,7 +209,7 @@ _wrapM m = \k -> m >>= k
212209
213210-- | Make an empty stream from a stop function.
214211fromStopK :: IsStream t => StopK m -> t m a
215−fromStopK k = mkStream $ \_ stp _ _ -> k stp
212+fromStopK k = mkStream $ \_ _ _ stp -> k stp
216213
217214-- | Make a singleton stream from a yield function.
218215fromYieldK :: IsStream t => YieldK m a -> t m a
@@ -220,7 +217,7 @@ fromYieldK k = mkStream $ \_ _ sng _ -> k sng
220217
221218-- | Add a yield function at the head of the stream.
222219consK :: 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)
224221
225222-- XXX Build a stream from a repeating callback function.
226223
@@ -235,15 +232,15 @@ consK k r = mkStream $ \_ _ _ yld -> k (\x -> yld x r)
235232foldStreamShared
236233 :: IsStream t
237234 => State Stream m a
238− -> m r
239− -> (a -> m r)
240235 -> (a -> t m a -> m r)
236+ -> (a -> m r)
237+ -> m r
241238 -> t m a
242239 -> m r
243−foldStreamShared st stp sng yld m =
240+foldStreamShared st yld sng stp m =
244241 let yieldk a x = yld a (fromStream x)
245242 MkStream k = toStream m
246− in k st stp sng yieldk
243+ in k st yieldk sng stp
247244
248245-- | Fold a stream by providing a State, stop continuation, a singleton
249246-- continuation and a yield continuation. The stream will not use the SVar
@@ -252,15 +249,15 @@ foldStreamShared st stp sng yld m =
252249foldStream
253250 :: IsStream t
254251 => State Stream m a
255− -> m r
256− -> (a -> m r)
257252 -> (a -> t m a -> m r)
253+ -> (a -> m r)
254+ -> m r
258255 -> t m a
259256 -> m r
260−foldStream st stp sng yld m =
257+foldStream st yld sng stp m =
261258 let yieldk a x = yld a (fromStream x)
262259 MkStream k = toStream m
263− in k (adaptState st) stp sng yieldk
260+ in k (adaptState st) yieldk sng stp
264261
265262-- Run the stream using a run function associated with the SVar that runs the
266263-- streams with a captured snapshot of the monadic state.
@@ -269,14 +266,14 @@ foldStreamSVar
269266 :: (IsStream t, MonadIO m)
270267 => SVar Stream m a
271268 -> State Stream m a -- state
272− -> m r -- stop
273− -> (a -> m r) -- singleton
274269 -> (a -> t m a -> m r) -- yield
270+ -> (a -> m r) -- singleton
271+ -> m r -- stop
275272 -> t m a
276273 -> m ()
277−foldStreamSVar sv st stp sng yld m =
274+foldStreamSVar sv st yld sng stp m =
278275 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
280277
281278-------------------------------------------------------------------------------
282279-- Instances
@@ -284,7 +281,7 @@ foldStreamSVar sv st stp sng yld m =
284281
285282{-# INLINE consMSerial #-}
286283consMSerial :: (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
288285
289286-------------------------------------------------------------------------------
290287-- IsStream Stream
@@ -317,11 +314,11 @@ instance IsStream Stream where
317314serial :: IsStream t => t m a -> t m a -> t m a
318315serial m1 m2 = go m1
319316 where
320− go m = mkStream $ \st stp sng yld ->
321− let stop = foldStream st stp sng yld m2
317+ go m = mkStream $ \st yld sng stp ->
318+ let stop = foldStream st yld sng stp m2
322319 single a = yld a m2
323320 yieldk a r = yld a (go r)
324− in foldStream st stop single yieldk m
321+ in foldStream st yieldk single stop m
325322
326323instance Semigroup (Stream m a) where
327324 (<>) = serial
@@ -339,7 +336,7 @@ instance Semigroup (Stream m a) where
339336--
340337-- @since 0.1.0
341338nil :: IsStream t => t m a
342−nil = mkStream $ \_ stp _ _ -> stp
339+nil = mkStream $ \_ _ _ stp -> stp
343340
344341instance Monoid (Stream m a) where
345342 mempty = nil
@@ -352,10 +349,10 @@ instance Monoid (Stream m a) where
352349
353350{-# INLINE map #-}
354351map :: (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 ->
356353 let single = sng . f
357354 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
359356
360357instance Monad m => Functor (Stream m) where
361358 fmap = map