Rename "parserK" to "toParserK"

benchmark/Streamly/Benchmark/Data/Array/Stream.hs

@@ -240,7 +240,7 @@ fold s = void $ Array.foldBreak Fold.drain $ StreamK.fromStream s
 parse :: Int -> Stream IO (Array.Array Int) -> IO ()
 parse value s =
     void $ Array.parseBreak
-            (Array.parserK (drainWhile (< value)))
+            (Array.toParserK (drainWhile (< value)))
             (StreamK.fromStream s)
 
 {-# INLINE foldBreak #-}
@@ -252,7 +252,7 @@ foldBreak s = do
 {-# INLINE parseBreak #-}
 parseBreak :: StreamK IO (Array.Array Int) -> IO ()
 parseBreak s = do
-    r <- Array.parseBreak (Array.parserK Parser.one) s
+    r <- Array.parseBreak (Array.toParserK Parser.one) s
     case r of
         (Left _, _) -> return ()
         (Right _, s1) -> parseBreak s1

benchmark/Streamly/Benchmark/Data/ParserK.hs

@@ -62,7 +62,7 @@ import Streamly.Benchmark.Common
 #ifdef BENCH_CHUNKED
 
 #define PARSE_OP Array.parse
-#define FROM_PARSER Array.parserK
+#define FROM_PARSER Array.toParserK
 #define INPUT (Array a)
 #define PARSE_ELEM (Array Int)
 #define CONSTRAINT_IO (MonadIO m, Unbox a)
@@ -74,7 +74,7 @@ import Streamly.Benchmark.Common
 #ifdef BENCH_CHUNKED_GENERIC
 
 #define PARSE_OP GenArr.parse
-#define FROM_PARSER GenArr.parserK
+#define FROM_PARSER GenArr.toParserK
 #define INPUT (Array a)
 #define PARSE_ELEM (Array Int)
 #define CONSTRAINT_IO (MonadIO m)
@@ -86,7 +86,7 @@ import Streamly.Benchmark.Common
 #ifdef BENCH_SINGULAR
 
 #define PARSE_OP StreamK.parse
-#define FROM_PARSER PR.parserK
+#define FROM_PARSER PR.toParserK
 #define INPUT a
 #define PARSE_ELEM Int
 #define CONSTRAINT_IO (MonadIO m)

core/src/Streamly/Data/Array.hs

@@ -76,7 +76,7 @@ module Streamly.Data.Array
 
     -- * Stream of Arrays
     , chunksOf
-    , parserK
+    , toParserK
     , parse
     , parseBreak
     , parsePos

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

@@ -35,7 +35,7 @@ module Streamly.Data.Array.Generic
 
     -- * Stream of Arrays
     , chunksOf
-    , parserK
+    , toParserK
     , parse
     , parseBreak
     , parsePos

core/src/Streamly/Data/Parser.hs

@@ -94,13 +94,13 @@
 -- ParserK is suitable for recursive definitions:
 --
 -- >>> import Streamly.Data.ParserK (ParserK)
--- >>> import Streamly.Data.StreamK (parserK)
+-- >>> import Streamly.Data.StreamK (toParserK)
 -- >>> import qualified Streamly.Data.StreamK as StreamK
 --
 -- >>> :{
 -- >>> p, p1, p2 :: Monad m => ParserK Char m String
--- >>> p1 = parserK (Parser.satisfy (== '(')) *> p
--- >>> p2 = parserK (Parser.fromFold Fold.toList)
+-- >>> p1 = toParserK (Parser.satisfy (== '(')) *> p
+-- >>> p2 = toParserK (Parser.fromFold Fold.toList)
 -- >>> p = p1 <|> p2
 -- >>> :}
 --

core/src/Streamly/Data/ParserK.hs

@@ -32,9 +32,10 @@
 -- All the fused parsers from the "Streamly.Data.Parser" module can be
 -- converted to the CPS ParserK, for use with different types of parser
 -- drivers, using
--- the @parserK@ combinators - Streamly.Data.Array.'Streamly.Data.Array.parserK',
--- Streamly.Data.StreamK.'Streamly.Data.StreamK.parserK', and
--- Streamly.Data.Array.Generic.'Streamly.Data.Array.Generic.parserK'.
+-- the @toParserK@ combinators -
+-- Streamly.Data.Array.'Streamly.Data.Array.toParserK',
+-- Streamly.Data.StreamK.'Streamly.Data.StreamK.toParserK', and
+-- Streamly.Data.Array.Generic.'Streamly.Data.Array.Generic.toParserK'
 --
 -- To parse a stream of unboxed arrays, use
 -- Streamly.Data.Array.'Streamly.Data.Array.parse' for running the parser, this
@@ -63,7 +64,7 @@
 -- >>> token p1 p2 = ((:) <$> p1 <*> ((:) <$> p2 <*> pure []))
 -- >>> :{
 -- backtracking :: Monad m => ParserK Char m String
--- backtracking = StreamK.parserK $
+-- backtracking = StreamK.toParserK $
 --     token (Parser.satisfy isDigit) (Parser.satisfy isAlpha) -- e.g. "9a"
 --     <|>
 --     token (Parser.satisfy isAlpha) (Parser.satisfy isDigit) -- e.g. "a9"
@@ -86,11 +87,11 @@
 -- >>> :{
 -- lookbehind :: Monad m => ParserK Char m String
 -- lookbehind = do
---     x1 <- StreamK.parserK $
+--     x1 <- StreamK.toParserK $
 --              Digit <$> Parser.satisfy isDigit
 --          <|> Alpha <$> Parser.satisfy isAlpha
 --     -- Note: the parse depends on what we parsed already
---     x2 <- StreamK.parserK $
+--     x2 <- StreamK.toParserK $
 --           case x1 of
 --              Digit _ -> Parser.satisfy isAlpha
 --              Alpha _ -> Parser.satisfy isDigit
@@ -143,13 +144,13 @@ import Streamly.Internal.Data.ParserK
 
 #include "DocTestDataParserK.hs"
 
-{-# DEPRECATED fromFold "Please use \"Array.parserK . Parser.fromFold\" instead." #-}
+{-# DEPRECATED fromFold "Please use \"Array.toParserK . Parser.fromFold\" instead." #-}
 {-# INLINE fromFold #-}
 fromFold :: (MonadIO m, Unbox a) => Fold m a b -> ParserK (Array a) m b
-fromFold = Array.parserK . ParserD.fromFold
+fromFold = Array.toParserK . ParserD.fromFold
 
-{-# DEPRECATED fromParser "Please use \"Array.parserK\" instead." #-}
+{-# DEPRECATED fromParser "Please use \"Array.toParserK\" instead." #-}
 {-# INLINE fromParser #-}
 fromParser ::
        (MonadIO m, Unbox a) => ParserD.Parser a m b -> ParserK (Array a) m b
-fromParser = Array.parserK
+fromParser = Array.toParserK

core/src/Streamly/Data/StreamK.hs

@@ -127,7 +127,7 @@ module Streamly.Data.StreamK
     -- , foldBreak
 
     -- ** Parsing
-    , parserK
+    , toParserK
     , parse
     , parseBreak
     , parsePos

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

@@ -75,7 +75,7 @@ module Streamly.Internal.Data.Array
     , foldChunks
     , foldBreak
     -- , parseBreakChunksK -- XXX uses Parser. parseBreak is better?
-    , parserK
+    , toParserK
     , parseBreak
     , parseBreakPos
     , parse
@@ -1173,7 +1173,7 @@ adaptCWith pstep initial extract cont !offset0 !usedCount !input = do
 --
 -- /Pre-release/
 --
-{-# INLINE_LATE parserK #-}
-parserK :: (Monad m, Unbox a) => ParserD.Parser a m b -> ParserK (Array a) m b
-parserK (ParserD.Parser step initial extract) =
+{-# INLINE_LATE toParserK #-}
+toParserK :: (Monad m, Unbox a) => ParserD.Parser a m b -> ParserK (Array a) m b
+toParserK (ParserD.Parser step initial extract) =
     ParserK.MkParser $ adaptCWith step initial extract

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

@@ -50,7 +50,7 @@ module Streamly.Internal.Data.Array.Generic.Type
     , dropAround
 
     -- * Parsing Stream of Arrays
-    , parserK
+    , toParserK
 
     -- * Deprecated
     , strip
@@ -489,7 +489,7 @@ adaptCGWith pstep initial extract cont !offset0 !usedCount !input = do
 --
 -- /Pre-release/
 --
-{-# INLINE_LATE parserK #-}
-parserK :: Monad m => ParserD.Parser a m b -> ParserK (Array a) m b
-parserK (ParserD.Parser step initial extract) =
+{-# INLINE_LATE toParserK #-}
+toParserK :: Monad m => ParserD.Parser a m b -> ParserK (Array a) m b
+toParserK (ParserD.Parser step initial extract) =
     ParserK.MkParser $ adaptCGWith step initial extract

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

@@ -294,7 +294,7 @@ parseBreak ::
 parseBreak p s =
     fmap fromStreamD <$> parseBreakD (PRD.fromParserK p) (toStreamD s)
 -}
-parseBreak p = Array.parseBreak (Array.parserK p)
+parseBreak p = Array.parseBreak (Array.toParserK p)
 
 -------------------------------------------------------------------------------
 -- Elimination - Running Array Folds and parsers

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

@@ -27,13 +27,13 @@ import qualified Streamly.Internal.Data.Array.Generic as GenArray
 
 #include "inline.hs"
 
-{-# DEPRECATED adaptC "Use Streamly.Data.Array.parserK" #-}
+{-# DEPRECATED adaptC "Use Streamly.Data.Array.toParserK" #-}
 {-# INLINE_LATE adaptC #-}
 adaptC :: (Monad m, Unbox a) => Parser a m b -> ParserK (Array a) m b
-adaptC = Array.parserK
+adaptC = Array.toParserK
 
-{-# DEPRECATED adaptCG "Use Streamly.Data.Array.Generic.parserK" #-}
+{-# DEPRECATED adaptCG "Use Streamly.Data.Array.Generic.toParserK" #-}
 {-# INLINE_LATE adaptCG #-}
 adaptCG ::
        Monad m => Parser a m b -> ParserK (GenArray.Array a) m b
-adaptCG = GenArray.parserK
+adaptCG = GenArray.toParserK

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

@@ -33,7 +33,7 @@ module Streamly.Internal.Data.ParserK.Type
 
     -- * Adapting from Parser
     , parserDone
-    , parserK -- XXX move to StreamK module
+    , toParserK -- XXX move to StreamK module
     , toParser -- XXX unParserK, unK, unPK
 
     -- * Basic Parsers
@@ -503,12 +503,12 @@ adaptWith pstep initial extract cont !relPos !usedCount !input = do
 --
 -- /Pre-release/
 --
-{-# INLINE_LATE parserK #-}
-parserK, adapt :: Monad m => ParserD.Parser a m b -> ParserK a m b
-parserK (ParserD.Parser step initial extract) =
+{-# INLINE_LATE toParserK #-}
+toParserK, adapt :: Monad m => ParserD.Parser a m b -> ParserK a m b
+toParserK (ParserD.Parser step initial extract) =
     MkParser $ adaptWith step initial extract
 
-RENAME(adapt,parserK)
+RENAME(adapt,toParserK)
 
 -------------------------------------------------------------------------------
 -- Convert CPS style 'Parser' to direct style 'D.Parser'
@@ -527,7 +527,7 @@ parserDone (Failure n e) _ _ =
 
 -- XXX Note that this works only for single element parsers and not for Array
 -- input parsers. The asserts will fail for array parsers.
--- XXX We should move this to StreamK module along with parserK
+-- XXX We should move this to StreamK module along with toParserK
 
 -- | Convert a CPS style 'ParserK' to a direct style 'Parser'.
 --
@@ -558,18 +558,18 @@ toParser parser = ParserD.Parser step initial extract
             Continue n cont1 ->
                 assert (n <= 0) (return $ ParserD.FContinue n cont1)
 
-{-# RULES "parserK/toParser fusion" [2]
-    forall s. toParser (parserK s) = s #-}
-{-# RULES "toParser/parserK fusion" [2]
-    forall s. parserK (toParser s) = s #-}
+{-# RULES "toParserK/toParser fusion" [2]
+    forall s. toParser (toParserK s) = s #-}
+{-# RULES "toParser/toParserK fusion" [2]
+    forall s. toParserK (toParser s) = s #-}
 
 -- | @chainl1 p op x@ parses /one/ or more occurrences of @p@, separated by
 -- @op@. Returns a value obtained by a /left/ associative application of all
 -- functions returned by @op@ to the values returned by @p@.
 --
 -- >>> num = Parser.decimal
 -- >>> plus = Parser.char '+' *> pure (+)
--- >>> expr = ParserK.chainl1 (StreamK.parserK num) (StreamK.parserK plus)
+-- >>> expr = ParserK.chainl1 (StreamK.toParserK num) (StreamK.toParserK plus)
 -- >>> StreamK.parse expr $ StreamK.fromStream $ Stream.fromList "1+2+3"
 -- Right 6
 --
@@ -604,7 +604,7 @@ chainl p op x = chainl1 p op <|> pure x
 --
 -- >>> num = Parser.decimal
 -- >>> pow = Parser.char '^' *> pure (^)
--- >>> expr = ParserK.chainr1 (StreamK.parserK num) (StreamK.parserK pow)
+-- >>> expr = ParserK.chainr1 (StreamK.toParserK num) (StreamK.toParserK pow)
 -- >>> StreamK.parse expr $ StreamK.fromStream $ Stream.fromList "2^3^2"
 -- Right 512
 --

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

@@ -40,7 +40,7 @@ module Streamly.Internal.Data.StreamK
     , foldBreak
     , foldEither
     , foldConcat
-    , ParserK.parserK -- XXX move the code to this module
+    , ParserK.toParserK -- XXX move the code to this module
     , parseDBreak
     , parseD
     , parseBreak
@@ -1273,7 +1273,7 @@ parseD f = fmap fst . parseDBreak f
 -- ParserK Chunked
 -------------------------------------------------------------------------------
 
--- XXX parseDBreakChunks may be faster than converting parserD to parserK and
+-- XXX parseDBreakChunks may be faster than converting parserD to toParserK and
 -- using parseBreakChunks. We can also use parseBreak as an alternative to the
 -- monad instance of ParserD.
 

test/Streamly/Test/Data/Array/Stream.hs

@@ -57,7 +57,7 @@ parseBreak = do
                                 $ chunksOf
                                 clen (Array.createOf clen) (Stream.fromList ls)
                         parser = Parser.fromFold (Fold.take tlen Fold.toList)
-                     in run $ Array.parseBreak (Array.parserK parser) input
+                     in run $ Array.parseBreak (Array.toParserK parser) input
                 ls2 <- run $ Stream.fold Fold.toList (Array.concat $ Stream.fromStreamK str)
                 case ls1 of
                     Right x -> listEquals (==) (x ++ ls2) ls

test/Streamly/Test/Data/Parser.hs

@@ -341,7 +341,7 @@ sanityParseBreak jumps = it (show jumps) $ do
 
 sanityParseDBreak :: [Move] -> SpecWith ()
 sanityParseDBreak jumps = it (show jumps) $ do
-    (val, rest) <- K.parseBreakPos (PK.parserK (jumpParser jumps)) $ K.fromList tape
+    (val, rest) <- K.parseBreakPos (PK.toParserK (jumpParser jumps)) $ K.fromList tape
     lst <- K.toList rest
     (val, lst) `shouldBe` (expectedResult jumps tape)
 
@@ -399,11 +399,11 @@ takeWhileFailD predicate (Fold fstep finitial _ ffinal) =
 {-# INLINE takeWhileFail #-}
 takeWhileFail :: MonadIO m =>
     (a -> Bool) -> Fold m a b -> PK.ParserK a m b
-takeWhileFail p f = PK.parserK (takeWhileFailD p f)
+takeWhileFail p f = PK.toParserK (takeWhileFailD p f)
 
 {-# INLINE takeWhileK #-}
 takeWhileK :: MonadIO m => (a -> Bool) -> PK.ParserK a m [a]
-takeWhileK p = PK.parserK $ P.takeWhile p FL.toList
+takeWhileK p = PK.toParserK $ P.takeWhile p FL.toList
 
 {-# INLINE alt2 #-}
 alt2 :: MonadIO m => K.StreamK m Int -> m (Either ParseError [Int])

test/Streamly/Test/Data/Parser/Common.hs

@@ -1088,18 +1088,18 @@ runParserTC tm runner =
             runner $ \p -> mapMTup S.toList . S.parseBreakPos p . S.fromList
         TMParserKStreamK ->
             runner $ \p ->
-                mapMTup K.toList . K.parseBreakPos (PK.parserK p) . K.fromList
+                mapMTup K.toList . K.parseBreakPos (PK.toParserK p) . K.fromList
         TMParserKStreamKChunks ->
             runner $ \p ->
                 mapMTup
                     (fmap (concatMap A.toList) . K.toList)
-                        . A.parseBreakPos (A.parserK p)
+                        . A.parseBreakPos (A.toParserK p)
                         . producerChunks A.fromList
         TMParserKStreamKChunksGeneric ->
             runner $ \p ->
                 mapMTup
                     (fmap (concatMap GA.toList) . K.toList)
-                        . GA.parseBreakPos (GA.parserK p)
+                        . GA.parseBreakPos (GA.toParserK p)
                         . producerChunks GA.fromList
 
     where
@@ -1118,13 +1118,13 @@ runParserTC_temp :: (Unbox a, Monad m) => TestMode -> ParserTestCase_Temp a m b
 runParserTC_temp tm runner =
     case tm of
         TMParserStream -> runner S.fromList S.parsePos
-        TMParserKStreamK -> runner K.fromList (K.parsePos . PK.parserK)
+        TMParserKStreamK -> runner K.fromList (K.parsePos . PK.toParserK)
         TMParserKStreamKChunks ->
-            runner (producerChunks A.fromList) (A.parsePos . A.parserK)
+            runner (producerChunks A.fromList) (A.parsePos . A.toParserK)
         TMParserKStreamKChunksGeneric ->
             runner
                 (producerChunks GA.fromList)
-                (GA.parsePos . GA.parserK)
+                (GA.parsePos . GA.toParserK)
 
     where
     cSize = 50