From 61305730f25324c68d7344adef4e225089637aa5 Mon Sep 17 00:00:00 2001
From: Ranjeet Kumar Ranjan <ranjeetr@composewell.com>
Date: Sat, 19 Aug 2023 14:06:23 +0530
Subject: [PATCH 1/2] Use CPP macro for ParserK tests

---
 test/Streamly/Test/Data/Parser.hs  | 284 ++++++----
 test/Streamly/Test/Data/ParserK.hs | 836 -----------------------------
 test/streamly-tests.cabal          |   3 +-
 3 files changed, 194 insertions(+), 929 deletions(-)
 delete mode 100644 test/Streamly/Test/Data/ParserK.hs

diff --git a/test/Streamly/Test/Data/Parser.hs b/test/Streamly/Test/Data/Parser.hs
index 25190943e6..58c38baabe 100644
--- a/test/Streamly/Test/Data/Parser.hs
+++ b/test/Streamly/Test/Data/Parser.hs
@@ -1,3 +1,5 @@
+{-# LANGUAGE CPP #-}
+
 module Main (main) where
 
 import Control.Applicative ((<|>))
@@ -25,6 +27,11 @@ import qualified Streamly.Internal.Data.Producer as Producer
 import qualified Streamly.Internal.Data.Unfold as Unfold
 import qualified Test.Hspec as H
 
+#ifdef PARSER_K
+import qualified Streamly.Internal.Data.StreamK as SK
+import qualified Streamly.Data.ParserK as PR
+#endif
+
 #if MIN_VERSION_QuickCheck(2,14,0)
 
 import Test.QuickCheck (chooseAny)
@@ -59,11 +66,26 @@ max_length = 1000
 
 -- Accumulator Tests
 
+#ifdef PARSER_K
+streamOfArray :: [Int] -> SK.StreamK m (A.Array Int)
+streamOfArray = SK.fromPure . A.fromList
+
+#define INPUT_FROM_LIST streamOfArray
+#define PARSER_RUNNER SK.parseChunks
+#define FROM_PARSER_D PR.adaptC
+#else
+#define INPUT_FROM_LIST S.fromList
+#define PARSER_RUNNER S.parse
+#define FROM_PARSER_D
+#endif
+
 fromFold :: Property
 fromFold =
     forAll (listOf $ chooseInt (min_value, max_value)) $ \ls ->
         monadicIO $ do
-        s1 <- S.parse (P.fromFold FL.sum) (S.fromList ls)
+        s1 <- PARSER_RUNNER
+                (FROM_PARSER_D (P.fromFold FL.sum))
+                (INPUT_FROM_LIST ls)
         o2 <- S.fold FL.sum (S.fromList ls)
         return $
             case s1 of
@@ -73,35 +95,45 @@ fromFold =
 fromPure :: Property
 fromPure =
     forAll (chooseInt (min_value, max_value)) $ \x ->
-        case runIdentity $ S.parse (P.fromPure x) (S.fromList [1 :: Int]) of
+        case runIdentity $ PARSER_RUNNER
+                (FROM_PARSER_D (P.fromPure x))
+                (INPUT_FROM_LIST [1 :: Int]) of
             Right r -> r == x
             Left _ -> False
 
 fromEffect :: Property
 fromEffect =
     forAll (chooseInt (min_value, max_value)) $ \x ->
-        case runIdentity $ S.parse (P.fromEffect $ return x) (S.fromList [1 :: Int]) of
+        case runIdentity $ PARSER_RUNNER
+                (FROM_PARSER_D (P.fromEffect $ return x))
+                (INPUT_FROM_LIST [1 :: Int]) of
             Right r -> r == x
             Left _ -> False
 
 die :: Property
 die =
     property $
-    case runIdentity $ S.parse (P.die "die test") (S.fromList [0 :: Int]) of
+    case runIdentity $ PARSER_RUNNER
+            (FROM_PARSER_D (P.die "die test"))
+            (INPUT_FROM_LIST [0 :: Int]) of
         Right _ -> False
         Left _ -> True
 
 dieM :: Property
 dieM =
     property $
-    case runIdentity $ S.parse (P.dieM (Identity "die test")) (S.fromList [0 :: Int]) of
+    case runIdentity $ PARSER_RUNNER
+            (FROM_PARSER_D (P.dieM (Identity "die test")))
+            (INPUT_FROM_LIST [0 :: Int]) of
         Right _ -> False
         Left _ -> True
 
 parserFail :: Property
 parserFail =
     property $
-        case runIdentity $ S.parse (Fail.fail err) (S.fromList [0 :: Int]) of
+        case runIdentity $ PARSER_RUNNER
+                (FROM_PARSER_D (Fail.fail err))
+                (INPUT_FROM_LIST [0 :: Int]) of
             Right _ -> False
             Left (ParseError e) -> err == e
     where
@@ -113,7 +145,9 @@ peekPass :: Property
 peekPass =
     forAll (chooseInt (1, max_length)) $ \list_length ->
         forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
-            case runIdentity $ S.parse P.peek (S.fromList ls) of
+            case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D P.peek)
+                    (INPUT_FROM_LIST ls) of
                 Right head_value -> case ls of
                     head_ls : _ -> head_value == head_ls
                     _ -> False
@@ -121,13 +155,17 @@ peekPass =
 
 peekFail :: Property
 peekFail =
-    property (case runIdentity $ S.parse P.peek (S.fromList []) of
+    property (case runIdentity $ PARSER_RUNNER
+            (FROM_PARSER_D P.peek)
+            (INPUT_FROM_LIST []) of
         Right _ -> False
         Left _ -> True)
 
 eofPass :: Property
 eofPass =
-    property (case runIdentity $ S.parse P.eof (S.fromList []) of
+    property (case runIdentity $ PARSER_RUNNER
+            (FROM_PARSER_D P.eof)
+            (INPUT_FROM_LIST []) of
         Right _ -> True
         Left _ -> False)
 
@@ -135,7 +173,9 @@ eofFail :: Property
 eofFail =
     forAll (chooseInt (1, max_length)) $ \list_length ->
         forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
-            case runIdentity $ S.parse P.eof (S.fromList ls) of
+            case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D P.eof)
+                    (INPUT_FROM_LIST ls) of
                 Right _ -> False
                 Left _ -> True
 
@@ -147,14 +187,18 @@ satisfyPass =
                 ls = first_element : ls_tail
                 predicate = (>= mid_value)
             in
-                case runIdentity $ S.parse (P.satisfy predicate) (S.fromList ls) of
+                case runIdentity $ PARSER_RUNNER
+                        (FROM_PARSER_D (P.satisfy predicate))
+                        (INPUT_FROM_LIST ls) of
                     Right r -> r == first_element
                     Left _ -> False
 
 satisfy :: Property
 satisfy =
     forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
-        case runIdentity $ S.parse (P.satisfy predicate) (S.fromList ls) of
+        case runIdentity $ PARSER_RUNNER
+                (FROM_PARSER_D (P.satisfy predicate))
+                (INPUT_FROM_LIST ls) of
             Right r -> case ls of
                 [] -> False
                 (x : _) -> predicate x && (r == x)
@@ -167,14 +211,16 @@ satisfy =
 onePass :: Property
 onePass =
     forAll (chooseInt (1, max_value)) $ \int ->
-        property (case runIdentity $ S.parse P.one (S.fromList [int]) of
+        property (case runIdentity $ PARSER_RUNNER
+                (FROM_PARSER_D P.one) (INPUT_FROM_LIST [int]) of
             Right i -> i  == int
             Left _ -> False)
 
 one :: Property
 one =
     property $
-        case runIdentity $ S.parse P.one (S.fromList []) of
+        case runIdentity $ PARSER_RUNNER
+                (FROM_PARSER_D P.one) (INPUT_FROM_LIST []) of
             Left _ -> True
             Right _ -> False
 
@@ -186,8 +232,9 @@ takeBetweenPass =
             forAll (chooseInt (m, max_value)) $ \list_length ->
                 forAll (vectorOf list_length (chooseInt (min_value, max_value)))
                     $ \ls ->
-                        case runIdentity $ S.parse (P.takeBetween m n FL.toList)
-                                (S.fromList ls) of
+                        case runIdentity $ PARSER_RUNNER
+                                (FROM_PARSER_D (P.takeBetween m n FL.toList))
+                                (INPUT_FROM_LIST ls) of
                             Right parsed_list ->
                                 let lpl = Prelude.length parsed_list
                                 in checkListEqual parsed_list
@@ -207,7 +254,9 @@ takeBetween =
         let inputLen = Prelude.length ls
          in do
             let p = P.takeBetween m n FL.toList
-            case runIdentity $ S.parse p (S.fromList ls) of
+            case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D p)
+                    (INPUT_FROM_LIST ls) of
                 Right xs ->
                     let parsedLen = Prelude.length xs
                     in if inputLen >= m && parsedLen >= m && parsedLen <= n
@@ -220,7 +269,9 @@ take :: Property
 take =
     forAll (chooseInt (min_value, max_value)) $ \n ->
         forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
-            case runIdentity $ S.parse (P.fromFold $ FL.take n FL.toList) (S.fromList ls) of
+            case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D (P.fromFold $ FL.take n FL.toList))
+                    (INPUT_FROM_LIST ls) of
                 Right parsed_list -> checkListEqual parsed_list (Prelude.take n ls)
                 Left _ -> property False
 
@@ -230,7 +281,9 @@ takeEQPass =
         forAll (chooseInt (n, max_value)) $ \list_length ->
             forAll (vectorOf list_length
                         (chooseInt (min_value, max_value))) $ \ls ->
-                case runIdentity $ S.parse (P.takeEQ n FL.toList) (S.fromList ls) of
+                case runIdentity $ PARSER_RUNNER
+                        (FROM_PARSER_D (P.takeEQ n FL.toList))
+                        (INPUT_FROM_LIST ls) of
                     Right parsed_list ->
                         checkListEqual parsed_list (Prelude.take n ls)
                     Left _ -> property False
@@ -242,7 +295,9 @@ takeEQ =
             let
                 list_length = Prelude.length ls
             in
-                case runIdentity $ S.parse (P.takeEQ n FL.toList) (S.fromList ls) of
+                case runIdentity $ PARSER_RUNNER
+                        (FROM_PARSER_D (P.takeEQ n FL.toList))
+                        (INPUT_FROM_LIST ls) of
                     Right parsed_list ->
                         if n <= list_length
                         then checkListEqual parsed_list (Prelude.take n ls)
@@ -255,7 +310,9 @@ takeGEPass =
         forAll (chooseInt (n, max_value)) $ \list_length ->
             forAll (vectorOf list_length (chooseInt (min_value, max_value)))
                 $ \ls ->
-                    case runIdentity $ S.parse (P.takeGE n FL.toList) (S.fromList ls) of
+                    case runIdentity $ PARSER_RUNNER
+                            (FROM_PARSER_D (P.takeGE n FL.toList))
+                            (INPUT_FROM_LIST ls) of
                         Right parsed_list -> checkListEqual parsed_list ls
                         Left _ -> property False
 
@@ -266,7 +323,9 @@ takeGE =
             let
                 list_length = Prelude.length ls
             in
-                case runIdentity $ S.parse (P.takeGE n FL.toList) (S.fromList ls) of
+                case runIdentity $ PARSER_RUNNER
+                        (FROM_PARSER_D (P.takeGE n FL.toList))
+                        (INPUT_FROM_LIST ls) of
                     Right parsed_list ->
                         if n <= list_length
                         then checkListEqual parsed_list ls
@@ -283,7 +342,8 @@ nLessThanEqual0 ::
 nLessThanEqual0 tk ltk =
     forAll (elements [0, (-1)]) $ \n ->
         forAll (listOf arbitrary) $ \ls ->
-            case runIdentity $ S.parse (tk n FL.toList) (S.fromList ls) of
+            case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D (tk n FL.toList)) (INPUT_FROM_LIST ls) of
                 Right parsed_list -> checkListEqual parsed_list (ltk n ls)
                 Left _ -> property False
 
@@ -309,7 +369,8 @@ lookAheadPass =
         in
             forAll (chooseInt (n+1, max_value)) $ \list_length ->
                 forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
-                    case runIdentity $ S.parse parseTwice (S.fromList ls) of
+                    case runIdentity $ PARSER_RUNNER
+                            (FROM_PARSER_D parseTwice) (INPUT_FROM_LIST ls) of
                         Right (ls_1, ls_2) -> checkListEqual ls_1 ls_2 .&&. checkListEqual ls_1 (Prelude.take n ls)
                         Left _ -> property $ False
 
@@ -325,7 +386,7 @@ lookAheadPass =
 --         in
 --             forAll (chooseInt (min_value, n - 1)) $ \list_length ->
 --                 forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
---                     case S.parse parseTwice (S.fromList ls) of
+--                     case PARSER_RUNNER parseTwice (INPUT_FROM_LIST ls) of
 --                         Right _ -> False
 --                         Left _ -> True
 
@@ -340,7 +401,8 @@ lookAhead =
                 return (parsed_list_1, parsed_list_2)
         in
             forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
-                case runIdentity $ S.parse parseTwice (S.fromList ls) of
+                case runIdentity $ PARSER_RUNNER
+                        (FROM_PARSER_D parseTwice) (INPUT_FROM_LIST ls) of
                     Right (ls_1, ls_2) -> checkListEqual ls_1 ls_2 .&&. checkListEqual ls_1 (Prelude.take n ls)
                     Left _ -> property ((list_length < n) || (list_length == n && n == 0))
                         where
@@ -349,7 +411,8 @@ lookAhead =
 takeEndBy_ :: Property
 takeEndBy_ =
     forAll (listOf (chooseInt (min_value, max_value )))  $ \ls ->
-        case runIdentity $ S.parse (P.takeEndBy_ predicate prsr) (S.fromList ls) of
+        case runIdentity $ PARSER_RUNNER
+                (FROM_PARSER_D (P.takeEndBy_ predicate prsr)) (INPUT_FROM_LIST ls) of
             Right parsed_list ->
                 checkListEqual parsed_list (tkwhl ls)
             Left _ -> property False
@@ -362,7 +425,9 @@ takeEndByOrMax_ :: Property
 takeEndByOrMax_ =
     forAll (chooseInt (min_value, max_value)) $ \n ->
         forAll (listOf (chooseInt (0, 1))) $ \ls ->
-            case runIdentity $ S.parse (P.fromFold $ FL.takeEndBy_ predicate (FL.take n FL.toList)) (S.fromList ls) of
+            case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D (P.fromFold $ FL.takeEndBy_ predicate (FL.take n FL.toList)))
+                    (INPUT_FROM_LIST ls) of
                 Right parsed_list -> checkListEqual parsed_list (Prelude.take n (Prelude.takeWhile (not . predicate) ls))
                 Left _ -> property False
             where
@@ -373,7 +438,8 @@ takeStartBy =
     forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
         let ls1 = 1:ls
         in
-            case runIdentity $ S.parse parser (S.fromList ls1) of
+            case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D parser) (INPUT_FROM_LIST ls1) of
                 Right parsed_list ->
                   if not $ Prelude.null ls1
                   then
@@ -391,7 +457,8 @@ takeStartBy =
 takeWhile :: Property
 takeWhile =
     forAll (listOf (chooseInt (0, 1))) $ \ ls ->
-        case runIdentity $ S.parse (P.takeWhile predicate FL.toList) (S.fromList ls) of
+        case runIdentity $ PARSER_RUNNER
+                (FROM_PARSER_D (P.takeWhile predicate FL.toList)) (INPUT_FROM_LIST ls) of
             Right parsed_list ->
                 checkListEqual parsed_list (Prelude.takeWhile predicate ls)
             Left _ -> property False
@@ -404,9 +471,10 @@ takeP =
         ((,) <$> chooseInt (min_value, max_value)
              <*> listOf (chooseInt (0, 1)))
         $ \(takeNum, ls) ->
-              case runIdentity $ S.parse
-                       (P.takeP takeNum (P.fromFold FL.toList))
-                       (S.fromList ls) of
+              case runIdentity $
+                        PARSER_RUNNER
+                        (FROM_PARSER_D (P.takeP takeNum (P.fromFold FL.toList)))
+                        (INPUT_FROM_LIST ls) of
                   Right parsed_list ->
                       checkListEqual parsed_list (Prelude.take takeNum ls)
                   Left _ -> property False
@@ -414,7 +482,8 @@ takeP =
 takeWhile1 :: Property
 takeWhile1 =
     forAll (listOf (chooseInt (0, 1))) $ \ ls ->
-        case runIdentity $ S.parse (P.takeWhile1 predicate  FL.toList) (S.fromList ls) of
+        case runIdentity $ PARSER_RUNNER
+                (FROM_PARSER_D (P.takeWhile1 predicate  FL.toList)) (INPUT_FROM_LIST ls) of
             Right parsed_list -> case ls of
                 [] -> property False
                 (x : _) ->
@@ -444,7 +513,8 @@ takeWhileP =
                 takeWhileTillLen maxLen prd list =
                     Prelude.take maxLen $ Prelude.takeWhile prd list
             in
-                case runIdentity $ S.parse prsr (S.fromList ls) of
+                case runIdentity $ PARSER_RUNNER
+                        (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
                     Right parsed_list ->
                         checkListEqual
                         parsed_list
@@ -459,7 +529,7 @@ choice =
              <*> chooseInt (min_value, max_value)
              <*> listOf (chooseInt (0, 1)))
         $ \(i, j, ls) ->
-              case S.parse (P.choice [parser i, parser j]) (S.fromList ls) of
+              case PARSER_RUNNER (FROM_PARSER_D (P.choice [parser i, parser j])) (INPUT_FROM_LIST ls) of
                   Right parsed_list ->
                       checkListEqual parsed_list $ take (min i j) ls
                   Left _ -> property False
@@ -473,7 +543,8 @@ groupBy :: Property
 groupBy =
     forAll (listOf (chooseInt (0, 1)))
         $ \ls ->
-              case runIdentity $ S.parse parser (S.fromList ls) of
+              case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D parser) (INPUT_FROM_LIST ls) of
                   Right parsed -> checkListEqual parsed (groupByLF ls)
                   Left _ -> property False
 
@@ -489,7 +560,8 @@ groupByRolling :: Property
 groupByRolling =
     forAll (listOf (chooseInt (0, 1)))
         $ \ls ->
-              case runIdentity $ S.parse parser (S.fromList ls) of
+              case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D parser) (INPUT_FROM_LIST ls) of
                   Right parsed -> checkListEqual parsed (groupByLF Nothing ls)
                   Left _ -> property False
 
@@ -508,12 +580,18 @@ wordBy :: Property
 wordBy =
     forAll (listOf (elements [' ', 's']))
         $ \ls ->
-              case runIdentity $ S.parse parser (S.fromList ls) of
+              case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D parser) (strm ls) of
                   Right parsed -> checkListEqual parsed (words' ls)
                   Left _ -> property False
 
     where
 
+#ifdef PARSER_K
+    strm = SK.fromPure . A.fromList
+#else
+    strm = S.fromList
+#endif
     predicate = (== ' ')
     parser = P.many (P.wordBy predicate FL.toList) FL.toList
     words' lst =
@@ -573,7 +651,9 @@ parseManyWordQuotedBy =
 splitWith :: Property
 splitWith =
     forAll (listOf (chooseInt (0, 1))) $ \ls ->
-        case runIdentity $ S.parse (P.splitWith (,) (P.satisfy (== 0)) (P.satisfy (== 1))) (S.fromList ls) of
+        case runIdentity $ PARSER_RUNNER
+                (FROM_PARSER_D (P.splitWith (,) (P.satisfy (== 0)) (P.satisfy (== 1))))
+                (INPUT_FROM_LIST ls) of
             Right (result_first, result_second) -> case ls of
                 0 : 1 : _ -> (result_first == 0) && (result_second == 1)
                 _ -> False
@@ -583,19 +663,25 @@ splitWith =
 
 splitWithFailLeft :: Property
 splitWithFailLeft =
-    property (case runIdentity $ S.parse (P.splitWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
+    property (case runIdentity $ PARSER_RUNNER
+            (FROM_PARSER_D (P.splitWith (,) (P.die "die") (P.fromPure (1 :: Int))))
+            (INPUT_FROM_LIST [1 :: Int]) of
         Right _ -> False
         Left _ -> True)
 
 splitWithFailRight :: Property
 splitWithFailRight =
-    property (case runIdentity $ S.parse (P.splitWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
+    property (case runIdentity $ PARSER_RUNNER
+            (FROM_PARSER_D (P.splitWith (,) (P.fromPure (1 :: Int)) (P.die "die")))
+            (INPUT_FROM_LIST [1 :: Int]) of
         Right _ -> False
         Left _ -> True)
 
 splitWithFailBoth :: Property
 splitWithFailBoth =
-    property (case runIdentity $ S.parse (P.splitWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
+    property (case runIdentity $ PARSER_RUNNER
+            (FROM_PARSER_D (P.splitWith (,) (P.die "die") (P.die "die")))
+            (INPUT_FROM_LIST [1 :: Int]) of
         Right _ -> False
         Left _ -> True)
 
@@ -606,25 +692,25 @@ splitWithFailBoth =
 --             let
 --                 prsr = P.fromFold $ FL.take n FL.toList
 --             in
---                 case S.parse (P.teeWith (,) prsr prsr) (S.fromList ls) of
+--                 case PARSER_RUNNER (FROM_PARSER_D (P.teeWith (,) prsr prsr)) (INPUT_FROM_LIST ls) of
 --                     Right (ls_1, ls_2) -> checkListEqual (Prelude.take n ls) ls_1 .&&. checkListEqual ls_1 ls_2
 --                     Left _ -> property False
 
 -- teeWithFailLeft :: Property
 -- teeWithFailLeft =
---     property (case S.parse (P.teeWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
+--     property (case PARSER_RUNNER (FROM_PARSER_D (P.teeWith (,) (P.die "die") (P.fromPure (1 :: Int)))) (INPUT_FROM_LIST [1 :: Int]) of
 --         Right _ -> False
 --         Left _ -> True)
 
 -- teeWithFailRight :: Property
 -- teeWithFailRight =
---     property (case S.parse (P.teeWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
+--     property (case PARSER_RUNNER (FROM_PARSER_D (P.teeWith (,) (P.fromPure (1 :: Int)) (P.die "die"))) (INPUT_FROM_LIST [1 :: Int]) of
 --         Right _ -> False
 --         Left _ -> True)
 
 -- teeWithFailBoth :: Property
 -- teeWithFailBoth =
---     property (case S.parse (P.teeWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
+--     property (case PARSER_RUNNER (FROM_PARSER_D (P.teeWith (,) (P.die "die") (P.die "die"))) (INPUT_FROM_LIST [1 :: Int]) of
 --         Right _ -> False
 --         Left _ -> True)
 
@@ -632,7 +718,7 @@ splitWithFailBoth =
 deintercalate :: Property
 deintercalate =
     forAll (listOf (chooseAny :: Gen Int)) $ \ls ->
-        case runIdentity $ S.parse p (S.fromList ls) of
+        case runIdentity $ PARSER_RUNNER p (INPUT_FROM_LIST ls) of
             Right evenOdd -> evenOdd == List.partition even ls
             Left _ -> False
 
@@ -654,28 +740,28 @@ deintercalate =
 --             prsr_2 = P.takeWhile (<= mid_value) FL.toList
 --             prsr_shortest = P.shortest prsr_1 prsr_2
 --         in
---             case S.parse prsr_shortest (S.fromList ls) of
+--             case PARSER_RUNNER prsr_shortest (INPUT_FROM_LIST ls) of
 --                 Right short_list -> checkListEqual short_list (Prelude.takeWhile (<= half_mid_value) ls)
 --                 Left _ -> property False
 
 -- shortestPassLeft :: Property
 -- shortestPassLeft =
---     property (case S.parse (P.shortest (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
+--     property (case PARSER_RUNNER (FROM_PARSER_D (P.shortest (P.die "die") (P.fromPure (1 :: Int)))) (INPUT_FROM_LIST [1 :: Int]) of
 --         Right r -> r == 1
 --         Left _ -> False)
 --
 -- shortestPassRight :: Property
 -- shortestPassRight =
---     property (case S.parse (P.shortest (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
+--     property (case PARSER_RUNNER (FROM_PARSER_D (P.shortest (P.fromPure (1 :: Int)) (P.die "die"))) (INPUT_FROM_LIST [1 :: Int]) of
 --         Right r -> r == 1
 --         Left _ -> False)
 
 -- shortestFailBoth :: Property
 -- shortestFailBoth =
 --     property
---         (case S.parse
+--         (case PARSER_RUNNER
 --                   (P.shortest (P.die "die") (P.die "die"))
---                   (S.fromList [1 :: Int]) of
+--                   (INPUT_FROM_LIST [1 :: Int]) of
 --              Right _ -> False
 --              Left _ -> True)
 --
@@ -688,26 +774,26 @@ deintercalate =
 --             prsr_2 = P.takeWhile (<= mid_value) FL.toList
 --             prsr_longest = P.longest prsr_1 prsr_2
 --         in
---             case S.parse prsr_longest (S.fromList ls) of
+--             case PARSER_RUNNER prsr_longest (INPUT_FROM_LIST ls) of
 --                 Right long_list -> long_list == Prelude.takeWhile (<= mid_value) ls
 --                 Left _ -> False
 --
 -- longestPassLeft :: Property
 -- longestPassLeft =
---     property (case S.parse (P.shortest (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
+--     property (case PARSER_RUNNER (FROM_PARSER_D (P.shortest (P.die "die") (P.fromPure (1 :: Int)))) (INPUT_FROM_LIST [1 :: Int]) of
 --         Right r -> r == 1
 --         Left _ -> False)
 --
 -- longestPassRight :: Property
 -- longestPassRight =
---     property (case S.parse (P.shortest (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
+--     property (case PARSER_RUNNER (FROM_PARSER_D (P.shortest (P.fromPure (1 :: Int)) (P.die "die"))) (INPUT_FROM_LIST [1 :: Int]) of
 --         Right r -> r == 1
 --         Left _ -> False)
 --
 -- longestFailBoth :: Property
 -- longestFailBoth =
 --     property
---         (case S.parse (P.shortest (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
+--         (case PARSER_RUNNER (FROM_PARSER_D (P.shortest (P.die "die") (P.die "die"))) (INPUT_FROM_LIST [1 :: Int]) of
 --         Right _ -> False
 --         Left _ -> True)
 
@@ -719,14 +805,17 @@ many =
             prsr =
                 flip P.many concatFold
                     $ P.fromFold $ FL.takeEndBy_ (== 1) FL.toList
-         in case runIdentity $ S.parse prsr (S.fromList ls) of
+         in case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
                 Right res_list ->
                     checkListEqual res_list (Prelude.filter (== 0) ls)
                 Left _ -> property False
 
 many_empty :: Property
 many_empty =
-    property (case runIdentity $ S.parse (flip P.many FL.toList (P.die "die")) (S.fromList [1 :: Int]) of
+    property (case runIdentity $ PARSER_RUNNER
+            (FROM_PARSER_D (flip P.many FL.toList (P.die "die")))
+            (INPUT_FROM_LIST [1 :: Int]) of
         Right res_list -> checkListEqual res_list ([] :: [Int])
         Left _ -> property False)
 
@@ -740,13 +829,16 @@ some =
             prsr =
                 flip P.some concatFold
                     $ P.fromFold $ FL.takeEndBy_ (== 1) FL.toList
-         in case runIdentity $ S.parse prsr (S.fromList ls) of
+         in case runIdentity $ PARSER_RUNNER
+                    (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
                 Right res_list -> res_list == Prelude.filter (== 0) ls
                 Left _ -> False
 
 someFail :: Property
 someFail =
-    property (case runIdentity $ S.parse (P.some (P.die "die") FL.toList) (S.fromList [1 :: Int]) of
+    property (case runIdentity $ PARSER_RUNNER
+            (FROM_PARSER_D (P.some (P.die "die") FL.toList))
+            (INPUT_FROM_LIST [1 :: Int]) of
         Right _ -> False
         Left _ -> True)
 
@@ -763,7 +855,9 @@ applicative =
                         <$> P.fromFold (FL.take (length list1) FL.toList)
                         <*> P.fromFold (FL.take (length list2) FL.toList)
              in
-                case runIdentity $ S.parse parser (S.fromList $ list1 ++ list2) of
+                case runIdentity $ PARSER_RUNNER
+                        (FROM_PARSER_D parser)
+                        (INPUT_FROM_LIST $ list1 ++ list2) of
                     Right (olist1, olist2) -> olist1 == list1 && olist2 == list2
                     Left _ -> False
 
@@ -773,9 +867,9 @@ sequence =
         let p xs = P.fromFold (FL.take (length xs) FL.toList)
          in monadicIO $ do
                 outs <- run $
-                        S.parse
-                            (Prelude.sequence $ fmap p ins)
-                            (S.fromList $ concat ins)
+                        PARSER_RUNNER
+                            (FROM_PARSER_D (Prelude.sequence $ fmap p ins))
+                            (INPUT_FROM_LIST $ concat ins)
                 return $
                     case outs of
                         Right ls -> ls == ins
@@ -784,9 +878,9 @@ sequence =
 altEOF1 :: Property
 altEOF1 =
     monadicIO $ do
-    s1 <- S.parse
-        (P.satisfy (> 0) <|> return 66)
-        (S.fromList ([]::[Int]))
+    s1 <- PARSER_RUNNER
+        (FROM_PARSER_D (P.satisfy (> 0) <|> return 66))
+        (INPUT_FROM_LIST ([]::[Int]))
     return $
         case s1 of
             Right x -> x == 66
@@ -795,9 +889,9 @@ altEOF1 =
 altEOF2 :: Property
 altEOF2 =
     monadicIO $ do
-    s1 <- S.parse
-        ((P.takeEQ 2 FL.toList) <|> (P.takeEQ 1 FL.toList))
-        (S.fromList ([51]::[Int]))
+    s1 <- PARSER_RUNNER
+        (FROM_PARSER_D ((P.takeEQ 2 FL.toList) <|> (P.takeEQ 1 FL.toList)))
+        (INPUT_FROM_LIST ([51]::[Int]))
     return $
         case s1 of
             Right x -> x == [51]
@@ -812,7 +906,9 @@ monad =
                     olist2 <- P.fromFold (FL.take (length list2) FL.toList)
                     return (olist1, olist2)
              in monadicIO $ do
-                    s <- S.parse parser (S.fromList $ list1 ++ list2)
+                    s <- PARSER_RUNNER
+                            (FROM_PARSER_D parser)
+                            (INPUT_FROM_LIST $ list1 ++ list2)
                     return $
                         case s of
                             Right (olist1, olist2) -> olist1 == list1 && olist2 == list2
@@ -868,15 +964,19 @@ parserSequence :: Property
 parserSequence =
   forAll (vectorOf 11 (listOf (chooseAny :: Gen Int))) $ \ins ->
     monadicIO $ do
-    let parsers = S.fromList
-            $ fmap (\xs -> P.fromFold $ FL.take (length xs) FL.sum) ins
-    let sequencedParser = P.sequence parsers FL.sum
-    outs <-
-        S.parse sequencedParser $ S.concatMap S.fromList (S.fromList ins)
-    return $
-        case outs of
-            Right x -> x == sum (map sum ins)
-            Left _ -> False
+        let parsers = S.fromList
+                $ fmap (\xs -> P.fromFold $ FL.take (length xs) FL.sum) ins
+        let sequencedParser = FROM_PARSER_D (P.sequence parsers FL.sum)
+#ifdef PARSER_K
+            strm = SK.map A.fromList (SK.fromList ins)
+#else
+            strm = S.concatMap S.fromList (S.fromList ins)
+#endif
+        outs <- PARSER_RUNNER sequencedParser strm
+        return $
+            case outs of
+                Right x -> x == sum (map sum ins)
+                Left _ -> False
 
 -------------------------------------------------------------------------------
 -- Test for a particular case hit during fs events testing
@@ -947,9 +1047,9 @@ manyEqParseMany =
     forAll (listOf (chooseInt (0, 100))) $ \lst ->
     forAll (chooseInt (1, 100)) $ \i ->
         monadicIO $ do
-            let strm = S.fromList lst
-            r1 <- run $ S.parse (P.many (split i) FL.toList) strm
-            r2 <- run $ S.fold FL.toList $ S.catRights $ S.parseMany (split i) strm
+            let strm = INPUT_FROM_LIST lst
+            r1 <- run $ PARSER_RUNNER (FROM_PARSER_D (P.many (split i) FL.toList)) strm
+            r2 <- run $ S.fold FL.toList $ S.catRights $ S.parseMany (split i) (S.fromList lst)
             return $
                 case r1 of
                     Right o1 -> o1 == r2
@@ -963,7 +1063,7 @@ manyEqParseMany =
 takeEndBy1 :: Property
 takeEndBy1 =
     forAll (listOf (chooseInt (0, 1))) $ \ls ->
-        case runIdentity $ S.parse (P.takeEndBy predicate prsr) (S.fromList ls) of
+        case runIdentity $ PARSER_RUNNER (FROM_PARSER_D (P.takeEndBy predicate prsr)) (INPUT_FROM_LIST ls) of
             Right parsed_list ->
                 checkListEqual
                 parsed_list
@@ -1053,7 +1153,7 @@ takeEndByEsc =
                     Just _ ->
                             x : escapeSep Nothing xs
         in
-            case runIdentity $ S.parse prsr (S.fromList ls) of
+            case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
                 Right parsed_list -> checkListEqual parsed_list $ escapeSep Nothing ls
                 Left err -> property (displayException err == msg)
 
@@ -1129,7 +1229,7 @@ takeFramedByEsc_ =
                 in
                     helper l Nothing (0 :: Int)
         in
-            case runIdentity $ S.parse prsr (S.fromList ls) of
+            case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
                 Right parsed_list ->
                     if checkPassBeg ls
                     then checkListEqual parsed_list $
@@ -1186,7 +1286,7 @@ takeFramedByEsc_Pass =
                 in
                     helper l Nothing (0 :: Int)
         in
-            case runIdentity $ S.parse prsr (S.fromList ls) of
+            case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
                 Right parsed_list -> checkListEqual parsed_list $ escapeFrame isBegin isEnd isEsc ls
                 _ -> property False
 
@@ -1205,7 +1305,7 @@ takeFramedByEsc_Fail1 =
 
         ls = [0 :: Int]
     in
-        case runIdentity $ S.parse prsr (S.fromList ls) of
+        case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
             Right _ -> property False
             Left err -> property (displayException err == msg)
 
@@ -1224,7 +1324,7 @@ takeFramedByEsc_Fail2 =
 
         ls = [1 :: Int]
     in
-        case runIdentity $ S.parse prsr (S.fromList ls) of
+        case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
             Right _ -> property False
             Left err -> property (displayException err == msg)
 
@@ -1243,7 +1343,7 @@ takeFramedByEsc_Fail3 =
 
         ls = [2 :: Int]
     in
-        case runIdentity $ S.parse prsr (S.fromList ls) of
+        case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
             Right _ -> property False
             Left err -> property $ (displayException err == msg)
 
@@ -1253,7 +1353,7 @@ takeStartBy_ =
         let ls1 = 1:ls
             msg = "takeFramedByGeneric: empty token"
         in
-            case runIdentity $ S.parse parser (S.fromList ls1) of
+            case runIdentity $ PARSER_RUNNER (FROM_PARSER_D parser) (INPUT_FROM_LIST ls1) of
                 Right parsed_list ->
                   if not $ Prelude.null ls1
                   then
diff --git a/test/Streamly/Test/Data/ParserK.hs b/test/Streamly/Test/Data/ParserK.hs
deleted file mode 100644
index ae75a648a6..0000000000
--- a/test/Streamly/Test/Data/ParserK.hs
+++ /dev/null
@@ -1,836 +0,0 @@
-module Main (main) where
-
-import Control.Applicative ((<|>))
-import Control.Exception (SomeException(..), try)
-import Data.Word (Word8, Word32, Word64)
-import Streamly.Test.Common (listEquals, checkListEqual, chooseInt)
-import Test.Hspec (Spec, hspec, describe)
-import Test.Hspec.QuickCheck
-import Test.QuickCheck
-       (arbitrary, forAll, elements, Property,
-        property, listOf, vectorOf, (.&&.), Gen)
-import Test.QuickCheck.Monadic (monadicIO, assert, run)
-
-import qualified Data.List as List
-import qualified Prelude
-import qualified Streamly.Data.Stream as S
-import qualified Streamly.Internal.Data.Array as A
-import qualified Streamly.Internal.Data.Fold as FL
-import qualified Streamly.Internal.Data.Parser as P
-import qualified Streamly.Internal.Data.Producer as Producer
-import qualified Streamly.Internal.Data.Stream as S
-import qualified Streamly.Internal.Data.Stream as D
-import qualified Streamly.Internal.Data.Unfold as Unfold
-import qualified Test.Hspec as H
-
-import Prelude hiding (sequence)
-
-#if MIN_VERSION_QuickCheck(2,14,0)
-
-import Test.QuickCheck (chooseAny)
-import Control.Monad.Identity (runIdentity, Identity (Identity))
-
-#else
-
-import System.Random (Random(random))
-import Test.QuickCheck.Gen (Gen(MkGen))
-
--- | Generates a random element over the natural range of `a`.
-chooseAny :: Random a => Gen a
-chooseAny = MkGen (\r _ -> let (x,_) = random r in x)
-
-#endif
-
-maxTestCount :: Int
-maxTestCount = 100
-
-min_value :: Int
-min_value = 0
-
-mid_value :: Int
-mid_value = 5000
-
-max_value :: Int
-max_value = 10000
-
-max_length :: Int
-max_length = 1000
-
-toList :: Monad m => S.Stream m a -> m [a]
-toList = S.fold FL.toList
-
--- Accumulator Tests
-
-fromFold :: Property
-fromFold =
-    forAll (listOf $ chooseInt (min_value, max_value))
-      $ \ls ->
-            case (==) <$> runIdentity (S.parseD (P.fromFold FL.sum) (S.fromList ls))
-                   <*> (S.fold FL.sum (S.fromList ls)) of
-                Right is_equal -> is_equal
-                Left _ -> False
-
-fromPure :: Property
-fromPure =
-    forAll (chooseInt (min_value, max_value)) $ \x ->
-        case runIdentity $ S.parseD (P.fromPure x) (S.fromList [1 :: Int]) of
-            Right r -> r == x
-            Left _ -> False
-
-fromEffect :: Property
-fromEffect =
-    forAll (chooseInt (min_value, max_value)) $ \x ->
-        case runIdentity $ S.parseD (P.fromEffect $ return x) (S.fromList [1 :: Int]) of
-            Right r -> r == x
-            Left _ -> False
-
-die :: Property
-die =
-    property $
-    case runIdentity (S.parseD (P.die "die test") (S.fromList [0 :: Int])) of
-        Right _ -> False
-        Left _ -> True
-
-dieM :: Property
-dieM =
-    property $
-    case runIdentity (S.parseD (P.dieM (Identity "die test")) (S.fromList [0 :: Int])) of
-        Right _ -> False
-        Left _ -> True
-
--- Element Parser Tests
-
-peekPass :: Property
-peekPass =
-    forAll (chooseInt (1, max_length)) $ \list_length ->
-        forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
-            case runIdentity $ S.parseD P.peek (S.fromList ls) of
-                Right head_value -> case ls of
-                    head_ls : _ -> head_value == head_ls
-                    _ -> False
-                Left _ -> False
-
-peekFail :: Property
-peekFail =
-    property (case runIdentity $ S.parseD P.peek (S.fromList []) of
-        Right _ -> False
-        Left _ -> True)
-
-eofPass :: Property
-eofPass =
-    property (case S.parseD P.eof (S.fromList []) of
-        Right _ -> True
-        Left _ -> False)
-
-eofFail :: Property
-eofFail =
-    forAll (chooseInt (1, max_length)) $ \list_length ->
-        forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
-            case runIdentity $ S.parseD P.eof (S.fromList ls) of
-                Right _ -> False
-                Left _ -> True
-
-satisfyPass :: Property
-satisfyPass =
-    forAll (chooseInt (mid_value, max_value)) $ \first_element ->
-        forAll (listOf (chooseInt (min_value, max_value))) $ \ls_tail ->
-            let
-                ls = first_element : ls_tail
-                predicate = (>= mid_value)
-            in
-                case runIdentity $ S.parseD (P.satisfy predicate) (S.fromList ls) of
-                    Right r -> r == first_element
-                    Left _ -> False
-
-satisfy :: Property
-satisfy =
-    forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
-        case runIdentity $ S.parseD (P.satisfy predicate) (S.fromList ls) of
-            Right r -> case ls of
-                [] -> False
-                (x : _) -> predicate x && (r == x)
-            Left _ -> case ls of
-                [] -> True
-                (x : _) -> not $ predicate x
-        where
-            predicate = (>= mid_value)
-
--- Sequence Parsers Tests
-takeBetweenPass :: Property
-takeBetweenPass =
-    forAll (chooseInt (min_value, max_value)) $ \m ->
-        forAll (chooseInt (m, max_value)) $ \n ->
-            forAll (chooseInt (m, max_value)) $ \list_length ->
-                forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
-                    case runIdentity $ S.parseD (P.takeBetween m n FL.toList) (S.fromList ls) of
-                        Right parsed_list ->
-                            let lpl = Prelude.length parsed_list
-                            in checkListEqual parsed_list (Prelude.take lpl ls)
-                        Left _ -> property False
-
-
-takeBetween :: Property
-takeBetween =
-    forAll (chooseInt (min_value, max_value)) $ \m ->
-        forAll (chooseInt (min_value, max_value)) $ \n ->
-            forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
-                let
-                    list_length = Prelude.length ls
-                in monadicIO $ do
-                    let p = P.takeBetween m n FL.toList
-                    r <- run $ try $ S.parseD p (S.fromList ls)
-                    return $ case r of
-                        Right x -> case x of
-                            Right parsed_list ->
-                                if m <= list_length && n >= m
-                                then
-                                    let len = Prelude.length parsed_list
-                                    in checkListEqual
-                                            parsed_list (Prelude.take len ls)
-                                else property False
-                            Left _ ->
-                                property (m > n || list_length < m)
-                        Left (_ :: SomeException) ->
-                            property (m > n || list_length < m)
-
-take :: Property
-take =
-    forAll (chooseInt (min_value, max_value)) $ \n ->
-        forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
-            case runIdentity $ S.parseD (P.fromFold $ FL.take n FL.toList) (S.fromList ls) of
-                Right parsed_list -> checkListEqual parsed_list (Prelude.take n ls)
-                Left _ -> property False
-
-takeEQPass :: Property
-takeEQPass =
-    forAll (chooseInt (min_value, max_value)) $ \n ->
-        forAll (chooseInt (n, max_value)) $ \list_length ->
-            forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
-                case runIdentity $ S.parseD (P.takeEQ n FL.toList) (S.fromList ls) of
-                    Right parsed_list -> checkListEqual parsed_list (Prelude.take n ls)
-                    Left _ -> property False
-
-takeEQ :: Property
-takeEQ =
-    forAll (chooseInt (min_value, max_value)) $ \n ->
-        forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
-            let
-                list_length = Prelude.length ls
-            in
-                case runIdentity $ S.parseD (P.takeEQ n FL.toList) (S.fromList ls) of
-                    Right parsed_list ->
-                        if (n <= list_length) then
-                            checkListEqual parsed_list (Prelude.take n ls)
-                        else
-                            property False
-                    Left _ -> property (n > list_length)
-
-takeGEPass :: Property
-takeGEPass =
-    forAll (chooseInt (min_value, max_value)) $ \n ->
-        forAll (chooseInt (n, max_value)) $ \list_length ->
-            forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
-                case runIdentity $ S.parseD (P.takeGE n FL.toList) (S.fromList ls) of
-                    Right parsed_list -> checkListEqual parsed_list ls
-                    Left _ -> property False
-
-takeGE :: Property
-takeGE =
-    forAll (chooseInt (min_value, max_value)) $ \n ->
-        forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
-            let
-                list_length = Prelude.length ls
-            in
-                case runIdentity $ S.parseD (P.takeGE n FL.toList) (S.fromList ls) of
-                    Right parsed_list ->
-                        if (n <= list_length) then
-                            checkListEqual parsed_list ls
-                        else
-                            property False
-                    Left _ -> property (n > list_length)
-
-nLessThanEqual0 ::
-       (  Int
-       -> FL.Fold Identity Int [Int]
-       -> P.Parser Int Identity [Int]
-       )
-    -> (Int -> [Int] -> [Int])
-    -> Property
-nLessThanEqual0 tk ltk =
-    forAll (elements [0, (-1)]) $ \n ->
-        forAll (listOf arbitrary) $ \ls ->
-            case runIdentity $ S.parseD (tk n FL.toList) (S.fromList ls) of
-                Right parsed_list -> checkListEqual parsed_list (ltk n ls)
-                Left _ -> property False
-
-takeProperties :: Spec
-takeProperties =
-    describe "take combinators when n <= 0/" $ do
-        prop "takeEQ n FL.toList = []" $
-            nLessThanEqual0 P.takeEQ (\_ -> const [])
-        prop "takeGE n FL.toList xs = xs" $
-            nLessThanEqual0 P.takeGE (\_ -> id)
-
-
--- XXX lookAhead can't deal with EOF which in this case means when
--- n==list_length, this test will fail. So excluding that case for now.
-lookAheadPass :: Property
-lookAheadPass =
-    forAll (chooseInt (min_value, max_value)) $ \n ->
-        let
-            takeWithoutConsume = P.lookAhead $ P.fromFold $ FL.take n FL.toList
-            parseTwice = do
-                parsed_list_1 <- takeWithoutConsume
-                parsed_list_2 <- takeWithoutConsume
-                return (parsed_list_1, parsed_list_2)
-        in
-            forAll (chooseInt (n+1, max_value)) $ \list_length ->
-                forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
-                    case runIdentity $ S.parseD parseTwice (S.fromList ls) of
-                        Right (ls_1, ls_2) -> checkListEqual ls_1 ls_2 .&&. checkListEqual ls_1 (Prelude.take n ls)
-                        Left _ -> property $ False
-
-lookAhead :: Property
-lookAhead =
-    forAll (chooseInt (min_value, max_value)) $ \n ->
-        let
-            takeWithoutConsume = P.lookAhead $ P.fromFold $ FL.take n FL.toList
-            parseTwice = do
-                parsed_list_1 <- takeWithoutConsume
-                parsed_list_2 <- takeWithoutConsume
-                return (parsed_list_1, parsed_list_2)
-        in
-            forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
-                case runIdentity $ S.parseD parseTwice (S.fromList ls) of
-                    Right (ls_1, ls_2) -> checkListEqual ls_1 ls_2 .&&. checkListEqual ls_1 (Prelude.take n ls)
-                    Left _ -> property ((list_length < n) || (list_length == n && n == 0))
-                        where
-                            list_length = Prelude.length ls
-
-takeWhile :: Property
-takeWhile =
-    forAll (listOf (chooseInt (0, 1))) $ \ ls ->
-        case runIdentity $ S.parseD (P.takeWhile predicate FL.toList) (S.fromList ls) of
-            Right parsed_list -> checkListEqual parsed_list (Prelude.takeWhile predicate ls)
-            Left _ -> property False
-        where
-            predicate = (== 0)
-
-takeWhile1 :: Property
-takeWhile1 =
-    forAll (listOf (chooseInt (0, 1))) $ \ ls ->
-        case runIdentity $ S.parseD (P.takeWhile1 predicate  FL.toList) (S.fromList ls) of
-            Right parsed_list -> case ls of
-                [] -> property False
-                (x : _) ->
-                    if predicate x then
-                        checkListEqual parsed_list (Prelude.takeWhile predicate ls)
-                    else
-                        property False
-            Left _ -> case ls of
-                [] -> property True
-                (x : _) -> property (not $ predicate x)
-        where
-            predicate = (== 0)
-
-groupBy :: Property
-groupBy =
-    forAll (listOf (chooseInt (0, 1)))
-        $ \ls ->
-              case runIdentity $ S.parseD parser (S.fromList ls) of
-                  Right parsed -> checkListEqual parsed (groupByLF ls)
-                  Left _ -> property False
-
-    where
-
-    cmp = (==)
-    parser = P.groupBy cmp FL.toList
-    groupByLF lst
-        | null lst = []
-        | otherwise = head $ List.groupBy cmp lst
-
-groupByRolling :: Property
-groupByRolling =
-    forAll (listOf (chooseInt (0, 1)))
-        $ \ls ->
-              case runIdentity $ S.parseD parser (S.fromList ls) of
-                  Right parsed -> checkListEqual parsed (groupByLF Nothing ls)
-                  Left _ -> property False
-
-    where
-
-    cmp = (==)
-    parser = P.groupBy cmp FL.toList
-    groupByLF _ [] = []
-    groupByLF Nothing (x:xs) = x : groupByLF (Just x) xs
-    groupByLF (Just y) (x:xs) =
-        if cmp y x
-        then x : groupByLF (Just x) xs
-        else []
-
-takeEndByOrMax :: Property
-takeEndByOrMax =
-    forAll (chooseInt (min_value, max_value)) $ \n ->
-        forAll (listOf (chooseInt (0, 1))) $ \ls ->
-            case runIdentity $ S.parseD (P.fromFold $ FL.takeEndBy_ predicate (FL.take n FL.toList)) (S.fromList ls) of
-                Right parsed_list -> checkListEqual parsed_list (Prelude.take n (Prelude.takeWhile (not . predicate) ls))
-                Left _ -> property False
-            where
-                predicate = (== 1)
-
-wordBy :: Property
-wordBy =
-    forAll (listOf (elements [' ', 's']))
-        $ \ls ->
-              case runIdentity $ S.parseD parser (S.fromList ls) of
-                  Right parsed -> checkListEqual parsed (words' ls)
-                  Left _ -> property False
-
-    where
-
-    predicate = (== ' ')
-    parser = P.many (P.wordBy predicate FL.toList) FL.toList
-    words' lst =
-        let wrds = words lst
-         in if wrds == [] && length lst > 0 then [""] else wrds
-
-
-splitWith :: Property
-splitWith =
-    forAll (listOf (chooseInt (0, 1))) $ \ls ->
-        case runIdentity $ S.parseD (P.splitWith (,) (P.satisfy (== 0)) (P.satisfy (== 1))) (S.fromList ls) of
-            Right (result_first, result_second) -> case ls of
-                0 : 1 : _ -> (result_first == 0) && (result_second == 1)
-                _ -> False
-            Left _ -> case ls of
-                0 : 1 : _ -> False
-                _ -> True
-
-splitWithFailLeft :: Property
-splitWithFailLeft =
-    property (case runIdentity $ S.parseD (P.splitWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
-        Right _ -> False
-        Left _ -> True)
-
-splitWithFailRight :: Property
-splitWithFailRight =
-    property (case runIdentity $ S.parseD (P.splitWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
-        Right _ -> False
-        Left _ -> True)
-
-splitWithFailBoth :: Property
-splitWithFailBoth =
-    property (case runIdentity $ S.parseD (P.splitWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
-        Right _ -> False
-        Left _ -> True)
-
-{-
-teeWithPass :: Property
-teeWithPass =
-    forAll (chooseInt (min_value, max_value)) $ \n ->
-        forAll (listOf (chooseInt (0, 1))) $ \ls ->
-            let
-                prsr = P.fromFold $ FL.take n FL.toList
-            in
-                case S.parseD (P.teeWith (,) prsr prsr) (S.fromList ls) of
-                    Right (ls_1, ls_2) -> checkListEqual (Prelude.take n ls) ls_1 .&&. checkListEqual ls_1 ls_2
-                    Left _ -> property False
-
-teeWithFailLeft :: Property
-teeWithFailLeft =
-    property (case S.parseD (P.teeWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
-        Right _ -> False
-        Left _ -> True)
-
-teeWithFailRight :: Property
-teeWithFailRight =
-    property (case S.parseD (P.teeWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
-        Right _ -> False
-        Left _ -> True)
-
-teeWithFailBoth :: Property
-teeWithFailBoth =
-    property (case S.parseD (P.teeWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
-        Right _ -> False
-        Left _ -> True)
-
-shortestPass :: Property
-shortestPass =
-    forAll (listOf (chooseInt(min_value, max_value))) $ \ls ->
-        let
-            half_mid_value = mid_value `Prelude.div` 2
-            prsr_1 = P.takeWhile (<= half_mid_value) FL.toList
-            prsr_2 = P.takeWhile (<= mid_value) FL.toList
-            prsr_shortest = P.shortest prsr_1 prsr_2
-        in
-            case S.parseD prsr_shortest (S.fromList ls) of
-                Right short_list -> checkListEqual short_list (Prelude.takeWhile (<= half_mid_value) ls)
-                Left _ -> property False
-
-shortestPassLeft :: Property
-shortestPassLeft =
-    property (case S.parseD (P.shortest (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
-        Right r -> r == 1
-        Left _ -> False)
-
-shortestPassRight :: Property
-shortestPassRight =
-    property (case S.parseD (P.shortest (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
-        Right r -> r == 1
-        Left _ -> False)
-
-shortestFailBoth :: Property
-shortestFailBoth =
-    property
-        (case S.parseD
-                  (P.shortest (P.die "die") (P.die "die"))
-                  (S.fromList [1 :: Int]) of
-             Right _ -> False
-             Left _ -> True)
-
-longestPass :: Property
-longestPass =
-    forAll (listOf (chooseInt(min_value, max_value))) $ \ls ->
-        let
-            half_mid_value = mid_value `Prelude.div` 2
-            prsr_1 = P.takeWhile (<= half_mid_value) FL.toList
-            prsr_2 = P.takeWhile (<= mid_value) FL.toList
-            prsr_longest = P.longest prsr_1 prsr_2
-        in
-            case S.parseD prsr_longest (S.fromList ls) of
-                Right long_list -> long_list == Prelude.takeWhile (<= mid_value) ls
-                Left _ -> False
-
-longestPassLeft :: Property
-longestPassLeft =
-    property (case S.parseD (P.shortest (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
-        Right r -> r == 1
-        Left _ -> False)
-
-longestPassRight :: Property
-longestPassRight =
-    property (case S.parseD (P.shortest (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
-        Right r -> r == 1
-        Left _ -> False)
-
-longestFailBoth :: Property
-longestFailBoth =
-    property
-        (case S.parseD (P.shortest (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
-        Right _ -> False
-        Left _ -> True)
--}
-
-many :: Property
-many =
-    forAll (listOf (chooseInt (0, 1)))
-      $ \ls ->
-            let fldstp conL currL = return $ FL.Partial (conL ++ currL)
-                concatFold =
-                    FL.Fold fldstp (return (FL.Partial [])) return
-                prsr =
-                    flip P.many concatFold
-                        $ P.fromFold $ FL.takeEndBy_ (== 1) FL.toList
-             in case runIdentity $ S.parseD prsr (S.fromList ls) of
-                    Right res_list ->
-                        checkListEqual res_list (Prelude.filter (== 0) ls)
-                    Left _ -> property False
-
-many_empty :: Property
-many_empty =
-    property (case runIdentity $ S.parseD (flip P.many FL.toList (P.die "die")) (S.fromList [1 :: Int]) of
-        Right res_list -> checkListEqual res_list ([] :: [Int])
-        Left _ -> property False)
-
-some :: Property
-some =
-    forAll (listOf (chooseInt (0, 1)))
-      $ \ls ->
-            let fldstp conL currL = return $ FL.Partial $ conL ++ currL
-                concatFold = FL.Fold fldstp (return (FL.Partial [])) return
-                prsr =
-                    flip P.some concatFold
-                        $ P.fromFold $ FL.takeEndBy_ (== 1) FL.toList
-             in case runIdentity $ S.parseD prsr (S.fromList ls) of
-                    Right res_list -> res_list == Prelude.filter (== 0) ls
-                    Left _ -> False
-
-someFail :: Property
-someFail =
-    property (case runIdentity $ S.parseD (P.some (P.die "die") FL.toList) (S.fromList [1 :: Int]) of
-        Right _ -> False
-        Left _ -> True)
-
--------------------------------------------------------------------------------
--- Instances
--------------------------------------------------------------------------------
-
-applicative :: Property
-applicative =
-    forAll (listOf (chooseAny :: Gen Int)) $ \ list1 ->
-        forAll (listOf (chooseAny :: Gen Int)) $ \ list2 ->
-            monadicIO $ do
-            let parser =
-                        (,)
-                            <$> P.fromFold (FL.take (length list1) FL.toList)
-                            <*> P.fromFold (FL.take (length list2) FL.toList)
-
-            return $
-                case runIdentity $ S.parseD parser (S.fromList $ list1 ++ list2) of
-                    Right (olist1, olist2) -> olist1 == list1 && olist2 == list2
-                    Left _ -> False
-
-sequence :: Property
-sequence =
-    forAll (vectorOf 11 (listOf (chooseAny :: Gen Int))) $ \ ins ->
-        monadicIO $ do
-        let parsers = fmap (\xs -> P.fromFold $ FL.take (length xs) FL.toList) ins
-        outs <- S.parseD
-                    (Prelude.sequence parsers)
-                    (S.fromList $ concat ins)
-        return $
-            case outs of
-                Right x -> x == ins
-                Left _ -> False
-
-altEOF1 :: Property
-altEOF1 =
-    monadicIO $ do
-    s1 <- S.parseD
-        (P.satisfy (> 0) <|> return 66)
-        (S.fromList ([]::[Int]))
-    return $
-        case s1 of
-            Right x -> x == 66
-            Left _ -> False
-
-altEOF2 :: Property
-altEOF2 =
-    monadicIO $ do
-    s1 <- S.parseD
-        ((P.takeEQ 2 FL.toList) <|> (P.takeEQ 1 FL.toList))
-        (S.fromList ([51]::[Int]))
-    return $
-        case s1 of
-            Right x -> x == [51]
-            Left _ -> False
-
-monad :: Property
-monad =
-    forAll (listOf (chooseAny :: Gen Int)) $ \ list1 ->
-        forAll (listOf (chooseAny :: Gen Int)) $ \ list2 ->
-            monadicIO $ do
-            let parser = do
-                            olist1 <- P.fromFold (FL.take (length list1) FL.toList)
-                            olist2 <- P.fromFold (FL.take (length list2) FL.toList)
-                            return (olist1, olist2)
-            s1 <- S.parseD parser (S.fromList $ list1 ++ list2)
-            return $
-                case s1 of
-                Right (olist1, olist2) -> olist1 == list1 && olist2 == list2
-                Left _ -> False
-
--------------------------------------------------------------------------------
--- Stream parsing
--------------------------------------------------------------------------------
-
-parseMany :: Property
-parseMany =
-    forAll (chooseInt (1,100)) $ \len ->
-        forAll (listOf (vectorOf len (chooseAny :: Gen Int))) $ \ ins ->
-            monadicIO $ do
-            outs <-
-                (toList $ S.catRights $ S.parseManyD
-                    (P.fromFold $ FL.take len FL.toList) (S.fromList $ concat ins)
-                )
-            return $ outs == ins
-
--- basic sanity test for parsing from arrays
-parseUnfold :: Property
-parseUnfold = do
-    let len = 200
-    -- ls = input list (stream)
-    -- clen = chunk size
-    -- tlen = parser take size
-    forAll
-        ((,,)
-            <$> vectorOf len (chooseAny :: Gen Int)
-            <*> chooseInt (1, len)
-            <*> chooseInt (1, len)) $ \(ls, clen, tlen) ->
-        monadicIO $ do
-            arrays <- toList $ S.chunksOf clen (S.fromList ls)
-            let src = Producer.source (Just (Producer.OuterLoop arrays))
-            let parser = P.fromFold (FL.take tlen FL.toList)
-            let readSrc =
-                    Producer.producer
-                        $ Producer.concat Producer.fromList A.producer
-            let streamParser =
-                    Producer.simplify (Producer.parseManyD parser readSrc)
-            xs <- run
-                $ toList
-                $ S.unfoldMany Unfold.fromList
-                $ S.catRights
-                $ S.unfold streamParser src
-
-            listEquals (==) xs ls
-
-parserSequence :: Property
-parserSequence =
-  forAll (vectorOf 11 (listOf (chooseAny :: Gen Int))) $ \ins ->
-    monadicIO $ do
-    let parsers = D.fromList
-            $ fmap (\xs -> P.fromFold $ FL.take (length xs) FL.sum) ins
-    let sequencedParser = P.sequence parsers FL.sum
-    outs <-
-        S.parseD sequencedParser $ S.concatMap S.fromList (S.fromList ins)
-    return $
-        case outs of
-            Right x -> x == sum (map sum ins)
-            Left _ -> False
-
--------------------------------------------------------------------------------
--- Test for a particular case hit during fs events testing
--------------------------------------------------------------------------------
-
-evId :: [Word8]
-evId = [96,238,17,9,0,0,0,0]
-
-evFlags :: [Word8]
-evFlags = [0,4,1,0,0,0,0,0]
-
-evPathLen :: [Word8]
-evPathLen = [71,0,0,0,0,0,0,0]
-
-evPath :: [Word8]
-evPath =
-    [47,85,115,101,114,115,47,118,111,108,47,118,101,109,98,97,47,99,111,109
-    ,112,111,115,101,119,101 ,108,108,45,116,101,99,104,47,69,110,103,47,112
-    ,114,111,106,101,99,116,115,47,115,116,114,101,97,109,108,121,47,115,116
-    ,114,101,97,109,108,121,47,116,109,112,47,122,122
-    ]
-
-event :: [Word8]
-event = evId ++ evFlags ++ evPathLen ++ evPath
-
-data Event = Event
-   { eventId :: Word64
-   , eventFlags :: Word32
-   , eventAbsPath :: A.Array Word8
-   } deriving (Show, Ord, Eq)
-
-readOneEvent :: P.Parser Word8 IO Event
-readOneEvent = do
-    arr <- P.takeEQ 24 (A.writeN 24)
-    let arr1 = A.castUnsafe arr :: A.Array Word64
-        eid = A.getIndexUnsafe 0 arr1
-        eflags = A.getIndexUnsafe 1 arr1
-        pathLen = fromIntegral $ A.getIndexUnsafe 2 arr1
-    path <- P.takeEQ pathLen (A.writeN pathLen)
-    return $ Event
-        { eventId = eid
-        , eventFlags = fromIntegral eflags
-        , eventAbsPath = path
-        }
-
-parseMany2Events :: Property
-parseMany2Events =
-    monadicIO $ do
-        xs <-
-            ( run
-            $ toList
-            $ S.catRights
-            $ S.parseManyD readOneEvent
-            $ S.fromList (concat (replicate 2 event))
-            )
-        assert (length xs == 2)
-        -- XXX assuming little endian machine
-        let ev = Event
-                { eventId = 152170080
-                , eventFlags = 66560
-                , eventAbsPath = A.fromList evPath
-                }
-         in listEquals (==) xs (replicate 2 ev)
-
--------------------------------------------------------------------------------
--- Main
--------------------------------------------------------------------------------
-
-moduleName :: String
-moduleName = "Data.ParserK"
-
-main :: IO ()
-main =
-  hspec $
-  H.parallel $
-  modifyMaxSuccess (const maxTestCount) $ do
-  describe moduleName $ do
-
-    describe "Instances" $ do
-        prop "applicative" applicative
-        prop "Alternative: end of input 1" altEOF1
-        prop "Alternative: end of input 2" altEOF2
-        prop "monad" monad
-        prop "sequence" sequence
-
-    describe "Stream parsing" $ do
-        prop "parseMany" parseMany
-        prop "parseMany2Events" parseMany2Events
-        prop "parseUnfold" parseUnfold
-        prop "parserSequence" parserSequence
-
-    describe "test for accumulator" $ do
-        prop "P.fromFold FL.sum = FL.sum" fromFold
-        prop "fromPure value provided" fromPure
-        prop "fromPure monadic value provided" fromEffect
-        prop "always fail" die
-        prop "always fail but monadic" dieM
-
-    describe "test for element parser" $ do
-        prop "peek = head with list length > 0" peekPass
-        prop "peek fail on []" peekFail
-        prop "eof pass on []" eofPass
-        prop "eof fail on non-empty list" eofFail
-        prop "first element exists and >= mid_value" satisfyPass
-        prop "check first element exists and satisfies predicate" satisfy
-
-    describe "test for sequence parser" $ do
-        prop "P.takeBetween m n = Prelude.take when len >= m and len <= n"
-                takeBetweenPass
-        prop ("P.takeBetween m n = Prelude.take when len >= m and len <= n and"
-            ++ " fail otherwise") takeBetween
-        prop "P.take = Prelude.take" Main.take
-        prop "P.takeEQ = Prelude.take when len >= n" takeEQPass
-        prop "P.takeEQ = Prelude.take when len >= n and fail otherwise" Main.takeEQ
-        prop "P.takeGE n ls = ls when len >= n" takeGEPass
-        prop "P.takeGE n ls = ls when len >= n and fail otherwise" Main.takeGE
-        prop "lookAhead . take n >> lookAhead . take n = lookAhead . take n" lookAheadPass
-        prop "lookAhead . take n >> lookAhead . take n = lookAhead . take n, else fail" lookAhead
-        prop "P.takeWhile = Prelude.takeWhile" Main.takeWhile
-        prop "P.takeWhile1 = Prelude.takeWhile if taken something, else check why failed" takeWhile1
-        prop "P.groupBy = Prelude.head . Prelude.groupBy" groupBy
-        prop "groupByRolling" groupByRolling
-        prop "P.takeEndByOrMax = Prelude.take n (Prelude.takeWhile (not . predicate)" takeEndByOrMax
-        prop "many (P.wordBy ' ') = words'" wordBy
-        prop "parse 0, then 1, else fail" splitWith
-        prop "fail due to die as left parser" splitWithFailLeft
-        prop "fail due to die as right parser" splitWithFailRight
-        prop "fail due to die as both parsers" splitWithFailBoth
-        {-
-        prop "parsed two lists should be equal" teeWithPass
-        prop "fail due to die as left parser" teeWithFailLeft
-        prop "fail due to die as right parser" teeWithFailRight
-        prop "fail due to die as both parsers" teeWithFailBoth
-        prop "P.takeWhile (<= half_mid_value) = Prelude.takeWhile half_mid_value" shortestPass
-        prop "pass even if die is left parser" shortestPassLeft
-        prop "pass even if die is right parser" shortestPassRight
-        prop "fail due to die as both parsers" shortestFailBoth
-        prop "P.takeWhile (<= mid_value) = Prelude.takeWhile (<= mid_value)" longestPass
-        prop "pass even if die is left parser" longestPassLeft
-        prop "pass even if die is right parser" longestPassRight
-        prop "fail due to die as both parsers" longestFailBoth
-        -}
-        prop "P.many concatFold $ P.takeEndBy_ (== 1) FL.toList = Prelude.filter (== 0)" many
-        prop "[] due to parser being die" many_empty
-        prop "P.some concatFold $ P.takeEndBy_ (== 1) FL.toList = Prelude.filter (== 0)" some
-        prop "fail due to parser being die" someFail
-    takeProperties
diff --git a/test/streamly-tests.cabal b/test/streamly-tests.cabal
index 80e0cc307d..20171e8406 100644
--- a/test/streamly-tests.cabal
+++ b/test/streamly-tests.cabal
@@ -326,7 +326,8 @@ test-suite Data.Parser
 test-suite Data.ParserK
   import: test-options
   type: exitcode-stdio-1.0
-  main-is: Streamly/Test/Data/ParserK.hs
+  main-is: Streamly/Test/Data/Parser.hs
+  cpp-options: -DPARSER_K
   if flag(limit-build-mem)
     ghc-options: +RTS -M1500M -RTS
 

From e8ebb98e09fc1de92f25bebbe3e64063cb4850c8 Mon Sep 17 00:00:00 2001
From: Ranjeet Kumar Ranjan <ranjeetr@composewell.com>
Date: Sat, 19 Aug 2023 14:54:32 +0530
Subject: [PATCH 2/2] Fix up

---
 .hlint.ignore  | 1 -
 streamly.cabal | 1 -
 2 files changed, 2 deletions(-)

diff --git a/.hlint.ignore b/.hlint.ignore
index 0eb6542b15..0a2ca7eb58 100644
--- a/.hlint.ignore
+++ b/.hlint.ignore
@@ -4,7 +4,6 @@ core/src/Streamly/Internal/Unicode/Stream.hs
 src/Streamly/Internal/Data/SmallArray/Type.hs
 test/Streamly/Test/Data/Array.hs
 test/Streamly/Test/Data/Parser.hs
-test/Streamly/Test/Data/ParserK.hs
 test/Streamly/Test/Data/SmallArray.hs
 test/Streamly/Test/Data/Unfold.hs
 test/Streamly/Test/FileSystem/Event.hs
diff --git a/streamly.cabal b/streamly.cabal
index e040668ece..60034531eb 100644
--- a/streamly.cabal
+++ b/streamly.cabal
@@ -108,7 +108,6 @@ extra-source-files:
     test/Streamly/Test/Data/Ring/Unboxed.hs
     test/Streamly/Test/Data/Array/Stream.hs
     test/Streamly/Test/Data/Parser.hs
-    test/Streamly/Test/Data/ParserK.hs
     test/Streamly/Test/Data/Stream/Concurrent.hs
     test/Streamly/Test/FileSystem/Event.hs
     test/Streamly/Test/FileSystem/Event/Common.hs