diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,8 @@
+1.2.0.0 [2024-03-15]
+--------------------
+* Mini.Transformers.ParserT:
+    * Simplify parse errors
+
 1.1.1.0 [2024-03-14]
 --------------------
 * Mini.Transformers.ParserT:
diff --git a/Mini/Transformers/ParserT.hs b/Mini/Transformers/ParserT.hs
--- a/Mini/Transformers/ParserT.hs
+++ b/Mini/Transformers/ParserT.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE TupleSections #-}
 
@@ -52,6 +53,9 @@
 import Data.Functor (
   (<&>),
  )
+import Data.List (
+  intersperse,
+ )
 import Mini.Transformers.Class (
   MonadTrans (
     lift
@@ -64,7 +68,7 @@
 
 -- | A transformer parsing symbols /s/, inner monad /m/, return /a/
 newtype ParserT s m a = ParserT
-  { runParserT :: [s] -> m (Either [ParseError s] (a, [s]))
+  { runParserT :: [s] -> m (Either ParseError (a, [s]))
   -- ^ Unwrap a 'ParserT' computation with a sequence of symbols to parse
   }
 
@@ -76,7 +80,7 @@
   (<*>) = ap
 
 instance (Monad m, Eq s) => Alternative (ParserT s m) where
-  empty = ParserT . const . pure $ Left [EmptyError]
+  empty = ParserT . const . pure $ Left mempty
   m <|> n = ParserT $ \ss ->
     runParserT m ss
       >>= either
@@ -106,61 +110,54 @@
   mempty = pure mempty
 
 instance (Monad m) => MonadFail (ParserT s m) where
-  fail msg = ParserT . const . pure $ Left [FailError msg]
+  fail = ParserT . const . pure . Left . ParseError . pure
 
--- | Abstract representation of a parse error for symbols /s/
-data ParseError s
-  = EndOfInput
-  | Unexpected s
-  | EmptyError
-  | FailError String
+-- | Abstract representation of a parse error
+newtype ParseError = ParseError [String]
+  deriving (Semigroup, Monoid)
 
-instance (Show s) => Show (ParseError s) where
-  show = \case
-    EndOfInput -> "unexpected EOF"
-    Unexpected s -> "unexpected " <> show s
-    EmptyError -> "empty"
-    FailError msg -> msg
+instance Show ParseError where
+  show (ParseError es) = "(parse error: " <> concat (intersperse ", " es) <> ")"
 
 {-
  - Parsers
  -}
 
 -- | Parse symbols satisfying a predicate
-sat :: (Applicative m) => (s -> Bool) -> ParserT s m s
+sat :: (Applicative m, Show s) => (s -> Bool) -> ParserT s m s
 sat p = ParserT $ \case
-  [] -> pure $ Left [EndOfInput]
+  [] -> pure . Left $ ParseError ["end of input"]
   (s : ss) ->
     bool
-      (pure $ Left [Unexpected s])
+      (pure . Left $ ParseError ["unexpected " <> show s])
       (pure $ Right (s, ss))
       $ p s
 
 -- | Parse any symbol
-item :: (Applicative m) => ParserT s m s
+item :: (Applicative m, Show s) => ParserT s m s
 item = sat $ const True
 
 -- | Parse a symbol
-symbol :: (Applicative m, Eq s) => s -> ParserT s m s
+symbol :: (Applicative m, Show s, Eq s) => s -> ParserT s m s
 symbol = sat . (==)
 
 -- | Parse a sequence of symbols
-string :: (Monad m, Traversable t, Eq s) => t s -> ParserT s m (t s)
+string :: (Monad m, Traversable t, Show s, Eq s) => t s -> ParserT s m (t s)
 string = traverse symbol
 
 -- | Parse symbols included in a collection
-oneOf :: (Applicative m, Foldable t, Eq s) => t s -> ParserT s m s
+oneOf :: (Applicative m, Foldable t, Show s, Eq s) => t s -> ParserT s m s
 oneOf = sat . flip elem
 
 -- | Parse symbols excluded from a collection
-noneOf :: (Applicative m, Foldable t, Eq s) => t s -> ParserT s m s
+noneOf :: (Applicative m, Foldable t, Show s, Eq s) => t s -> ParserT s m s
 noneOf = sat . flip notElem
 
 -- | Parse successfully only at end of input
-eof :: (Applicative m) => ParserT s m ()
+eof :: (Applicative m, Show s) => ParserT s m ()
 eof = ParserT $ \case
   [] -> pure $ Right ((), [])
-  (s : _) -> pure $ Left [Unexpected s]
+  (s : _) -> pure . Left $ ParseError ["unexpected " <> show s]
 
 {-
  - Combinators
diff --git a/mini.cabal b/mini.cabal
--- a/mini.cabal
+++ b/mini.cabal
@@ -1,6 +1,6 @@
 cabal-version:      2.4
 name:               mini
-version:            1.1.1.0
+version:            1.2.0.0
 license:            MIT
 license-file:       LICENSE
 copyright:          (c) 2023-2024 Victor Wallsten