@@ -141,8 +141,8 @@ import Prelude hiding (filter, drop, dropWhile, take,
141141import qualified Prelude
142142import qualified System.IO as IO
143143
144−import Streamly.Streams.CPS
145−import qualified Streamly.Streams.CPS as C
144+import Streamly.Streams.StreamK
145+import qualified Streamly.Streams.StreamK as K
146146import Streamly.Streams.Zip
147147import Streamly.Streams.Serial
148148import Streamly.SVar (MonadAsync)
@@ -172,7 +172,7 @@ import Streamly.SVar (MonadAsync)
172172unfoldr :: IsStream t => (b -> Maybe (a, b)) -> b -> t m a
173173unfoldr step = fromStream . go
174174 where
175− go s = C.Stream $ \_ stp _ yld ->
175+ go s = K.Stream $ \_ stp _ yld ->
176176 case step s of
177177 Nothing -> stp
178178 Just (a, b) -> yld a (go b)
@@ -212,12 +212,12 @@ unfoldr step = fromStream . go
212212unfoldrM :: (IsStream t, MonadAsync m) => (b -> m (Maybe (a, b))) -> b -> t m a
213213unfoldrM step = go
214214 where
215− go s = fromStream $ C.Stream $ \svr stp sng yld -> do
215+ go s = fromStream $ K.Stream $ \svr stp sng yld -> do
216216 mayb <- step s
217217 case mayb of
218218 Nothing -> stp
219219 Just (a, b) ->
220− C.runStream (toStream (return a |: go b)) svr stp sng yld
220+ K.runStream (toStream (return a |: go b)) svr stp sng yld
221221
222222-- | Construct a stream from a 'Foldable' containing pure values.
223223--
@@ -284,7 +284,7 @@ repeatM = go
284284iterate :: IsStream t => (a -> a) -> a -> t m a
285285iterate step = fromStream . go
286286 where
287− go s = C.cons s (go (step s))
287+ go s = K.cons s (go (step s))
288288
289289-- | Iterate a monadic function from a seed value, streaming the results
290290-- forever.
@@ -308,9 +308,9 @@ iterate step = fromStream . go
308308iterateM :: (IsStream t, MonadAsync m) => (a -> m a) -> a -> t m a
309309iterateM step = go
310310 where
311− go s = fromStream $ C.Stream $ \svr stp sng yld -> do
311+ go s = fromStream $ K.Stream $ \svr stp sng yld -> do
312312 next <- step s
313− C.runStream (toStream (return s |: go next)) svr stp sng yld
313+ K.runStream (toStream (return s |: go next)) svr stp sng yld
314314
315315-- | Read lines from an IO Handle into a stream of Strings.
316316--
@@ -318,7 +318,7 @@ iterateM step = go
318318fromHandle :: (IsStream t, MonadIO m) => IO.Handle -> t m String
319319fromHandle h = fromStream go
320320 where
321− go = C.Stream $ \_ stp _ yld -> do
321+ go = K.Stream $ \_ stp _ yld -> do
322322 eof <- liftIO $ IO.hIsEOF h
323323 if eof
324324 then stp
@@ -345,7 +345,7 @@ foldr step acc m = go (toStream m)
345345 let stop = return acc
346346 single a = return (step a acc)
347347 yield a r = go r >>= \b -> return (step a b)
348− in (C.runStream m1) Nothing stop single yield
348+ in (K.runStream m1) Nothing stop single yield
349349
350350-- | Lazy right fold with a monadic step function. For example, to fold a
351351-- stream into a list:
@@ -364,7 +364,7 @@ foldrM step acc m = go (toStream m)
364364 let stop = return acc
365365 single a = step a acc
366366 yield a r = go r >>= step a
367− in (C.runStream m1) Nothing stop single yield
367+ in (K.runStream m1) Nothing stop single yield
368368
369369-- | Strict left scan with an extraction function. Like 'scanl'', but applies a
370370-- user supplied extraction function (the third argument) at each step. This is
@@ -377,12 +377,12 @@ scanx :: IsStream t => (x -> a -> x) -> x -> (x -> b) -> t m a -> t m b
377377scanx step begin done m =
378378 cons (done begin) $ fromStream $ go (toStream m) begin
379379 where
380− go m1 !acc = C.Stream $ \_ stp sng yld ->
380+ go m1 !acc = K.Stream $ \_ stp sng yld ->
381381 let single a = sng (done $ step acc a)
382382 yield a r =
383383 let s = step acc a
384384 in yld (done s) (go r s)
385− in C.runStream m1 Nothing stp single yield
385+ in K.runStream m1 Nothing stp single yield
386386
387387-- |
388388-- @since 0.1.1
@@ -413,19 +413,19 @@ foldx step begin done m = get $ go (toStream m) begin
413413 {-# NOINLINE get #-}
414414 get m1 =
415415 let single = return . done
416− in (C.runStream m1) Nothing undefined single undefined
416+ in (K.runStream m1) Nothing undefined single undefined
417417
418418 -- Note, this can be implemented by making a recursive call to "go",
419419 -- however that is more expensive because of unnecessary recursion
420420 -- that cannot be tail call optimized. Unfolding recursion explicitly via
421421 -- continuations is much more efficient.
422− go m1 !acc = C.Stream $ \_ _ sng yld ->
422+ go m1 !acc = K.Stream $ \_ _ sng yld ->
423423 let stop = sng acc
424424 single a = sng $ step acc a
425425 yield a r =
426426 let stream = go r (step acc a)
427− in (C.runStream stream) Nothing undefined sng yld
428− in (C.runStream m1) Nothing stop single yield
427+ in (K.runStream stream) Nothing undefined sng yld
428+ in (K.runStream m1) Nothing stop single yield
429429
430430-- |
431431-- @since 0.1.0
@@ -451,7 +451,7 @@ foldxM step begin done m = go begin (toStream m)
451451 let stop = acc >>= done
452452 single a = acc >>= \b -> step b a >>= done
453453 yield a r = acc >>= \b -> go (step b a) r
454− in (C.runStream m1) Nothing stop single yield
454+ in (K.runStream m1) Nothing stop single yield
455455
456456-- |
457457-- @since 0.1.0
@@ -475,7 +475,7 @@ uncons m =
475475 let stop = return Nothing
476476 single a = return (Just (a, nil))
477477 yield a r = return (Just (a, fromStream r))
478− in (C.runStream (toStream m)) Nothing stop single yield
478+ in (K.runStream (toStream m)) Nothing stop single yield
479479
480480-- | Write a stream of Strings to an IO Handle.
481481--
@@ -487,7 +487,7 @@ toHandle h m = go (toStream m)
487487 let stop = return ()
488488 single a = liftIO (IO.hPutStrLn h a)
489489 yield a r = liftIO (IO.hPutStrLn h a) >> go r
490− in (C.runStream m1) Nothing stop single yield
490+ in (K.runStream m1) Nothing stop single yield
491491
492492------------------------------------------------------------------------------
493493-- Special folds
@@ -507,9 +507,9 @@ toList = foldrM (\a xs -> return (a : xs)) []
507507take :: IsStream t => Int -> t m a -> t m a
508508take n m = fromStream $ go n (toStream m)
509509 where
510− go n1 m1 = C.Stream $ \_ stp sng yld ->
510+ go n1 m1 = K.Stream $ \_ stp sng yld ->
511511 let yield a r = yld a (go (n1 - 1) r)
512− in if n1 <= 0 then stp else (C.runStream m1) Nothing stp sng yield
512+ in if n1 <= 0 then stp else (K.runStream m1) Nothing stp sng yield
513513
514514-- | Include only those elements that pass a predicate.
515515--
@@ -518,12 +518,12 @@ take n m = fromStream $ go n (toStream m)
518518filter :: IsStream t => (a -> Bool) -> t m a -> t m a
519519filter p m = fromStream $ go (toStream m)
520520 where
521− go m1 = C.Stream $ \_ stp sng yld ->
521+ go m1 = K.Stream $ \_ stp sng yld ->
522522 let single a | p a = sng a
523523 | otherwise = stp
524524 yield a r | p a = yld a (go r)
525− | otherwise = (C.runStream r) Nothing stp single yield
526− in (C.runStream m1) Nothing stp single yield
525+ | otherwise = (K.runStream r) Nothing stp single yield
526+ in (K.runStream m1) Nothing stp single yield
527527
528528-- | End the stream as soon as the predicate fails on an element.
529529--
@@ -532,12 +532,12 @@ filter p m = fromStream $ go (toStream m)
532532takeWhile :: IsStream t => (a -> Bool) -> t m a -> t m a
533533takeWhile p m = fromStream $ go (toStream m)
534534 where
535− go m1 = C.Stream $ \_ stp sng yld ->
535+ go m1 = K.Stream $ \_ stp sng yld ->
536536 let single a | p a = sng a
537537 | otherwise = stp
538538 yield a r | p a = yld a (go r)
539539 | otherwise = stp
540− in (C.runStream m1) Nothing stp single yield
540+ in (K.runStream m1) Nothing stp single yield
541541
542542-- | Discard first 'n' elements from the stream and take the rest.
543543--
@@ -545,13 +545,13 @@ takeWhile p m = fromStream $ go (toStream m)
545545drop :: IsStream t => Int -> t m a -> t m a
546546drop n m = fromStream $ go n (toStream m)
547547 where
548− go n1 m1 = C.Stream $ \_ stp sng yld ->
548+ go n1 m1 = K.Stream $ \_ stp sng yld ->
549549 let single _ = stp
550− yield _ r = (C.runStream $ go (n1 - 1) r) Nothing stp sng yld
550+ yield _ r = (K.runStream $ go (n1 - 1) r) Nothing stp sng yld
551551 -- Somehow "<=" check performs better than a ">"
552552 in if n1 <= 0
553− then (C.runStream m1) Nothing stp sng yld
554− else (C.runStream m1) Nothing stp single yield
553+ then (K.runStream m1) Nothing stp sng yld
554+ else (K.runStream m1) Nothing stp single yield
555555
556556-- | Drop elements in the stream as long as the predicate succeeds and then
557557-- take the rest of the stream.
@@ -561,12 +561,12 @@ drop n m = fromStream $ go n (toStream m)
561561dropWhile :: IsStream t => (a -> Bool) -> t m a -> t m a
562562dropWhile p m = fromStream $ go (toStream m)
563563 where
564− go m1 = C.Stream $ \_ stp sng yld ->
564+ go m1 = K.Stream $ \_ stp sng yld ->
565565 let single a | p a = stp
566566 | otherwise = sng a
567− yield a r | p a = (C.runStream r) Nothing stp single yield
567+ yield a r | p a = (K.runStream r) Nothing stp single yield
568568 | otherwise = yld a r
569− in (C.runStream m1) Nothing stp single yield
569+ in (K.runStream m1) Nothing stp single yield
570570
571571-- | Determine whether all elements of a stream satisfy a predicate.
572572--
@@ -579,7 +579,7 @@ all p m = go (toStream m)
579579 | otherwise = return False
580580 yield a r | p a = go r
581581 | otherwise = return False
582− in (C.runStream m1) Nothing (return True) single yield
582+ in (K.runStream m1) Nothing (return True) single yield
583583
584584-- | Determine whether any of the elements of a stream satisfy a predicate.
585585--
@@ -592,7 +592,7 @@ any p m = go (toStream m)
592592 | otherwise = return False
593593 yield a r | p a = return True
594594 | otherwise = go r
595− in (C.runStream m1) Nothing (return False) single yield
595+ in (K.runStream m1) Nothing (return False) single yield
596596
597597-- | Determine the sum of all elements of a stream of numbers
598598--
@@ -614,7 +614,7 @@ head m =
614614 let stop = return Nothing
615615 single a = return (Just a)
616616 yield a _ = return (Just a)
617− in (C.runStream (toStream m)) Nothing stop single yield
617+ in (K.runStream (toStream m)) Nothing stop single yield
618618
619619-- | Extract all but the first element of the stream, if any.
620620--
@@ -624,7 +624,7 @@ tail m =
624624 let stop = return Nothing
625625 single _ = return $ Just nil
626626 yield _ r = return $ Just $ fromStream r
627− in (C.runStream (toStream m)) Nothing stop single yield
627+ in (K.runStream (toStream m)) Nothing stop single yield
628628
629629-- | Extract the last element of the stream, if any.
630630--
@@ -641,7 +641,7 @@ null m =
641641 let stop = return True
642642 single _ = return False
643643 yield _ _ = return False
644− in (C.runStream (toStream m)) Nothing stop single yield
644+ in (K.runStream (toStream m)) Nothing stop single yield
645645
646646-- | Determine whether an element is present in the stream.
647647--
@@ -653,7 +653,7 @@ elem e m = go (toStream m)
653653 let stop = return False
654654 single a = return (a == e)
655655 yield a r = if a == e then return True else go r
656− in (C.runStream m1) Nothing stop single yield
656+ in (K.runStream m1) Nothing stop single yield
657657
658658-- | Determine whether an element is not present in the stream.
659659--
@@ -665,7 +665,7 @@ notElem e m = go (toStream m)
665665 let stop = return True
666666 single a = return (a /= e)
667667 yield a r = if a == e then return False else go r
668− in (C.runStream m1) Nothing stop single yield
668+ in (K.runStream m1) Nothing stop single yield
669669
670670-- | Determine the length of the stream.
671671--
@@ -678,14 +678,14 @@ length = foldl (\n _ -> n + 1) 0 id
678678--
679679-- @since 0.1.1
680680reverse :: (IsStream t) => t m a -> t m a
681−reverse m = fromStream $ go C.nil (toStream m)
681+reverse m = fromStream $ go K.nil (toStream m)
682682 where
683− go rev rest = C.Stream $ \_ stp sng yld ->
684− let runIt x = C.runStream x Nothing stp sng yld
683+ go rev rest = K.Stream $ \_ stp sng yld ->
684+ let runIt x = K.runStream x Nothing stp sng yld
685685 stop = runIt rev
686− single a = runIt $ a `C.cons` rev
687− yield a r = runIt $ go (a `C.cons` rev) r
688− in C.runStream rest Nothing stop single yield
686+ single a = runIt $ a `K.cons` rev
687+ yield a r = runIt $ go (a `K.cons` rev) r
688+ in K.runStream rest Nothing stop single yield
689689
690690-- XXX replace the recursive "go" with continuation
691691-- | Determine the minimum element in a stream.
@@ -698,7 +698,7 @@ minimum m = go Nothing (toStream m)
698698 let stop = return res
699699 single a = return $ min_ a res
700700 yield a r = go (min_ a res) r
701− in (C.runStream m1) Nothing stop single yield
701+ in (K.runStream m1) Nothing stop single yield
702702
703703 min_ a res = case res of
704704 Nothing -> Just a
@@ -715,7 +715,7 @@ maximum m = go Nothing (toStream m)
715715 let stop = return res
716716 single a = return $ max_ a res
717717 yield a r = go (max_ a res) r
718− in (C.runStream m1) Nothing stop single yield
718+ in (K.runStream m1) Nothing stop single yield
719719
720720 max_ a res = case res of
721721 Nothing -> Just a
@@ -743,10 +743,10 @@ maximum m = go Nothing (toStream m)
743743mapM :: (IsStream t, MonadAsync m) => (a -> m b) -> t m a -> t m b
744744mapM f m = go (toStream m)
745745 where
746− go m1 = fromStream $ C.Stream $ \svr stp sng yld ->
746+ go m1 = fromStream $ K.Stream $ \svr stp sng yld ->
747747 let single a = f a >>= sng
748− yield a r = C.runStream (toStream (f a |: (go r))) svr stp sng yld
749− in (C.runStream m1) Nothing stp single yield
748+ yield a r = K.runStream (toStream (f a |: (go r))) svr stp sng yld
749+ in (K.runStream m1) Nothing stp single yield
750750
751751-- | Map a 'Maybe' returning function to a stream, filter out the 'Nothing'
752752-- elements, and return a stream of values extracted from 'Just'.
@@ -756,14 +756,14 @@ mapM f m = go (toStream m)
756756mapMaybe :: (IsStream t) => (a -> Maybe b) -> t m a -> t m b
757757mapMaybe f m = go (toStream m)
758758 where
759− go m1 = fromStream $ C.Stream $ \_ stp sng yld ->
759+ go m1 = fromStream $ K.Stream $ \_ stp sng yld ->
760760 let single a = case f a of
761761 Just b -> sng b
762762 Nothing -> stp
763763 yield a r = case f a of
764764 Just b -> yld b (toStream $ go r)
765− Nothing -> (C.runStream r) Nothing stp single yield
766− in (C.runStream m1) Nothing stp single yield
765+ Nothing -> (K.runStream r) Nothing stp single yield
766+ in (K.runStream m1) Nothing stp single yield
767767
768768-- | Like 'mapMaybe' but maps a monadic function.
769769--
@@ -787,7 +787,7 @@ mapM_ f m = go (toStream m)
787787 let stop = return ()
788788 single a = void (f a)
789789 yield a r = f a >> go r
790− in (C.runStream m1) Nothing stop single yield
790+ in (K.runStream m1) Nothing stop single yield
791791
792792-- | Reduce a stream of monadic actions to a stream of the output of those
793793-- actions.
@@ -806,7 +806,7 @@ mapM_ f m = go (toStream m)
806806sequence :: (IsStream t, MonadAsync m) => t m (m a) -> t m a
807807sequence m = go (toStream m)
808808 where
809− go m1 = fromStream $ C.Stream $ \svr stp sng yld ->
809+ go m1 = fromStream $ K.Stream $ \svr stp sng yld ->
810810 let single ma = ma >>= sng
811− yield ma r = C.runStream (toStream $ ma |: go r) svr stp sng yld
812− in (C.runStream m1) Nothing stp single yield
811+ yield ma r = K.runStream (toStream $ ma |: go r) svr stp sng yld
812+ in (K.runStream m1) Nothing stp single yield