diff --git a/megaparsec-tests.cabal b/megaparsec-tests.cabal
--- a/megaparsec-tests.cabal
+++ b/megaparsec-tests.cabal
@@ -1,6 +1,6 @@
 cabal-version:   2.4
 name:            megaparsec-tests
-version:         9.3.0
+version:         9.3.1
 license:         BSD-2-Clause
 license-file:    LICENSE.md
 maintainer:      Mark Karpov <markkarpov92@gmail.com>
@@ -31,7 +31,7 @@
         hspec >=2.0 && <3.0,
         hspec-expectations >=0.8 && <0.9,
         hspec-megaparsec >=2.0 && <3.0,
-        megaparsec ==9.3.0,
+        megaparsec ==9.3.1,
         mtl >=2.2.2 && <3.0,
         text >=0.2 && <2.1,
         transformers >=0.4 && <0.7
@@ -71,7 +71,7 @@
         hspec >=2.0 && <3.0,
         hspec-expectations >=0.8 && <0.9,
         hspec-megaparsec >=2.0 && <3.0,
-        megaparsec ==9.3.0,
+        megaparsec ==9.3.1,
         megaparsec-tests,
         mtl >=2.2.2 && <3.0,
         parser-combinators >=1.0 && <2.0,
diff --git a/src/Test/Hspec/Megaparsec/AdHoc.hs b/src/Test/Hspec/Megaparsec/AdHoc.hs
--- a/src/Test/Hspec/Megaparsec/AdHoc.hs
+++ b/src/Test/Hspec/Megaparsec/AdHoc.hs
@@ -121,7 +121,7 @@
 -- all supported monads transformers in turn).
 grs ::
   -- | Parser to run
-  (forall m. MonadParsecDbg Void String m => m a) ->
+  (forall m. (MonadParsecDbg Void String m) => m a) ->
   -- | Input for the parser
   String ->
   -- | How to check result of parsing
@@ -141,7 +141,7 @@
 -- | 'grs'' to 'grs' is as 'prs'' to 'prs'.
 grs' ::
   -- | Parser to run
-  (forall m. MonadParsecDbg Void String m => m a) ->
+  (forall m. (MonadParsecDbg Void String m) => m a) ->
   -- | Input for the parser
   String ->
   -- | How to check result of parsing
@@ -158,18 +158,18 @@
   r (prs' (evalRWSTL p) s)
   r (prs' (evalRWSTS p) s)
 
-evalWriterTL :: Monad m => L.WriterT [Int] m a -> m a
+evalWriterTL :: (Monad m) => L.WriterT [Int] m a -> m a
 evalWriterTL = fmap fst . L.runWriterT
 
-evalWriterTS :: Monad m => S.WriterT [Int] m a -> m a
+evalWriterTS :: (Monad m) => S.WriterT [Int] m a -> m a
 evalWriterTS = fmap fst . S.runWriterT
 
-evalRWSTL :: Monad m => L.RWST () [Int] () m a -> m a
+evalRWSTL :: (Monad m) => L.RWST () [Int] () m a -> m a
 evalRWSTL m = do
   (a, _, _) <- L.runRWST m () ()
   return a
 
-evalRWSTS :: Monad m => S.RWST () [Int] () m a -> m a
+evalRWSTS :: (Monad m) => S.RWST () [Int] () m a -> m a
 evalRWSTS m = do
   (a, _, _) <- S.runRWST m () ()
   return a
@@ -201,11 +201,11 @@
     prs_ p s `shouldParse` s'
 
 -- | Get tab width from 'PosState'. Use with care only for testing.
-getTabWidth :: MonadParsec e s m => m Pos
+getTabWidth :: (MonadParsec e s m) => m Pos
 getTabWidth = pstateTabWidth . statePosState <$> getParserState
 
 -- | Set tab width in 'PosState'. Use with care only for testing.
-setTabWidth :: MonadParsec e s m => Pos -> m ()
+setTabWidth :: (MonadParsec e s m) => Pos -> m ()
 setTabWidth w = updateParserState $ \st ->
   let pst = statePosState st
    in st {statePosState = pst {pstateTabWidth = w}}
@@ -277,7 +277,7 @@
       <*> arbitrary
       <*> arbitrary
 
-instance Arbitrary t => Arbitrary (ErrorItem t) where
+instance (Arbitrary t) => Arbitrary (ErrorItem t) where
   arbitrary =
     oneof
       [ Tokens <$> (NE.fromList . getNonEmpty <$> arbitrary),
@@ -307,7 +307,7 @@
           <*> (E.fromList <$> scaleDown arbitrary)
       ]
 
-instance Arbitrary s => Arbitrary (State s e) where
+instance (Arbitrary s) => Arbitrary (State s e) where
   arbitrary = do
     input <- scaleDown arbitrary
     offset <- choose (1, 10000)
@@ -324,7 +324,7 @@
           stateParseErrors = []
         }
 
-instance Arbitrary s => Arbitrary (PosState s) where
+instance (Arbitrary s) => Arbitrary (PosState s) where
   arbitrary =
     PosState
       <$> arbitrary
@@ -345,5 +345,5 @@
 instance Arbitrary BL.ByteString where
   arbitrary = BL.pack <$> arbitrary
 
-instance Arbitrary a => Arbitrary (NonEmpty a) where
+instance (Arbitrary a) => Arbitrary (NonEmpty a) where
   arbitrary = NE.fromList <$> (arbitrary `suchThat` (not . null))
diff --git a/tests/Text/Megaparsec/DebugSpec.hs b/tests/Text/Megaparsec/DebugSpec.hs
--- a/tests/Text/Megaparsec/DebugSpec.hs
+++ b/tests/Text/Megaparsec/DebugSpec.hs
@@ -30,14 +30,14 @@
   describe "dbg" $ do
     context "when inner parser succeeds consuming input" $ do
       it "has no effect on how parser works" $ do
-        let p :: MonadParsecDbg Void String m => m Char
+        let p :: (MonadParsecDbg Void String m) => m Char
             p = dbg "char" (char 'a')
             s = "ab"
         shouldStderr p s "char> IN: \"ab\"\nchar> MATCH (COK): 'a'\nchar> VALUE: 'a'\n\n"
         grs p s (`shouldParse` 'a')
         grs' p s (`succeedsLeaving` "b")
       it "its hints are preserved" $ do
-        let p :: MonadParsecDbg Void String m => m String
+        let p :: (MonadParsecDbg Void String m) => m String
             p = dbg "many chars" (many (char 'a')) <* empty
             s = "abcd"
         shouldStderr p s "many chars> IN: \"abcd\"\nmany chars> MATCH (COK): 'a'\nmany chars> VALUE: \"a\"\n\n"
@@ -45,7 +45,7 @@
         grs' p s (`failsLeaving` "bcd")
     context "when inner parser fails consuming input" $
       it "has no effect on how parser works" $ do
-        let p :: MonadParsecDbg Void String m => m Char
+        let p :: (MonadParsecDbg Void String m) => m Char
             p = dbg "chars" (char 'a' *> char 'c')
             s = "abc"
         shouldStderr p s "chars> IN: \"abc\"\nchars> MATCH (CERR): 'a'\nchars> ERROR:\nchars> offset=1:\nchars> unexpected 'b'\nchars> expecting 'c'\n\n"
@@ -53,14 +53,14 @@
         grs' p s (`failsLeaving` "bc")
     context "when inner parser succeeds without consuming" $ do
       it "has no effect on how parser works" $ do
-        let p :: MonadParsecDbg Void String m => m Char
+        let p :: (MonadParsecDbg Void String m) => m Char
             p = dbg "return" (return 'a')
             s = "abc"
         shouldStderr p s "return> IN: \"abc\"\nreturn> MATCH (EOK): <EMPTY>\nreturn> VALUE: 'a'\n\n"
         grs p s (`shouldParse` 'a')
         grs' p s (`succeedsLeaving` s)
       it "its hints are preserved" $ do
-        let p :: MonadParsecDbg Void String m => m String
+        let p :: (MonadParsecDbg Void String m) => m String
             p = dbg "many chars" (many (char 'a')) <* empty
             s = "bcd"
         shouldStderr p s "many chars> IN: \"bcd\"\nmany chars> MATCH (EOK): <EMPTY>\nmany chars> VALUE: \"\"\n\n"
@@ -68,7 +68,7 @@
         grs' p s (`failsLeaving` "bcd")
     context "when inner parser fails without consuming" $
       it "has no effect on how parser works" $ do
-        let p :: MonadParsecDbg Void String m => m ()
+        let p :: (MonadParsecDbg Void String m) => m ()
             p = dbg "empty" (void empty)
             s = "abc"
         shouldStderr p s "empty> IN: \"abc\"\nempty> MATCH (EERR): <EMPTY>\nempty> ERROR:\nempty> offset=0:\nempty> unknown parse error\n\n"
diff --git a/tests/Text/Megaparsec/ErrorSpec.hs b/tests/Text/Megaparsec/ErrorSpec.hs
--- a/tests/Text/Megaparsec/ErrorSpec.hs
+++ b/tests/Text/Megaparsec/ErrorSpec.hs
@@ -167,9 +167,12 @@
             errorBundlePretty bundle
               `shouldBe` "1:10:\n  |\n1 | foo\n  | \nunexpected 'o'\nexpecting 'x'\n"
     it "takes tab width into account correctly" $
-      property $ \w' -> do
-        let s = "\tsomething\t" :: String
-            pe = err 1 (utok 's' <> etok 'x') :: PE
+      property $ \w' i' -> do
+        let w = unPos w'
+            i = unPos i' `rem` (w * 2)
+            as = replicate i 'a'
+            s = "\t" ++ as ++ "\tb" :: String
+            pe = err (2 + i) (utok 'b' <> etok 'x') :: PE
             bundle =
               ParseErrorBundle
                 { bundleErrors = pe :| [],
@@ -182,18 +185,19 @@
                         pstateLinePrefix = ""
                       }
                 }
-            w = unPos w'
-            tabRep = replicate w ' '
+            secondTabApparentWidth = w - (i `rem` w)
+            errColumn = w + i + secondTabApparentWidth
         errorBundlePretty bundle
           `shouldBe` ( "1:"
-                         ++ show (w + 1)
+                         ++ show (errColumn + 1)
                          ++ ":\n  |\n1 | "
-                         ++ tabRep
-                         ++ "something"
-                         ++ tabRep
+                         ++ replicate w ' '
+                         ++ as
+                         ++ replicate secondTabApparentWidth ' '
+                         ++ "b"
                          ++ "\n  | "
-                         ++ tabRep
-                         ++ "^\nunexpected 's'\nexpecting 'x'\n"
+                         ++ replicate errColumn ' '
+                         ++ "^\nunexpected 'b'\nexpecting 'x'\n"
                      )
     it "displays multi-error bundle correctly" $ do
       let s = "something\ngood\n" :: String
@@ -266,7 +270,7 @@
 
 type PE = ParseError String Void
 
-contains :: Foldable t => (PE -> t a) -> (a -> String) -> PE -> Property
+contains :: (Foldable t) => (PE -> t a) -> (a -> String) -> PE -> Property
 contains g r e = property (all f (g e))
   where
     rendered = parseErrorPretty e
diff --git a/tests/Text/Megaparsec/StreamSpec.hs b/tests/Text/Megaparsec/StreamSpec.hs
--- a/tests/Text/Megaparsec/StreamSpec.hs
+++ b/tests/Text/Megaparsec/StreamSpec.hs
@@ -496,7 +496,7 @@
                 }
             (r, _) = reachOffset 2 pst
             w = unPos (pstateTabWidth pst)
-            r' = replicate (w * 2) ' ' ++ "a" ++ replicate w ' '
+            r' = replicate (w * 2) ' ' ++ "a" ++ replicate (max 1 (w - 1)) ' '
         r `shouldBe` Just r'
     it "returns correct line (with line prefix)" $
       property $ \pst' -> do
diff --git a/tests/Text/MegaparsecSpec.hs b/tests/Text/MegaparsecSpec.hs
--- a/tests/Text/MegaparsecSpec.hs
+++ b/tests/Text/MegaparsecSpec.hs
@@ -422,7 +422,7 @@
     describe "parseError" $ do
       it "immediately fails with given parse error" $
         property $ \st e -> do
-          let p :: MonadParsec Void String m => m ()
+          let p :: (MonadParsec Void String m) => m ()
               p = parseError e
           runParser' p st `shouldBe` (st, Left (mkBundle st (nes e)))
 
@@ -432,7 +432,7 @@
           it "collection of hints remains empty" $
             property $ \lbl a ->
               not (null lbl) ==> do
-                let p :: MonadParsec Void String m => m Char
+                let p :: (MonadParsec Void String m) => m Char
                     p = label lbl (char a) <* empty
                     s = [a]
                 grs p s (`shouldFailWith` err 1 mempty)
@@ -441,7 +441,7 @@
           it "does not alter the hints" $
             property $ \lbl a ->
               not (null lbl) ==> do
-                let p :: MonadParsec Void String m => m String
+                let p :: (MonadParsec Void String m) => m String
                     p = label lbl (many (char a)) <* empty
                     s = [a]
                 grs p s (`shouldFailWith` err 1 (etok a))
@@ -450,7 +450,7 @@
         it "reports parse error without modification" $
           property $ \lbl a b c ->
             not (null lbl) && b /= c ==> do
-              let p :: MonadParsec Void String m => m Char
+              let p :: (MonadParsec Void String m) => m Char
                   p = label lbl (char a *> char b)
                   s = [a, c]
               grs p s (`shouldFailWith` err 1 (utok c <> etok b))
@@ -460,28 +460,28 @@
           it "collection of hints remains empty" $
             property $ \lbl a ->
               not (null lbl) ==> do
-                let p :: MonadParsec Void String m => m Char
+                let p :: (MonadParsec Void String m) => m Char
                     p = label lbl (return a) <* empty
                 grs p "" (`shouldFailWith` err 0 mempty)
         context "inner parser produces hints" $
           it "replaces the last hint with given label" $
             property $ \lbl a ->
               not (null lbl) ==> do
-                let p :: MonadParsec Void String m => m String
+                let p :: (MonadParsec Void String m) => m String
                     p = label lbl (many (char a)) <* empty
                 grs p "" (`shouldFailWith` err 0 (elabel lbl))
       context "when inner parser fails without consuming" $ do
         it "is mentioned in parse error via its label" $
           property $ \lbl ->
             not (null lbl) ==> do
-              let p :: MonadParsec Void String m => m ()
+              let p :: (MonadParsec Void String m) => m ()
                   p = label lbl empty
               grs p "" (`shouldFailWith` err 0 (elabel lbl))
         context "when inner parser is composite with 2-hint sources" $
           it "both hint groups are replaced by the label" $
             property $ \lbl a b ->
               not (null lbl) && a /= b ==> do
-                let p :: MonadParsec Void String m => m (Maybe Char)
+                let p :: (MonadParsec Void String m) => m (Maybe Char)
                     p = label lbl (optional (char a) *> optional (char b)) <* empty
                 grs p "" (`shouldFailWith` err 0 (elabel lbl))
     describe "hidden" $ do
@@ -489,7 +489,7 @@
         context "inner parser does not produce any hints" $
           it "collection of hints remains empty" $
             property $ \a -> do
-              let p :: MonadParsec Void String m => m Char
+              let p :: (MonadParsec Void String m) => m Char
                   p = hidden (char a) <* empty
                   s = [a]
               grs p s (`shouldFailWith` err 1 mempty)
@@ -497,7 +497,7 @@
         context "inner parser produces hints" $
           it "hides the parser in the error message" $
             property $ \a -> do
-              let p :: MonadParsec Void String m => m String
+              let p :: (MonadParsec Void String m) => m String
                   p = hidden (many (char a)) <* empty
                   s = [a]
               grs p s (`shouldFailWith` err 1 mempty)
@@ -506,7 +506,7 @@
         it "reports parse error without modification" $
           property $ \a b c ->
             b /= c ==> do
-              let p :: MonadParsec Void String m => m Char
+              let p :: (MonadParsec Void String m) => m Char
                   p = hidden (char a *> char b)
                   s = [a, c]
               grs p s (`shouldFailWith` err 1 (utok c <> etok b))
@@ -515,19 +515,19 @@
         context "inner parser does not produce any hints" $
           it "collection of hints remains empty" $
             property $ \a -> do
-              let p :: MonadParsec Void String m => m Char
+              let p :: (MonadParsec Void String m) => m Char
                   p = hidden (return a) <* empty
               grs p "" (`shouldFailWith` err 0 mempty)
         context "inner parser produces hints" $
           it "hides the parser in the error message" $
             property $ \a -> do
-              let p :: MonadParsec Void String m => m String
+              let p :: (MonadParsec Void String m) => m String
                   p = hidden (many (char a)) <* empty
               grs p "" (`shouldFailWith` err 0 mempty)
       context "when inner parser fails without consuming" $
         it "hides the parser in the error message" $
           do
-            let p :: MonadParsec Void String m => m ()
+            let p :: (MonadParsec Void String m) => m ()
                 p = hidden empty
             grs p "" (`shouldFailWith` err 0 mempty)
 
@@ -535,7 +535,7 @@
       context "when inner parser succeeds consuming" $
         it "try has no effect" $
           property $ \a -> do
-            let p :: MonadParsec Void String m => m Char
+            let p :: (MonadParsec Void String m) => m Char
                 p = try (char a)
                 s = [a]
             grs p s (`shouldParse` a)
@@ -544,7 +544,7 @@
         it "backtracks, it appears as if the parser has not consumed anything" $
           property $ \a b c ->
             b /= c ==> do
-              let p :: MonadParsec Void String m => m Char
+              let p :: (MonadParsec Void String m) => m Char
                   p = try (char a *> char b)
                   s = [a, c]
               grs p s (`shouldFailWith` err 1 (utok c <> etok b))
@@ -552,7 +552,7 @@
         it "hints from the inner parse error do not leak" $
           property $ \a b c ->
             b /= c ==> do
-              let p :: MonadParsec Void String m => m (Maybe Char)
+              let p :: (MonadParsec Void String m) => m (Maybe Char)
                   p = (optional . try) (char a *> char b) <* empty
                   s = [a, c]
               grs p s (`shouldFailWith` err 0 mempty)
@@ -560,13 +560,13 @@
       context "when inner parser succeeds without consuming" $
         it "try has no effect" $
           property $ \a -> do
-            let p :: MonadParsec Void String m => m Char
+            let p :: (MonadParsec Void String m) => m Char
                 p = try (return a)
             grs p "" (`shouldParse` a)
       context "when inner parser fails without consuming" $
         it "try backtracks parser state anyway" $
           property $ \w -> do
-            let p :: MonadParsec Void String m => m Char
+            let p :: (MonadParsec Void String m) => m Char
                 p = try (setTabWidth w *> empty)
             grs p "" (`shouldFailWith` err 0 mempty)
             grs' p "" ((`shouldBe` defaultTabWidth) . grabTabWidth)
@@ -575,14 +575,14 @@
       context "when inner parser succeeds consuming" $ do
         it "result is returned but parser state is not changed" $
           property $ \a w -> do
-            let p :: MonadParsec Void String m => m Pos
+            let p :: (MonadParsec Void String m) => m Pos
                 p = lookAhead (setTabWidth w *> char a) *> getTabWidth
                 s = [a]
             grs p s (`shouldParse` defaultTabWidth)
             grs' p s (`succeedsLeaving` s)
         it "hints are not preserved" $
           property $ \a -> do
-            let p :: MonadParsec Void String m => m String
+            let p :: (MonadParsec Void String m) => m String
                 p = lookAhead (many (char a)) <* empty
                 s = [a]
             grs p s (`shouldFailWith` err 0 mempty)
@@ -591,7 +591,7 @@
         it "error message is reported as usual" $
           property $ \a b c ->
             b /= c ==> do
-              let p :: MonadParsec Void String m => m Char
+              let p :: (MonadParsec Void String m) => m Char
                   p = lookAhead (char a *> char b)
                   s = [a, c]
               grs p s (`shouldFailWith` err 1 (utok c <> etok b))
@@ -599,7 +599,7 @@
       context "when inner parser succeeds without consuming" $ do
         it "result is returned but parser state in not changed" $
           property $ \a w -> do
-            let p :: MonadParsec Void String m => m Pos
+            let p :: (MonadParsec Void String m) => m Pos
                 p = lookAhead (setTabWidth w *> char a) *> getTabWidth
                 s = [a]
             grs p s (`shouldParse` defaultTabWidth)
@@ -607,7 +607,7 @@
         it "hints are not preserved" $
           property $ \a b ->
             a /= b ==> do
-              let p :: MonadParsec Void String m => m String
+              let p :: (MonadParsec Void String m) => m String
                   p = lookAhead (many (char a)) <* empty
                   s = [b]
               grs p s (`shouldFailWith` err 0 mempty)
@@ -615,7 +615,7 @@
       context "when inner parser fails without consuming" $
         it "error message is reported as usual" $
           do
-            let p :: MonadParsec Void String m => m Char
+            let p :: (MonadParsec Void String m) => m Char
                 p = lookAhead empty
             grs p "" (`shouldFailWith` err 0 mempty)
 
@@ -623,7 +623,7 @@
       context "when inner parser succeeds consuming" $
         it "signals correct parse error" $
           property $ \a w -> do
-            let p :: MonadParsec Void String m => m ()
+            let p :: (MonadParsec Void String m) => m ()
                 p = notFollowedBy (setTabWidth w <* char a)
                 s = [a]
             grs p s (`shouldFailWith` err 0 (utok a))
@@ -633,7 +633,7 @@
         it "succeeds without consuming" $
           property $ \a b c w ->
             b /= c ==> do
-              let p :: MonadParsec Void String m => m ()
+              let p :: (MonadParsec Void String m) => m ()
                   p = notFollowedBy (setTabWidth w *> char a *> char b)
                   s = [a, c]
               grs' p s (`succeedsLeaving` s)
@@ -641,7 +641,7 @@
         it "hints are not preserved" $
           property $ \a b ->
             a /= b ==> do
-              let p :: MonadParsec Void String m => m ()
+              let p :: (MonadParsec Void String m) => m ()
                   p = notFollowedBy (char b *> many (char a) <* char a) <* empty
                   s = [b, b]
               grs p s (`shouldFailWith` err 0 mempty)
@@ -649,7 +649,7 @@
       context "when inner parser succeeds without consuming" $
         it "signals correct parse error" $
           property $ \a w -> do
-            let p :: MonadParsec Void String m => m ()
+            let p :: (MonadParsec Void String m) => m ()
                 p = notFollowedBy (setTabWidth w *> return a)
                 s = [a]
             grs p s (`shouldFailWith` err 0 (utok a))
@@ -658,13 +658,13 @@
       context "when inner parser fails without consuming" $ do
         it "succeeds without consuming" $
           property $ \w -> do
-            let p :: MonadParsec Void String m => m ()
+            let p :: (MonadParsec Void String m) => m ()
                 p = notFollowedBy (setTabWidth w *> empty)
             grs p "" (`shouldParse` ())
             grs' p "" ((`shouldBe` defaultTabWidth) . grabTabWidth)
         it "hints are not preserved" $
           property $ \a -> do
-            let p :: MonadParsec Void String m => m ()
+            let p :: (MonadParsec Void String m) => m ()
                 p = notFollowedBy (many (char a) <* char a) <* empty
                 s = ""
             grs p s (`shouldFailWith` err 0 mempty)
@@ -674,7 +674,7 @@
       context "when inner parser succeeds consuming" $
         it "the result is returned as usual" $
           property $ \a as -> do
-            let p :: MonadParsec Void String m => m (Maybe Char)
+            let p :: (MonadParsec Void String m) => m (Maybe Char)
                 p = withRecovery (const $ return Nothing) (pure <$> char a)
                 s = a : as
             grs p s (`shouldParse` Just a)
@@ -684,7 +684,7 @@
           it "its result is returned and position is advanced" $
             property $ \a b c as ->
               b /= c ==> do
-                let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+                let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                     p =
                       withRecovery
                         (\e -> Left e <$ string (c : as))
@@ -695,7 +695,7 @@
           it "hints are not preserved" $
             property $ \a b c as ->
               b /= c ==> do
-                let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+                let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                     p =
                       withRecovery
                         (\e -> Left e <$ string (c : as))
@@ -708,7 +708,7 @@
           it "the original parse error (and state) is reported" $
             property $ \a b c as ->
               b /= c ==> do
-                let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+                let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                     p =
                       withRecovery
                         (\e -> Left e <$ char c <* empty)
@@ -720,7 +720,7 @@
           it "its result is returned (and state)" $
             property $ \a b c as ->
               b /= c ==> do
-                let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+                let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                     p = withRecovery (return . Left) (Right <$> char a <* char b)
                     s = a : c : as
                 grs p s (`shouldParse` Left (err 1 (utok c <> etok b)))
@@ -728,7 +728,7 @@
           it "original hints are preserved" $
             property $ \a b c as ->
               b /= c ==> do
-                let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+                let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                     p =
                       withRecovery
                         (return . Left)
@@ -741,7 +741,7 @@
           it "the original parse error (and state) is reported" $
             property $ \a b c as ->
               b /= c ==> do
-                let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+                let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                     p =
                       withRecovery
                         (\e -> Left e <$ empty)
@@ -752,7 +752,7 @@
       context "when inner parser succeeds without consuming" $
         it "the result is returned as usual" $
           property $ \a s -> do
-            let p :: MonadParsec Void String m => m (Maybe Char)
+            let p :: (MonadParsec Void String m) => m (Maybe Char)
                 p = withRecovery (const $ return Nothing) (return a)
             grs p s (`shouldParse` a)
             grs' p s (`succeedsLeaving` s)
@@ -760,7 +760,7 @@
         context "when recovering parser succeeds consuming input" $
           it "its result is returned and position is advanced" $
             property $ \a as -> do
-              let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+              let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                   p = withRecovery (\e -> Left e <$ string s) empty
                   s = a : as
               grs p s (`shouldParse` Left (err 0 mempty))
@@ -769,7 +769,7 @@
           it "the original parse error (and state) is reported" $
             property $ \a b as ->
               a /= b ==> do
-                let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+                let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                     p =
                       withRecovery
                         (\e -> Left e <$ char a <* char b <* empty)
@@ -780,14 +780,14 @@
         context "when recovering parser succeeds without consuming" $ do
           it "its result is returned (and state)" $
             property $ \s -> do
-              let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+              let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                   p = withRecovery (return . Left) empty
               grs p s (`shouldParse` Left (err 0 mempty))
               grs' p s (`succeedsLeaving` s)
           it "original hints are preserved" $
             property $ \a b as ->
               a /= b ==> do
-                let p :: MonadParsec Void String m => m (Either (ParseError String Void) String)
+                let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) String)
                     p =
                       withRecovery
                         (return . Left)
@@ -799,13 +799,13 @@
         context "when recovering parser fails without consuming" $
           it "the original parse error (and state) is reported" $
             property $ \s -> do
-              let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+              let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                   p = withRecovery (\e -> Left e <$ empty) empty
               grs p s (`shouldFailWith` err 0 mempty)
               grs' p s (`failsLeaving` s)
       it "works in complex situations too" $
         property $ \(NonNegative a) (NonNegative b) (NonNegative c) -> do
-          let p :: MonadParsec Void String m => m (Either (ParseError String Void) String)
+          let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) String)
               p =
                 let g = count' 1 3 . char
                  in v
@@ -836,7 +836,7 @@
       context "when inner parser succeeds consuming" $
         it "returns its result in Right" $
           property $ \a as -> do
-            let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+            let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                 p = observing (char a)
                 s = a : as
             grs p s (`shouldParse` Right a)
@@ -845,7 +845,7 @@
         it "returns its parse error in Left preserving state" $
           property $ \a b c as ->
             b /= c ==> do
-              let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+              let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                   p = observing (char a *> char b)
                   s = a : c : as
               grs p s (`shouldParse` Left (err 1 (utok c <> etok b)))
@@ -853,7 +853,7 @@
         it "does not create any hints" $
           property $ \a b c as ->
             b /= c ==> do
-              let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+              let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                   p = observing (char a *> char b) *> empty
                   s = a : c : as
               grs p s (`shouldFailWith` err 1 mempty)
@@ -861,21 +861,21 @@
       context "when inner parser succeeds without consuming" $
         it "returns its result in Right" $
           property $ \a s -> do
-            let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+            let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                 p = observing (return a)
             grs p s (`shouldParse` Right a)
             grs' p s (`succeedsLeaving` s)
       context "when inner parser fails without consuming" $ do
         it "returns its parse error in Left preserving state" $
           property $ \s -> do
-            let p :: MonadParsec Void String m => m (Either (ParseError String Void) ())
+            let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) ())
                 p = observing empty
             grs p s (`shouldParse` Left (err 0 mempty))
             grs' p s (`succeedsLeaving` s)
         it "creates correct hints" $
           property $ \a b as ->
             a /= b ==> do
-              let p :: MonadParsec Void String m => m (Either (ParseError String Void) Char)
+              let p :: (MonadParsec Void String m) => m (Either (ParseError String Void) Char)
                   p = observing (char a) <* empty
                   s = b : as
               grs p s (`shouldFailWith` err 0 (etok a))
@@ -898,7 +898,7 @@
       context "when supplied predicate is satisfied" $
         it "succeeds" $
           property $ \a as -> do
-            let p :: MonadParsec Void String m => m Char
+            let p :: (MonadParsec Void String m) => m Char
                 p = token (testChar a) (expected a)
                 s = a : as
             grs p s (`shouldParse` a)
@@ -907,7 +907,7 @@
         it "signals correct parse error" $
           property $ \a b as ->
             a /= b ==> do
-              let p :: MonadParsec Void String m => m Char
+              let p :: (MonadParsec Void String m) => m Char
                   p = token (testChar b) (expected b)
                   s = a : as
                   us = pure (Tokens $ nes a)
@@ -917,7 +917,7 @@
       context "when stream is empty" $
         it "signals correct parse error" $
           property $ \a -> do
-            let p :: MonadParsec Void String m => m Char
+            let p :: (MonadParsec Void String m) => m Char
                 p = token (testChar a) ps
                 us = pure EndOfInput
                 ps = expected a
@@ -927,7 +927,7 @@
       context "when stream is prefixed with given string" $
         it "parses the string" $
           property $ \str s -> do
-            let p :: MonadParsec Void String m => m String
+            let p :: (MonadParsec Void String m) => m String
                 p = tokens (==) str
                 s' = str ++ s
             grs p s' (`shouldParse` str)
@@ -936,7 +936,7 @@
         it "signals correct parse error" $
           property $ \str s ->
             not (str `isPrefixOf` s) ==> do
-              let p :: MonadParsec Void String m => m String
+              let p :: (MonadParsec Void String m) => m String
                   p = tokens (==) str
                   z = take (length str) s
               grs p s (`shouldFailWith` err 0 (utoks z <> etoks str))
@@ -944,7 +944,7 @@
       context "when matching the empty string" $
         it "eok continuation is used" $
           property $ \str s -> do
-            let p :: MonadParsec Void String m => m String
+            let p :: (MonadParsec Void String m) => m String
                 p = (tokens (==) "" <* empty) <|> pure str
             grs p s (`shouldParse` str)
             grs' p s (`succeedsLeaving` s)
@@ -954,19 +954,19 @@
         it "consumes all matching tokens, zero or more" $
           property $ \s ->
             not (null s) ==> do
-              let p :: MonadParsec Void String m => m String
+              let p :: (MonadParsec Void String m) => m String
                   p = takeWhileP Nothing isLetter
                   (z, zs) = DL.span isLetter s
               grs p s (`shouldParse` z)
               grs' p s (`succeedsLeaving` zs)
       context "when stream is empty" $
         it "succeeds returning empty chunk" $ do
-          let p :: MonadParsec Void String m => m String
+          let p :: (MonadParsec Void String m) => m String
               p = takeWhileP Nothing isLetter
           grs p "" (`shouldParse` "")
           grs' p "" (`succeedsLeaving` "")
       context "with two takeWhileP in a row (testing hints)" $ do
-        let p :: MonadParsec Void String m => m String
+        let p :: (MonadParsec Void String m) => m String
             p = do
               void $ takeWhileP (Just "foo") (== 'a')
               void $ takeWhileP (Just "bar") (== 'b')
@@ -985,7 +985,7 @@
             grs' p s (`failsLeaving` "")
       context "without label (testing hints)" $
         it "there are no hints" $ do
-          let p :: MonadParsec Void String m => m String
+          let p :: (MonadParsec Void String m) => m String
               p = takeWhileP Nothing (== 'a') <* empty
               s = "aaa"
           grs p s (`shouldFailWith` err 3 mempty)
@@ -995,7 +995,7 @@
       context "when stream is prefixed with matching tokens" $
         it "consumes the tokens" $
           property $ \s' -> do
-            let p :: MonadParsec Void String m => m String
+            let p :: (MonadParsec Void String m) => m String
                 p = takeWhile1P Nothing isLetter
                 s = 'a' : s'
                 (z, zs) = DL.span isLetter s
@@ -1004,7 +1004,7 @@
       context "when stream is not prefixed with at least one matching token" $
         it "signals correct parse error" $
           property $ \s' -> do
-            let p :: MonadParsec Void String m => m String
+            let p :: (MonadParsec Void String m) => m String
                 p = takeWhile1P (Just "foo") isLetter
                 s = '3' : s'
                 pe = err 0 (utok '3' <> elabel "foo")
@@ -1013,20 +1013,20 @@
       context "when stream is empty" $ do
         context "with label" $
           it "signals correct parse error" $ do
-            let p :: MonadParsec Void String m => m String
+            let p :: (MonadParsec Void String m) => m String
                 p = takeWhile1P (Just "foo") isLetter
                 pe = err 0 (ueof <> elabel "foo")
             grs p "" (`shouldFailWith` pe)
             grs' p "" (`failsLeaving` "")
         context "without label" $
           it "signals correct parse error" $ do
-            let p :: MonadParsec Void String m => m String
+            let p :: (MonadParsec Void String m) => m String
                 p = takeWhile1P Nothing isLetter
                 pe = err 0 ueof
             grs p "" (`shouldFailWith` pe)
             grs' p "" (`failsLeaving` "")
       context "with two takeWhile1P in a row (testing hints)" $ do
-        let p :: MonadParsec Void String m => m String
+        let p :: (MonadParsec Void String m) => m String
             p = do
               void $ takeWhile1P (Just "foo") (== 'a')
               void $ takeWhile1P (Just "bar") (== 'b')
@@ -1045,7 +1045,7 @@
             grs' p s (`failsLeaving` "")
       context "without label (testing hints)" $
         it "there are no hints" $ do
-          let p :: MonadParsec Void String m => m String
+          let p :: (MonadParsec Void String m) => m String
               p = takeWhile1P Nothing (== 'a') <* empty
               s = "aaa"
           grs p s (`shouldFailWith` err 3 mempty)
@@ -1055,14 +1055,14 @@
       context "when taking 0 tokens" $ do
         context "when stream is empty" $
           it "succeeds returning zero-length chunk" $ do
-            let p :: MonadParsec Void String m => m String
+            let p :: (MonadParsec Void String m) => m String
                 p = takeP Nothing 0
             grs p "" (`shouldParse` "")
         context "when stream is not empty" $
           it "succeeds returning zero-length chunk" $
             property $ \s ->
               not (null s) ==> do
-                let p :: MonadParsec Void String m => m String
+                let p :: (MonadParsec Void String m) => m String
                     p = takeP Nothing 0
                 grs p s (`shouldParse` "")
                 grs' p s (`succeedsLeaving` s)
@@ -1070,14 +1070,14 @@
         context "when stream is empty" $
           it "succeeds returning zero-length chunk" $
             property $ \(Negative n) -> do
-              let p :: MonadParsec Void String m => m String
+              let p :: (MonadParsec Void String m) => m String
                   p = takeP Nothing n
               grs p "" (`shouldParse` "")
         context "when stream is not empty" $
           it "succeeds returning zero-length chunk" $
             property $ \(Negative n) s ->
               not (null s) ==> do
-                let p :: MonadParsec Void String m => m String
+                let p :: (MonadParsec Void String m) => m String
                     p = takeP Nothing n
                 grs p s (`shouldParse` "")
                 grs' p s (`succeedsLeaving` s)
@@ -1086,7 +1086,7 @@
           context "with label" $
             it "signals correct parse error" $
               property $ \(Positive n) -> do
-                let p :: MonadParsec Void String m => m String
+                let p :: (MonadParsec Void String m) => m String
                     p = takeP (Just "foo") n
                     pe = err 0 (ueof <> elabel "foo")
                 grs p "" (`shouldFailWith` pe)
@@ -1094,14 +1094,14 @@
           context "without label" $
             it "signals correct parse error" $
               property $ \(Positive n) -> do
-                let p :: MonadParsec Void String m => m String
+                let p :: (MonadParsec Void String m) => m String
                     p = takeP Nothing n
                     pe = err 0 ueof
                 grs p "" (`shouldFailWith` pe)
         context "when stream has not enough tokens" $
           it "signals correct parse error" $
             property $ \(Positive n) s -> do
-              let p :: MonadParsec Void String m => m String
+              let p :: (MonadParsec Void String m) => m String
                   p = takeP (Just "foo") n
                   m = length s
                   pe = err m (ueof <> elabel "foo")
@@ -1112,7 +1112,7 @@
           it "succeeds returning the extracted tokens" $
             property $ \(Positive n) s ->
               length s >= n ==> do
-                let p :: MonadParsec Void String m => m String
+                let p :: (MonadParsec Void String m) => m String
                     p = takeP (Just "foo") n
                     (s0, s1) = splitAt n s
                 grs p s (`shouldParse` s0)
@@ -1121,7 +1121,7 @@
         it "there are no hints to influence the parse error" $
           property $ \(Positive n) s ->
             length s >= n ==> do
-              let p :: MonadParsec Void String m => m String
+              let p :: (MonadParsec Void String m) => m String
                   p = takeP (Just "foo") n <* empty
                   pe = err n mempty
               grs p s (`shouldFailWith` pe)
@@ -1131,28 +1131,28 @@
     describe "failure" $
       it "signals correct parse error" $
         property $ \us ps -> do
-          let p :: MonadParsec Void String m => m ()
+          let p :: (MonadParsec Void String m) => m ()
               p = void (failure us ps)
           grs p "" (`shouldFailWith` TrivialError 0 us ps)
 
     describe "fancyFailure" $
       it "singals correct parse error" $
         property $ \xs -> do
-          let p :: MonadParsec Void String m => m ()
+          let p :: (MonadParsec Void String m) => m ()
               p = void (fancyFailure xs)
           grs p "" (`shouldFailWith` FancyError 0 xs)
 
     describe "unexpected" $
       it "signals correct parse error" $
         property $ \item -> do
-          let p :: MonadParsec Void String m => m ()
+          let p :: (MonadParsec Void String m) => m ()
               p = void (unexpected item)
           grs p "" (`shouldFailWith` TrivialError 0 (pure item) E.empty)
 
     describe "customFailure" $
       it "signals correct parse error" $
         property $ \n st -> do
-          let p :: MonadParsec Int String m => m ()
+          let p :: (MonadParsec Int String m) => m ()
               p = void (customFailure n)
               xs = E.singleton (ErrorCustom n)
           runParser p "" (stateInput st) `shouldFailWith` FancyError 0 xs
@@ -1209,7 +1209,7 @@
     describe "registerParseError" $ do
       it "immediately fails with given parse error" $
         property $ \st es -> do
-          let p :: MonadParsec Void String m => m ()
+          let p :: (MonadParsec Void String m) => m ()
               p = forM_ (NE.reverse es) registerParseError
               st' =
                 st
@@ -1223,14 +1223,14 @@
     describe "registerFailure" $
       it "signals correct parse error" $
         property $ \us ps -> do
-          let p :: MonadParsec Void String m => m ()
+          let p :: (MonadParsec Void String m) => m ()
               p = void (registerFailure us ps)
           grs p "" (`shouldFailWith` TrivialError 0 us ps)
 
     describe "reisterFancyFailure" $
       it "singals correct parse error" $
         property $ \xs -> do
-          let p :: MonadParsec Void String m => m ()
+          let p :: (MonadParsec Void String m) => m ()
               p = void (registerFancyFailure xs)
           grs p "" (`shouldFailWith` FancyError 0 xs)
 
@@ -1239,7 +1239,7 @@
     -- "Text.Megaparsec.Byte".
 
     describe "anySingle" $ do
-      let p :: MonadParsec Void String m => m Char
+      let p :: (MonadParsec Void String m) => m Char
           p = anySingle
       context "when stream is not empty" $
         it "succeeds consuming next character in the stream" $
@@ -1255,7 +1255,7 @@
       context "when stream begins with the character specified as argument" $
         it "signals correct parse error" $
           property $ \ch s' -> do
-            let p :: MonadParsec Void String m => m Char
+            let p :: (MonadParsec Void String m) => m Char
                 p = anySingleBut ch
                 s = ch : s'
             grs p s (`shouldFailWith` err 0 (utok ch))
@@ -1264,7 +1264,7 @@
         it "parses first character in the stream" $
           property $ \ch s ->
             not (null s) && ch /= head s ==> do
-              let p :: MonadParsec Void String m => m Char
+              let p :: (MonadParsec Void String m) => m Char
                   p = anySingleBut ch
               grs p s (`shouldParse` head s)
               grs' p s (`succeedsLeaving` tail s)
@@ -1388,7 +1388,7 @@
     describe "setParserState and getParserState" $
       it "sets parser state and gets it back" $
         property $ \s1 s2 -> do
-          let p :: MonadParsec Void String m => m (State String Void)
+          let p :: (MonadParsec Void String m) => m (State String Void)
               p = do
                 st <- getParserState
                 guard (st == initialState s)