60d3228 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Combine Yield and YieldB constructors

60d3228Harendra Kumar6 years ago

bin/bench-exec-one.sh+2−2

compare with master

unifiedsplit

@@ -64,8 +64,8 @@ bench_rts_opts_specific () {

64 Prelude.WAsync/o-n-space/monad-outer-product/*) echo -n "-K4M" ;;

66 # XXX need to investigate these, taking too much stack

67− Data.Parser.ParserD/o-1-space/some) echo -n "-K1M" ;;

67+ Data.Parser.ParserD/o-1-space/some) echo -n "-K8M" ;;

68− Data.Parser/o-1-space/some) echo -n "-K1M" ;;

68+ Data.Parser/o-1-space/some) echo -n "-K8M" ;;

69 Data.Parser.ParserD/o-1-space/manyTill) echo -n "-K4M" ;;

70 Data.Parser/o-1-space/manyTill) echo -n "-K4M" ;;

src/Streamly/Internal/Data/Parser/ParserD.hs+2−5

@@ -588,8 +588,7 @@ lookAhead (Parser step1 initial1 _) =

588 r <- step1 st a

589 let cnt1 = cnt + 1

590 return $ case r of

591− Yield _ s -> Skip 0 (Tuple' cnt1 s)

592− YieldB n s -> Skip n (Tuple' (cnt1 - n) s)

591+ Yield n s -> Skip n (Tuple' (cnt1 - n) s)

593 Skip n s -> Skip n (Tuple' (cnt1 - n) s)

592 Skip n s -> Skip n (Tuple' (cnt1 - n) s)

594 Stop _ b -> Stop cnt1 b

593 Stop _ b -> Stop cnt1 b

595 Error err -> Error err

594 Error err -> Error err

@@ -713,7 +712,6 @@ manyTill (Fold fstep finitial fextract)

713 r <- stepR st a

712 r <- stepR st a

714 case r of

713 case r of

715 Yield n s -> return $ Yield n (ManyTillR 0 fs s)

714 Yield n s -> return $ Yield n (ManyTillR 0 fs s)

716− YieldB n s -> return $ YieldB n (ManyTillR 0 fs s)

717 Skip n s -> do

715 Skip n s -> do

718 assert (cnt + 1 - n >= 0) (return ())

716 assert (cnt + 1 - n >= 0) (return ())

719 return $ Skip n (ManyTillR (cnt + 1 - n) fs s)

717 return $ Skip n (ManyTillR (cnt + 1 - n) fs s)

@@ -728,12 +726,11 @@ manyTill (Fold fstep finitial fextract)

728 r <- stepL st a

726 r <- stepL st a

729 case r of

727 case r of

730 Yield n s -> return $ Yield n (ManyTillL fs s)

728 Yield n s -> return $ Yield n (ManyTillL fs s)

731− YieldB n s -> return $ YieldB n (ManyTillL fs s)

732 Skip n s -> return $ Skip n (ManyTillL fs s)

729 Skip n s -> return $ Skip n (ManyTillL fs s)

733 Stop n b -> do

730 Stop n b -> do

734 fs1 <- fstep fs b

731 fs1 <- fstep fs b

735 l <- initialR

732 l <- initialR

736− return $ YieldB n (ManyTillR 0 fs1 l)

733+ return $ Yield n (ManyTillR 0 fs1 l)

737 Error err -> return $ Error err

734 Error err -> return $ Error err

738

735

739 extract (ManyTillL fs sR) = extractL sR >>= fstep fs >>= fextract

736 extract (ManyTillL fs sR) = extractL sR >>= fstep fs >>= fextract

src/Streamly/Internal/Data/Parser/ParserD/Tee.hs+15−15

@@ -137,10 +137,10 @@ teeWith zf (Parser stepL initialL extractL) (Parser stepR initialR extractR) =

137 useStream buf inp1 inp2 stp st y = do

138 (buf1, r, inp11, inp21) <- consume buf inp1 inp2 stp st y

139 case r of

140+ Yield 0 s ->

141+ let state = ([], StepState s, inp11, inp21)

142+ in return (state, Yld 0)

140 Yield n s ->

143 Yield n s ->

141− let state = (Prelude.take n buf1, StepState s, inp11, inp21)

142− in assert (n <= length buf1) (return (state, Yld n))

143− YieldB n s ->

144 let src0 = Prelude.take n buf1

145 src = Prelude.reverse src0

146 state = ([], StepState s, src ++ inp11, inp21)

@@ -261,10 +261,10 @@ teeWithFst zf (Parser stepL initialL extractL)

261 useStream buf inp1 inp2 stp st y = do

262 (buf1, r, inp11, inp21) <- consume buf inp1 inp2 stp st y

263 case r of

264− Yield n s ->

264+ Yield 0 s ->

265− let state = (Prelude.take n buf1, StepState s, inp11, inp21)

265+ let state = ([], StepState s, inp11, inp21)

266− in assert (n <= length buf1) (return (state, Yld n))

266+ in return (state, Yld 0)

267− YieldB _ _ -> undefined

267+ Yield n _ -> return (undefined, Yld n) -- Not implemented

268 Stop n b ->

269 let state = (Prelude.take n buf1, StepResult b, inp11, inp21)

270 in assert (n <= length buf1) (return (state, Stp n))

@@ -383,10 +383,10 @@ shortest (Parser stepL initialL extractL) (Parser stepR initialR _) =

383 useStream buf inp1 inp2 stp st y = do

384 (buf1, r, inp11, inp21) <- consume buf inp1 inp2 stp st y

385 case r of

386− Yield n s ->

386+ Yield 0 s ->

387− let state = (Prelude.take n buf1, StepState s, inp11, inp21)

387+ let state = ([], StepState s, inp11, inp21)

388− in assert (n <= length buf1) (return (state, Yld n))

388+ in return (state, Yld 0)

389− YieldB _ _ -> undefined

389+ Yield n _ -> return (undefined, Yld n) -- Not implemented

390 Stop n b ->

391 let state = (Prelude.take n buf1, StepResult b, inp11, inp21)

392 in assert (n <= length buf1) (return (state, Stp n))

@@ -460,10 +460,10 @@ longest (Parser stepL initialL extractL) (Parser stepR initialR extractR) =

460 useStream buf inp1 inp2 stp st y = do

461 (buf1, r, inp11, inp21) <- consume buf inp1 inp2 stp st y

462 case r of

463− Yield n s ->

463+ Yield 0 s ->

464− let state = (Prelude.take n buf1, StepState s, inp11, inp21)

464+ let state = ([], StepState s, inp11, inp21)

465− in assert (n <= length buf1) (return (state, Yld n))

465+ in return (state, Yld 0)

466− YieldB _ _ -> undefined

466+ Yield n _ -> return (undefined, Yld n) -- Not implemented

467 Stop n b ->

468 let state = (Prelude.take n buf1, StepResult b, inp11, inp21)

469 in assert (n <= length buf1) (return (state, Stp n))

src/Streamly/Internal/Data/Parser/ParserD/Types.hs+14−34

@@ -161,20 +161,13 @@ import Streamly.Internal.Data.Strict (Tuple3'(..))

161--

162{-# ANN type Step Fuse #-}

163data Step s b =

164− Yield Int s

165− -- ^ Trim the backtracking buffer keeping only most recent @n@ items.

166− -- @Yield n state@ indicates that the parser has yielded a new result

167− -- which is a point of no return. The result can be extracted using

168− -- @extract@. The driver drops the buffer except @n@ most recent

169− -- elements. The rule is that if a parser has yielded at least once it

170− -- cannot return a failure result.

171−

172− | YieldB Int s

164+ Yield Int s

173 -- ^ Go back by @n@ items in the input buffer and drop the rest.

165 -- ^ Go back by @n@ items in the input buffer and drop the rest.

174− -- @YieldB n state@ indicates that the parser has yielded a new result

166+ -- @Yield n state@ indicates that the parser has yielded a new result

175 -- which is a point of no return. The result can be extracted using

167 -- which is a point of no return. The result can be extracted using

176 -- @extract@. The driver moves back the current position of the cursor by

168 -- @extract@. The driver moves back the current position of the cursor by

177− -- @n@ elements and drops any buffer before that.

169+ -- @n@ elements and drops any buffer before that. The rule is that if a

170+ -- parser has yielded at least once it cannot return a failure result.

178

171

179 -- only rewind

172 -- only rewind

180 | Skip Int s

173 | Skip Int s

@@ -202,7 +195,6 @@ data Step s b =

202instance Functor (Step s) where

195instance Functor (Step s) where

203 {-# INLINE fmap #-}

196 {-# INLINE fmap #-}

204 fmap _ (Yield n s) = Yield n s

197 fmap _ (Yield n s) = Yield n s

205− fmap _ (YieldB n s) = YieldB n s

206 fmap _ (Skip n s) = Skip n s

198 fmap _ (Skip n s) = Skip n s

207 fmap f (Stop n b) = Stop n (f b)

199 fmap f (Stop n b) = Stop n (f b)

208 fmap _ (Error err) = Error err

200 fmap _ (Error err) = Error err

@@ -303,8 +295,7 @@ splitWith func (Parser stepL initialL extractL)

303 -- e.g. in ((,) <$> p1 <*> p2) <|> p3, if p2 fails we have to

295 -- e.g. in ((,) <$> p1 <*> p2) <|> p3, if p2 fails we have to

304 -- backtrack and start running p3. So we need to keep the input

296 -- backtrack and start running p3. So we need to keep the input

305 -- buffered until we know that the applicative cannot fail.

297 -- buffered until we know that the applicative cannot fail.

306− Yield _ s -> return $ Skip 0 (SeqParseL s)

307− YieldB n s -> return $ Skip n (SeqParseL s)

298+ Yield n s -> return $ Skip n (SeqParseL s)

308 Skip n s -> return $ Skip n (SeqParseL s)

299 Skip n s -> return $ Skip n (SeqParseL s)

309 Stop n b -> Skip n <$> (SeqParseR (func b) <$> initialR)

300 Stop n b -> Skip n <$> (SeqParseR (func b) <$> initialR)

310 Error err -> return $ Error err

301 Error err -> return $ Error err

@@ -313,7 +304,6 @@ splitWith func (Parser stepL initialL extractL)

313 r <- stepR st a

304 r <- stepR st a

314 return $ case r of

305 return $ case r of

315 Yield n s -> Yield n (SeqParseR f s)

306 Yield n s -> Yield n (SeqParseR f s)

316− YieldB n s -> YieldB n (SeqParseR f s)

317 Skip n s -> Skip n (SeqParseR f s)

307 Skip n s -> Skip n (SeqParseR f s)

318 Stop n b -> Stop n (f b)

308 Stop n b -> Stop n (f b)

319 Error err -> Error err

309 Error err -> Error err

@@ -348,8 +338,7 @@ split_ (Parser stepL initialL extractL) (Parser stepR initialR extractR) =

348 (\r i -> case r of

338 (\r i -> case r of

349 -- Note: this leads to buffering even if we are not in an

339 -- Note: this leads to buffering even if we are not in an

350 -- Alternative composition.

340 -- Alternative composition.

351− Yield _ s -> Skip 0 (SeqAL s)

352− YieldB n s -> Skip n (SeqAL s)

341+ Yield n s -> Skip n (SeqAL s)

353 Skip n s -> Skip n (SeqAL s)

342 Skip n s -> Skip n (SeqAL s)

354 Stop n _ -> Skip n (SeqAR i)

343 Stop n _ -> Skip n (SeqAR i)

355 -- XXX should we sequence initialR monadically?

344 -- XXX should we sequence initialR monadically?

@@ -358,7 +347,6 @@ split_ (Parser stepL initialL extractL) (Parser stepR initialR extractR) =

358 step (SeqAR st) a = do

347 step (SeqAR st) a = do

359 (\r -> case r of

348 (\r -> case r of

360 Yield n s -> Yield n (SeqAR s)

349 Yield n s -> Yield n (SeqAR s)

361− YieldB n s -> YieldB n (SeqAR s)

362 Skip n s -> Skip n (SeqAR s)

350 Skip n s -> Skip n (SeqAR s)

363 Stop n b -> Stop n b

351 Stop n b -> Stop n b

364 Error err -> Error err) <$> stepR st a

352 Error err -> Error err) <$> stepR st a

@@ -413,7 +401,6 @@ alt (Parser stepL initialL extractL) (Parser stepR initialR extractR) =

413 r <- stepL st a

401 r <- stepL st a

414 case r of

402 case r of

415 Yield n s -> return $ Yield n (AltParseL 0 s)

403 Yield n s -> return $ Yield n (AltParseL 0 s)

416− YieldB n s -> return $ YieldB n (AltParseL 0 s)

417 Skip n s -> do

404 Skip n s -> do

418 assert (cnt + 1 - n >= 0) (return ())

405 assert (cnt + 1 - n >= 0) (return ())

419 return $ Skip n (AltParseL (cnt + 1 - n) s)

406 return $ Skip n (AltParseL (cnt + 1 - n) s)

@@ -426,7 +413,6 @@ alt (Parser stepL initialL extractL) (Parser stepR initialR extractR) =

426 r <- stepR st a

413 r <- stepR st a

427 return $ case r of

414 return $ case r of

428 Yield n s -> Yield n (AltParseR s)

415 Yield n s -> Yield n (AltParseR s)

429− YieldB n s -> YieldB n (AltParseR s)

430 Skip n s -> Skip n (AltParseR s)

416 Skip n s -> Skip n (AltParseR s)

431 Stop n b -> Stop n b

417 Stop n b -> Stop n b

432 Error err -> Error err

418 Error err -> Error err

@@ -455,8 +441,7 @@ splitMany (Fold fstep finitial fextract) (Parser step1 initial1 extract1) =

455 r <- step1 st a

441 r <- step1 st a

456 let cnt1 = cnt + 1

442 let cnt1 = cnt + 1

457 case r of

443 case r of

458− Yield _ s -> return $ Skip 0 (Tuple3' s cnt1 fs)

459− YieldB n s -> do

444+ Yield n s -> do

460 assert (cnt1 - n >= 0) (return ())

445 assert (cnt1 - n >= 0) (return ())

461 return $ Skip n (Tuple3' s (cnt1 - n) fs)

446 return $ Skip n (Tuple3' s (cnt1 - n) fs)

462 Skip n s -> do

447 Skip n s -> do

@@ -465,7 +450,7 @@ splitMany (Fold fstep finitial fextract) (Parser step1 initial1 extract1) =

465 Stop n b -> do

450 Stop n b -> do

466 s <- initial1

451 s <- initial1

467 fs1 <- fstep fs b

452 fs1 <- fstep fs b

468− return $ YieldB n (Tuple3' s 0 fs1)

453+ return $ Yield n (Tuple3' s 0 fs1)

469 Error _ -> do

454 Error _ -> do

470 xs <- fextract fs

455 xs <- fextract fs

471 return $ Stop cnt1 xs

456 return $ Stop cnt1 xs

@@ -497,29 +482,27 @@ splitSome (Fold fstep finitial fextract) (Parser step1 initial1 extract1) =

497 step (Tuple3' st _ (Left fs)) a = do

482 step (Tuple3' st _ (Left fs)) a = do

498 r <- step1 st a

483 r <- step1 st a

499 case r of

484 case r of

500− Yield _ s -> return $ Skip 0 (Tuple3' s undefined (Left fs))

501− YieldB n s -> return $ Skip n (Tuple3' s undefined (Left fs))

485+ Yield n s -> return $ Skip n (Tuple3' s undefined (Left fs))

502 Skip n s -> return $ Skip n (Tuple3' s undefined (Left fs))

486 Skip n s -> return $ Skip n (Tuple3' s undefined (Left fs))

503 Stop n b -> do

487 Stop n b -> do

504 s <- initial1

488 s <- initial1

505 fs1 <- fstep fs b

489 fs1 <- fstep fs b

506− return $ YieldB n (Tuple3' s 0 (Right fs1))

490+ return $ Yield n (Tuple3' s 0 (Right fs1))

507 Error err -> return $ Error err

491 Error err -> return $ Error err

508 step (Tuple3' st cnt (Right fs)) a = do

492 step (Tuple3' st cnt (Right fs)) a = do

509 r <- step1 st a

493 r <- step1 st a

510 let cnt1 = cnt + 1

494 let cnt1 = cnt + 1

511 case r of

495 case r of

512− Yield _ s -> return $ Yield 0 (Tuple3' s cnt1 (Right fs))

513− YieldB n s -> do

496+ Yield n s -> do

514 assert (cnt1 - n >= 0) (return ())

497 assert (cnt1 - n >= 0) (return ())

515− return $ YieldB n (Tuple3' s (cnt1 - n) (Right fs))

498+ return $ Yield n (Tuple3' s (cnt1 - n) (Right fs))

516 Skip n s -> do

499 Skip n s -> do

517 assert (cnt1 - n >= 0) (return ())

500 assert (cnt1 - n >= 0) (return ())

518 return $ Skip n (Tuple3' s (cnt1 - n) (Right fs))

501 return $ Skip n (Tuple3' s (cnt1 - n) (Right fs))

519 Stop n b -> do

502 Stop n b -> do

520 s <- initial1

503 s <- initial1

521 fs1 <- fstep fs b

504 fs1 <- fstep fs b

522− return $ YieldB n (Tuple3' s 0 (Right fs1))

505+ return $ Yield n (Tuple3' s 0 (Right fs1))

523 Error _ -> Stop cnt1 <$> fextract fs

506 Error _ -> Stop cnt1 <$> fextract fs

524

507

525 -- XXX The "try" may impact performance if this parser is used as a scan

508 -- XXX The "try" may impact performance if this parser is used as a scan

@@ -598,8 +581,7 @@ concatMap func (Parser stepL initialL extractL) = Parser step initial extract

598 step (ConcatParseL st) a = do

581 step (ConcatParseL st) a = do

599 r <- stepL st a

582 r <- stepL st a

600 return $ case r of

583 return $ case r of

601− Yield _ s -> Skip 0 (ConcatParseL s)

602− YieldB n s -> Skip n (ConcatParseL s)

584+ Yield n s -> Skip n (ConcatParseL s)

603 Skip n s -> Skip n (ConcatParseL s)

585 Skip n s -> Skip n (ConcatParseL s)

604 Stop n b -> Skip n (ConcatParseR (func b))

586 Stop n b -> Skip n (ConcatParseR (func b))

605 Error err -> Error err

587 Error err -> Error err

@@ -610,8 +592,6 @@ concatMap func (Parser stepL initialL extractL) = Parser step initial extract

610 return $ case r of

592 return $ case r of

611 Yield n s ->

593 Yield n s ->

612 Yield n (ConcatParseR (Parser stepR (return s) extractR))

594 Yield n (ConcatParseR (Parser stepR (return s) extractR))

613− YieldB n s ->

614− YieldB n (ConcatParseR (Parser stepR (return s) extractR))

615 Skip n s ->

595 Skip n s ->

616 Skip n (ConcatParseR (Parser stepR (return s) extractR))

596 Skip n (ConcatParseR (Parser stepR (return s) extractR))

617 Stop n b -> Stop n b

597 Stop n b -> Stop n b

src/Streamly/Internal/Data/Stream/StreamD.hs+14−31

@@ -998,11 +998,8 @@ parselMx' pstep initial extract (Stream step state) = do

998 Yield x s -> do

999 pRes <- pstep pst x

1000 case pRes of

1001− -- PR.Yield 0 pst1 -> go SPEC s [] pst1

1001+ PR.Yield 0 pst1 -> go SPEC s [] pst1

1002 PR.Yield n pst1 -> do

1003− assert (n <= length (x:buf)) (return ())

1004− go SPEC s (Prelude.take n (x:buf)) pst1

1005− PR.YieldB n pst1 -> do

1006 assert (n <= length (x:buf)) (return ())

1003 assert (n <= length (x:buf)) (return ())

1007 let src0 = Prelude.take n (x:buf)

1004 let src0 = Prelude.take n (x:buf)

1008 src = Prelude.reverse src0

1005 src = Prelude.reverse src0

@@ -1022,11 +1019,9 @@ parselMx' pstep initial extract (Stream step state) = do

1022 gobuf !_ s buf (x:xs) !pst = do

1019 gobuf !_ s buf (x:xs) !pst = do

1023 pRes <- pstep pst x

1020 pRes <- pstep pst x

1024 case pRes of

1021 case pRes of

1025− -- PR.Yield 0 pst1 -> go SPEC s [] pst1

1022+ PR.Yield 0 pst1 ->

1023+ gobuf SPEC s [] xs pst1

1026 PR.Yield n pst1 -> do

1024 PR.Yield n pst1 -> do

1027− assert (n <= length (x:buf)) (return ())

1028− gobuf SPEC s (Prelude.take n (x:buf)) xs pst1

1029− PR.YieldB n pst1 -> do

1030 assert (n <= length (x:buf)) (return ())

1025 assert (n <= length (x:buf)) (return ())

1031 let src0 = Prelude.take n (x:buf)

1026 let src0 = Prelude.take n (x:buf)

1032 src = Prelude.reverse src0 ++ xs

1027 src = Prelude.reverse src0 ++ xs

@@ -1082,12 +1077,9 @@ parseMany (PRD.Parser pstep initial extract) (Stream step state) =

1082 Yield x s -> do

1077 Yield x s -> do

1083 pRes <- pstep pst x

1078 pRes <- pstep pst x

1084 case pRes of

1079 case pRes of

1085− -- PR.Yield 0 pst1 -> go SPEC s [] pst1

1080+ PR.Yield 0 pst1 ->

1081+ return $ Skip $ ParseChunksStream s [] pst1

1086 PR.Yield n pst1 -> do

1082 PR.Yield n pst1 -> do

1087− assert (n <= length (x:buf)) (return ())

1088− let buf1 = Prelude.take n (x:buf)

1089− return $ Skip $ ParseChunksStream s buf1 pst1

1090− PR.YieldB n pst1 -> do

1091 assert (n <= length (x:buf)) (return ())

1083 assert (n <= length (x:buf)) (return ())

1092 let src0 = Prelude.take n (x:buf)

1084 let src0 = Prelude.take n (x:buf)

1093 src = Prelude.reverse src0

1085 src = Prelude.reverse src0

@@ -1121,12 +1113,9 @@ parseMany (PRD.Parser pstep initial extract) (Stream step state) =

1121 stepOuter _ (ParseChunksBuf (x:xs) s buf pst) = do

1113 stepOuter _ (ParseChunksBuf (x:xs) s buf pst) = do

1122 pRes <- pstep pst x

1114 pRes <- pstep pst x

1123 case pRes of

1115 case pRes of

1124− -- PR.Yield 0 pst1 ->

1116+ PR.Yield 0 pst1 ->

1125− PR.Yield n pst1 -> do

1126− assert (n <= length (x:buf)) (return ())

1127− let buf1 = Prelude.take n (x:buf)

1128− return $ Skip $ ParseChunksBuf xs s buf1 pst1

1117+ return $ Skip $ ParseChunksBuf xs s [] pst1

1129− PR.YieldB n pst1 -> do

1118+ PR.Yield n pst1 -> do

1130 assert (n <= length (x:buf)) (return ())

1119 assert (n <= length (x:buf)) (return ())

1131 let src0 = Prelude.take n (x:buf)

1120 let src0 = Prelude.take n (x:buf)

1132 src = Prelude.reverse src0 ++ xs

1121 src = Prelude.reverse src0 ++ xs

@@ -1190,13 +1179,10 @@ parseIterate func seed (Stream step state) =

1190 pst <- initial

1179 pst <- initial

1191 pRes <- pstep pst x

1180 pRes <- pstep pst x

1192 case pRes of

1181 case pRes of

1193− -- PR.Yield 0 pst1 -> go SPEC s [] pst1

1182+ PR.Yield 0 pst1 ->

1194− PR.Yield n pst1 -> do

1195− assert (n <= length (x:buf)) (return ())

1196− let buf1 = Prelude.take n (x:buf)

1197− return $ Skip $ ConcatParseStream s buf1

1183+ return $ Skip $ ConcatParseStream s []

1198 (PRD.Parser pstep (return pst1) extract)

1184 (PRD.Parser pstep (return pst1) extract)

1199− PR.YieldB n pst1 -> do

1185+ PR.Yield n pst1 -> do

1200 assert (n <= length (x:buf)) (return ())

1186 assert (n <= length (x:buf)) (return ())

1201 let src0 = Prelude.take n (x:buf)

1187 let src0 = Prelude.take n (x:buf)

1202 src = Prelude.reverse src0

1188 src = Prelude.reverse src0

@@ -1235,13 +1221,10 @@ parseIterate func seed (Stream step state) =

1235 pst <- initial

1221 pst <- initial

1236 pRes <- pstep pst x

1222 pRes <- pstep pst x

1237 case pRes of

1223 case pRes of

1238− -- PR.Yield 0 pst1 ->

1224+ PR.Yield 0 pst1 ->

1239− PR.Yield n pst1 -> do

1240− assert (n <= length (x:buf)) (return ())

1241− let buf1 = Prelude.take n (x:buf)

1242− return $ Skip $ ConcatParseBuf xs s buf1

1225+ return $ Skip $ ConcatParseBuf xs s []

1243 (PRD.Parser pstep (return pst1) extract)

1226 (PRD.Parser pstep (return pst1) extract)

1244− PR.YieldB n pst1 -> do

1227+ PR.Yield n pst1 -> do

1245 assert (n <= length (x:buf)) (return ())

1228 assert (n <= length (x:buf)) (return ())

1246 let src0 = Prelude.take n (x:buf)

1229 let src0 = Prelude.take n (x:buf)

1247 src = Prelude.reverse src0 ++ xs

1230 src = Prelude.reverse src0 ++ xs

src/Streamly/Internal/Data/Zipper.hs+7−16

@@ -221,11 +221,8 @@ parse pstep initial extract (Zipper [] ls rs stream) =

221 yieldk x r = do

222 acc1 <- acc >>= \b -> pstep b x

223 case acc1 of

224− -- PR.Yield 0 pst1 -> go SPEC s [] pst1

224+ PR.Yield 0 pst1 -> go r [] (return pst1)

225 PR.Yield n pst1 -> do

226− assert (n <= length (x:buf)) (return ())

227− go r (Prelude.take n (x:buf)) (return pst1)

228− PR.YieldB n pst1 -> do

229 assert (n <= length (x:buf)) (return ())

226 assert (n <= length (x:buf)) (return ())

230 let src0 = Prelude.take n (x:buf)

227 let src0 = Prelude.take n (x:buf)

231 src = Prelude.reverse src0

228 src = Prelude.reverse src0

@@ -250,11 +247,9 @@ parse pstep initial extract (Zipper [] ls rs stream) =

250 r <- pst

247 r <- pst

251 pRes <- pstep r x

248 pRes <- pstep r x

252 case pRes of

249 case pRes of

253− -- PR.Yield 0 pst1 -> go SPEC s [] pst1

250+ PR.Yield 0 pst1 ->

251+ gobuf s [] xs (return pst1)

254 PR.Yield n pst1 -> do

252 PR.Yield n pst1 -> do

255− assert (n <= length (x:buf)) (return ())

256− gobuf s (Prelude.take n (x:buf)) xs (return pst1)

257− PR.YieldB n pst1 -> do

258 assert (n <= length (x:buf)) (return ())

253 assert (n <= length (x:buf)) (return ())

259 let src0 = Prelude.take n (x:buf)

254 let src0 = Prelude.take n (x:buf)

260 src = Prelude.reverse src0

255 src = Prelude.reverse src0

@@ -296,11 +291,9 @@ parse pstep initial extract (Zipper (cp:cps) ls rs stream) =

296 acc1 <- acc >>= \b -> pstep b x

291 acc1 <- acc >>= \b -> pstep b x

297 let cnt1 = cnt + 1

292 let cnt1 = cnt + 1

298 case acc1 of

293 case acc1 of

299− -- PR.Yield 0 pst1 -> go SPEC s [] pst1

294+ PR.Yield 0 pst1 ->

295+ go cnt1 r [] (return pst1)

300 PR.Yield n pst1 -> do

296 PR.Yield n pst1 -> do

301− assert (n <= length (x:buf)) (return ())

302− go cnt1 r (x:buf) (return pst1)

303− PR.YieldB n pst1 -> do

304 assert (n <= length (x:buf)) (return ())

297 assert (n <= length (x:buf)) (return ())

305 let src0 = Prelude.take n (x:buf)

298 let src0 = Prelude.take n (x:buf)

306 src = Prelude.reverse src0

299 src = Prelude.reverse src0

@@ -332,11 +325,9 @@ parse pstep initial extract (Zipper (cp:cps) ls rs stream) =

332 pRes <- pstep r x

325 pRes <- pstep r x

333 let cnt1 = cnt + 1

326 let cnt1 = cnt + 1

334 case pRes of

327 case pRes of

335− -- PR.Yield 0 pst1 -> go SPEC s [] pst1

328+ PR.Yield 0 pst1 ->

329+ gobuf cnt1 s [] xs (return pst1)

336 PR.Yield n pst1 -> do

330 PR.Yield n pst1 -> do

337− assert (n <= length (x:buf)) (return ())

338− gobuf cnt1 s (x:buf) xs (return pst1)

339− PR.YieldB n pst1 -> do

340 assert (n <= length (x:buf)) (return ())

331 assert (n <= length (x:buf)) (return ())

341 let src0 = Prelude.take n (x:buf)

332 let src0 = Prelude.take n (x:buf)

342 src = Prelude.reverse src0

333 src = Prelude.reverse src0