@@ -117,10 +117,10 @@ module Streamly.Internal.Data.Stream.StreamK
117117 , foldBreak
118118 , foldEither
119119 , foldConcat
120− , parseBreak
121− , parse
122− , parseKBreakChunks
123− , parseKChunks
120+ , parseDBreak
121+ , parseD
122+ , chunkParseBreak
123+ , chunkParse
124124
125125 -- ** Specialized Folds
126126 , drain
@@ -371,7 +371,7 @@ foldlMx' step begin done = go begin
371371-- Definitions:
372372--
373373-- >>> fold f = fmap fst . StreamK.foldBreak f
374−-- >>> fold f = StreamK.parse (Parser.fromFold f)
374+-- >>> fold f = StreamK.parseD (Parser.fromFold f)
375375--
376376-- Example:
377377--
@@ -1146,13 +1146,13 @@ splitAt n ls
11461146 (xs', xs'') = splitAt' (m - 1) xs
11471147
11481148-- | Run a 'Parser' over a stream and return rest of the Stream.
1149−{-# INLINE_NORMAL parseBreakD #-}
1150−parseBreakD
1149+{-# INLINE_NORMAL parseDBreak #-}
1150+parseDBreak
11511151 :: Monad m
11521152 => PR.Parser a m b
11531153 -> Stream m a
11541154 -> m (Either ParseError b, Stream m a)
1155−parseBreakD (PR.Parser pstep initial extract) stream = do
1155+parseDBreak (PR.Parser pstep initial extract) stream = do
11561156 res <- initial
11571157 case res of
11581158 PR.IPartial s -> goStream stream [] s
@@ -1232,23 +1232,14 @@ parseBreakD (PR.Parser pstep initial extract) stream = do
12321232 return (Right b, append (fromList src) st)
12331233 PR.Error err -> return (Left (ParseError err), nil)
12341234
1235−-- | Parse a stream using the supplied 'Parser'.
1236−--
1237−-- /CPS/
1238−--
1239−{-# INLINE parseBreak #-}
1240−parseBreak :: Monad m =>
1241− Parser.Parser a m b -> Stream m a -> m (Either ParseError b, Stream m a)
1242−parseBreak = parseBreakD
1243−
12441235-- Using ParserD or ParserK on StreamK may not make much difference. We should
12451236-- perhaps use only chunked parsing on StreamK. We can always convert a stream
12461237-- to chunks before parsing. Or just have a ParserK element parser for StreamK
12471238-- and convert ParserD to ParserK for element parsing using StreamK.
1248−{-# INLINE parse #-}
1249−parse :: Monad m =>
1239+{-# INLINE parseD #-}
1240+parseD :: Monad m =>
12501241 Parser.Parser a m b -> Stream m a -> m (Either ParseError b)
1251−parse f = fmap fst . parseBreak f
1242+parseD f = fmap fst . parseDBreak f
12521243
12531244-------------------------------------------------------------------------------
12541245-- Chunked parsing using ParserK
@@ -1289,13 +1280,13 @@ parserDone (ParserK.Success n b) _ _ = pure $ ParserK.Done n b
12891280parserDone (ParserK.Failure n e) _ _ = pure $ ParserK.Error n e
12901281
12911282-- | Run a 'ParserK' over a chunked 'StreamK' and return the rest of the Stream.
1292−{-# INLINE_NORMAL parseKBreakChunks #-}
1293−parseKBreakChunks
1283+{-# INLINE_NORMAL chunkParseBreak #-}
1284+chunkParseBreak
12941285 :: (Monad m, Unbox a)
12951286 => ParserK.Parser a m b
12961287 -> StreamK m (Array a)
12971288 -> m (Either ParseError b, StreamK m (Array a))
1298−parseKBreakChunks parser input = do
1289+chunkParseBreak parser input = do
12991290 let parserk = \arr -> ParserK.runParser parser parserDone 0 0 arr
13001291 in go [] parserk input
13011292
@@ -1380,10 +1371,10 @@ parseKBreakChunks parser input = do
13801371 in foldStream
13811372 defState (yieldk backBuf parserk) single stop stream
13821373
1383−{-# INLINE parseKChunks #-}
1384−parseKChunks :: (Monad m, Unbox a) =>
1374+{-# INLINE chunkParse #-}
1375+chunkParse :: (Monad m, Unbox a) =>
13851376 ParserK.Parser a m b -> Stream m (Array a) -> m (Either ParseError b)
1386−parseKChunks f = fmap fst . parseKBreakChunks f
1377+chunkParse f = fmap fst . chunkParseBreak f
13871378
13881379-------------------------------------------------------------------------------
13891380-- Sorting