diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,9 @@
+Version 0.7.1
+---------------
+* Added a Show instance for every Show1 to satisfy the new class declaration
+* Bumped the upper bound of the `template-haskell` dependency
+* Eliminated a bunch of compiler warnings
+
 Version 0.7.0.1
 ---------------
 * Bumped the upper bound of the `rank2classes` dependency
diff --git a/examples/Boolean.hs b/examples/Boolean.hs
--- a/examples/Boolean.hs
+++ b/examples/Boolean.hs
@@ -1,10 +1,11 @@
 {-# LANGUAGE FlexibleContexts, FlexibleInstances, KindSignatures, RecordWildCards, ScopedTypeVariables,
-             TypeFamilies, TemplateHaskell, UndecidableInstances #-}
+             TemplateHaskell, TypeFamilies, TypeOperators, UndecidableInstances #-}
 module Boolean where
 
 import Control.Applicative
 import qualified Data.Bool
 import Data.Char (isSpace)
+import Data.Kind (Type)
 import Data.Monoid ((<>))
 import Text.Parser.Token (TokenParsing, symbol)
 
@@ -51,7 +52,7 @@
 
 $(Rank2.TH.deriveAll ''Boolean)
 
-boolean :: forall e p (g :: (* -> *) -> *).
+boolean :: forall e p (g :: (Type -> Type) -> Type).
            (BooleanDomain e, LexicalParsing (p g String), ParserInput (p g String) ~ String) =>
            p g String e -> Boolean e (p g String) -> Boolean e (p g String)
 boolean p Boolean{..} = Boolean{
diff --git a/grammatical-parsers.cabal b/grammatical-parsers.cabal
--- a/grammatical-parsers.cabal
+++ b/grammatical-parsers.cabal
@@ -1,5 +1,5 @@
 name:                grammatical-parsers
-version:             0.7.0.1
+version:             0.7.1
 synopsis:            parsers that combine into grammars
 description:
   /Gram/matical-/pa/rsers, or Grampa for short, is a library of parser types whose values are meant to be assigned
@@ -50,7 +50,7 @@
   ghc-options:         -Wall
   build-depends:       base >=4.9 && <5,
                        containers >= 0.4 && < 0.7,
-                       transformers >= 0.5 && < 0.6,
+                       transformers >= 0.5 && < 0.7,
                        monoid-subclasses >=1.0 && <1.3,
                        parsers < 0.13,
                        input-parsers < 0.4,
diff --git a/src/Text/Grampa/ContextFree/Continued.hs b/src/Text/Grampa/ContextFree/Continued.hs
--- a/src/Text/Grampa/ContextFree/Continued.hs
+++ b/src/Text/Grampa/ContextFree/Continued.hs
@@ -8,7 +8,7 @@
 import Control.Monad (MonadFail(fail))
 #endif
 
-import Data.Functor.Classes (Show1(..))
+import Data.Functor.Classes (Show1(..), showsPrec1)
 import Data.Functor.Compose (Compose(..))
 import Data.Kind (Type)
 import Data.Semigroup (Semigroup(..))
@@ -33,7 +33,7 @@
 import Text.Parser.Input.Position (fromEnd)
 import Text.Grampa.Class (CommittedParsing(..), DeterministicParsing(..),
                           InputParsing(..), InputCharParsing(..), MultiParsing(..),
-                          ParseResults, ParseFailure(..), FailureDescription(..), Pos)
+                          ParseResults, ParseFailure(..), Pos)
 import Text.Grampa.Internal (emptyFailure, erroneous, expected, expectedInput, replaceExpected, TraceableParsing(..))
 
 data Result (g :: (Type -> Type) -> Type) s v =
@@ -45,6 +45,9 @@
 -- class but with potentially exponential performance for longer ambiguous prefixes.
 newtype Parser (g :: (Type -> Type) -> Type) s r =
    Parser{applyParser :: forall x. s -> (r -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x}
+
+instance (Show s, Show a) => Show (Result g s a) where
+   showsPrec = showsPrec1
 
 instance Show s => Show1 (Result g s) where
    liftShowsPrec showsPrecSub _showList prec Parsed{parsedPrefix= r} rest = "Parsed " ++ showsPrecSub prec r rest
diff --git a/src/Text/Grampa/ContextFree/Continued/Measured.hs b/src/Text/Grampa/ContextFree/Continued/Measured.hs
--- a/src/Text/Grampa/ContextFree/Continued/Measured.hs
+++ b/src/Text/Grampa/ContextFree/Continued/Measured.hs
@@ -8,7 +8,7 @@
 import Control.Monad (MonadFail(fail))
 #endif
 
-import Data.Functor.Classes (Show1(..))
+import Data.Functor.Classes (Show1(..), showsPrec1)
 import Data.Functor.Compose (Compose(..))
 import Data.Kind (Type)
 import Data.Semigroup (Semigroup(..))
@@ -45,6 +45,9 @@
 -- class but with potentially exponential performance for longer ambiguous prefixes.
 newtype Parser (g :: (Type -> Type) -> Type) s r =
    Parser{applyParser :: forall x. s -> (r -> Int -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x}
+
+instance (Show s, Show a) => Show (Result g s a) where
+   showsPrec = showsPrec1
 
 instance Show s => Show1 (Result g s) where
    liftShowsPrec showsPrecSub _showList prec Parsed{parsedPrefix= r} rest = "Parsed " ++ showsPrecSub prec r rest
diff --git a/src/Text/Grampa/ContextFree/Memoizing.hs b/src/Text/Grampa/ContextFree/Memoizing.hs
--- a/src/Text/Grampa/ContextFree/Memoizing.hs
+++ b/src/Text/Grampa/ContextFree/Memoizing.hs
@@ -383,8 +383,8 @@
 longest :: Parser g s a -> Backtrack.Parser g [(s, g (ResultList g s))] a
 longest p = Backtrack.Parser q where
    q rest = case applyParser p rest
-            of ResultList EmptyTree (ParseFailure pos (FailureDescription expected inputs) errors)
-                  -> Backtrack.NoParse (ParseFailure pos (FailureDescription expected $ map wrap inputs) errors)
+            of ResultList EmptyTree (ParseFailure pos (FailureDescription static inputs) errors)
+                  -> Backtrack.NoParse (ParseFailure pos (FailureDescription static $ map wrap inputs) errors)
                ResultList rs _ -> parsed (maximumBy (compare `on` resultLength) rs)
    resultLength (ResultInfo l _ _) = l
    parsed (ResultInfo l s r) = Backtrack.Parsed l r s
@@ -395,8 +395,8 @@
 peg p = Parser q where
    q rest = case Backtrack.applyParser p rest
             of Backtrack.Parsed l result suffix -> ResultList (Leaf $ ResultInfo l suffix result) mempty
-               Backtrack.NoParse (ParseFailure pos (FailureDescription expected inputs) errors)
-                  -> ResultList mempty (ParseFailure pos (FailureDescription expected (fst . head <$> inputs)) errors)
+               Backtrack.NoParse (ParseFailure pos (FailureDescription static inputs) errors)
+                  -> ResultList mempty (ParseFailure pos (FailureDescription static (fst . head <$> inputs)) errors)
 
 -- | Turns a backtracking PEG parser into a context-free parser
 terminalPEG :: (Monoid s, Ord s) => Backtrack.Parser g s a -> Parser g s a
diff --git a/src/Text/Grampa/ContextFree/SortedMemoizing.hs b/src/Text/Grampa/ContextFree/SortedMemoizing.hs
--- a/src/Text/Grampa/ContextFree/SortedMemoizing.hs
+++ b/src/Text/Grampa/ContextFree/SortedMemoizing.hs
@@ -341,8 +341,8 @@
 longest :: Parser g s a -> Backtrack.Parser g [(s, g (ResultList g s))] a
 longest p = Backtrack.Parser q where
    q rest = case applyParser p rest
-            of ResultList [] (ParseFailure pos (FailureDescription expected inputs) errors)
-                  -> Backtrack.NoParse (ParseFailure pos (FailureDescription expected $ map wrap inputs) errors)
+            of ResultList [] (ParseFailure pos (FailureDescription static inputs) errors)
+                  -> Backtrack.NoParse (ParseFailure pos (FailureDescription static $ map wrap inputs) errors)
                ResultList rs _ -> parsed (last rs)
    parsed (ResultsOfLength l s (r:|_)) = Backtrack.Parsed l r s
    wrap s = [(s, error "longest")]
@@ -352,8 +352,8 @@
 peg p = Parser q where
    q rest = case Backtrack.applyParser p rest
             of Backtrack.Parsed l result suffix -> ResultList [ResultsOfLength l suffix (result:|[])] mempty
-               Backtrack.NoParse (ParseFailure pos (FailureDescription expected inputs) errors)
-                  -> ResultList mempty (ParseFailure pos (FailureDescription expected (fst . head <$> inputs)) errors)
+               Backtrack.NoParse (ParseFailure pos (FailureDescription static inputs) errors)
+                  -> ResultList mempty (ParseFailure pos (FailureDescription static (fst . head <$> inputs)) errors)
 
 -- | Turns a backtracking PEG parser into a context-free parser
 terminalPEG :: Monoid s => Ord s => Backtrack.Parser g s a -> Parser g s a
diff --git a/src/Text/Grampa/ContextFree/SortedMemoizing/Transformer.hs b/src/Text/Grampa/ContextFree/SortedMemoizing/Transformer.hs
--- a/src/Text/Grampa/ContextFree/SortedMemoizing/Transformer.hs
+++ b/src/Text/Grampa/ContextFree/SortedMemoizing/Transformer.hs
@@ -391,8 +391,8 @@
 longest :: ParserT Identity g s a -> Backtrack.Parser g [(s, g (ResultListT Identity g s))] a
 longest p = Backtrack.Parser q where
    q rest = case applyParser p rest
-            of ResultList [] (ParseFailure pos (FailureDescription expected inputs) errors)
-                  -> Backtrack.NoParse (ParseFailure pos (FailureDescription expected $ map wrap inputs) errors)
+            of ResultList [] (ParseFailure pos (FailureDescription static inputs) errors)
+                  -> Backtrack.NoParse (ParseFailure pos (FailureDescription static $ map wrap inputs) errors)
                ResultList rs _ -> parsed (last rs)
    parsed (ResultsOfLengthT (ROL l s (Identity r:|_))) = Backtrack.Parsed l r s
    wrap s = [(s, error "longest")]
@@ -402,8 +402,8 @@
 peg p = Parser q where
    q rest = case Backtrack.applyParser p rest
             of Backtrack.Parsed l result suffix -> singleResult l suffix result
-               Backtrack.NoParse (ParseFailure pos (FailureDescription expected inputs) errors)
-                  -> ResultList mempty (ParseFailure pos (FailureDescription expected (fst . head <$> inputs)) errors)
+               Backtrack.NoParse (ParseFailure pos (FailureDescription static inputs) errors)
+                  -> ResultList mempty (ParseFailure pos (FailureDescription static (fst . head <$> inputs)) errors)
 
 -- | Turns a backtracking PEG parser into a context-free parser
 terminalPEG :: (Applicative m, Monoid s, Ord s) => Backtrack.Parser g s a -> ParserT m g s a
diff --git a/src/Text/Grampa/Internal.hs b/src/Text/Grampa/Internal.hs
--- a/src/Text/Grampa/Internal.hs
+++ b/src/Text/Grampa/Internal.hs
@@ -69,7 +69,7 @@
 erroneous pos msg = ParseFailure pos (FailureDescription [] []) [msg]
 
 replaceExpected :: Pos -> String -> ParseFailure Pos s -> ParseFailure Pos s
-replaceExpected pos msg f@(ParseFailure pos' msgs errs) = ParseFailure pos' msgs' errs
+replaceExpected pos msg (ParseFailure pos' msgs errs) = ParseFailure pos' msgs' errs
    where msgs' | pos == pos' = FailureDescription [msg] []
                | otherwise = msgs
 
diff --git a/src/Text/Grampa/Internal/LeftRecursive.hs b/src/Text/Grampa/Internal/LeftRecursive.hs
--- a/src/Text/Grampa/Internal/LeftRecursive.hs
+++ b/src/Text/Grampa/Internal/LeftRecursive.hs
@@ -959,12 +959,12 @@
                            combine (Const False) _ = Const False
                            combine (Const True) results = Const (hasSuccess results)
                            combineFailures _ (Const False) _ = Const False
-                           combineFailures (ParseFailure pos (FailureDescription expected inputs) errors) (Const True) rl =
+                           combineFailures (ParseFailure pos (FailureDescription expected _inputs) errors) (Const True) rl =
                               Const (pos < pos'
                                      || pos == pos' && (any (`notElem` expected) expected'
                                                         || any (`notElem` expected) expected')
                                                         || any (`notElem` errors) errors')
-                              where ParseFailure pos' (FailureDescription expected' inputs') errors' = failureOf rl
+                              where ParseFailure pos' (FailureDescription expected' _inputs) errors' = failureOf rl
                   choiceWhile (Const (Just DynamicDependencies)) t t'
                      | getAny (Rank2.foldMap (Any . hasSuccess) marginal) = t'
                      | hasSuccess t = t
diff --git a/src/Text/Grampa/PEG/Backtrack.hs b/src/Text/Grampa/PEG/Backtrack.hs
--- a/src/Text/Grampa/PEG/Backtrack.hs
+++ b/src/Text/Grampa/PEG/Backtrack.hs
@@ -8,7 +8,7 @@
 import Control.Monad (MonadFail(fail))
 #endif
 
-import Data.Functor.Classes (Show1(..))
+import Data.Functor.Classes (Show1(..), showsPrec1)
 import Data.Functor.Compose (Compose(..))
 import Data.Kind (Type)
 import Data.Semigroup (Semigroup(..))
@@ -33,7 +33,7 @@
 import Text.Parser.Input.Position (fromEnd)
 import Text.Grampa.Class (CommittedParsing(..), DeterministicParsing(..),
                           InputParsing(..), InputCharParsing(..), MultiParsing(..),
-                          ParseResults, ParseFailure(..), FailureDescription(..), Pos)
+                          ParseResults, ParseFailure(..), Pos)
 import Text.Grampa.Internal (emptyFailure, erroneous, expected, expectedInput, replaceExpected, TraceableParsing(..))
 
 data Result (g :: (Type -> Type) -> Type) s v =
@@ -44,6 +44,9 @@
 -- | Parser type for Parsing Expression Grammars that uses a backtracking algorithm, fast for grammars in LL(1) class
 -- but with potentially exponential performance for longer ambiguous prefixes.
 newtype Parser g s r = Parser{applyParser :: s -> Result g s r}
+
+instance (Show s, Show a) => Show (Result g s a) where
+   showsPrec = showsPrec1
 
 instance Show s => Show1 (Result g s) where
    liftShowsPrec showsPrecSub _showList prec Parsed{parsedPrefix= r} rest = "Parsed " ++ showsPrecSub prec r rest
diff --git a/src/Text/Grampa/PEG/Backtrack/Measured.hs b/src/Text/Grampa/PEG/Backtrack/Measured.hs
--- a/src/Text/Grampa/PEG/Backtrack/Measured.hs
+++ b/src/Text/Grampa/PEG/Backtrack/Measured.hs
@@ -8,7 +8,7 @@
 import Control.Monad (MonadFail(fail))
 #endif
 
-import Data.Functor.Classes (Show1(..))
+import Data.Functor.Classes (Show1(..), showsPrec1)
 import Data.Functor.Compose (Compose(..))
 import Data.Kind (Type)
 import Data.Semigroup (Semigroup(..))
@@ -45,6 +45,9 @@
 -- | Parser type for Parsing Expression Grammars that uses a backtracking algorithm, fast for grammars in LL(1) class
 -- but with potentially exponential performance for longer ambiguous prefixes.
 newtype Parser g s r = Parser{applyParser :: s -> Result g s r}
+
+instance (Show s, Show a) => Show (Result g s a) where
+   showsPrec = showsPrec1
 
 instance Show s => Show1 (Result g s) where
    liftShowsPrec showsPrecSub _showList prec Parsed{parsedResult= r} rest = "Parsed " ++ showsPrecSub prec r rest
diff --git a/src/Text/Grampa/PEG/Continued.hs b/src/Text/Grampa/PEG/Continued.hs
--- a/src/Text/Grampa/PEG/Continued.hs
+++ b/src/Text/Grampa/PEG/Continued.hs
@@ -8,7 +8,7 @@
 import Control.Monad (MonadFail(fail))
 #endif
 
-import Data.Functor.Classes (Show1(..))
+import Data.Functor.Classes (Show1(..), showsPrec1)
 import Data.Functor.Compose (Compose(..))
 import Data.Kind (Type)
 import Data.Semigroup (Semigroup((<>)))
@@ -44,6 +44,9 @@
 -- LL(1) class but with potentially exponential performance for longer ambiguous prefixes.
 newtype Parser (g :: (Type -> Type) -> Type) s r =
    Parser{applyParser :: forall x. s -> (r -> s -> x) -> (ParseFailure Pos s -> x) -> x}
+
+instance (Show s, Show a) => Show (Result g s a) where
+   showsPrec = showsPrec1
 
 instance Show s => Show1 (Result g s) where
    liftShowsPrec showsPrecSub _showList prec Parsed{parsedPrefix= r} rest = "Parsed " ++ showsPrecSub prec r rest
diff --git a/src/Text/Grampa/PEG/Continued/Measured.hs b/src/Text/Grampa/PEG/Continued/Measured.hs
--- a/src/Text/Grampa/PEG/Continued/Measured.hs
+++ b/src/Text/Grampa/PEG/Continued/Measured.hs
@@ -32,7 +32,7 @@
 import Text.Parser.Input.Position (fromEnd)
 import Text.Grampa.Class (CommittedParsing(..), DeterministicParsing(..),
                           InputParsing(..), InputCharParsing(..), ConsumedInputParsing(..),
-                          MultiParsing(..), ParseResults, ParseFailure(..), FailureDescription(..), Pos)
+                          MultiParsing(..), ParseResults, ParseFailure(..), Pos)
 import Text.Grampa.Internal (TraceableParsing(..), emptyFailure, erroneous, expected, expectedInput, replaceExpected)
 import Text.Grampa.PEG.Continued (Result(..))
 
diff --git a/src/Text/Grampa/PEG/Packrat.hs b/src/Text/Grampa/PEG/Packrat.hs
--- a/src/Text/Grampa/PEG/Packrat.hs
+++ b/src/Text/Grampa/PEG/Packrat.hs
@@ -8,7 +8,7 @@
 import Control.Monad (MonadFail(fail))
 #endif
 
-import Data.Functor.Classes (Show1(..))
+import Data.Functor.Classes (Show1(..), showsPrec1)
 import Data.Functor.Compose (Compose(..))
 import Data.Monoid (Monoid(mappend, mempty))
 import Data.Monoid.Factorial(FactorialMonoid)
@@ -46,6 +46,9 @@
 -- but with worse constants and more memory consumption than the backtracking 'Text.Grampa.PEG.Backtrack.Parser'. The
 -- 'parse' function returns an input prefix parse paired with the remaining input suffix.
 newtype Parser g s r = Parser{applyParser :: [(s, g (Result g s))] -> Result g s r}
+
+instance (Show s, Show a) => Show (Result g s a) where
+   showsPrec = showsPrec1
 
 instance Show s => Show1 (Result g s) where
    liftShowsPrec showsPrecSub _showList prec Parsed{parsedPrefix= r} rest = "Parsed " ++ showsPrecSub prec r rest
diff --git a/test/Test.hs b/test/Test.hs
--- a/test/Test.hs
+++ b/test/Test.hs
@@ -1,5 +1,6 @@
 {-# Language FlexibleContexts, FlexibleInstances, RankNTypes, RecordWildCards, 
-             ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TypeFamilies, UndecidableInstances #-}
+             ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TypeFamilies, TypeOperators,
+             UndecidableInstances #-}
 module Main where
 
 import Control.Applicative (Applicative, Alternative, Const(..), pure, empty, liftA2, many, optional, (<*>), (*>), (<|>))