diff --git a/hspec-core.cabal b/hspec-core.cabal
--- a/hspec-core.cabal
+++ b/hspec-core.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:             hspec-core
-version:          2.10.6
+version:          2.10.7
 license:          MIT
 license-file:     LICENSE
 copyright:        (c) 2011-2022 Simon Hengel,
@@ -43,6 +43,7 @@
     , deepseq
     , directory
     , filepath
+    , haskell-lexer
     , hspec-expectations ==0.8.2.*
     , process
     , quickcheck-io >=0.2.0
@@ -80,7 +81,7 @@
       Test.Hspec.Core.Formatters.Internal
       Test.Hspec.Core.Formatters.Pretty
       Test.Hspec.Core.Formatters.Pretty.Parser
-      Test.Hspec.Core.Formatters.Pretty.Parser.Types
+      Test.Hspec.Core.Formatters.Pretty.Parser.Parser
       Test.Hspec.Core.Formatters.Pretty.Unicode
       Test.Hspec.Core.Formatters.V1.Free
       Test.Hspec.Core.Formatters.V1.Monad
@@ -96,10 +97,6 @@
       Data.Algorithm.Diff
       Paths_hspec_core
   default-language: Haskell2010
-  if impl(ghc >= 8.2.1)
-    build-depends:
-        ghc
-      , ghc-boot-th
   if impl(ghc >= 8.4.1)
     build-depends:
         stm >=2.2
@@ -129,6 +126,7 @@
     , deepseq
     , directory
     , filepath
+    , haskell-lexer
     , hspec-expectations ==0.8.2.*
     , hspec-meta ==2.10.5
     , process
@@ -163,7 +161,7 @@
       Test.Hspec.Core.Formatters.Internal
       Test.Hspec.Core.Formatters.Pretty
       Test.Hspec.Core.Formatters.Pretty.Parser
-      Test.Hspec.Core.Formatters.Pretty.Parser.Types
+      Test.Hspec.Core.Formatters.Pretty.Parser.Parser
       Test.Hspec.Core.Formatters.Pretty.Unicode
       Test.Hspec.Core.Formatters.V1
       Test.Hspec.Core.Formatters.V1.Free
@@ -217,10 +215,6 @@
       Test.Hspec.Core.UtilSpec
       Paths_hspec_core
   default-language: Haskell2010
-  if impl(ghc >= 8.2.1)
-    build-depends:
-        ghc
-      , ghc-boot-th
   if impl(ghc >= 8.4.1)
     build-depends:
         stm >=2.2
diff --git a/src/Test/Hspec/Core/Formatters/Pretty.hs b/src/Test/Hspec/Core/Formatters/Pretty.hs
--- a/src/Test/Hspec/Core/Formatters/Pretty.hs
+++ b/src/Test/Hspec/Core/Formatters/Pretty.hs
@@ -24,16 +24,12 @@
   (Just expected_, Just actual_) -> (expected_, actual_)
   _ -> case (pretty unicode expected, pretty unicode actual) of
     (Just expected_, Just actual_) -> (expected_, actual_)
-#if __GLASGOW_HASKELL__ >= 802
-    _ -> (expected, actual)
-#else
     _ -> (rec expected, rec actual)
   where
     rec = if unicode then urecover else id
 
     urecover :: String -> String
     urecover xs = maybe xs ushow $ readMaybe xs
-#endif
 
 recoverString :: Bool -> String -> Maybe String
 recoverString unicode input = case readMaybe input of
@@ -45,24 +41,22 @@
     isSafe c = (unicode || isAscii c) && (not $ isControl c) || c == '\n'
 
 pretty :: Bool -> String -> Maybe String
-pretty unicode = parseExpression >=> render_
+pretty unicode = parseValue >=> render_
   where
-    render_ :: Expression -> Maybe String
-    render_ expr = guard (shouldParseBack expr) >> Just (renderExpression unicode expr)
+    render_ :: Value -> Maybe String
+    render_ value = guard (shouldParseBack value) >> Just (renderValue unicode value)
 
-    shouldParseBack :: Expression -> Bool
+    shouldParseBack :: Value -> Bool
     shouldParseBack = go
       where
-        go expr = case expr of
-          Literal (String _) -> True
-          Literal _ -> False
-          Id _ -> False
-          App (Id _) e -> go e
-          App _ _ -> False
-          Parentheses e -> go e
+        go value = case value of
+          Char _ -> False
+          String _ -> True
+          Number _ -> False
+          Record _ _ -> True
+          Constructor _ xs -> any go xs
           Tuple xs -> any go xs
           List xs -> any go xs
-          Record _ _ -> True
 
 newtype Builder = Builder ShowS
 
@@ -91,24 +85,18 @@
 instance IsString Builder where
   fromString = Builder . showString
 
-renderExpression :: Bool -> Expression -> String
-renderExpression unicode = runBuilder . render
+renderValue :: Bool -> Value -> String
+renderValue unicode = runBuilder . render
   where
-    renderLiteral lit = case lit of
+    render :: Value -> Builder
+    render value = case value of
       Char c -> shows c
       String str -> if unicode then Builder $ ushows str else shows str
-      Integer n -> shows n
-      Rational n -> fromString n
-
-    render :: Expression -> Builder
-    render expr = case expr of
-      Literal lit -> renderLiteral lit
-      Id name -> fromString name
-      App a b -> render a <> " " <> render b
-      Parentheses e@Record{} -> render e
-      Parentheses e -> "(" <> render e <> ")"
+      Number n -> fromString n
+      Record name fields -> fromString name <> " {\n  " <> (intercalate ",\n  " $ map renderField fields) <> "\n}"
+      Constructor name values -> intercalate " " (fromString name : map render values)
+      Tuple [e@Record{}] -> render e
       Tuple xs -> "(" <> intercalate ", " (map render xs) <> ")"
       List xs -> "[" <> intercalate ", " (map render xs) <> "]"
-      Record name fields -> fromString name <> " {\n  " <> (intercalate ",\n  " $ map renderField fields) <> "\n}"
 
     renderField (name, value) = fromString name <> " = " <> render value
diff --git a/src/Test/Hspec/Core/Formatters/Pretty/Parser.hs b/src/Test/Hspec/Core/Formatters/Pretty/Parser.hs
--- a/src/Test/Hspec/Core/Formatters/Pretty/Parser.hs
+++ b/src/Test/Hspec/Core/Formatters/Pretty/Parser.hs
@@ -1,395 +1,102 @@
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE RankNTypes #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE FlexibleInstances #-}
-#if __GLASGOW_HASKELL__ >= 810
-{-# LANGUAGE EmptyCase #-}
-#endif
 module Test.Hspec.Core.Formatters.Pretty.Parser (
-  Expression(..)
-, Literal(..)
-, parseExpression
-, unsafeParseExpression
+  Value(..)
+, parseValue
 ) where
 
 import           Prelude ()
-import           Test.Hspec.Core.Compat hiding (fail)
-import           Test.Hspec.Core.Formatters.Pretty.Parser.Types
-
-#ifndef __GHCJS__
-#if __GLASGOW_HASKELL__ >= 802 && __GLASGOW_HASKELL__ <= 904
-#define PRETTY_PRINTING_SUPPORTED
-#endif
-#endif
-
-#ifndef PRETTY_PRINTING_SUPPORTED
-
-parseExpression :: String -> Maybe Expression
-parseExpression _ = Nothing
-
-unsafeParseExpression :: String -> Maybe Expression
-unsafeParseExpression _ = Nothing
-
-#else
-
-import           GHC.Stack
-import           GHC.Exception (throw, errorCallWithCallStackException)
-
-#if __GLASGOW_HASKELL__ >= 904
-import           GHC.Utils.Error
-import           GHC.Utils.Outputable
-#endif
-
-#if __GLASGOW_HASKELL__ >= 804 && __GLASGOW_HASKELL__ < 904
-import           GHC.LanguageExtensions.Type
-#endif
-
-#if __GLASGOW_HASKELL__ >= 902
-import           GHC.Types.SourceText
-#elif __GLASGOW_HASKELL__ >= 900
-import           GHC.Types.Basic
-import           GHC.Unit.Types
-#endif
-
-#if __GLASGOW_HASKELL__ >= 900
-import qualified GHC.Parser as GHC
-import           GHC.Parser.Lexer
-import           GHC.Data.StringBuffer
-import           GHC.Data.FastString
-import           GHC.Types.SrcLoc
-import           GHC.Types.Name
-import           GHC.Types.Name.Reader
-import           GHC.Parser.PostProcess hiding (Tuple)
-#else
-import           Lexer
-import qualified Parser as GHC
-import           StringBuffer
-import           FastString
-import           SrcLoc
-import           Name
-import           RdrName
-import           BasicTypes
-import           Module
-#endif
-
-#if __GLASGOW_HASKELL__ >= 804 && __GLASGOW_HASKELL__ < 904
-#if __GLASGOW_HASKELL__ >= 900
-import qualified GHC.Data.EnumSet as EnumSet
-#else
-import qualified EnumSet
-#endif
-#endif
-
-#if __GLASGOW_HASKELL__ == 810
-import           RdrHsSyn hiding (Tuple)
-#endif
-
-#if __GLASGOW_HASKELL__ >= 810
-import           GHC.Hs
-#else
-import           HsSyn
-#endif
-
-#if __GLASGOW_HASKELL__ <= 806
-import           Data.Bits
-import           Control.Exception
-#endif
-
-parseExpression :: String -> Maybe Expression
-parseExpression = parseWith (const Nothing)
-
-unsafeParseExpression :: String -> Maybe Expression
-unsafeParseExpression = parseWith throwError
-
-parseWith :: (Error -> Maybe Expression) -> String -> Maybe Expression
-parseWith err = parse >=> either err Just . toExpression
-
-data Error = Error CallStack String
-
-throwError :: Error -> a
-throwError (Error stack err) = throw $ errorCallWithCallStackException err stack
-
-fail :: HasCallStack => String -> Either Error a
-fail = Left . Error callStack
-
-class ToExpression a where
-  toExpression :: a -> Either Error Expression
-
-#if __GLASGOW_HASKELL__ < 806
-#define _x
-#endif
-
-#if __GLASGOW_HASKELL__ >= 900
-#define X(name, expr)
-#elif __GLASGOW_HASKELL__ == 810
-#define X(name, expr) name none -> case none of
-#elif __GLASGOW_HASKELL__ >= 806
-#define X(name, expr) name none -> case none of NoExt -> expr
-#else
-#define X(name, expr)
-#endif
-
-#if __GLASGOW_HASKELL__ >= 804
-#define GhcPsHsLit GhcPs
-#else
-type GhcPs = RdrName
-#define GhcPsHsLit
-#endif
-
-#if __GLASGOW_HASKELL__ >= 902
-#define _listSynExpr
-#endif
-
-#if __GLASGOW_HASKELL__ >= 806
-#define RecCon(name, fields) RecordCon _ (L _ name) fields
-#else
-#define RecCon(name, fields) RecordCon (L _ name) _ _ fields
-#endif
-
-#define REJECT(name) name{} -> fail "name"
+import           Test.Hspec.Core.Compat
 
-instance ToExpression (HsExpr GhcPs) where
-  toExpression expr = case expr of
-    HsVar _x name -> toExpression name
-    HsLit _x lit -> toExpression lit
-    HsOverLit _x lit -> toExpression lit
-    HsApp _x f x -> App <$> toExpression f <*> toExpression x
-    NegApp _x e _ -> toExpression e >>= \ x -> case x of
-      Literal (Rational n) -> return $ Literal (Rational $ '-' : n)
-      Literal (Integer n) -> return $ Literal (Integer $ negate n)
-      _ -> fail "NegApp"
+import           Test.Hspec.Core.Formatters.Pretty.Parser.Parser hiding (Parser)
+import qualified Test.Hspec.Core.Formatters.Pretty.Parser.Parser as P
 
-    HsPar _x
-#if __GLASGOW_HASKELL__ >= 904
-      _ e _ ->
-#else
-      e ->
-#endif
-        Parentheses <$> toExpression e
-    ExplicitTuple _x xs _ -> Tuple <$> mapM toExpression xs
-    ExplicitList _ _listSynExpr xs -> List <$> mapM toExpression xs
-    RecCon(name, fields) -> Record (showRdrName name) <$> (recordFields $ rec_flds fields)
-      where
-#if __GLASGOW_HASKELL__ >= 904
-        hsRecFieldLbl = hfbLHS
-        hsRecFieldArg = hfbRHS
-#endif
-        fieldName = showFieldLabel . unLoc . hsRecFieldLbl
-        recordFields = mapM (recordField . unLoc)
-        recordField field = (,) (fieldName field) <$> toExpression (hsRecFieldArg field)
+import           Language.Haskell.Lexer hiding (Pos(..))
 
-    REJECT(HsUnboundVar)
-    REJECT(HsOverLabel)
-    REJECT(HsIPVar)
-    REJECT(HsLam)
-    REJECT(HsLamCase)
-    REJECT(HsAppType)
-    REJECT(OpApp)
-    REJECT(SectionL)
-    REJECT(SectionR)
-    REJECT(ExplicitSum)
-    REJECT(HsCase)
-    REJECT(HsIf)
-    REJECT(HsMultiIf)
-    REJECT(HsLet)
-    REJECT(HsDo)
-    REJECT(RecordUpd)
-    REJECT(ExprWithTySig)
-    REJECT(ArithSeq)
-    REJECT(HsSpliceE)
-    REJECT(HsProc)
-    REJECT(HsStatic)
+type Name = String
 
-#if __GLASGOW_HASKELL__ >= 904
-    REJECT(HsRecSel)
-    REJECT(HsTypedBracket)
-    REJECT(HsUntypedBracket)
-#endif
-#if __GLASGOW_HASKELL__ >= 902
-    REJECT(HsGetField)
-    REJECT(HsProjection)
-#endif
-#if __GLASGOW_HASKELL__ >= 900
-    REJECT(HsPragE)
-#endif
+data Value =
+    Char Char
+  | String String
+  | Number String
+  | Record Name [(Name, Value)]
+  | Constructor Name [Value]
+  | Tuple [Value]
+  | List [Value]
+  deriving (Eq, Show)
 
-#if __GLASGOW_HASKELL__ < 904
-    REJECT(HsConLikeOut)
-    REJECT(HsRecFld)
-    REJECT(HsBracket)
-    REJECT(HsRnBracketOut)
-    REJECT(HsTcBracketOut)
-    REJECT(HsTick)
-    REJECT(HsBinTick)
-#endif
-#if __GLASGOW_HASKELL__ < 900
-    REJECT(HsSCC)
-    REJECT(HsCoreAnn)
-    REJECT(HsTickPragma)
-    REJECT(HsWrap)
-#endif
-#if __GLASGOW_HASKELL__ < 810
-    REJECT(HsArrApp)
-    REJECT(HsArrForm)
-    REJECT(EWildPat)
-    REJECT(EAsPat)
-    REJECT(EViewPat)
-    REJECT(ELazyPat)
-#endif
-#if __GLASGOW_HASKELL__ < 806
-    REJECT(HsAppTypeOut)
-    REJECT(ExplicitPArr)
-    REJECT(ExprWithTySigOut)
-    REJECT(PArrSeq)
-#endif
-    X(XExpr, fail "XExpr")
+type Parser = P.Parser (Token, String)
 
-instance ToExpression RdrName where
-  toExpression = return . Id . showRdrName
+parseValue :: String -> Maybe Value
+parseValue input = case runParser value (tokenize input) of
+  Just (v, []) -> Just v
+  _ -> Nothing
 
-instance ToExpression (HsTupArg GhcPs) where
-  toExpression t = case t of
-    Present _x expr -> toExpression expr
-    Missing _ -> fail "Missing (tuple section)"
-    X(XTupArg, fail "XTupArg")
+value :: Parser Value
+value =
+      char
+  <|> string
+  <|> number
+  <|> record
+  <|> constructor
+  <|> tuple
+  <|> list
 
-instance ToExpression e => ToExpression (GenLocated l e) where
-  toExpression (L _ e) = toExpression e
+char :: Parser Value
+char = Char <$> (token CharLit >>= readA)
 
-instance ToExpression (HsOverLit GhcPs) where
-  toExpression = toExpression . ol_val
+string :: Parser Value
+string = String <$> (token StringLit >>= readA)
 
-#if __GLASGOW_HASKELL__ > 802
-#define _integralSource
+number :: Parser Value
+number = integer <|> float
+  where
+    integer :: Parser Value
+    integer = Number <$> token IntLit
 
-instance ToExpression IntegralLit where
-  toExpression il = toExpression (il_value il)
-#endif
+    float :: Parser Value
+    float = Number <$> token FloatLit
 
-instance ToExpression OverLitVal where
-  toExpression lit = case lit of
-    HsIntegral _integralSource il -> toExpression il
-    HsFractional fl -> toExpression fl
-    HsIsString _ str -> toExpression str
+record :: Parser Value
+record = Record <$> token Conid <* special "{" <*> fields <* special "}"
+  where
+    fields :: Parser [(Name, Value)]
+    fields = field `sepBy1` comma
 
-instance ToExpression FractionalLit where
-  toExpression fl = case fl_text fl of
-#if __GLASGOW_HASKELL__ > 802
-    REJECT(NoSourceText)
-    SourceText n
-#else
-    n
-#endif
-      -> return . Literal $ Rational n
+    field :: Parser (Name, Value)
+    field = (,) <$> token Varid <* equals <*> value
 
-instance ToExpression FastString where
-  toExpression = return . Literal . String . unpackFS
+constructor :: Parser Value
+constructor = Constructor <$> token Conid <*> many value
 
-instance ToExpression Integer where
-  toExpression = return . Literal . Integer
+tuple :: Parser Value
+tuple = Tuple <$> (special "(" *> items) <* special ")"
 
-instance ToExpression Char where
-  toExpression = return . Literal . Char
+list :: Parser Value
+list = List <$> (special "[" *> items) <* special "]"
 
-instance ToExpression (HsLit GhcPsHsLit) where
-  toExpression lit = case lit of
-    HsChar _ c -> toExpression c
-    HsString _ str -> toExpression str
-    REJECT(HsCharPrim)
-    REJECT(HsStringPrim)
-    REJECT(HsInt)
-    REJECT(HsIntPrim)
-    REJECT(HsWordPrim)
-    REJECT(HsInt64Prim)
-    REJECT(HsWord64Prim)
-    REJECT(HsInteger)
-    REJECT(HsRat)
-    REJECT(HsFloatPrim)
-    REJECT(HsDoublePrim)
-    X(XLit, fail "XLit")
+items :: Parser [Value]
+items = value `sepBy` comma
 
-showFieldLabel :: FieldOcc GhcPs -> String
-showFieldLabel label = case label of
-#if __GLASGOW_HASKELL__ >= 806
-  FieldOcc _ (L _ name) -> showRdrName name
-#else
-  FieldOcc (L _ name) _ -> showRdrName name
-#endif
-  X(XFieldOcc, "")
+special :: String -> Parser ()
+special s = require (Special, s)
 
-showRdrName :: RdrName -> String
-showRdrName n = case n of
-  Unqual name -> showOccName name
-  Qual _ name -> showOccName name
-  Orig _ name -> showOccName name
-  Exact name -> showOccName (nameOccName name)
+comma :: Parser ()
+comma = special ","
 
-showOccName :: OccName -> String
-showOccName = unpackFS . occNameFS
+equals :: Parser ()
+equals = require (Reservedop, "=")
 
-parse :: String -> Maybe (HsExpr GhcPs)
-parse input = case runParser input pHsExpr of
-  POk _ (L _ x) -> Just x
-  PFailed {} -> Nothing
-  where
-    pHsExpr = do
-      r <- GHC.parseExpression
-      runPV (unECP r)
+token :: Token -> Parser String
+token t = snd <$> satisfy (fst >>> (== t))
 
-#if __GLASGOW_HASKELL__ <= 900
-#if __GLASGOW_HASKELL__ >= 810
-    unECP = runECP_PV
-#else
-    unECP = return
-    runPV = id
-#endif
-#endif
+require :: (Token, String) -> Parser ()
+require t = void $ satisfy (== t)
 
-runParser :: String -> P a -> ParseResult a
-runParser str parser = unP parser parseState
+tokenize :: String -> [(Token, String)]
+tokenize = go . map (fmap snd) . rmSpace . lexerPass0
   where
-    location = mkRealSrcLoc "" 1 1
-    input = stringToStringBuffer str
-    parseState = initParserState opts input location
-    opts = mkParserOpts warn
-#if __GLASGOW_HASKELL__ >= 904
-      (DiagOpts mempty mempty False False Nothing defaultSDocContext)
-#endif
-      extensions False False False True
-
-#if __GLASGOW_HASKELL__ >= 804 && __GLASGOW_HASKELL__ < 904
-    warn = EnumSet.empty
-#else
-    warn = mempty
-#endif
-
-#if __GLASGOW_HASKELL__ >= 904
-    extensions = ["TraditionalRecordSyntax"]
-#elif __GLASGOW_HASKELL__ >= 804
-    extensions = EnumSet.fromList [TraditionalRecordSyntax]
-#else
-    extensions = mempty
-#endif
-
-#if __GLASGOW_HASKELL__ <= 900
-    initParserState = mkPStatePure
-    mkParserOpts warningFlags extensionFlags = mkParserFlags' warningFlags extensionFlags unit
-#if __GLASGOW_HASKELL__ == 900
-    unit = UnitId ""
-#else
-    unit = fsToUnitId ""
-#endif
-#endif
-
-#if __GLASGOW_HASKELL__ <= 806
-    mkParserFlags' ws es u _ _ _ _ = assert (traditionalRecordSyntaxEnabled extensionsBitmap) $
-      ParserFlags ws es u extensionsBitmap
-    extensionsBitmap = shift 1 traditionalRecordSyntaxBit
-#if __GLASGOW_HASKELL__ == 806
-    traditionalRecordSyntaxBit = 28
-#else
-    traditionalRecordSyntaxBit = 29
-#endif
-#endif
-
-#endif
+    go :: [(Token, String)] -> [(Token, String)]
+    go tokens = case tokens of
+      [] -> []
+      (Varsym, "-") : (IntLit, n) : xs -> (IntLit, "-" ++ n) : go xs
+      (Varsym, "-") : (FloatLit, n) : xs -> (FloatLit, "-" ++ n) : go xs
+      x : xs -> x : go xs
diff --git a/src/Test/Hspec/Core/Formatters/Pretty/Parser/Parser.hs b/src/Test/Hspec/Core/Formatters/Pretty/Parser/Parser.hs
new file mode 100644
--- /dev/null
+++ b/src/Test/Hspec/Core/Formatters/Pretty/Parser/Parser.hs
@@ -0,0 +1,34 @@
+{-# LANGUAGE DeriveFunctor #-}
+module Test.Hspec.Core.Formatters.Pretty.Parser.Parser where
+
+import           Prelude ()
+import           Test.Hspec.Core.Compat
+
+newtype Parser token a = Parser { runParser :: [token] -> Maybe (a, [token]) }
+  deriving Functor
+
+instance Applicative (Parser token) where
+  pure a = Parser $ \ input -> Just (a, input)
+  (<*>) = ap
+
+instance Monad (Parser token) where
+  return = pure
+  p1 >>= p2 = Parser $ runParser p1 >=> uncurry (runParser . p2)
+
+instance Alternative (Parser token) where
+  empty = Parser $ const Nothing
+  p1 <|> p2 = Parser $ \ input -> runParser p1 input <|> runParser p2 input
+
+satisfy :: (token -> Bool) -> Parser token token
+satisfy p = Parser $ \ input -> case input of
+  t : ts | p t -> Just (t, ts)
+  _ -> Nothing
+
+sepBy :: Alternative m => m a -> m sep -> m [a]
+sepBy p sep = sepBy1 p sep <|> pure []
+
+sepBy1 :: Alternative m => m a -> m sep -> m [a]
+sepBy1 p sep = (:) <$> p <*> many (sep *> p)
+
+readA :: (Alternative m, Read a) => String -> m a
+readA = maybe empty pure . readMaybe
diff --git a/src/Test/Hspec/Core/Formatters/Pretty/Parser/Types.hs b/src/Test/Hspec/Core/Formatters/Pretty/Parser/Types.hs
deleted file mode 100644
--- a/src/Test/Hspec/Core/Formatters/Pretty/Parser/Types.hs
+++ /dev/null
@@ -1,21 +0,0 @@
-module Test.Hspec.Core.Formatters.Pretty.Parser.Types where
-
-import           Prelude ()
-import           Test.Hspec.Core.Compat
-
-data Expression =
-    Literal Literal
-  | Id String
-  | App Expression Expression
-  | Parentheses Expression
-  | Tuple [Expression]
-  | List [Expression]
-  | Record String [(String, Expression)]
-  deriving (Eq, Show)
-
-data Literal =
-    Char Char
-  | String String
-  | Integer Integer
-  | Rational String
-  deriving (Eq, Show)
diff --git a/test/Test/Hspec/Core/Formatters/Pretty/ParserSpec.hs b/test/Test/Hspec/Core/Formatters/Pretty/ParserSpec.hs
--- a/test/Test/Hspec/Core/Formatters/Pretty/ParserSpec.hs
+++ b/test/Test/Hspec/Core/Formatters/Pretty/ParserSpec.hs
@@ -1,4 +1,5 @@
-{-# LANGUAGE CPP #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ConstraintKinds #-}
 module Test.Hspec.Core.Formatters.Pretty.ParserSpec (spec, Person(..)) where
 
 import           Prelude ()
@@ -11,59 +12,61 @@
 , personAge :: Int
 } deriving (Eq, Show)
 
-string :: String -> Expression
-string = Literal . String
+infix 1 `shouldParseAs`
 
-integer :: Integer -> Expression
-integer = Literal . Integer
+shouldParseAs :: HasCallStack => String -> Value -> Expectation
+shouldParseAs input expected = parseValue input `shouldBe` Just expected
 
+unit :: Value
+unit = Tuple []
+
+parentheses :: Value -> Value
+parentheses value = Tuple [value]
+
 spec :: Spec
 spec = do
-  let parse = unsafeParseExpression
-  describe "parseExpression" $ do
+  describe "parseValue" $ do
+    it "parses unit" $ do
+      show () `shouldParseAs` unit
+
     it "parses characters" $ do
-      parse (show 'c') `shouldBe` just (Literal $ Char 'c')
+      show 'c' `shouldParseAs` Char 'c'
 
     it "parses strings" $ do
-      parse (show "foo") `shouldBe` just (string "foo")
+      show "foo" `shouldParseAs` String "foo"
 
-    it "parses integers" $ do
-      parse "23" `shouldBe` just (integer 23)
+    context "when parsing numbers" $ do
+      it "accepts integers" $ do
+        "23" `shouldParseAs` Number "23"
 
-    it "parses negative integers" $ do
-      parse "-23" `shouldBe` just (integer (-23))
+      it "accepts negative integers" $ do
+        "-23" `shouldParseAs` Number "-23"
 
-    it "parses rationals" $ do
-      parse "23.0" `shouldBe` just (Literal $ Rational "23.0")
+      it "accepts floats" $ do
+        show (23.0 :: Float) `shouldParseAs` Number "23.0"
 
-    it "parses negative rationals" $ do
-      parse "-23.0" `shouldBe` just (Literal $ Rational "-23.0")
+      it "accepts negative floats" $ do
+        show (-23.0 :: Float) `shouldParseAs` Number "-23.0"
 
     it "parses lists" $ do
-      parse (show ["foo", "bar", "baz"]) `shouldBe` just (List [string "foo", string "bar", string "baz"])
+      show ["foo", "bar", "baz"] `shouldParseAs` List [String "foo", String "bar", String "baz"]
 
     it "parses tuples" $ do
-      parse (show ("foo", "bar", "baz")) `shouldBe` just (Tuple [string "foo", string "bar", string "baz"])
+      show ("foo", "bar", "baz") `shouldParseAs` Tuple [String "foo", String "bar", String "baz"]
 
     it "parses Nothing" $ do
-      parse (show (Nothing :: Maybe Int)) `shouldBe` just (Id "Nothing")
+      show (Nothing :: Maybe Int) `shouldParseAs` Constructor "Nothing" []
 
     it "parses Just" $ do
-      parse (show $ Just "foo") `shouldBe` just (App (Id "Just") (string "foo"))
+      show (Just "foo") `shouldParseAs` Constructor "Just" [String "foo"]
 
     it "parses nested Just" $ do
-      parse (show $ Just $ Just "foo") `shouldBe` just (App (Id "Just") . Parentheses $ App (Id "Just") (string "foo"))
+      show (Just $ Just "foo") `shouldParseAs` Constructor "Just" [parentheses (Constructor "Just" [String "foo"])]
 
     it "parses records" $ do
       let person = Person "Joe" 23
 
-      parse (show person) `shouldBe` just (Record "Person" [
-          ("personName", string "Joe")
-        , ("personAge", integer 23)
-        ])
-  where
-#if __GLASGOW_HASKELL__ >= 802
-    just = Just
-#else
-    just _ = Nothing
-#endif
+      show person `shouldParseAs` Record "Person" [
+          ("personName", String "Joe")
+        , ("personAge", Number "23")
+        ]
diff --git a/test/Test/Hspec/Core/Formatters/PrettySpec.hs b/test/Test/Hspec/Core/Formatters/PrettySpec.hs
--- a/test/Test/Hspec/Core/Formatters/PrettySpec.hs
+++ b/test/Test/Hspec/Core/Formatters/PrettySpec.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP #-}
 module Test.Hspec.Core.Formatters.PrettySpec (spec) where
 
 import           Prelude ()
@@ -110,8 +109,4 @@
         let input = unlines ["foo", "bar", "baz"]
         pretty True input `shouldBe` Nothing
   where
-#if __GLASGOW_HASKELL__ >= 802
     just = Just . intercalate "\n"
-#else
-    just _ = Nothing
-#endif
diff --git a/version.yaml b/version.yaml
--- a/version.yaml
+++ b/version.yaml
@@ -1,1 +1,1 @@
-&version 2.10.6
+&version 2.10.7