@@ -77,7 +77,6 @@ where
77#include "inline.hs"
77#include "inline.hs"
79import Control.Exception (assert)
79import Control.Exception (assert)
80−import Control.Monad.Catch (MonadThrow, throwM)
81import GHC.Exts (SpecConstrAnnotation(..))
80import GHC.Exts (SpecConstrAnnotation(..))
82import GHC.Types (SPEC(..))
81import GHC.Types (SPEC(..))
83import Streamly.Internal.Data.Parser (ParseError(..))
82import Streamly.Internal.Data.Parser (ParseError(..))
@@ -141,10 +140,10 @@ newtype List a = List {getList :: [a]}
141-- | Run a 'Parse' over a stream.
140-- | Run a 'Parse' over a stream.
142{-# INLINE_NORMAL parse #-}
141{-# INLINE_NORMAL parse #-}
144− :: MonadThrow m
143+ :: Monad m
145 => PRD.Parser a m b
144 => PRD.Parser a m b
146 -> Stream m a
145 -> Stream m a
147− -> m b
146+ -> m (Either ParseError b)
148parse parser strm = do
147parse parser strm = do
149 (b, _) <- parseBreak parser strm
148 (b, _) <- parseBreak parser strm
@@ -152,16 +151,16 @@ parse parser strm = do
152-- | Run a 'Parse' over a stream and return rest of the Stream.
151-- | Run a 'Parse' over a stream and return rest of the Stream.
153{-# INLINE_NORMAL parseBreak #-}
152{-# INLINE_NORMAL parseBreak #-}
154parseBreak
153parseBreak
155− :: MonadThrow m
154+ :: Monad m
156 => PRD.Parser a m b
155 => PRD.Parser a m b
157 -> Stream m a
156 -> Stream m a
158− -> m (b, Stream m a)
157+ -> m (Either ParseError b, Stream m a)
159parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
158parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
160 res <- initial
159 res <- initial
161 case res of
160 case res of
162 PRD.IPartial s -> go SPEC state (List []) s
161 PRD.IPartial s -> go SPEC state (List []) s
163− PRD.IDone b -> return (b, stream)
162+ PRD.IDone b -> return (Right b, stream)
164− PRD.IError err -> throwM $ ParseError err
163+ PRD.IError err -> return (Left (ParseError err), stream)
@@ -190,15 +189,18 @@ parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
190 let (src0, buf1) = splitAt n (x:getList buf)
189 let (src0, buf1) = splitAt n (x:getList buf)
191 src = Prelude.reverse src0
190 src = Prelude.reverse src0
192 gobuf SPEC s (List buf1) (List src) pst1
191 gobuf SPEC s (List buf1) (List src) pst1
193− PR.Done 0 b -> return (b, Stream step st)
192+ PR.Done 0 b -> return $ (Right b, Stream step s)
194 PR.Done n b -> do
193 PR.Done n b -> do
195 assert (n <= length (x:getList buf)) (return ())
194 assert (n <= length (x:getList buf)) (return ())
196 let src0 = Prelude.take n (x:getList buf)
195 let src0 = Prelude.take n (x:getList buf)
197 src = Prelude.reverse src0
196 src = Prelude.reverse src0
198 -- XXX This would make it quadratic. We should probably
197 -- XXX This would make it quadratic. We should probably
199 -- use StreamK if we have to append many times.
198 -- use StreamK if we have to append many times.
200− return (b, Nesting.append (fromList src) (Stream step s))
201+ Nesting.append (fromList src) (Stream step s))
201− PR.Error err -> throwM $ ParseError err
202+ PR.Error err ->
203+ return (Left (ParseError err), Stream step s)
202 Skip s -> go SPEC s buf pst
204 Skip s -> go SPEC s buf pst
203 Stop -> goStop buf pst
205 Stop -> goStop buf pst
@@ -218,13 +220,13 @@ parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
218 PR.Continue n _ -> do
220 PR.Continue n _ -> do
219 error $ "parseBreak: parser bug, go1: Continue n = " ++ show n
221 error $ "parseBreak: parser bug, go1: Continue n = " ++ show n
220 PR.Done 0 b -> do
222 PR.Done 0 b -> do
221− return (b, Stream step s)
223+ return (Right b, Stream step s)
222 PR.Done 1 b -> do
224 PR.Done 1 b -> do
223− return (b, StreamD.cons x (Stream step s))
225+ return (Right b, StreamD.cons x (Stream step s))
224 PR.Done n _ -> do
226 PR.Done n _ -> do
225 error $ "parseBreak: parser bug, go1: Done n = " ++ show n
227 error $ "parseBreak: parser bug, go1: Done n = " ++ show n
226 PR.Error err ->
228 PR.Error err ->
227− throwM $ ParseError err
229+ return (Left (ParseError err), Stream step s)
229 gobuf !_ s buf (List []) !pst = go SPEC s buf pst
231 gobuf !_ s buf (List []) !pst = go SPEC s buf pst
230 gobuf !_ s buf (List (x:xs)) !pst = do
232 gobuf !_ s buf (List (x:xs)) !pst = do
@@ -248,8 +250,8 @@ parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
248 assert (n <= length (x:getList buf)) (return ())
250 assert (n <= length (x:getList buf)) (return ())
249 let src0 = Prelude.take n (x:getList buf)
251 let src0 = Prelude.take n (x:getList buf)
250 src = Prelude.reverse src0
252 src = Prelude.reverse src0
251− return (b, Nesting.append (fromList src) (Stream step s))
253+ return (Right b, Nesting.append (fromList src) (Stream step s))
252− PR.Error err -> throwM $ ParseError err
254+ PR.Error err -> return (Left (ParseError err), Stream step s)
254 -- This is simplified gobuf
256 -- This is simplified gobuf
255 goExtract !_ buf (List []) !pst = goStop buf pst
257 goExtract !_ buf (List []) !pst = goStop buf pst
@@ -274,8 +276,8 @@ parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
274 assert (n <= length (x:getList buf)) (return ())
276 assert (n <= length (x:getList buf)) (return ())
275 let src0 = Prelude.take n (x:getList buf)
277 let src0 = Prelude.take n (x:getList buf)
276 src = Prelude.reverse src0
278 src = Prelude.reverse src0
277− return (b, fromList src)
279+ return (Right b, fromList src)
278− PR.Error err -> throwM $ ParseError err
280+ PR.Error err -> return (Left (ParseError err), fromList (x:xs))
280 -- This is simplified goExtract
282 -- This is simplified goExtract
281 -- XXX Use SPEC?
283 -- XXX Use SPEC?
@@ -290,13 +292,13 @@ parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
290 let (src0, buf1) = splitAt n (getList buf)
292 let (src0, buf1) = splitAt n (getList buf)
291 src = Prelude.reverse src0
293 src = Prelude.reverse src0
292 goExtract SPEC (List buf1) (List src) pst1
294 goExtract SPEC (List buf1) (List src) pst1
293− PR.Done 0 b -> return (b, StreamD.nil)
295+ PR.Done 0 b -> return (Right b, StreamD.nil)
294 PR.Done n b -> do
296 PR.Done n b -> do
295 assert (n <= length (getList buf)) (return ())
297 assert (n <= length (getList buf)) (return ())
296 let src0 = Prelude.take n (getList buf)
298 let src0 = Prelude.take n (getList buf)
297 src = Prelude.reverse src0
299 src = Prelude.reverse src0
298− return (b, fromList src)
300+ return (Right b, fromList src)
299− PR.Error err -> throwM $ ParseError err
301+ PR.Error err -> return (Left (ParseError err), fromList (getList buf))
301------------------------------------------------------------------------------
303------------------------------------------------------------------------------
302-- Specialized Folds
304-- Specialized Folds