diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
 # Parser combinators tests
 
-Test suite for the `parser-combinators` package as a separate package. This
-allows us to avoid a circular dependency with `megaparsec` (which depends on
-`parser-combinators`).
+A test suite for the `parser-combinators` package as a separate package.
+This allows us to avoid a circular dependency with `megaparsec` (which
+depends on `parser-combinators`).
 
 ## License
 
diff --git a/Setup.hs b/Setup.hs
deleted file mode 100644
--- a/Setup.hs
+++ /dev/null
@@ -1,6 +0,0 @@
-module Main (main) where
-
-import Distribution.Simple
-
-main :: IO ()
-main = defaultMain
diff --git a/parser-combinators-tests.cabal b/parser-combinators-tests.cabal
--- a/parser-combinators-tests.cabal
+++ b/parser-combinators-tests.cabal
@@ -1,11 +1,11 @@
-cabal-version:   1.18
+cabal-version:   2.4
 name:            parser-combinators-tests
-version:         1.3.0
-license:         BSD3
+version:         1.3.1
+license:         BSD-3-Clause
 license-file:    LICENSE.md
 maintainer:      Mark Karpov <markkarpov92@gmail.com>
 author:          Mark Karpov <markkarpov92@gmail.com>
-tested-with:     ghc ==8.6.5 ghc ==8.8.4 ghc ==8.10.3
+tested-with:     ghc ==9.8.4 ghc ==9.10.3 ghc ==9.12.1
 homepage:        https://github.com/mrkkrp/parser-combinators
 bug-reports:     https://github.com/mrkkrp/parser-combinators/issues
 synopsis:        Test suite of parser-combinators
@@ -24,10 +24,10 @@
     manual:      True
 
 test-suite test-suite
-    type:             exitcode-stdio-1.0
-    main-is:          Spec.hs
-    build-tools:      hspec-discover >=2.0 && <3.0
-    hs-source-dirs:   tests
+    type:               exitcode-stdio-1.0
+    main-is:            Spec.hs
+    build-tool-depends: hspec-discover:hspec-discover >=2.0 && <3.0
+    hs-source-dirs:     tests
     other-modules:
         Control.Applicative.CombinatorsSpec
         Control.Applicative.PermutationsSpec
@@ -35,19 +35,23 @@
         Control.Monad.CombinatorsSpec
         Control.Monad.PermutationsSpec
 
-    default-language: Haskell2010
+    default-language:   Haskell2010
     build-depends:
-        QuickCheck >=2.7 && <2.15,
-        base >=4.12 && <5.0,
-        hspec >=2.0 && <3.0,
-        hspec-expectations >=0.8 && <0.9,
-        hspec-megaparsec >=2.0 && <3.0,
-        megaparsec >=8.0 && <10.0,
-        megaparsec-tests >=8.0 && <10.0,
-        parser-combinators ==1.3.0
+        QuickCheck >=2.7 && <2.17,
+        base >=4.15 && <5,
+        hspec >=2.0 && <3,
+        hspec-megaparsec >=2 && <3,
+        megaparsec >=8 && <10,
+        megaparsec-tests >=8 && <10,
+        parser-combinators ==1.3.1
 
     if flag(dev)
-        ghc-options: -Wall -Werror
+        ghc-options:
+            -Wall -Werror -Wredundant-constraints -Wpartial-fields
+            -Wunused-packages
 
     else
         ghc-options: -O2 -Wall
+
+    if impl(ghc >=9.8)
+        ghc-options: -Wno-x-partial
diff --git a/tests/Control/Applicative/CombinatorsSpec.hs b/tests/Control/Applicative/CombinatorsSpec.hs
--- a/tests/Control/Applicative/CombinatorsSpec.hs
+++ b/tests/Control/Applicative/CombinatorsSpec.hs
@@ -26,7 +26,8 @@
           prs_ p s
             `shouldFailWith` err
               (length pre + n + b)
-              ( etoks post <> etok c
+              ( etoks post
+                  <> etok c
                   <> if length post == b
                     then ueof
                     else utoks (drop b post)
@@ -57,15 +58,15 @@
           p = count' m n (char 'x')
           s = replicate x 'x'
       if
-          | n <= 0 || m > n ->
+        | n <= 0 || m > n ->
             if x == 0
               then prs_ p s `shouldParse` ""
               else prs_ p s `shouldFailWith` err 0 (utok 'x' <> eeof)
-          | m <= x && x <= n ->
+        | m <= x && x <= n ->
             prs_ p s `shouldParse` s
-          | x < m ->
+        | x < m ->
             prs_ p s `shouldFailWith` err x (ueof <> etok 'x')
-          | otherwise ->
+        | otherwise ->
             prs_ p s `shouldFailWith` err n (utok 'x' <> eeof)
     rightOrder (count' 1 3 letterChar) "abc" "abc"
 
@@ -74,9 +75,9 @@
       let p = eitherP letterChar digitChar
           s = pure ch
       if
-          | isLetter ch -> prs_ p s `shouldParse` Left ch
-          | isDigit ch -> prs_ p s `shouldParse` Right ch
-          | otherwise ->
+        | isLetter ch -> prs_ p s `shouldParse` Left ch
+        | isDigit ch -> prs_ p s `shouldParse` Right ch
+        | otherwise ->
             prs_ p s
               `shouldFailWith` err 0 (utok ch <> elabel "letter" <> elabel "digit")
 
@@ -86,13 +87,13 @@
           p = endBy (char 'a') (char '-')
           s = intersperse '-' (replicate n 'a') ++ [c]
       if
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldFailWith` err 1 (ueof <> etok '-')
-          | c == 'a' ->
+        | c == 'a' ->
             prs_ p s `shouldFailWith` err (g n) (utok 'a' <> etok '-')
-          | c == '-' && n == 0 ->
+        | c == '-' && n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok '-' <> etok 'a' <> eeof)
-          | c /= '-' ->
+        | c /= '-' ->
             prs_ p s
               `shouldFailWith` err
                 (g n)
@@ -100,7 +101,7 @@
                     <> (if n > 0 then etok '-' else eeof)
                     <> (if n == 0 then etok 'a' else mempty)
                 )
-          | otherwise -> prs_ p s `shouldParse` replicate n 'a'
+        | otherwise -> prs_ p s `shouldParse` replicate n 'a'
     rightOrder (endBy letterChar (char ',')) "a,b,c," "abc"
 
   describe "endBy1" $ do
@@ -109,13 +110,13 @@
           p = endBy1 (char 'a') (char '-')
           s = intersperse '-' (replicate n 'a') ++ [c]
       if
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldFailWith` err 1 (ueof <> etok '-')
-          | c == 'a' ->
+        | c == 'a' ->
             prs_ p s `shouldFailWith` err (g n) (utok 'a' <> etok '-')
-          | c == '-' && n == 0 ->
+        | c == '-' && n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok '-' <> etok 'a')
-          | c /= '-' ->
+        | c /= '-' ->
             prs_ p s
               `shouldFailWith` err
                 (g n)
@@ -123,13 +124,12 @@
                     <> (if n > 0 then etok '-' else mempty)
                     <> (if n == 0 then etok 'a' else mempty)
                 )
-          | otherwise -> prs_ p s `shouldParse` replicate n 'a'
+        | otherwise -> prs_ p s `shouldParse` replicate n 'a'
     rightOrder (endBy1 letterChar (char ',')) "a,b,c," "abc"
 
   describe "manyTill" $ do
-    it "works" . property $ \a' b' c' -> do
-      let [a, b, c] = getNonNegative <$> [a', b', c']
-          p = (,) <$> manyTill letterChar (char 'c') <*> many letterChar
+    it "works" . property $ \(NonNegative a) (NonNegative b) (NonNegative c) -> do
+      let p = (,) <$> manyTill letterChar (char 'c') <*> many letterChar
           s = abcRow a b c
       if c == 0
         then
@@ -143,9 +143,8 @@
     rightOrder (manyTill letterChar (char 'd')) "abcd" "abc"
 
   describe "manyTill_" $ do
-    it "works" . property $ \a' b' c' -> do
-      let [a, b, c] = getNonNegative <$> [a', b', c']
-          p = (,) <$> manyTill_ letterChar (char 'c') <*> many letterChar
+    it "works" . property $ \(NonNegative a) (NonNegative b) (NonNegative c) -> do
+      let p = (,) <$> manyTill_ letterChar (char 'c') <*> many letterChar
           s = abcRow a b c
       if c == 0
         then
@@ -159,45 +158,43 @@
     rightOrder (fst <$> manyTill_ letterChar (char 'd')) "abcd" "abc"
 
   describe "someTill" $ do
-    it "works" . property $ \a' b' c' -> do
-      let [a, b, c] = getNonNegative <$> [a', b', c']
-          p = (,) <$> someTill letterChar (char 'c') <*> many letterChar
+    it "works" . property $ \(NonNegative a) (NonNegative b) (NonNegative c) -> do
+      let p = (,) <$> someTill letterChar (char 'c') <*> many letterChar
           s = abcRow a b c
       if
-          | null s ->
+        | null s ->
             prs_ p s `shouldFailWith` err 0 (ueof <> elabel "letter")
-          | c == 0 ->
+        | c == 0 ->
             prs_ p s
               `shouldFailWith` err
                 (a + b)
                 (ueof <> etok 'c' <> elabel "letter")
-          | s == "c" ->
+        | s == "c" ->
             prs_ p s `shouldFailWith` err 1 (ueof <> etok 'c' <> elabel "letter")
-          | head s == 'c' ->
+        | head s == 'c' ->
             prs_ p s `shouldParse` ("c", drop 2 s)
-          | otherwise ->
+        | otherwise ->
             let (pre, post) = break (== 'c') s
              in prs_ p s `shouldParse` (pre, drop 1 post)
     rightOrder (someTill letterChar (char 'd')) "abcd" "abc"
 
   describe "someTill_" $ do
-    it "works" . property $ \a' b' c' -> do
-      let [a, b, c] = getNonNegative <$> [a', b', c']
-          p = (,) <$> someTill_ letterChar (char 'c') <*> many letterChar
+    it "works" . property $ \(NonNegative a) (NonNegative b) (NonNegative c) -> do
+      let p = (,) <$> someTill_ letterChar (char 'c') <*> many letterChar
           s = abcRow a b c
       if
-          | null s ->
+        | null s ->
             prs_ p s `shouldFailWith` err 0 (ueof <> elabel "letter")
-          | c == 0 ->
+        | c == 0 ->
             prs_ p s
               `shouldFailWith` err
                 (a + b)
                 (ueof <> etok 'c' <> elabel "letter")
-          | s == "c" ->
+        | s == "c" ->
             prs_ p s `shouldFailWith` err 1 (ueof <> etok 'c' <> elabel "letter")
-          | head s == 'c' ->
+        | head s == 'c' ->
             prs_ p s `shouldParse` (("c", 'c'), drop 2 s)
-          | otherwise ->
+        | otherwise ->
             let (pre, post) = break (== 'c') s
              in prs_ p s `shouldParse` ((pre, 'c'), drop 1 post)
     rightOrder (fst <$> someTill_ letterChar (char 'd')) "abcd" "abc"
@@ -215,15 +212,15 @@
           p = sepBy (char 'a') (char '-')
           s = intersperse '-' (replicate n 'a') ++ maybeToList c'
       if
-          | isNothing c' ->
+        | isNothing c' ->
             prs_ p s `shouldParse` replicate n 'a'
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldParse` "a"
-          | n == 0 ->
+        | n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok c <> etok 'a' <> eeof)
-          | c == '-' ->
+        | c == '-' ->
             prs_ p s `shouldFailWith` err (length s) (ueof <> etok 'a')
-          | otherwise ->
+        | otherwise ->
             prs_ p s `shouldFailWith` err (g n) (utok c <> etok '-' <> eeof)
     rightOrder (sepBy letterChar (char ',')) "a,b,c" "abc"
 
@@ -234,17 +231,17 @@
           p = sepBy1 (char 'a') (char '-')
           s = intersperse '-' (replicate n 'a') ++ maybeToList c'
       if
-          | isNothing c' && n >= 1 ->
+        | isNothing c' && n >= 1 ->
             prs_ p s `shouldParse` replicate n 'a'
-          | isNothing c' ->
+        | isNothing c' ->
             prs_ p s `shouldFailWith` err 0 (ueof <> etok 'a')
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldParse` "a"
-          | n == 0 ->
+        | n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok c <> etok 'a')
-          | c == '-' ->
+        | c == '-' ->
             prs_ p s `shouldFailWith` err (length s) (ueof <> etok 'a')
-          | otherwise ->
+        | otherwise ->
             prs_ p s `shouldFailWith` err (g n) (utok c <> etok '-' <> eeof)
     rightOrder (sepBy1 letterChar (char ',')) "a,b,c" "abc"
 
@@ -256,15 +253,15 @@
           a = replicate n 'a'
           s = intersperse '-' (replicate n 'a') ++ maybeToList c'
       if
-          | isNothing c' ->
+        | isNothing c' ->
             prs_ p s `shouldParse` a
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldParse` "a"
-          | n == 0 ->
+        | n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok c <> etok 'a' <> eeof)
-          | c == '-' ->
+        | c == '-' ->
             prs_ p s `shouldParse` a
-          | otherwise ->
+        | otherwise ->
             prs_ p s `shouldFailWith` err (g n) (utok c <> etok '-' <> eeof)
     rightOrder (sepEndBy letterChar (char ',')) "a,b,c," "abc"
 
@@ -276,17 +273,17 @@
           a = replicate n 'a'
           s = intersperse '-' (replicate n 'a') ++ maybeToList c'
       if
-          | isNothing c' && n >= 1 ->
+        | isNothing c' && n >= 1 ->
             prs_ p s `shouldParse` a
-          | isNothing c' ->
+        | isNothing c' ->
             prs_ p s `shouldFailWith` err 0 (ueof <> etok 'a')
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldParse` "a"
-          | n == 0 ->
+        | n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok c <> etok 'a')
-          | c == '-' ->
+        | c == '-' ->
             prs_ p s `shouldParse` a
-          | otherwise ->
+        | otherwise ->
             prs_ p s `shouldFailWith` err (g n) (utok c <> etok '-' <> eeof)
     rightOrder (sepEndBy1 letterChar (char ',')) "a,b,c," "abc"
 
diff --git a/tests/Control/Applicative/PermutationsSpec.hs b/tests/Control/Applicative/PermutationsSpec.hs
--- a/tests/Control/Applicative/PermutationsSpec.hs
+++ b/tests/Control/Applicative/PermutationsSpec.hs
@@ -147,7 +147,8 @@
 
 testPermParser :: Permutation Parser String
 testPermParser =
-  f <$> toPermutationWithDefault 'x' (char 'a')
+  f
+    <$> toPermutationWithDefault 'x' (char 'a')
     <*> toPermutationWithDefault 'y' (char 'b')
     <*> toPermutationWithDefault 'z' (char 'c')
   where
diff --git a/tests/Control/Monad/Combinators/ExprSpec.hs b/tests/Control/Monad/Combinators/ExprSpec.hs
--- a/tests/Control/Monad/Combinators/ExprSpec.hs
+++ b/tests/Control/Monad/Combinators/ExprSpec.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE TypeFamilies #-}
 
@@ -12,10 +11,6 @@
 import Test.QuickCheck
 import Text.Megaparsec
 import Text.Megaparsec.Char
-
-#if !MIN_VERSION_base(4,13,0)
-import Data.Semigroup ((<>))
-#endif
 
 spec :: Spec
 spec =
diff --git a/tests/Control/Monad/CombinatorsSpec.hs b/tests/Control/Monad/CombinatorsSpec.hs
--- a/tests/Control/Monad/CombinatorsSpec.hs
+++ b/tests/Control/Monad/CombinatorsSpec.hs
@@ -28,15 +28,15 @@
           p = count' m n (char 'x')
           s = replicate x 'x'
       if
-          | n <= 0 || m > n ->
+        | n <= 0 || m > n ->
             if x == 0
               then prs_ p s `shouldParse` ""
               else prs_ p s `shouldFailWith` err 0 (utok 'x' <> eeof)
-          | m <= x && x <= n ->
+        | m <= x && x <= n ->
             prs_ p s `shouldParse` s
-          | x < m ->
+        | x < m ->
             prs_ p s `shouldFailWith` err x (ueof <> etok 'x')
-          | otherwise ->
+        | otherwise ->
             prs_ p s `shouldFailWith` err n (utok 'x' <> eeof)
     rightOrder (count' 1 3 letterChar) "abc" "abc"
 
@@ -46,13 +46,13 @@
           p = endBy (char 'a') (char '-')
           s = intersperse '-' (replicate n 'a') ++ [c]
       if
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldFailWith` err 1 (ueof <> etok '-')
-          | c == 'a' ->
+        | c == 'a' ->
             prs_ p s `shouldFailWith` err (g n) (utok 'a' <> etok '-')
-          | c == '-' && n == 0 ->
+        | c == '-' && n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok '-' <> etok 'a' <> eeof)
-          | c /= '-' ->
+        | c /= '-' ->
             prs_ p s
               `shouldFailWith` err
                 (g n)
@@ -60,7 +60,7 @@
                     <> (if n > 0 then etok '-' else eeof)
                     <> (if n == 0 then etok 'a' else mempty)
                 )
-          | otherwise -> prs_ p s `shouldParse` replicate n 'a'
+        | otherwise -> prs_ p s `shouldParse` replicate n 'a'
     rightOrder (endBy letterChar (char ',')) "a,b,c," "abc"
 
   describe "endBy1" $ do
@@ -69,13 +69,13 @@
           p = endBy1 (char 'a') (char '-')
           s = intersperse '-' (replicate n 'a') ++ [c]
       if
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldFailWith` err (1 :: Int) (ueof <> etok '-')
-          | c == 'a' ->
+        | c == 'a' ->
             prs_ p s `shouldFailWith` err (g n) (utok 'a' <> etok '-')
-          | c == '-' && n == 0 ->
+        | c == '-' && n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok '-' <> etok 'a')
-          | c /= '-' ->
+        | c /= '-' ->
             prs_ p s
               `shouldFailWith` err
                 (g n)
@@ -83,13 +83,12 @@
                     <> (if n > 0 then etok '-' else mempty)
                     <> (if n == 0 then etok 'a' else mempty)
                 )
-          | otherwise -> prs_ p s `shouldParse` replicate n 'a'
+        | otherwise -> prs_ p s `shouldParse` replicate n 'a'
     rightOrder (endBy1 letterChar (char ',')) "a,b,c," "abc"
 
   describe "manyTill" $ do
-    it "works" . property $ \a' b' c' -> do
-      let [a, b, c] = getNonNegative <$> [a', b', c']
-          p = (,) <$> manyTill letterChar (char 'c') <*> many letterChar
+    it "works" . property $ \(NonNegative a) (NonNegative b) (NonNegative c) -> do
+      let p = (,) <$> manyTill letterChar (char 'c') <*> many letterChar
           s = abcRow a b c
       if c == 0
         then
@@ -103,9 +102,8 @@
     rightOrder (manyTill letterChar (char 'd')) "abcd" "abc"
 
   describe "manyTill_" $ do
-    it "works" . property $ \a' b' c' -> do
-      let [a, b, c] = getNonNegative <$> [a', b', c']
-          p = (,) <$> manyTill_ letterChar (char 'c') <*> many letterChar
+    it "works" . property $ \(NonNegative a) (NonNegative b) (NonNegative c) -> do
+      let p = (,) <$> manyTill_ letterChar (char 'c') <*> many letterChar
           s = abcRow a b c
       if c == 0
         then
@@ -119,45 +117,43 @@
     rightOrder (fmap fst . manyTill_ letterChar $ char 'd') "abcd" "abc"
 
   describe "someTill" $ do
-    it "works" . property $ \a' b' c' -> do
-      let [a, b, c] = getNonNegative <$> [a', b', c']
-          p = (,) <$> someTill letterChar (char 'c') <*> many letterChar
+    it "works" . property $ \(NonNegative a) (NonNegative b) (NonNegative c) -> do
+      let p = (,) <$> someTill letterChar (char 'c') <*> many letterChar
           s = abcRow a b c
       if
-          | null s ->
+        | null s ->
             prs_ p s `shouldFailWith` err 0 (ueof <> elabel "letter")
-          | c == 0 ->
+        | c == 0 ->
             prs_ p s
               `shouldFailWith` err
                 (a + b)
                 (ueof <> etok 'c' <> elabel "letter")
-          | s == "c" ->
+        | s == "c" ->
             prs_ p s `shouldFailWith` err 1 (ueof <> etok 'c' <> elabel "letter")
-          | head s == 'c' ->
+        | head s == 'c' ->
             prs_ p s `shouldParse` ("c", drop 2 s)
-          | otherwise ->
+        | otherwise ->
             let (pre, post) = break (== 'c') s
              in prs_ p s `shouldParse` (pre, drop 1 post)
     rightOrder (someTill letterChar (char 'd')) "abcd" "abc"
 
   describe "someTill_" $ do
-    it "works" . property $ \a' b' c' -> do
-      let [a, b, c] = getNonNegative <$> [a', b', c']
-          p = (,) <$> someTill_ letterChar (char 'c') <*> many letterChar
+    it "works" . property $ \(NonNegative a) (NonNegative b) (NonNegative c) -> do
+      let p = (,) <$> someTill_ letterChar (char 'c') <*> many letterChar
           s = abcRow a b c
       if
-          | null s ->
+        | null s ->
             prs_ p s `shouldFailWith` err 0 (ueof <> elabel "letter")
-          | c == 0 ->
+        | c == 0 ->
             prs_ p s
               `shouldFailWith` err
                 (a + b)
                 (ueof <> etok 'c' <> elabel "letter")
-          | s == "c" ->
+        | s == "c" ->
             prs_ p s `shouldFailWith` err 1 (ueof <> etok 'c' <> elabel "letter")
-          | head s == 'c' ->
+        | head s == 'c' ->
             prs_ p s `shouldParse` (("c", 'c'), drop 2 s)
-          | otherwise ->
+        | otherwise ->
             let (pre, post) = break (== 'c') s
              in prs_ p s `shouldParse` ((pre, 'c'), drop 1 post)
     rightOrder (fmap fst . someTill_ letterChar $ char 'd') "abcd" "abc"
@@ -169,15 +165,15 @@
           p = sepBy (char 'a') (char '-')
           s = intersperse '-' (replicate n 'a') ++ maybeToList c'
       if
-          | isNothing c' ->
+        | isNothing c' ->
             prs_ p s `shouldParse` replicate n 'a'
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldParse` "a"
-          | n == 0 ->
+        | n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok c <> etok 'a' <> eeof)
-          | c == '-' ->
+        | c == '-' ->
             prs_ p s `shouldFailWith` err (length s) (ueof <> etok 'a')
-          | otherwise ->
+        | otherwise ->
             prs_ p s `shouldFailWith` err (g n) (utok c <> etok '-' <> eeof)
     rightOrder (sepBy letterChar (char ',')) "a,b,c" "abc"
 
@@ -188,17 +184,17 @@
           p = sepBy1 (char 'a') (char '-')
           s = intersperse '-' (replicate n 'a') ++ maybeToList c'
       if
-          | isNothing c' && n >= 1 ->
+        | isNothing c' && n >= 1 ->
             prs_ p s `shouldParse` replicate n 'a'
-          | isNothing c' ->
+        | isNothing c' ->
             prs_ p s `shouldFailWith` err 0 (ueof <> etok 'a')
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldParse` "a"
-          | n == 0 ->
+        | n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok c <> etok 'a')
-          | c == '-' ->
+        | c == '-' ->
             prs_ p s `shouldFailWith` err (length s) (ueof <> etok 'a')
-          | otherwise ->
+        | otherwise ->
             prs_ p s `shouldFailWith` err (g n) (utok c <> etok '-' <> eeof)
     rightOrder (sepBy1 letterChar (char ',')) "a,b,c" "abc"
 
@@ -210,15 +206,15 @@
           a = replicate n 'a'
           s = intersperse '-' (replicate n 'a') ++ maybeToList c'
       if
-          | isNothing c' ->
+        | isNothing c' ->
             prs_ p s `shouldParse` a
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldParse` "a"
-          | n == 0 ->
+        | n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok c <> etok 'a' <> eeof)
-          | c == '-' ->
+        | c == '-' ->
             prs_ p s `shouldParse` a
-          | otherwise ->
+        | otherwise ->
             prs_ p s `shouldFailWith` err (g n) (utok c <> etok '-' <> eeof)
     rightOrder (sepEndBy letterChar (char ',')) "a,b,c," "abc"
 
@@ -230,17 +226,17 @@
           a = replicate n 'a'
           s = intersperse '-' (replicate n 'a') ++ maybeToList c'
       if
-          | isNothing c' && n >= 1 ->
+        | isNothing c' && n >= 1 ->
             prs_ p s `shouldParse` a
-          | isNothing c' ->
+        | isNothing c' ->
             prs_ p s `shouldFailWith` err 0 (ueof <> etok 'a')
-          | c == 'a' && n == 0 ->
+        | c == 'a' && n == 0 ->
             prs_ p s `shouldParse` "a"
-          | n == 0 ->
+        | n == 0 ->
             prs_ p s `shouldFailWith` err 0 (utok c <> etok 'a')
-          | c == '-' ->
+        | c == '-' ->
             prs_ p s `shouldParse` a
-          | otherwise ->
+        | otherwise ->
             prs_ p s `shouldFailWith` err (g n) (utok c <> etok '-' <> eeof)
     rightOrder (sepEndBy1 letterChar (char ',')) "a,b,c," "abc"
 
diff --git a/tests/Control/Monad/PermutationsSpec.hs b/tests/Control/Monad/PermutationsSpec.hs
--- a/tests/Control/Monad/PermutationsSpec.hs
+++ b/tests/Control/Monad/PermutationsSpec.hs
@@ -147,7 +147,8 @@
 
 testPermParser :: Permutation Parser String
 testPermParser =
-  f <$> toPermutationWithDefault 'x' (char 'a')
+  f
+    <$> toPermutationWithDefault 'x' (char 'a')
     <*> toPermutationWithDefault 'y' (char 'b')
     <*> toPermutationWithDefault 'z' (char 'c')
   where