63ba027 · streamly · git.iko.soy

git.iko.soy/streamly

Use assertM instead of assert in Parser code

commit63ba027ce47b95d8d66f8c6c8ddabc7dc956ae25 authorHarendra Kumar <harendra@composewell.com> dateThu 11 Aug 2022, 15:13 (4 years ago) parent95fc1d2

2 files changed+26−25

compare with master

unifiedsplit

core/src/Streamly/Internal/Data/Parser/ParserD.hs+9−8 core/src/Streamly/Internal/Data/Parser/ParserD/Type.hs+17−17

core/src/Streamly/Internal/Data/Parser/ParserD.hs+9−8

@@ -196,11 +196,12 @@ module Streamly.Internal.Data.Parser.ParserD

196196 )

197197where

198198

199−import Control.Exception (assert, Exception)

199+import Control.Exception (Exception)

200200import Control.Monad (when)

201201import Control.Monad.Catch (MonadCatch, MonadThrow(..))

202202import Data.Bifunctor (first)

203203import Fusion.Plugin.Types (Fuse(..))

204+import Streamly.Internal.Control.Exception (assertM)

204205import Streamly.Internal.Data.Fold.Type (Fold(..))

205206import Streamly.Internal.Data.SVar.Type (defState)

206207import Streamly.Internal.Data.Either.Strict (Either'(..))

@@ -1704,17 +1705,17 @@ takeP lim (Parser pstep pinitial pextract) = Parser step initial extract

17041705 IError e -> return $ IError e

17051706

17061707 step (Tuple' cnt r) a = do

1707− assert (cnt < lim) (return ())

1708+ assertM (cnt < lim)

17081709 res <- pstep r a

17091710 let cnt1 = cnt + 1

17101711 case res of

17111712 Partial 0 s -> do

1712− assert (cnt1 >= 0) (return ())

1713+ assertM (cnt1 >= 0)

17131714 if cnt1 < lim

17141715 then return $ Partial 0 $ Tuple' cnt1 s

17151716 else Done 0 <$> pextract s

17161717 Continue 0 s -> do

1717− assert (cnt1 >= 0) (return ())

1718+ assertM (cnt1 >= 0)

17181719 if cnt1 < lim

17191720 then return $ Continue 0 $ Tuple' cnt1 s

17201721 -- XXX This should error out?

@@ -1731,11 +1732,11 @@ takeP lim (Parser pstep pinitial pextract) = Parser step initial extract

17311732 else Done 0 <$> pextract s

17321733 Partial n s -> do

17331734 let taken = cnt1 - n

1734− assert (taken >= 0) (return ())

1735+ assertM (taken >= 0)

17351736 return $ Partial n $ Tuple' taken s

17361737 Continue n s -> do

17371738 let taken = cnt1 - n

1738− assert (taken >= 0) (return ())

1739+ assertM (taken >= 0)

17391740 return $ Continue n $ Tuple' taken s

17401741 Done n b -> return $ Done n b

17411742 Error str -> return $ Error str

@@ -2130,7 +2131,7 @@ manyTill (Fold fstep finitial fextract)

21302131 case r of

21312132 Partial n s -> return $ Partial n (ManyTillR 0 fs s)

21322133 Continue n s -> do

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

2134+ assertM (cnt + 1 - n >= 0)

21342135 return $ Continue n (ManyTillR (cnt + 1 - n) fs s)

21352136 Done n _ -> do

21362137 b <- fextract fs

@@ -2156,7 +2157,7 @@ manyTill (Fold fstep finitial fextract)

21562157 case r of

21572158 Partial n s -> return $ Partial n (ManyTillL 0 fs s)

21582159 Continue n s -> do

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

2160+ assertM (cnt + 1 - n >= 0)

21602161 return $ Continue n (ManyTillL (cnt + 1 - n) fs s)

21612162 Done n b -> do

21622163 fs1 <- fstep fs b

core/src/Streamly/Internal/Data/Parser/ParserD/Type.hs+17−17

@@ -208,7 +208,7 @@ module Streamly.Internal.Data.Parser.ParserD.Type

208208where

209209

210210import Control.Applicative (Alternative(..), liftA2)

211−import Control.Exception (assert, Exception(..))

211+import Control.Exception (Exception(..))

212212import Control.Monad (MonadPlus(..), (>=>))

213213import Control.Monad.IO.Class (MonadIO, liftIO)

214214import Control.Monad.Reader.Class (MonadReader, ask, local)

@@ -505,15 +505,15 @@ parseDToK pstep initial extract leftover (level, count) cont = do

505505 pRes <- pstep r x

506506 case pRes of

507507 Done n b -> do

508− assert (n <= cnt1) (return ())

508+ assertM (n <= cnt1)

509509 cont (level, cnt1 - n) (K.Success n b)

510510 Error err ->

511511 cont (level, cnt1) (K.Failure err)

512512 Partial n pst1 -> do

513− assert (n <= cnt1) (return ())

513+ assertM (n <= cnt1)

514514 return $ K.Partial n (parseCont (cnt1 - n) (return pst1))

515515 Continue n pst1 -> do

516− assert (n <= cnt1) (return ())

516+ assertM (n <= cnt1)

517517 return $ K.Continue n (parseCont (cnt1 - n) (return pst1))

518518 parseCont cnt acc Nothing = do

519519 pst <- acc

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

981981 case r of

982982 Partial n s -> return $ Partial n (AltParseL 0 s)

983983 Continue n s -> do

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

984+ assertM (cnt + 1 - n >= 0)

985985 return $ Continue n (AltParseL (cnt + 1 - n) s)

986986 Done n b -> return $ Done n b

987987 Error _ -> do

@@ -1038,13 +1038,13 @@ splitMany (Parser step1 initial1 extract1) (Fold fstep finitial fextract) =

10381038 let cnt1 = cnt + 1

10391039 case r of

10401040 Partial n s -> do

1041− assert (cnt1 - n >= 0) (return ())

1041+ assertM (cnt1 - n >= 0)

10421042 return $ Continue n (Tuple3' s (cnt1 - n) fs)

10431043 Continue n s -> do

1044− assert (cnt1 - n >= 0) (return ())

1044+ assertM (cnt1 - n >= 0)

10451045 return $ Continue n (Tuple3' s (cnt1 - n) fs)

10461046 Done n b -> do

1047− assert (cnt1 - n >= 0) (return ())

1047+ assertM (cnt1 - n >= 0)

10481048 fstep fs b >>= handleCollect (Partial n) (Done n)

10491049 Error _ -> do

10501050 xs <- fextract fs

@@ -1098,13 +1098,13 @@ splitManyPost (Parser step1 initial1 extract1) (Fold fstep finitial fextract) =

10981098 let cnt1 = cnt + 1

10991099 case r of

11001100 Partial n s -> do

1101− assert (cnt1 - n >= 0) (return ())

1101+ assertM (cnt1 - n >= 0)

11021102 return $ Continue n (Tuple3' s (cnt1 - n) fs)

11031103 Continue n s -> do

1104− assert (cnt1 - n >= 0) (return ())

1104+ assertM (cnt1 - n >= 0)

11051105 return $ Continue n (Tuple3' s (cnt1 - n) fs)

11061106 Done n b -> do

1107− assert (cnt1 - n >= 0) (return ())

1107+ assertM (cnt1 - n >= 0)

11081108 fstep fs b >>= handleCollect (Partial n) (Done n)

11091109 Error _ -> do

11101110 xs <- fextract fs

@@ -1171,13 +1171,13 @@ splitSome (Parser step1 initial1 extract1) (Fold fstep finitial fextract) =

11711171 let cnt1 = cnt + 1

11721172 case r of

11731173 Partial n s -> do

1174− assert (cnt1 - n >= 0) (return ())

1174+ assertM (cnt1 - n >= 0)

11751175 return $ Continue n (Tuple3' s (cnt1 - n) (Left fs))

11761176 Continue n s -> do

1177− assert (cnt1 - n >= 0) (return ())

1177+ assertM (cnt1 - n >= 0)

11781178 return $ Continue n (Tuple3' s (cnt1 - n) (Left fs))

11791179 Done n b -> do

1180− assert (cnt1 - n >= 0) (return ())

1180+ assertM (cnt1 - n >= 0)

11811181 fstep fs b >>= handleCollect (Partial n) (Done n)

11821182 Error err -> return $ Error err

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

@@ -1185,13 +1185,13 @@ splitSome (Parser step1 initial1 extract1) (Fold fstep finitial fextract) =

11851185 let cnt1 = cnt + 1

11861186 case r of

11871187 Partial n s -> do

1188− assert (cnt1 - n >= 0) (return ())

1188+ assertM (cnt1 - n >= 0)

11891189 return $ Partial n (Tuple3' s (cnt1 - n) (Right fs))

11901190 Continue n s -> do

1191− assert (cnt1 - n >= 0) (return ())

1191+ assertM (cnt1 - n >= 0)

11921192 return $ Continue n (Tuple3' s (cnt1 - n) (Right fs))

11931193 Done n b -> do

1194− assert (cnt1 - n >= 0) (return ())

1194+ assertM (cnt1 - n >= 0)

11951195 fstep fs b >>= handleCollect (Partial n) (Done n)

11961196 Error _ -> Done cnt1 <$> fextract fs

11971197