diff --git a/benchmark/Streamly/Benchmark/Data/Array/Stream.hs b/benchmark/Streamly/Benchmark/Data/Array/Stream.hs
index af3b36b01c..31677349ab 100644
--- a/benchmark/Streamly/Benchmark/Data/Array/Stream.hs
+++ b/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
diff --git a/benchmark/Streamly/Benchmark/Data/ParserK.hs b/benchmark/Streamly/Benchmark/Data/ParserK.hs
index 81be603e26..a9f45542db 100644
--- a/benchmark/Streamly/Benchmark/Data/ParserK.hs
+++ b/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)
diff --git a/core/src/Streamly/Data/Array.hs b/core/src/Streamly/Data/Array.hs
index b869df05d3..8630ab66a5 100644
--- a/core/src/Streamly/Data/Array.hs
+++ b/core/src/Streamly/Data/Array.hs
@@ -76,7 +76,7 @@ module Streamly.Data.Array
 
     -- * Stream of Arrays
     , chunksOf
-    , parserK
+    , toParserK
     , parse
     , parseBreak
     , parsePos
diff --git a/core/src/Streamly/Data/Array/Generic.hs b/core/src/Streamly/Data/Array/Generic.hs
index ce8866e170..e190a8da76 100644
--- a/core/src/Streamly/Data/Array/Generic.hs
+++ b/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
diff --git a/core/src/Streamly/Data/Parser.hs b/core/src/Streamly/Data/Parser.hs
index f7cdbf1dc7..fdcf54ffe8 100644
--- a/core/src/Streamly/Data/Parser.hs
+++ b/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
 -- >>> :}
 --
diff --git a/core/src/Streamly/Data/ParserK.hs b/core/src/Streamly/Data/ParserK.hs
index 269d265f71..2f6da45a26 100644
--- a/core/src/Streamly/Data/ParserK.hs
+++ b/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
diff --git a/core/src/Streamly/Data/StreamK.hs b/core/src/Streamly/Data/StreamK.hs
index d1d466b944..0e3144a8fe 100644
--- a/core/src/Streamly/Data/StreamK.hs
+++ b/core/src/Streamly/Data/StreamK.hs
@@ -127,7 +127,7 @@ module Streamly.Data.StreamK
     -- , foldBreak
 
     -- ** Parsing
-    , parserK
+    , toParserK
     , parse
     , parseBreak
     , parsePos
diff --git a/core/src/Streamly/Internal/Data/Array.hs b/core/src/Streamly/Internal/Data/Array.hs
index 42715819d1..74a7d6849b 100644
--- a/core/src/Streamly/Internal/Data/Array.hs
+++ b/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
diff --git a/core/src/Streamly/Internal/Data/Array/Generic/Type.hs b/core/src/Streamly/Internal/Data/Array/Generic/Type.hs
index ecdbbc2e57..ae6d80d927 100644
--- a/core/src/Streamly/Internal/Data/Array/Generic/Type.hs
+++ b/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
diff --git a/core/src/Streamly/Internal/Data/Array/Stream.hs b/core/src/Streamly/Internal/Data/Array/Stream.hs
index 97fb8d811c..1c9113a722 100644
--- a/core/src/Streamly/Internal/Data/Array/Stream.hs
+++ b/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
diff --git a/core/src/Streamly/Internal/Data/ParserK.hs b/core/src/Streamly/Internal/Data/ParserK.hs
index a5867f79bf..517ab69e28 100644
--- a/core/src/Streamly/Internal/Data/ParserK.hs
+++ b/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
diff --git a/core/src/Streamly/Internal/Data/ParserK/Type.hs b/core/src/Streamly/Internal/Data/ParserK/Type.hs
index f703653fbc..dc5bf8d495 100644
--- a/core/src/Streamly/Internal/Data/ParserK/Type.hs
+++ b/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,10 +558,10 @@ 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
@@ -569,7 +569,7 @@ toParser parser = ParserD.Parser step initial extract
 --
 -- >>> 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
 --
diff --git a/core/src/Streamly/Internal/Data/StreamK.hs b/core/src/Streamly/Internal/Data/StreamK.hs
index 777ac27845..eb0252152b 100644
--- a/core/src/Streamly/Internal/Data/StreamK.hs
+++ b/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.
 
diff --git a/test/Streamly/Test/Data/Array/Stream.hs b/test/Streamly/Test/Data/Array/Stream.hs
index 45d03d95cb..a784d05f29 100644
--- a/test/Streamly/Test/Data/Array/Stream.hs
+++ b/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
diff --git a/test/Streamly/Test/Data/Parser.hs b/test/Streamly/Test/Data/Parser.hs
index f4a8a970f3..65edbe9f5d 100644
--- a/test/Streamly/Test/Data/Parser.hs
+++ b/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])
diff --git a/test/Streamly/Test/Data/Parser/Common.hs b/test/Streamly/Test/Data/Parser/Common.hs
index 413afcb353..1284fa25c8 100644
--- a/test/Streamly/Test/Data/Parser/Common.hs
+++ b/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
diff --git a/test/Streamly/Test/Data/ParserK.hs b/test/Streamly/Test/Data/ParserK.hs
index 4e57cdb546..35e47a1f32 100644
--- a/test/Streamly/Test/Data/ParserK.hs
+++ b/test/Streamly/Test/Data/ParserK.hs
@@ -27,9 +27,9 @@ maxTestCount = 100
 
 toParser :: Spec
 toParser = do
-    let p = ParserK.toParser (ParserK.parserK Parser.one)
+    let p = ParserK.toParser (ParserK.toParserK Parser.one)
         runP xs = Stream.parsePos p (Stream.fromList xs)
-    describe "toParser . parserK" $ do
+    describe "toParser . toParserK" $ do
         it "empty stream" $ do
             r1 <- runP ([] :: [Int])
             case r1 of
@@ -43,9 +43,9 @@ toParser = do
             r3 <- runP [0,1::Int]
             fromRight undefined r3 `shouldBe` 0
 
-    let p1 = ParserK.parserK $ ParserK.toParser (ParserK.parserK Parser.one)
+    let p1 = ParserK.toParserK $ ParserK.toParser (ParserK.toParserK Parser.one)
         runP1 xs = StreamK.parsePos p1 (StreamK.fromStream $ Stream.fromList xs)
-    describe "parserK . toParser . parserK" $ do
+    describe "toParserK . toParser . toParserK" $ do
         it "empty stream" $ do
             r1 <- runP1 ([] :: [Int])
             case r1 of
@@ -64,15 +64,15 @@ toParser = do
     let p2 = Parser.takeWhile (<= 3) FL.toList
         runP2 xs = Stream.parseBreakPos p2 (Stream.fromList xs)
 
-        p3 = ParserK.parserK (Parser.takeWhile (<= 3) FL.toList)
+        p3 = ParserK.toParserK (Parser.takeWhile (<= 3) FL.toList)
         runP3 xs = StreamK.parseBreakPos p3 (StreamK.fromList xs)
 
         p4 =
             ParserK.toParser
                 $ fusionBreaker
-                $ ParserK.parserK (Parser.takeWhile (<= 3) FL.toList)
+                $ ParserK.toParserK (Parser.takeWhile (<= 3) FL.toList)
         runP4 xs = Stream.parseBreakPos p4 (Stream.fromList xs)
-    describe "toParser . parserK" $ do
+    describe "toParser . toParserK" $ do
         it "(<= 3) for [1, 2, 3, 4, 5]" $ do
             (a, b) <- runP2 ([1, 2, 3, 4, 5] :: [Int])
             fromRight undefined a `shouldBe` [1, 2, 3]
@@ -105,7 +105,7 @@ fusionBreaker = id
 sanityParseBreak :: [Move] -> H.SpecWith ()
 sanityParseBreak jumps = it (show jumps) $ do
     (val, rest) <-
-        StreamK.parseBreakPos (ParserK.parserK (jumpParser jumps))
+        StreamK.parseBreakPos (ParserK.toParserK (jumpParser jumps))
             $ StreamK.fromList tape
     lst <- StreamK.toList rest
     (val, lst) `shouldBe` (expectedResult jumps tape)
@@ -113,7 +113,7 @@ sanityParseBreak jumps = it (show jumps) $ do
 sanityParseBreakChunks :: [Move] -> H.SpecWith ()
 sanityParseBreakChunks jumps = it (show jumps) $ do
     (val, rest) <-
-        A.parseBreakPos (A.parserK (jumpParser jumps))
+        A.parseBreakPos (A.toParserK (jumpParser jumps))
             $ StreamK.fromList $ Prelude.map A.fromList chunkedTape
     lst <- Prelude.map A.toList <$> StreamK.toList rest
     (val, concat lst) `shouldBe` (expectedResult jumps tape)
@@ -121,7 +121,7 @@ sanityParseBreakChunks jumps = it (show jumps) $ do
 sanityParseBreakChunksGeneric :: [Move] -> H.SpecWith ()
 sanityParseBreakChunksGeneric jumps = it (show jumps) $ do
     (val, rest) <-
-        AG.parseBreakPos (AG.parserK (jumpParser jumps))
+        AG.parseBreakPos (AG.toParserK (jumpParser jumps))
             $ StreamK.fromList $ Prelude.map AG.fromList chunkedTape
     lst <- Prelude.map AG.toList <$> StreamK.toList rest
     (val, concat lst) `shouldBe` (expectedResult jumps tape)