Give TextShow{1,2} quantified superclasses

This mirrors a corresponding change to the `Show1` and `Show2` classes in
`base`—see haskell/core-libraries-committee#10.
A consequence of this change is that all `TextShow1` instances now require
corresponding `TextShow` instances. This affects the `TextShow.Generic` module,
as we now have to define a `TextShow` instance for `FromGeneric1`. Similarly,
all `TextShow2` instances now require corresponding `TextShow` and `TextShow1`
instances.

Fixes #56.

Author: RyanGlScott

CHANGELOG.md

@@ -42,6 +42,21 @@
     -instance (Show2 f, Show a)     => TextShow1 (FromStringShow2 f a)
     +instance (Show2 f, TextShow a) => TextShow1 (FromStringShow2 f a)
     ```
+* The `TextShow{1,2}` classes now have quantified superclasses:
+
+  ```hs
+  class (forall a. TextShow a => TextShow  (f a)) => TextShow1 f where ...
+  class (forall a. TextShow a => TextShow1 (f a)) => TextShow2 f where ...
+  ```
+
+  This mirrors corresponding changes made to `Show1` and `Show2` in the `base`
+  library. See https://github.com/haskell/core-libraries-committee/issues/10.
+
+  Because of this change, any code that defines a `TextShow1` instance for a
+  data type without a corresponding `TextShow` instance will no longer compile,
+  so you may need to define more `TextShow` instances to adapt to this change.
+  Similarly, `TextShow2` instances will now also require corresponding
+  `TextShow` and `TextShow1` instances.
 * The `GTextShow*` classes in `TextShow.Generic`, which power generic
   derivation of `TextShow` and `TextShow1` instances, have been split up to
   facilitate the addition of a quantified superclass to `TextShow1`. Moreover,

src/TextShow/Classes.hs

@@ -2,6 +2,11 @@
 {-# LANGUAGE DeriveDataTypeable         #-}
 {-# LANGUAGE OverloadedStrings          #-}
 {-# LANGUAGE StandaloneDeriving         #-}
+
+#if __GLASGOW_HASKELL__ >= 806
+{-# LANGUAGE QuantifiedConstraints      #-}
+#endif
+
 {-|
 Module:      TextShow.Classes
 Copyright:   (C) 2014-2017 Ryan Scott
@@ -392,7 +397,11 @@ showbToShowtl sf = toLazyText . sf
 -- | Lifting of the 'TextShow' class to unary type constructors.
 --
 -- /Since: 2/
-class TextShow1 f where
+class
+#if __GLASGOW_HASKELL__ >= 806
+      (forall a. TextShow a => TextShow (f a)) =>
+#endif
+      TextShow1 f where
     -- | 'showbPrec' function for an application of the type constructor
     -- based on 'showbPrec' and 'showbList' functions for the argument type.
     --
@@ -457,7 +466,21 @@ liftShowtlPrec sp sl = showbPrecToShowtlPrec $ liftShowbPrec (showtlPrecToShowbP
 -- | Lifting of the 'TextShow' class to binary type constructors.
 --
 -- /Since: 2/
-class TextShow2 f where
+class
+#if __GLASGOW_HASKELL__ >= 806
+      ( forall a. TextShow a => TextShow1 (f a)
+# if __GLASGOW_HASKELL__ < 900
+      -- Sadly, pre-9.0 versions of GHC have difficulty inferring this
+      -- superclass from the one above due to
+      -- https://gitlab.haskell.org/ghc/ghc/-/issues/17202.
+      -- As a workaround, we manually expand the superclass above to assist
+      -- type inference. Without doing this, the text-show test suite would
+      -- not compile on pre-9.0 versions of GHC.
+      , forall a b. (TextShow a, TextShow b) => TextShow (f a b)
+# endif
+      ) =>
+#endif
+      TextShow2 f where
     -- | 'showbPrec' function for an application of the type constructor
     -- based on 'showbPrec' and 'showbList' functions for the argument types.
     --

src/TextShow/Generic.hs

@@ -24,7 +24,11 @@
 {-# LANGUAGE UndecidableInstances  #-}
 
 #if __GLASGOW_HASKELL__ >= 800
-{-# LANGUAGE DeriveLift           #-}
+{-# LANGUAGE DeriveLift            #-}
+#endif
+
+#if __GLASGOW_HASKELL__ >= 806
+{-# LANGUAGE QuantifiedConstraints #-}
 #endif
 
 {-|
@@ -209,8 +213,21 @@ deriving instance Typeable FromGeneric1
 deriving instance ( Data (f a), Typeable f, Typeable a
                   ) => Data (FromGeneric1 f (a :: *))
 
+-- | /Since: 3.10/
+instance (Generic1 f, GTextShowB (Rep1 f a)) => TextShow (FromGeneric1 f a) where
+  showbPrec p = gShowbPrec p . from1 . fromGeneric1
+
 -- | /Since: 3.7.4/
-instance (Generic1 f, GTextShowB1 (Rep1 f)) => TextShow1 (FromGeneric1 f) where
+instance ( Generic1 f, GTextShowB1 (Rep1 f)
+#if __GLASGOW_HASKELL__ >= 806 && __GLASGOW_HASKELL__ < 902
+           -- Unfortunately, the quantified superclass for GTextShowB1 doesn't
+           -- work on pre-9.2 versions of GHC, perhaps due to
+           -- https://gitlab.haskell.org/ghc/ghc/-/issues/14860#note_454218.
+           -- Fortunately, we can make GHC come to its senses by using an
+           -- equality constraint.
+         , g ~ Rep1 f, forall a. TextShow a => GTextShowB (g a)
+#endif
+         ) => TextShow1 (FromGeneric1 f) where
   liftShowbPrec sp sl p = genericLiftShowbPrec sp sl p . fromGeneric1
 
 -- | A 'Generic' implementation of 'showt'.
@@ -367,6 +384,12 @@ one_hash  = mempty;              \
 two_hash  = mempty;
 #endif
 
+#if __GLASGOW_HASKELL__ >= 806
+#define QUANTIFIED_SUPERCLASS(class_name,f) (forall a. TextShow a => class_name (f a)) =>
+#else
+#define QUANTIFIED_SUPERCLASS(class_name,f)
+#endif
+
 #define GTEXT_SHOW(text_type,show_funs,one_hash,two_hash,gtext_show,gtext_show1,gshow_prec,glift_show_prec,gtext_show_con,gtext_show_con1,gshow_prec_con,glift_show_prec_con,show_prec,lift_show_prec,show_space,show_paren,show_list,show_list_with,from_char,from_string,c1_show_prec,s1_show_prec,product_show_prec,u_char_show_prec,u_double_show_prec,u_float_show_prec,u_int_show_prec,u_word_show_prec) \
 {- | Class of generic representation types that can be converted to a                   \
 'text_type'.                                                                            \
@@ -463,7 +486,8 @@ be converted to a 'text_type'.
                                                                                         \
 /Since: 3.10/                                                                           \
 -};                                                                                     \
-class gtext_show1 f where {                                                             \
+class QUANTIFIED_SUPERCLASS(gtext_show,f)                                               \
+      gtext_show1 f where {                                                             \
   ; glift_show_prec :: (Int -> a -> text_type) -> ([a] -> text_type)                    \
                     -> Int -> f a -> text_type                                          \
 };                                                                                      \
@@ -492,7 +516,8 @@ the 'ConType' has been determined.
                                                                                         \
 /Since: 3.10/                                                                           \
 -};                                                                                     \
-class gtext_show_con1 f where {                                                         \
+class QUANTIFIED_SUPERCLASS(gtext_show_con,f)                                           \
+      gtext_show_con1 f where {                                                         \
   ; glift_show_prec_con :: (Int -> a -> text_type) -> ([a] -> text_type)                \
                         -> ConType -> Int -> f a -> text_type                           \
 };                                                                                      \