Move array stream parsing funcs to array modules

benchmark/Streamly/Benchmark/Data/ParserK.hs

@@ -5,9 +5,9 @@
 -- License     : BSD-3-Clause
 -- Maintainer  : streamly@composewell.com
 
--- BENCH_CHUNKED             -> adaptC
--- BENCH_CHUNKED_GENERIC     -> adaptCG
--- BENCH_SINGULAR            -> adapt
+-- BENCH_CHUNKED             -> parse from Array stream
+-- BENCH_CHUNKED_GENERIC     -> parse from Generic Array stream
+-- BENCH_SINGULAR            -> parse from single element stream
 
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE FlexibleContexts #-}
@@ -24,11 +24,9 @@ import Control.Monad.IO.Class (MonadIO)
 import Data.Foldable (asum)
 #ifdef BENCH_CHUNKED
 import Streamly.Data.Array (Array, Unbox)
-import qualified Streamly.Internal.Data.Array as Array (chunksOf)
 #endif
 #ifdef BENCH_CHUNKED_GENERIC
 import Streamly.Data.Array.Generic (Array)
-import qualified Streamly.Internal.Data.Array.Generic as GenArr (chunksOf)
 #endif
 import Streamly.Internal.Data.Fold (Fold(..))
 import Streamly.Data.StreamK (StreamK)
@@ -48,6 +46,11 @@ import qualified Streamly.Internal.Data.Fold as Fold
 import qualified Streamly.Data.Parser as PRD
 import qualified Streamly.Internal.Data.ParserK as PR
 import qualified Streamly.Internal.Data.StreamK as StreamK
+#ifdef BENCH_CHUNKED
+import qualified Streamly.Internal.Data.Array as Array
+#elif defined(BENCH_CHUNKED_GENERIC)
+import qualified Streamly.Internal.Data.Array.Generic as GenArr
+#endif
 
 import Test.Tasty.Bench
 import Streamly.Benchmark.Common
@@ -58,8 +61,8 @@ import Streamly.Benchmark.Common
 
 #ifdef BENCH_CHUNKED
 
-#define PARSE_OP StreamK.parseChunks
-#define FROM_PARSER adaptC
+#define PARSE_OP Array.parse
+#define FROM_PARSER Array.parserK
 #define INPUT (Array a)
 #define PARSE_ELEM (Array Int)
 #define CONSTRAINT_IO (MonadIO m, Unbox a)
@@ -70,8 +73,8 @@ import Streamly.Benchmark.Common
 
 #ifdef BENCH_CHUNKED_GENERIC
 
-#define PARSE_OP StreamK.parseChunksGeneric
-#define FROM_PARSER adaptCG
+#define PARSE_OP GenArr.parse
+#define FROM_PARSER GenArr.parserK
 #define INPUT (Array a)
 #define PARSE_ELEM (Array Int)
 #define CONSTRAINT_IO (MonadIO m)
@@ -83,7 +86,7 @@ import Streamly.Benchmark.Common
 #ifdef BENCH_SINGULAR
 
 #define PARSE_OP StreamK.parse
-#define FROM_PARSER adapt
+#define FROM_PARSER PR.parserK
 #define INPUT a
 #define PARSE_ELEM Int
 #define CONSTRAINT_IO (MonadIO m)
@@ -136,18 +139,18 @@ one value = PARSE_OP p
     where
 
     p = do
-        m <- PR.FROM_PARSER (PRD.fromFold FL.one)
+        m <- FROM_PARSER (PRD.fromFold FL.one)
         case m of
           Just i -> if i >= value then pure m else p
           Nothing -> pure Nothing
 
 {-# INLINE satisfy #-}
 satisfy :: CONSTRAINT_IO => (a -> Bool) -> PR.ParserK INPUT m a
-satisfy = PR.FROM_PARSER . PRD.satisfy
+satisfy = FROM_PARSER . PRD.satisfy
 
 {-# INLINE takeWhile #-}
 takeWhile :: CONSTRAINT_IO => (a -> Bool) -> PR.ParserK INPUT m ()
-takeWhile p = PR.FROM_PARSER $ PRD.takeWhile p FL.drain
+takeWhile p = FROM_PARSER $ PRD.takeWhile p FL.drain
 
 {-# INLINE takeWhileK #-}
 takeWhileK :: MonadIO m =>
@@ -240,7 +243,7 @@ takeWhileFailD predicate (Fold fstep finitial _ ffinal) =
 {-# INLINE takeWhileFail #-}
 takeWhileFail :: CONSTRAINT =>
     (a -> Bool) -> Fold m a b -> PR.ParserK INPUT m b
-takeWhileFail p f = PR.FROM_PARSER (takeWhileFailD p f)
+takeWhileFail p f = FROM_PARSER (takeWhileFailD p f)
 
 {-# INLINE alt2 #-}
 alt2 :: MonadIO m

benchmark/streamly-benchmarks.cabal

@@ -349,7 +349,6 @@ benchmark Data.Parser
     else
       ghc-options: +RTS -M2500M -RTS
 
--- XXX This is chunked?
 benchmark Data.ParserK
   import: bench-options
   type: exitcode-stdio-1.0

core/src/Streamly/Data/Parser.hs

@@ -68,20 +68,23 @@
 -- >>> import Control.Applicative ((<|>))
 --
 -- >>> :{
--- >>> p :: Monad m => Parser Char m String
--- >>> p = Parser.satisfy (== '(') *> p <|> Parser.fromFold Fold.toList
+-- >>> p, p1, p2 :: Monad m => Parser Char m String
+-- >>> p1 = Parser.satisfy (== '(') *> p
+-- >>> p2 = Parser.fromFold Fold.toList
+-- >>> p = p1 <|> p2
 -- >>> :}
 --
 -- Use ParserK when recursive use is required:
 --
--- >>> import Streamly.Data.ParserK (ParserK)
+-- >>> import Streamly.Data.ParserK (ParserK, parserK)
 -- >>> import qualified Streamly.Data.StreamK as StreamK
 -- >>> import qualified Streamly.Internal.Data.StreamK as StreamK (parse)
--- >>> import qualified Streamly.Internal.Data.ParserK as ParserK (adapt)
 --
 -- >>> :{
--- >>> p :: Monad m => ParserK Char m String
--- >>> p = ParserK.adapt (Parser.satisfy (== '(')) *> p <|> ParserK.adapt (Parser.fromFold Fold.toList)
+-- >>> p, p1, p2 :: Monad m => ParserK Char m String
+-- >>> p1 = parserK (Parser.satisfy (== '(')) *> p
+-- >>> p2 = parserK (Parser.fromFold Fold.toList)
+-- >>> p = p1 <|> p2
 -- >>> :}
 --
 -- >>> StreamK.parse p $ StreamK.fromStream $ Stream.fromList "hello"

core/src/Streamly/Data/ParserK.hs

@@ -32,17 +32,17 @@
 --
 -- == Using ParserK
 --
--- All the parsers from the "Streamly.Data.Parser" module can be adapted to
--- ParserK using the 'Streamly.Data.ParserK.adaptC',
--- 'Streamly.Internal.Data.ParserK.adapt', and
--- 'Streamly.Internal.Data.ParserK.adaptCG' combinators.
+-- All the parsers from the "Streamly.Data.Parser" module can be converted to
+-- ParserK using the 'Streamly.Data.Array.parserK',
+-- 'Streamly.Internal.Data.ParserK.parserK', and
+-- 'Streamly.Internal.Data.Array.Generic.parserK' combinators.
 --
--- 'Streamly.Data.StreamK.parseChunks' runs a parser on a stream of unboxed
+-- 'Streamly.Data.Array.parse' runs a parser on a stream of unboxed
 -- arrays, this is the preferred and most efficient way to parse chunked input.
--- The more general 'Streamly.Data.StreamK.parseBreakChunks' function returns
+-- The more general 'Streamly.Data.Array.parseBreak' function returns
 -- the remaining stream as well along with the parse result. There are
--- 'Streamly.Internal.Data.StreamK.parseChunksGeneric',
--- 'Streamly.Internal.Data.StreamK.parseBreakChunksGeneric' as well to run
+-- 'Streamly.Internal.Data.Array.Generic.parse',
+-- 'Streamly.Internal.Data.Array.Generic.parseBreak' as well to run
 -- parsers on boxed arrays. 'Streamly.Internal.Data.StreamK.parse',
 -- 'Streamly.Internal.Data.StreamK.parseBreak' run parsers on a stream of
 -- individual elements instead of stream of arrays.
@@ -58,7 +58,7 @@
 -- >>> digits p1 p2 = ((:) <$> p1 <*> ((:) <$> p2 <*> pure []))
 -- >>> :{
 -- backtracking :: Monad m => ParserK Char m String
--- backtracking = ParserK.adapt $
+-- backtracking = ParserK.parserK $
 --     digits (Parser.satisfy isDigit) (Parser.satisfy isAlpha)
 --     <|>
 --     digits (Parser.satisfy isAlpha) (Parser.satisfy isDigit)
@@ -75,11 +75,11 @@
 -- >>> :{
 -- lookbehind :: Monad m => ParserK Char m String
 -- lookbehind = do
---     x1 <- ParserK.adapt $
+--     x1 <- ParserK.parserK $
 --              Digit <$> Parser.satisfy isDigit
 --          <|> Alpha <$> Parser.satisfy isAlpha
 --     -- Note: the parse depends on what we parsed already
---     x2 <- ParserK.adapt $
+--     x2 <- ParserK.parserK $
 --           case x1 of
 --              Digit _ -> Parser.satisfy isAlpha
 --              Alpha _ -> Parser.satisfy isDigit
@@ -106,9 +106,7 @@ module Streamly.Data.ParserK
 
     -- * Parsers
     -- ** Conversions
-    , adapt
-    , adaptC
-    , adaptCG
+    , parserK
     -- , toParser
 
     -- ** Without Input
@@ -119,6 +117,9 @@ module Streamly.Data.ParserK
     -- * Deprecated
     , fromFold
     , fromParser
+    , adapt
+    , adaptC
+    , adaptCG
     )
 
 where
@@ -128,18 +129,19 @@ import Streamly.Internal.Data.Fold (Fold)
 import Streamly.Internal.Data.Unbox (Unbox)
 import Streamly.Internal.Data.Array (Array)
 import qualified Streamly.Internal.Data.Parser as ParserD
+import qualified Streamly.Internal.Data.Array as Array
 
-import Streamly.Internal.Data.ParserK.Type
+import Streamly.Internal.Data.ParserK
 
 #include "DocTestDataParserK.hs"
 
-{-# DEPRECATED fromFold "Please use \"ParserK.adaptC . Parser.fromFold\" instead." #-}
+{-# DEPRECATED fromFold "Please use \"Array.parserK . Parser.fromFold\" instead." #-}
 {-# INLINE fromFold #-}
 fromFold :: (MonadIO m, Unbox a) => Fold m a b -> ParserK (Array a) m b
-fromFold = adaptC . ParserD.fromFold
+fromFold = Array.parserK . ParserD.fromFold
 
-{-# DEPRECATED fromParser "Please use \"adaptC\" instead." #-}
+{-# DEPRECATED fromParser "Please use \"Array.parserK\" instead." #-}
 {-# INLINE fromParser #-}
 fromParser ::
        (MonadIO m, Unbox a) => ParserD.Parser a m b -> ParserK (Array a) m b
-fromParser = adaptC
+fromParser = Array.parserK

core/src/Streamly/Data/StreamK.hs

@@ -124,8 +124,6 @@ module Streamly.Data.StreamK
     -- ** Parsing
     , parse
     , parseBreak
-    , parseBreakChunks
-    , parseChunks
 
     -- * Transformation
     , mapM
@@ -186,6 +184,10 @@ module Streamly.Data.StreamK
     -- | Please note that 'Stream' type does not observe any exceptions from
     -- the consumer of the stream whereas 'StreamK' does.
     , bracketIO
+
+    -- * Deprecated
+    , parseBreakChunks
+    , parseChunks
     )
 where