@@ -77,7 +77,6 @@ where
7777#include "inline.hs"
7878
7979import Control.Exception (assert)
80−import Control.Monad.Catch (MonadThrow, throwM)
8180import GHC.Exts (SpecConstrAnnotation(..))
8281import GHC.Types (SPEC(..))
8382import Streamly.Internal.Data.Parser (ParseError(..))
@@ -141,10 +140,10 @@ newtype List a = List {getList :: [a]}
141140-- | Run a 'Parse' over a stream.
142141{-# INLINE_NORMAL parse #-}
143142parse
144− :: MonadThrow m
143+ :: Monad m
145144 => PRD.Parser a m b
146145 -> Stream m a
147− -> m b
146+ -> m (Either ParseError b)
148147parse parser strm = do
149148 (b, _) <- parseBreak parser strm
150149 return b
@@ -152,16 +151,16 @@ parse parser strm = do
152151-- | Run a 'Parse' over a stream and return rest of the Stream.
153152{-# INLINE_NORMAL parseBreak #-}
154153parseBreak
155− :: MonadThrow m
154+ :: Monad m
156155 => PRD.Parser a m b
157156 -> Stream m a
158− -> m (b, Stream m a)
157+ -> m (Either ParseError b, Stream m a)
159158parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
160159 res <- initial
161160 case res of
162161 PRD.IPartial s -> go SPEC state (List []) s
163− PRD.IDone b -> return (b, stream)
164− PRD.IError err -> throwM $ ParseError err
162+ PRD.IDone b -> return (Right b, stream)
163+ PRD.IError err -> return (Left (ParseError err), stream)
165164
166165 where
167166
@@ -190,15 +189,18 @@ parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
190189 let (src0, buf1) = splitAt n (x:getList buf)
191190 src = Prelude.reverse src0
192191 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)
194193 PR.Done n b -> do
195194 assert (n <= length (x:getList buf)) (return ())
196195 let src0 = Prelude.take n (x:getList buf)
197196 src = Prelude.reverse src0
198197 -- XXX This would make it quadratic. We should probably
199198 -- use StreamK if we have to append many times.
200− return (b, Nesting.append (fromList src) (Stream step s))
201− PR.Error err -> throwM $ ParseError err
199+ return
200+ ( Right b,
201+ Nesting.append (fromList src) (Stream step s))
202+ PR.Error err ->
203+ return (Left (ParseError err), Stream step s)
202204 Skip s -> go SPEC s buf pst
203205 Stop -> goStop buf pst
204206
@@ -218,13 +220,13 @@ parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
218220 PR.Continue n _ -> do
219221 error $ "parseBreak: parser bug, go1: Continue n = " ++ show n
220222 PR.Done 0 b -> do
221− return (b, Stream step s)
223+ return (Right b, Stream step s)
222224 PR.Done 1 b -> do
223− return (b, StreamD.cons x (Stream step s))
225+ return (Right b, StreamD.cons x (Stream step s))
224226 PR.Done n _ -> do
225227 error $ "parseBreak: parser bug, go1: Done n = " ++ show n
226228 PR.Error err ->
227− throwM $ ParseError err
229+ return (Left (ParseError err), Stream step s)
228230
229231 gobuf !_ s buf (List []) !pst = go SPEC s buf pst
230232 gobuf !_ s buf (List (x:xs)) !pst = do
@@ -248,8 +250,8 @@ parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
248250 assert (n <= length (x:getList buf)) (return ())
249251 let src0 = Prelude.take n (x:getList buf)
250252 src = Prelude.reverse src0
251− return (b, Nesting.append (fromList src) (Stream step s))
252− PR.Error err -> throwM $ ParseError err
253+ return (Right b, Nesting.append (fromList src) (Stream step s))
254+ PR.Error err -> return (Left (ParseError err), Stream step s)
253255
254256 -- This is simplified gobuf
255257 goExtract !_ buf (List []) !pst = goStop buf pst
@@ -274,8 +276,8 @@ parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
274276 assert (n <= length (x:getList buf)) (return ())
275277 let src0 = Prelude.take n (x:getList buf)
276278 src = Prelude.reverse src0
277− return (b, fromList src)
278− PR.Error err -> throwM $ ParseError err
279+ return (Right b, fromList src)
280+ PR.Error err -> return (Left (ParseError err), fromList (x:xs))
279281
280282 -- This is simplified goExtract
281283 -- XXX Use SPEC?
@@ -290,13 +292,13 @@ parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do
290292 let (src0, buf1) = splitAt n (getList buf)
291293 src = Prelude.reverse src0
292294 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)
294296 PR.Done n b -> do
295297 assert (n <= length (getList buf)) (return ())
296298 let src0 = Prelude.take n (getList buf)
297299 src = Prelude.reverse src0
298− return (b, fromList src)
299− PR.Error err -> throwM $ ParseError err
300+ return (Right b, fromList src)
301+ PR.Error err -> return (Left (ParseError err), fromList (getList buf))
300302
301303------------------------------------------------------------------------------
302304-- Specialized Folds