@@ -84,6 +84,7 @@ import Streamly.Internal.Data.Parser (ParseError(..))
8484
8585import qualified Streamly.Internal.Data.Parser as PR
8686import qualified Streamly.Internal.Data.Parser.ParserD as PRD
87+import qualified Streamly.Internal.Data.Stream.StreamD.Nesting as Nesting
8788
8889import Prelude hiding
8990 ( all, any, elem, foldr, foldr1, head, last, lookup, mapM, mapM_
@@ -150,15 +151,18 @@ parse_
150151 => PRD.Parser m a b
151152 -> Stream m a
152153 -> m (b, Stream m a)
153−parse_ (PRD.Parser pstep initial extract) (Stream step state) = do
154+parse_ (PRD.Parser pstep initial extract) stream@(Stream step state) = do
154155 res <- initial
155156 case res of
156157 PRD.IPartial s -> go SPEC state (List []) s
157− PRD.IDone b -> return (b, Stream (\_ _ -> return Stop) ())
158+ PRD.IDone b -> return (b, stream)
158159 PRD.IError err -> throwM $ ParseError err
159160
160161 where
161162
163+ -- "buf" contains last few items in the stream that we may have to
164+ -- backtrack to.
165+ --
162166 -- XXX currently we are using a dumb list based approach for backtracking
163167 -- buffer. This can be replaced by a sliding/ring buffer using Data.Array.
164168 -- That will allow us more efficient random back and forth movement.
@@ -181,7 +185,14 @@ parse_ (PRD.Parser pstep initial extract) (Stream step state) = do
181185 let (src0, buf1) = splitAt n (x:getList buf)
182186 src = Prelude.reverse src0
183187 gobuf SPEC s (List buf1) (List src) pst1
184− PR.Done _ b -> return (b, Stream step_rest (Left (s, buf)))
188+ PR.Done 0 b -> return (b, Stream step st)
189+ PR.Done n b -> do
190+ assert (n <= length (x:getList buf)) (return ())
191+ let src0 = Prelude.take n (x:getList buf)
192+ src = Prelude.reverse src0
193+ -- XXX This would make it quadratic. We should probably
194+ -- use StreamK if we have to append many times.
195+ return (b, Nesting.append (fromList src) (Stream step s))
185196 PR.Error err -> throwM $ ParseError err
186197 Skip s -> go SPEC s buf pst
187198 Stop -> do
@@ -206,20 +217,13 @@ parse_ (PRD.Parser pstep initial extract) (Stream step state) = do
206217 let (src0, buf1) = splitAt n (x:getList buf)
207218 src = Prelude.reverse src0 ++ xs
208219 gobuf SPEC s (List buf1) (List src) pst1
209− PR.Done _ b -> return (b, Stream step_rest (Left (s, buf)))
220+ PR.Done n b -> do
221+ assert (n <= length (x:getList buf)) (return ())
222+ let src0 = Prelude.take n (x:getList buf)
223+ src = Prelude.reverse src0
224+ return (b, Nesting.append (fromList src) (Stream step s))
210225 PR.Error err -> throwM $ ParseError err
211226
212− {-# INLINE_LATE step_rest #-}
213− step_rest _ (Left (st, List [])) = return $ Skip (Right st)
214− step_rest _ (Left (st, List (x:[]))) = return $ Yield x (Right st)
215− step_rest _ (Left (st, List (x:xs))) = return $ Yield x (Left (st, List xs))
216− step_rest gst (Right st) = do
217− r <- step gst st
218− return $ case r of
219− Yield x s -> Yield x (Right s)
220− Skip s -> Skip (Right s)
221− Stop -> Stop
222−
223227------------------------------------------------------------------------------
224228-- Specialized Folds
225229------------------------------------------------------------------------------