39bc526 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Rename parseKChunks to chunkParse

39bc526Harendra Kumar4 years ago

benchmark/Streamly/Benchmark/Data/Parser/ParserK.hs+2−2

compare with master

unifiedsplit

@@ -68,12 +68,12 @@ benchIOSink value name f =

68-- Parsers

69-------------------------------------------------------------------------------

71−#define PARSE_OP StreamK.parseKChunks

71+#define PARSE_OP StreamK.chunkParse

73{-# INLINE one #-}

74one :: MonadIO m =>

75 Int -> StreamK m (Array Int) -> m (Either ParseError (Maybe Int))

76−one value = StreamK.parseKChunks p

76+one value = StreamK.chunkParse p

78 where

benchmark/Streamly/Benchmark/Data/Stream/Reduce.hs+1−1

@@ -179,7 +179,7 @@ refoldIterateM =

179{-# INLINE parseBreak #-}

180parseBreak :: Monad m => StreamK m Int -> m ()

181parseBreak s = do

182− r <- K.parseBreak PR.one s

182+ r <- K.parseDBreak PR.one s

183 case r of

184 (Left _, _) -> return ()

185 (Right _, s1) -> parseBreak s1

cabal.project−1

@@ -3,4 +3,3 @@ packages: streamly.cabal

3 , test/streamly-tests.cabal

4 , benchmark/streamly-benchmarks.cabal

5 , docs/streamly-docs.cabal

6−write-ghc-environment-files: always

core/src/Streamly/Data/Stream/StreamK.hs+2−2

@@ -53,8 +53,8 @@ module Streamly.Data.Stream.StreamK

54 -- ** Parsing

55 -- , parseBreak

56− , parseKBreakChunks

56+ , chunkParseBreak

57− -- , parseKChunks

57+ -- , chunkParse

59 -- * Combining Two Streams

60 -- ** Appending

core/src/Streamly/Internal/Data/Stream/StreamK.hs+17−26

@@ -117,10 +117,10 @@ module Streamly.Internal.Data.Stream.StreamK

117 , foldBreak

118 , foldEither

119 , foldConcat

120− , parseBreak

120+ , parseDBreak

121− , parse

121+ , parseD

122− , parseKBreakChunks

122+ , chunkParseBreak

123− , parseKChunks

123+ , chunkParse

124

125 -- ** Specialized Folds

126 , drain

@@ -371,7 +371,7 @@ foldlMx' step begin done = go begin

371-- Definitions:

372--

373-- >>> fold f = fmap fst . StreamK.foldBreak f

374−-- >>> fold f = StreamK.parse (Parser.fromFold f)

374+-- >>> fold f = StreamK.parseD (Parser.fromFold f)

375--

376-- Example:

377--

@@ -1146,13 +1146,13 @@ splitAt n ls

1146 (xs', xs'') = splitAt' (m - 1) xs

1147

1148-- | Run a 'Parser' over a stream and return rest of the Stream.

1149−{-# INLINE_NORMAL parseBreakD #-}

1149+{-# INLINE_NORMAL parseDBreak #-}

1150−parseBreakD

1150+parseDBreak

1151 :: Monad m

1152 => PR.Parser a m b

1153 -> Stream m a

1154 -> 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

1156 res <- initial

1157 case res of

1158 PR.IPartial s -> goStream stream [] s

@@ -1232,23 +1232,14 @@ parseBreakD (PR.Parser pstep initial extract) stream = do

1232 return (Right b, append (fromList src) st)

1233 PR.Error err -> return (Left (ParseError err), nil)

1234

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−

1244-- Using ParserD or ParserK on StreamK may not make much difference. We should

1235-- Using ParserD or ParserK on StreamK may not make much difference. We should

1245-- perhaps use only chunked parsing on StreamK. We can always convert a stream

1236-- perhaps use only chunked parsing on StreamK. We can always convert a stream

1246-- to chunks before parsing. Or just have a ParserK element parser for StreamK

1237-- to chunks before parsing. Or just have a ParserK element parser for StreamK

1247-- and convert ParserD to ParserK for element parsing using StreamK.

1238-- and convert ParserD to ParserK for element parsing using StreamK.

1248−{-# INLINE parse #-}

1239+{-# INLINE parseD #-}

1249−parse :: Monad m =>

1240+parseD :: Monad m =>

1250 Parser.Parser a m b -> Stream m a -> m (Either ParseError b)

1241 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

1252

1243

1253-------------------------------------------------------------------------------

1244-------------------------------------------------------------------------------

1254-- Chunked parsing using ParserK

1245-- Chunked parsing using ParserK

@@ -1289,13 +1280,13 @@ parserDone (ParserK.Success n b) _ _ = pure $ ParserK.Done n b

1289parserDone (ParserK.Failure n e) _ _ = pure $ ParserK.Error n e

1280parserDone (ParserK.Failure n e) _ _ = pure $ ParserK.Error n e

1290

1281

1291-- | Run a 'ParserK' over a chunked 'StreamK' and return the rest of the Stream.

1282-- | Run a 'ParserK' over a chunked 'StreamK' and return the rest of the Stream.

1292−{-# INLINE_NORMAL parseKBreakChunks #-}

1283+{-# INLINE_NORMAL chunkParseBreak #-}

1293−parseKBreakChunks

1284+chunkParseBreak

1294 :: (Monad m, Unbox a)

1285 :: (Monad m, Unbox a)

1295 => ParserK.Parser a m b

1286 => ParserK.Parser a m b

1296 -> StreamK m (Array a)

1287 -> StreamK m (Array a)

1297 -> m (Either ParseError b, StreamK m (Array a))

1288 -> m (Either ParseError b, StreamK m (Array a))

1298−parseKBreakChunks parser input = do

1289+chunkParseBreak parser input = do

1299 let parserk = \arr -> ParserK.runParser parser parserDone 0 0 arr

1290 let parserk = \arr -> ParserK.runParser parser parserDone 0 0 arr

1300 in go [] parserk input

1291 in go [] parserk input

1301

1292

@@ -1380,10 +1371,10 @@ parseKBreakChunks parser input = do

1380 in foldStream

1371 in foldStream

1381 defState (yieldk backBuf parserk) single stop stream

1372 defState (yieldk backBuf parserk) single stop stream

1382

1373

1383−{-# INLINE parseKChunks #-}

1374+{-# INLINE chunkParse #-}

1384−parseKChunks :: (Monad m, Unbox a) =>

1375+chunkParse :: (Monad m, Unbox a) =>

1385 ParserK.Parser a m b -> Stream m (Array a) -> m (Either ParseError b)

1376 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

1387

1378

1388-------------------------------------------------------------------------------

1379-------------------------------------------------------------------------------

1389-- Sorting

1380-- Sorting

src/Streamly/Internal/Data/Stream/IsStream/Eliminate.hs+1−1

@@ -170,7 +170,7 @@ import qualified Streamly.Internal.Data.Array as A

170import qualified Streamly.Internal.Data.Stream.Serial as Stream

171import qualified Streamly.Internal.Data.Fold as FL

172import qualified Streamly.Internal.Data.Parser.ParserD as PRD

173−import qualified Streamly.Internal.Data.Parser.ParserK.Type as PRK

173+-- import qualified Streamly.Internal.Data.Parser.ParserK.Type as PRK

174import qualified Streamly.Internal.Data.Stream.IsStream.Type as IsStream

175import qualified Streamly.Internal.Data.Stream.StreamD as D

176 (foldr1, foldlT, foldlM', mapM_, null, head, headElse, last, elem