Update

Author: adithyaov

core/src/Streamly/Internal/Data/Array.hs

@@ -1167,7 +1167,7 @@ adaptCWith
     :: forall m a s b r. (Monad m, Unbox a)
     => (s -> a -> m (ParserD.Step s b))
     -> m (ParserD.Initial s b)
-    -> (s -> m (ParserD.Step s b))
+    -> (s -> m (ParserD.Final s b))
     -> (ParseResult b -> Int -> Input (Array a) -> m (Step (Array a) m r))
     -> Int
     -> Int
@@ -1262,16 +1262,15 @@ adaptCWith pstep initial extract cont !offset0 !usedCount !input = do
     parseContNothing !count !pst = do
         r <- extract pst
         case r of
-            ParserD.SDone n b ->
+            ParserD.FDone n b ->
                 assert (n <= 0) (cont (Success n b) (count + n) None)
-            ParserD.SContinue n pst1 ->
+            ParserD.FContinue n pst1 ->
                 assert (n <= 0)
                     (return $ Continue n (parseCont (count + n) pst1))
-            ParserD.Error err ->
+            ParserD.FError err ->
                 -- XXX It is called only when there is no input arr. So using 0
                 -- as the position is correct?
                 cont (Failure 0 err) count None
-            ParserD.SPartial _ _ -> error "Bug: adaptCWith Partial unreachable"
 
     -- XXX Maybe we can use two separate continuations instead of using
     -- Just/Nothing cases here. That may help in avoiding the parseContJust

core/src/Streamly/Internal/Data/Array/Generic.hs

@@ -550,7 +550,7 @@ adaptCGWith
     :: forall m a s b r. (Monad m)
     => (s -> a -> m (ParserD.Step s b))
     -> m (ParserD.Initial s b)
-    -> (s -> m (ParserD.Step s b))
+    -> (s -> m (ParserD.Final s b))
     -> (ParseResult b -> Int -> Input (Array a) -> m (Step (Array a) m r))
     -> Int
     -> Int
@@ -639,16 +639,15 @@ adaptCGWith pstep initial extract cont !offset0 !usedCount !input = do
     parseContNothing !count !pst = do
         r <- extract pst
         case r of
-            ParserD.SDone n b ->
+            ParserD.FDone n b ->
                 assert (n <= 0) (cont (Success n b) (count + n) None)
-            ParserD.SContinue n pst1 ->
+            ParserD.FContinue n pst1 ->
                 assert (n <= 1)
                     (return $ Continue n (parseCont (count + n) pst1))
-            ParserD.Error err ->
+            ParserD.FError err ->
                 -- XXX It is called only when there is no input arr. So using 0
                 -- as the position is correct?
                 cont (Failure 0 err) count None
-            ParserD.SPartial _ _ -> error "Bug: adaptCGWith Partial unreachable"
 
     {-# INLINE parseCont #-}
     parseCont !cnt !pst (Chunk arr) = parseContChunk cnt 0 pst arr

core/src/Streamly/Internal/Data/Array/Stream.hs

@@ -418,25 +418,24 @@ runArrayParserDBreak
     goStop backBuf pst = do
         pRes <- extract pst
         case pRes of
-            PR.Partial _ _ -> error "Bug: runArrayParserDBreak: Partial in extract"
-            PR.Continue 0 pst1 ->
+            PR.FContinue 0 pst1 ->
                 goStop backBuf pst1
-            PR.Continue n pst1 -> do
+            PR.FContinue n pst1 -> do
                 assert
                     (n <= sum (map Array.length (getList backBuf)))
                     (return ())
                 let (src0, buf1) = splitAtArrayListRev n (getList backBuf)
                     src = Prelude.reverse src0
                 goExtract SPEC src (List buf1) pst1
-            PR.Done 0 b -> return (Right b, D.nil)
-            PR.Done n b -> do
+            PR.FDone 0 b -> return (Right b, D.nil)
+            PR.FDone n b -> do
                 assert
                     (n <= sum (map Array.length (getList backBuf)))
                     (return ())
                 let src0 = takeArrayListRev n (getList backBuf)
                     src = Prelude.reverse src0
                 return (Right b, D.fromList src)
-            PR.Error err -> do
+            PR.FError err -> do
                 let src0 = getList backBuf
                     src = Prelude.reverse src0
                 return (Left (ParseError err), D.fromList src)
@@ -683,26 +682,25 @@ runArrayFoldManyD
     stepOuter _ (ParseChunksStop backBuf pst) = do
         pRes <- extract pst
         case pRes of
-            PR.Partial _ _ -> error "runArrayFoldManyD: Partial in extract"
-            PR.Continue 0 pst1 ->
+            PR.FContinue 0 pst1 ->
                 return $ D.Skip $ ParseChunksStop backBuf pst1
-            PR.Continue n pst1 -> do
+            PR.FContinue n pst1 -> do
                 assert (n <= sum (map Array.length backBuf)) (return ())
                 let (src0, buf1) = splitAtArrayListRev n backBuf
                     src  = Prelude.reverse src0
                 return $ D.Skip $ ParseChunksExtract src buf1 pst1
-            PR.Done 0 b ->
+            PR.FDone 0 b ->
                 return
                     $ D.Skip
                     $ ParseChunksYield (Right b) (ParseChunksInitLeftOver [])
-            PR.Done n b -> do
+            PR.FDone n b -> do
                 assert (n <= sum (map Array.length backBuf)) (return ())
                 let src0 = takeArrayListRev n backBuf
                     src = Prelude.reverse src0
                 return
                     $ D.Skip
                     $ ParseChunksYield (Right b) (ParseChunksInitBuf src)
-            PR.Error err -> do
+            PR.FError err -> do
                 let next = ParseChunksInitLeftOver []
                 return
                     $ D.Skip

core/src/Streamly/Internal/Data/Binary/Parser.hs

@@ -61,7 +61,7 @@ import qualified Streamly.Internal.Data.Array as A
 import qualified Streamly.Internal.Data.Parser as PR
     (fromPure, either, satisfy, takeEQ)
 import qualified Streamly.Internal.Data.Parser as PRD
-    (Parser(..), Initial(..), Step(..))
+    (Parser(..), Initial(..), Step(..), Final(..))
 
 -- Note: The () type does not need to have an on-disk representation in theory.
 -- But we use a concrete representation for it so that we count how many ()
@@ -153,7 +153,7 @@ word16beD = PRD.Parser step initial extract
     step (Just' w) a =
         return $ PRD.SDone 1 (w .|. fromIntegral a)
 
-    extract _ = return $ PRD.Error "word16be: end of input"
+    extract _ = return $ PRD.FError "word16be: end of input"
 
 -- | Parse two bytes as a 'Word16', the first byte is the MSB of the Word16 and
 -- second byte is the LSB (big endian representation).
@@ -178,7 +178,7 @@ word16leD = PRD.Parser step initial extract
     step (Just' w) a =
         return $ PRD.SDone 1 (w .|. fromIntegral a `unsafeShiftL` 8)
 
-    extract _ = return $ PRD.Error "word16le: end of input"
+    extract _ = return $ PRD.FError "word16le: end of input"
 
 -- | Parse two bytes as a 'Word16', the first byte is the LSB of the Word16 and
 -- second byte is the MSB (little endian representation).
@@ -205,7 +205,7 @@ word32beD = PRD.Parser step initial extract
              in PRD.SContinue 1 (Tuple' w1 (sh - 8))
         else PRD.SDone 1 (w .|. fromIntegral a)
 
-    extract _ = return $ PRD.Error "word32beD: end of input"
+    extract _ = return $ PRD.FError "word32beD: end of input"
 
 -- | Parse four bytes as a 'Word32', the first byte is the MSB of the Word32
 -- and last byte is the LSB (big endian representation).
@@ -231,7 +231,7 @@ word32leD = PRD.Parser step initial extract
             then PRD.SContinue 1 (Tuple' w1 (sh + 8))
             else PRD.SDone 1 w1
 
-    extract _ = return $ PRD.Error "word32leD: end of input"
+    extract _ = return $ PRD.FError "word32leD: end of input"
 
 -- | Parse four bytes as a 'Word32', the first byte is the MSB of the Word32
 -- and last byte is the LSB (big endian representation).
@@ -258,7 +258,7 @@ word64beD = PRD.Parser step initial extract
              in PRD.SContinue 1 (Tuple' w1 (sh - 8))
         else PRD.SDone 1 (w .|. fromIntegral a)
 
-    extract _ = return $ PRD.Error "word64beD: end of input"
+    extract _ = return $ PRD.FError "word64beD: end of input"
 
 -- | Parse eight bytes as a 'Word64', the first byte is the MSB of the Word64
 -- and last byte is the LSB (big endian representation).
@@ -284,7 +284,7 @@ word64leD = PRD.Parser step initial extract
             then PRD.SContinue 1 (Tuple' w1 (sh + 8))
             else PRD.SDone 1 w1
 
-    extract _ = return $ PRD.Error "word64leD: end of input"
+    extract _ = return $ PRD.FError "word64leD: end of input"
 
 -- | Parse eight bytes as a 'Word64', the first byte is the MSB of the Word64
 -- and last byte is the LSB (big endian representation).

core/src/Streamly/Internal/Data/Fold/Chunked.hs

@@ -72,7 +72,7 @@ import Data.Proxy (Proxy(..))
 import Streamly.Internal.Data.Unbox (Unbox(..))
 import GHC.Types (SPEC(..))
 import Streamly.Internal.Data.Array (Array(..))
-import Streamly.Internal.Data.Parser (Initial(..), Step(..))
+import Streamly.Internal.Data.Parser (Initial(..), Step(..), Final(..))
 import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))
 
 import qualified Streamly.Internal.Data.Array.Type as Array
@@ -137,7 +137,7 @@ fromFold (Fold.Fold fstep finitial _ ffinal) =
                 Fold.Partial fs1 ->
                     goArray SPEC next fs1
 
-    extract = fmap (Done 0) . ffinal
+    extract = fmap (FDone 0) . ffinal
 
 -- | Convert an element 'ParserD.Parser' into an array stream fold. If the
 -- parser fails the fold would throw an exception.
@@ -320,8 +320,8 @@ take n (ChunkFold (ParserD.Parser step1 initial1 extract1)) =
     iextract s = do
         r <- extract1 s
         return $ case r of
-            Done _ b -> IDone b
-            Error err -> IError err
+            FDone _ b -> IDone b
+            FError err -> IError err
             _ -> error "Bug: ChunkFold take invalid state in initial"
 
     initial = do
@@ -343,10 +343,9 @@ take n (ChunkFold (ParserD.Parser step1 initial1 extract1)) =
                 -- i2 == i1 == j == 0
                 r <- extract1 s
                 return $ case r of
-                    Error err -> Error err
-                    Done n1 b -> Done n1 b
-                    Continue n1 s1 -> Continue n1 (Tuple' i2 s1)
-                    Partial _ _ -> error "Partial in extract"
+                    FError err -> Error err
+                    FDone n1 b -> Done n1 b
+                    FContinue n1 s1 -> Continue n1 (Tuple' i2 s1)
 
     -- Tuple' (how many more items to take) (fold state)
     step (Tuple' i r) arr = do
@@ -369,11 +368,11 @@ take n (ChunkFold (ParserD.Parser step1 initial1 extract1)) =
             res <- step1 r arr1
             case res of
                 Partial 0 s ->
-                    ParserD.bimapOverrideCount
+                    ParserD.bimapMorphOverrideCount
                         remaining (Tuple' 0) id <$> extract1 s
                 Partial j s -> return $ Partial (remaining + j) (Tuple' j s)
                 Continue 0 s ->
-                    ParserD.bimapOverrideCount
+                    ParserD.bimapMorphOverrideCount
                         remaining (Tuple' 0) id <$> extract1 s
                 Continue j s -> return $ Continue (remaining + j) (Tuple' j s)
                 Done j b -> return $ Done (remaining + j) b

core/src/Streamly/Internal/Data/MutArray/Type.hs

@@ -3738,8 +3738,8 @@ pCompactLeAs ps maxElems = Parser step initial extract
                 buf2 <- unsafeSplice buf1 arr
                 return $ Parser.SPartial 1 (Just buf2)
 
-    extract Nothing = return $ Parser.SDone 0 nil
-    extract (Just buf) = return $ Parser.SDone 0 buf
+    extract Nothing = return $ Parser.FDone 0 nil
+    extract (Just buf) = return $ Parser.FDone 0 buf
 
 -- | Parser @createCompactMax maxElems@ coalesces adjacent arrays in the
 -- input stream only if the combined size would be less than or equal to