    {-# LANGUAGE DeriveDataTypeable         #-}
    {-# LANGUAGE DeriveFoldable             #-}
    {-# LANGUAGE DeriveFunctor              #-}
    {-# LANGUAGE DeriveGeneric              #-}
    {-# LANGUAGE DeriveLift                 #-}
    {-# LANGUAGE DeriveTraversable          #-}
    {-# LANGUAGE FlexibleContexts           #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE KindSignatures             #-}
    {-# LANGUAGE PolyKinds                  #-}
    {-# LANGUAGE ScopedTypeVariables        #-}
    {-# LANGUAGE StandaloneDeriving         #-}
    {-# LANGUAGE TemplateHaskell            #-}

    {-# OPTIONS_GHC -Wno-name-shadowing #-}

    {-|
    Module:      TextShow.FromStringTextShow
    Copyright:   (C) 2014-2017 Ryan Scott
    License:     BSD-style (see the file LICENSE)
    Maintainer:  Ryan Scott
    Stability:   Provisional
    Portability: GHC

    The 'FromStringShow' and 'FromTextShow' data types.
    -}
    module TextShow.FromStringTextShow (
          FromStringShow(..)
        , FromTextShow(..)
        , FromStringShow1(..)
        , FromTextShow1(..)
        , FromStringShow2(..)
        , FromTextShow2(..)
        ) where

    import           Data.Bifunctor.TH (deriveBifunctor, deriveBifoldable,
                                        deriveBitraversable)
    import           Data.Coerce (coerce)
    import           Data.Data (Data)
    import           Data.Functor.Classes (Show1(..), Show2(..),
                                           showsPrec1, showsPrec2)

    import           GHC.Generics (Generic, Generic1)

    import           Language.Haskell.TH.Syntax (Lift)

    import           Prelude ()
    import           Prelude.Compat

    import           Text.ParserCombinators.ReadPrec (ReadPrec)
    import           Text.Read (Read(..))

    import           TextShow.Classes (TextShow(..), TextShow1(..), TextShow2(..),
                                       showbPrec1, showbPrec2,
                                       showbPrecToShowsPrec, showsPrecToShowbPrec,
                                       showbToShows, showsToShowb)

    -------------------------------------------------------------------------------

    -- | An adapter newtype, suitable for @DerivingVia@.
    -- The 'TextShow' instance for 'FromStringShow' is based on its @String@
    -- 'Show' instance. That is,
    --
    -- @
    -- showbPrec p ('FromStringShow' x) = 'showsToShowb' 'showsPrec' p x
    -- @
    --
    -- /Since: 2/
    newtype FromStringShow a = FromStringShow { forall a. FromStringShow a -> a
    fromStringShow :: a }
      deriving ( Typeable (FromStringShow a)
    Typeable (FromStringShow a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> FromStringShow a
     -> c (FromStringShow a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (FromStringShow a))
    -> (FromStringShow a -> Constr)
    -> (FromStringShow a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (FromStringShow a)))
    -> ((forall b. Data b => b -> b)
        -> FromStringShow a -> FromStringShow a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FromStringShow a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FromStringShow a -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> FromStringShow a -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FromStringShow a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> FromStringShow a -> m (FromStringShow a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromStringShow a -> m (FromStringShow a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromStringShow a -> m (FromStringShow a))
    -> Data (FromStringShow a)
    FromStringShow a -> Constr
    FromStringShow a -> DataType
    (forall b. Data b => b -> b)
    -> FromStringShow a -> FromStringShow a
    forall a. Data a => Typeable (FromStringShow a)
    forall a. Data a => FromStringShow a -> Constr
    forall a. Data a => FromStringShow a -> DataType
    forall a.
    Data a =>
    (forall b. Data b => b -> b)
    -> FromStringShow a -> FromStringShow a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> FromStringShow a -> u
    forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> FromStringShow a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow a -> m (FromStringShow a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow a -> m (FromStringShow a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FromStringShow a -> c (FromStringShow a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow a))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> FromStringShow a -> u
    forall u. (forall d. Data d => d -> u) -> FromStringShow a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow a -> m (FromStringShow a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow a -> m (FromStringShow a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FromStringShow a -> c (FromStringShow a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow a))
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FromStringShow a -> c (FromStringShow a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FromStringShow a -> c (FromStringShow a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow a)
    $ctoConstr :: forall a. Data a => FromStringShow a -> Constr
    toConstr :: FromStringShow a -> Constr
    $cdataTypeOf :: forall a. Data a => FromStringShow a -> DataType
    dataTypeOf :: FromStringShow a -> DataType
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow a))
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b)
    -> FromStringShow a -> FromStringShow a
    gmapT :: (forall b. Data b => b -> b)
    -> FromStringShow a -> FromStringShow a
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow a -> r
    $cgmapQ :: forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> FromStringShow a -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> FromStringShow a -> [u]
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> FromStringShow a -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> FromStringShow a -> u
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow a -> m (FromStringShow a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow a -> m (FromStringShow a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow a -> m (FromStringShow a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow a -> m (FromStringShow a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow a -> m (FromStringShow a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow a -> m (FromStringShow a)
    Data
               , FromStringShow a -> FromStringShow a -> Bool
    (FromStringShow a -> FromStringShow a -> Bool)
    -> (FromStringShow a -> FromStringShow a -> Bool)
    -> Eq (FromStringShow a)
    forall a. Eq a => FromStringShow a -> FromStringShow a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => FromStringShow a -> FromStringShow a -> Bool
    == :: FromStringShow a -> FromStringShow a -> Bool
    $c/= :: forall a. Eq a => FromStringShow a -> FromStringShow a -> Bool
    /= :: FromStringShow a -> FromStringShow a -> Bool
    Eq
               , (forall m. Monoid m => FromStringShow m -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromStringShow a -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromStringShow a -> m)
    -> (forall a b. (a -> b -> b) -> b -> FromStringShow a -> b)
    -> (forall a b. (a -> b -> b) -> b -> FromStringShow a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromStringShow a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromStringShow a -> b)
    -> (forall a. (a -> a -> a) -> FromStringShow a -> a)
    -> (forall a. (a -> a -> a) -> FromStringShow a -> a)
    -> (forall a. FromStringShow a -> [a])
    -> (forall a. FromStringShow a -> Bool)
    -> (forall a. FromStringShow a -> Int)
    -> (forall a. Eq a => a -> FromStringShow a -> Bool)
    -> (forall a. Ord a => FromStringShow a -> a)
    -> (forall a. Ord a => FromStringShow a -> a)
    -> (forall a. Num a => FromStringShow a -> a)
    -> (forall a. Num a => FromStringShow a -> a)
    -> Foldable FromStringShow
    forall a. Eq a => a -> FromStringShow a -> Bool
    forall a. Num a => FromStringShow a -> a
    forall a. Ord a => FromStringShow a -> a
    forall m. Monoid m => FromStringShow m -> m
    forall a. FromStringShow a -> Bool
    forall a. FromStringShow a -> Int
    forall a. FromStringShow a -> [a]
    forall a. (a -> a -> a) -> FromStringShow a -> a
    forall m a. Monoid m => (a -> m) -> FromStringShow a -> m
    forall b a. (b -> a -> b) -> b -> FromStringShow a -> b
    forall a b. (a -> b -> b) -> b -> FromStringShow a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => FromStringShow m -> m
    fold :: forall m. Monoid m => FromStringShow m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> FromStringShow a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> FromStringShow a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> FromStringShow a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> FromStringShow a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> FromStringShow a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> FromStringShow a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> FromStringShow a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> FromStringShow a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> FromStringShow a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> FromStringShow a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> FromStringShow a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> FromStringShow a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> FromStringShow a -> a
    foldr1 :: forall a. (a -> a -> a) -> FromStringShow a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> FromStringShow a -> a
    foldl1 :: forall a. (a -> a -> a) -> FromStringShow a -> a
    $ctoList :: forall a. FromStringShow a -> [a]
    toList :: forall a. FromStringShow a -> [a]
    $cnull :: forall a. FromStringShow a -> Bool
    null :: forall a. FromStringShow a -> Bool
    $clength :: forall a. FromStringShow a -> Int
    length :: forall a. FromStringShow a -> Int
    $celem :: forall a. Eq a => a -> FromStringShow a -> Bool
    elem :: forall a. Eq a => a -> FromStringShow a -> Bool
    $cmaximum :: forall a. Ord a => FromStringShow a -> a
    maximum :: forall a. Ord a => FromStringShow a -> a
    $cminimum :: forall a. Ord a => FromStringShow a -> a
    minimum :: forall a. Ord a => FromStringShow a -> a
    $csum :: forall a. Num a => FromStringShow a -> a
    sum :: forall a. Num a => FromStringShow a -> a
    $cproduct :: forall a. Num a => FromStringShow a -> a
    product :: forall a. Num a => FromStringShow a -> a
    Foldable
               , (forall a b. (a -> b) -> FromStringShow a -> FromStringShow b)
    -> (forall a b. a -> FromStringShow b -> FromStringShow a)
    -> Functor FromStringShow
    forall a b. a -> FromStringShow b -> FromStringShow a
    forall a b. (a -> b) -> FromStringShow a -> FromStringShow b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> FromStringShow a -> FromStringShow b
    fmap :: forall a b. (a -> b) -> FromStringShow a -> FromStringShow b
    $c<$ :: forall a b. a -> FromStringShow b -> FromStringShow a
    <$ :: forall a b. a -> FromStringShow b -> FromStringShow a
    Functor
               , (forall x. FromStringShow a -> Rep (FromStringShow a) x)
    -> (forall x. Rep (FromStringShow a) x -> FromStringShow a)
    -> Generic (FromStringShow a)
    forall x. Rep (FromStringShow a) x -> FromStringShow a
    forall x. FromStringShow a -> Rep (FromStringShow a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (FromStringShow a) x -> FromStringShow a
    forall a x. FromStringShow a -> Rep (FromStringShow a) x
    $cfrom :: forall a x. FromStringShow a -> Rep (FromStringShow a) x
    from :: forall x. FromStringShow a -> Rep (FromStringShow a) x
    $cto :: forall a x. Rep (FromStringShow a) x -> FromStringShow a
    to :: forall x. Rep (FromStringShow a) x -> FromStringShow a
    Generic
               , (forall a. FromStringShow a -> Rep1 FromStringShow a)
    -> (forall a. Rep1 FromStringShow a -> FromStringShow a)
    -> Generic1 FromStringShow
    forall a. Rep1 FromStringShow a -> FromStringShow a
    forall a. FromStringShow a -> Rep1 FromStringShow a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall a. FromStringShow a -> Rep1 FromStringShow a
    from1 :: forall a. FromStringShow a -> Rep1 FromStringShow a
    $cto1 :: forall a. Rep1 FromStringShow a -> FromStringShow a
    to1 :: forall a. Rep1 FromStringShow a -> FromStringShow a
    Generic1
               , (forall (m :: * -> *). Quote m => FromStringShow a -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        FromStringShow a -> Code m (FromStringShow a))
    -> Lift (FromStringShow a)
    forall a (m :: * -> *).
    (Lift a, Quote m) =>
    FromStringShow a -> m Exp
    forall a (m :: * -> *).
    (Lift a, Quote m) =>
    FromStringShow a -> Code m (FromStringShow a)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => FromStringShow a -> m Exp
    forall (m :: * -> *).
    Quote m =>
    FromStringShow a -> Code m (FromStringShow a)
    $clift :: forall a (m :: * -> *).
    (Lift a, Quote m) =>
    FromStringShow a -> m Exp
    lift :: forall (m :: * -> *). Quote m => FromStringShow a -> m Exp
    $cliftTyped :: forall a (m :: * -> *).
    (Lift a, Quote m) =>
    FromStringShow a -> Code m (FromStringShow a)
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    FromStringShow a -> Code m (FromStringShow a)
    Lift
               , Eq (FromStringShow a)
    Eq (FromStringShow a) =>
    (FromStringShow a -> FromStringShow a -> Ordering)
    -> (FromStringShow a -> FromStringShow a -> Bool)
    -> (FromStringShow a -> FromStringShow a -> Bool)
    -> (FromStringShow a -> FromStringShow a -> Bool)
    -> (FromStringShow a -> FromStringShow a -> Bool)
    -> (FromStringShow a -> FromStringShow a -> FromStringShow a)
    -> (FromStringShow a -> FromStringShow a -> FromStringShow a)
    -> Ord (FromStringShow a)
    FromStringShow a -> FromStringShow a -> Bool
    FromStringShow a -> FromStringShow a -> Ordering
    FromStringShow a -> FromStringShow a -> FromStringShow a
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall a. Ord a => Eq (FromStringShow a)
    forall a. Ord a => FromStringShow a -> FromStringShow a -> Bool
    forall a. Ord a => FromStringShow a -> FromStringShow a -> Ordering
    forall a.
    Ord a =>
    FromStringShow a -> FromStringShow a -> FromStringShow a
    $ccompare :: forall a. Ord a => FromStringShow a -> FromStringShow a -> Ordering
    compare :: FromStringShow a -> FromStringShow a -> Ordering
    $c< :: forall a. Ord a => FromStringShow a -> FromStringShow a -> Bool
    < :: FromStringShow a -> FromStringShow a -> Bool
    $c<= :: forall a. Ord a => FromStringShow a -> FromStringShow a -> Bool
    <= :: FromStringShow a -> FromStringShow a -> Bool
    $c> :: forall a. Ord a => FromStringShow a -> FromStringShow a -> Bool
    > :: FromStringShow a -> FromStringShow a -> Bool
    $c>= :: forall a. Ord a => FromStringShow a -> FromStringShow a -> Bool
    >= :: FromStringShow a -> FromStringShow a -> Bool
    $cmax :: forall a.
    Ord a =>
    FromStringShow a -> FromStringShow a -> FromStringShow a
    max :: FromStringShow a -> FromStringShow a -> FromStringShow a
    $cmin :: forall a.
    Ord a =>
    FromStringShow a -> FromStringShow a -> FromStringShow a
    min :: FromStringShow a -> FromStringShow a -> FromStringShow a
    Ord
               , Functor FromStringShow
    Foldable FromStringShow
    (Functor FromStringShow, Foldable FromStringShow) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> FromStringShow a -> f (FromStringShow b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        FromStringShow (f a) -> f (FromStringShow a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> FromStringShow a -> m (FromStringShow b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        FromStringShow (m a) -> m (FromStringShow a))
    -> Traversable FromStringShow
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    FromStringShow (m a) -> m (FromStringShow a)
    forall (f :: * -> *) a.
    Applicative f =>
    FromStringShow (f a) -> f (FromStringShow a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromStringShow a -> m (FromStringShow b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromStringShow a -> f (FromStringShow b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromStringShow a -> f (FromStringShow b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromStringShow a -> f (FromStringShow b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FromStringShow (f a) -> f (FromStringShow a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FromStringShow (f a) -> f (FromStringShow a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromStringShow a -> m (FromStringShow b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromStringShow a -> m (FromStringShow b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    FromStringShow (m a) -> m (FromStringShow a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    FromStringShow (m a) -> m (FromStringShow a)
    Traversable
               )

    instance Read a => Read (FromStringShow a) where
        readPrec :: ReadPrec (FromStringShow a)
    readPrec     = ReadPrec a -> ReadPrec (FromStringShow a)
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec a
    forall a. Read a => ReadPrec a
    readPrec     :: ReadPrec a)
        readsPrec :: Int -> ReadS (FromStringShow a)
    readsPrec    = (Int -> ReadS a) -> Int -> ReadS (FromStringShow a)
    forall a b. Coercible a b => a -> b
    coerce (Int -> ReadS a
    forall a. Read a => Int -> ReadS a
    readsPrec    :: Int -> ReadS a)
        readList :: ReadS [FromStringShow a]
    readList     = ReadS [a] -> ReadS [FromStringShow a]
    forall a b. Coercible a b => a -> b
    coerce (ReadS [a]
    forall a. Read a => ReadS [a]
    readList     :: ReadS [a])
        readListPrec :: ReadPrec [FromStringShow a]
    readListPrec = ReadPrec [a] -> ReadPrec [FromStringShow a]
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec [a]
    forall a. Read a => ReadPrec [a]
    readListPrec :: ReadPrec [a])

    instance Show a => TextShow (FromStringShow a) where
        showbPrec :: Int -> FromStringShow a -> Builder
    showbPrec Int
    p = (Int -> a -> ShowS) -> Int -> a -> Builder
    forall a. (Int -> a -> ShowS) -> Int -> a -> Builder
    showsPrecToShowbPrec Int -> a -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec Int
    p (a -> Builder)
    -> (FromStringShow a -> a) -> FromStringShow a -> Builder
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FromStringShow a -> a
    forall a. FromStringShow a -> a
    fromStringShow
        showb :: FromStringShow a -> Builder
    showb = (a -> ShowS) -> a -> Builder
    forall a. (a -> ShowS) -> a -> Builder
    showsToShowb a -> ShowS
    forall a. Show a => a -> ShowS
    shows (a -> Builder)
    -> (FromStringShow a -> a) -> FromStringShow a -> Builder
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FromStringShow a -> a
    forall a. FromStringShow a -> a
    fromStringShow
        showbList :: [FromStringShow a] -> Builder
    showbList [FromStringShow a]
    l = ([a] -> ShowS) -> [a] -> Builder
    forall a. (a -> ShowS) -> a -> Builder
    showsToShowb [a] -> ShowS
    forall a. Show a => [a] -> ShowS
    showList ([FromStringShow a] -> [a]
    forall a b. Coercible a b => a -> b
    coerce [FromStringShow a]
    l :: [a])

    instance Show a => Show (FromStringShow a) where
        showsPrec :: Int -> FromStringShow a -> ShowS
    showsPrec = (Int -> a -> ShowS) -> Int -> FromStringShow a -> ShowS
    forall a b. Coercible a b => a -> b
    coerce (Int -> a -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec :: Int -> a -> ShowS)
        show :: FromStringShow a -> String
    show      = (a -> String) -> FromStringShow a -> String
    forall a b. Coercible a b => a -> b
    coerce (a -> String
    forall a. Show a => a -> String
    show      :: a -> String)
        showList :: [FromStringShow a] -> ShowS
    showList  = ([a] -> ShowS) -> [FromStringShow a] -> ShowS
    forall a b. Coercible a b => a -> b
    coerce ([a] -> ShowS
    forall a. Show a => [a] -> ShowS
    showList  :: [a] -> ShowS)

    -------------------------------------------------------------------------------

    -- | An adapter newtype, suitable for @DerivingVia@.
    -- The @String@ 'Show' instance for 'FromTextShow' is based on its
    -- 'TextShow' instance. That is,
    --
    -- @
    -- showsPrec p ('FromTextShow' x) = 'showbToShows' 'showbPrec' p x
    -- @
    --
    -- /Since: 2/
    newtype FromTextShow a = FromTextShow { forall a. FromTextShow a -> a
    fromTextShow :: a }
      deriving ( Typeable (FromTextShow a)
    Typeable (FromTextShow a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> FromTextShow a -> c (FromTextShow a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (FromTextShow a))
    -> (FromTextShow a -> Constr)
    -> (FromTextShow a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (FromTextShow a)))
    -> ((forall b. Data b => b -> b)
        -> FromTextShow a -> FromTextShow a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FromTextShow a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FromTextShow a -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> FromTextShow a -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FromTextShow a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> FromTextShow a -> m (FromTextShow a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromTextShow a -> m (FromTextShow a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromTextShow a -> m (FromTextShow a))
    -> Data (FromTextShow a)
    FromTextShow a -> Constr
    FromTextShow a -> DataType
    (forall b. Data b => b -> b) -> FromTextShow a -> FromTextShow a
    forall a. Data a => Typeable (FromTextShow a)
    forall a. Data a => FromTextShow a -> Constr
    forall a. Data a => FromTextShow a -> DataType
    forall a.
    Data a =>
    (forall b. Data b => b -> b) -> FromTextShow a -> FromTextShow a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> FromTextShow a -> u
    forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> FromTextShow a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow a -> m (FromTextShow a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow a -> m (FromTextShow a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FromTextShow a -> c (FromTextShow a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow a))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> FromTextShow a -> u
    forall u. (forall d. Data d => d -> u) -> FromTextShow a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow a -> m (FromTextShow a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow a -> m (FromTextShow a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FromTextShow a -> c (FromTextShow a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow a))
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FromTextShow a -> c (FromTextShow a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FromTextShow a -> c (FromTextShow a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow a)
    $ctoConstr :: forall a. Data a => FromTextShow a -> Constr
    toConstr :: FromTextShow a -> Constr
    $cdataTypeOf :: forall a. Data a => FromTextShow a -> DataType
    dataTypeOf :: FromTextShow a -> DataType
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow a))
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b) -> FromTextShow a -> FromTextShow a
    gmapT :: (forall b. Data b => b -> b) -> FromTextShow a -> FromTextShow a
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow a -> r
    $cgmapQ :: forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> FromTextShow a -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> FromTextShow a -> [u]
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> FromTextShow a -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> FromTextShow a -> u
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow a -> m (FromTextShow a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow a -> m (FromTextShow a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow a -> m (FromTextShow a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow a -> m (FromTextShow a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow a -> m (FromTextShow a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow a -> m (FromTextShow a)
    Data
               , FromTextShow a -> FromTextShow a -> Bool
    (FromTextShow a -> FromTextShow a -> Bool)
    -> (FromTextShow a -> FromTextShow a -> Bool)
    -> Eq (FromTextShow a)
    forall a. Eq a => FromTextShow a -> FromTextShow a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => FromTextShow a -> FromTextShow a -> Bool
    == :: FromTextShow a -> FromTextShow a -> Bool
    $c/= :: forall a. Eq a => FromTextShow a -> FromTextShow a -> Bool
    /= :: FromTextShow a -> FromTextShow a -> Bool
    Eq
               , (forall m. Monoid m => FromTextShow m -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromTextShow a -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromTextShow a -> m)
    -> (forall a b. (a -> b -> b) -> b -> FromTextShow a -> b)
    -> (forall a b. (a -> b -> b) -> b -> FromTextShow a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromTextShow a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromTextShow a -> b)
    -> (forall a. (a -> a -> a) -> FromTextShow a -> a)
    -> (forall a. (a -> a -> a) -> FromTextShow a -> a)
    -> (forall a. FromTextShow a -> [a])
    -> (forall a. FromTextShow a -> Bool)
    -> (forall a. FromTextShow a -> Int)
    -> (forall a. Eq a => a -> FromTextShow a -> Bool)
    -> (forall a. Ord a => FromTextShow a -> a)
    -> (forall a. Ord a => FromTextShow a -> a)
    -> (forall a. Num a => FromTextShow a -> a)
    -> (forall a. Num a => FromTextShow a -> a)
    -> Foldable FromTextShow
    forall a. Eq a => a -> FromTextShow a -> Bool
    forall a. Num a => FromTextShow a -> a
    forall a. Ord a => FromTextShow a -> a
    forall m. Monoid m => FromTextShow m -> m
    forall a. FromTextShow a -> Bool
    forall a. FromTextShow a -> Int
    forall a. FromTextShow a -> [a]
    forall a. (a -> a -> a) -> FromTextShow a -> a
    forall m a. Monoid m => (a -> m) -> FromTextShow a -> m
    forall b a. (b -> a -> b) -> b -> FromTextShow a -> b
    forall a b. (a -> b -> b) -> b -> FromTextShow a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => FromTextShow m -> m
    fold :: forall m. Monoid m => FromTextShow m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> FromTextShow a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> FromTextShow a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> FromTextShow a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> FromTextShow a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> FromTextShow a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> FromTextShow a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> FromTextShow a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> FromTextShow a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> FromTextShow a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> FromTextShow a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> FromTextShow a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> FromTextShow a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> FromTextShow a -> a
    foldr1 :: forall a. (a -> a -> a) -> FromTextShow a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> FromTextShow a -> a
    foldl1 :: forall a. (a -> a -> a) -> FromTextShow a -> a
    $ctoList :: forall a. FromTextShow a -> [a]
    toList :: forall a. FromTextShow a -> [a]
    $cnull :: forall a. FromTextShow a -> Bool
    null :: forall a. FromTextShow a -> Bool
    $clength :: forall a. FromTextShow a -> Int
    length :: forall a. FromTextShow a -> Int
    $celem :: forall a. Eq a => a -> FromTextShow a -> Bool
    elem :: forall a. Eq a => a -> FromTextShow a -> Bool
    $cmaximum :: forall a. Ord a => FromTextShow a -> a
    maximum :: forall a. Ord a => FromTextShow a -> a
    $cminimum :: forall a. Ord a => FromTextShow a -> a
    minimum :: forall a. Ord a => FromTextShow a -> a
    $csum :: forall a. Num a => FromTextShow a -> a
    sum :: forall a. Num a => FromTextShow a -> a
    $cproduct :: forall a. Num a => FromTextShow a -> a
    product :: forall a. Num a => FromTextShow a -> a
    Foldable
               , (forall a b. (a -> b) -> FromTextShow a -> FromTextShow b)
    -> (forall a b. a -> FromTextShow b -> FromTextShow a)
    -> Functor FromTextShow
    forall a b. a -> FromTextShow b -> FromTextShow a
    forall a b. (a -> b) -> FromTextShow a -> FromTextShow b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> FromTextShow a -> FromTextShow b
    fmap :: forall a b. (a -> b) -> FromTextShow a -> FromTextShow b
    $c<$ :: forall a b. a -> FromTextShow b -> FromTextShow a
    <$ :: forall a b. a -> FromTextShow b -> FromTextShow a
    Functor
               , (forall x. FromTextShow a -> Rep (FromTextShow a) x)
    -> (forall x. Rep (FromTextShow a) x -> FromTextShow a)
    -> Generic (FromTextShow a)
    forall x. Rep (FromTextShow a) x -> FromTextShow a
    forall x. FromTextShow a -> Rep (FromTextShow a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (FromTextShow a) x -> FromTextShow a
    forall a x. FromTextShow a -> Rep (FromTextShow a) x
    $cfrom :: forall a x. FromTextShow a -> Rep (FromTextShow a) x
    from :: forall x. FromTextShow a -> Rep (FromTextShow a) x
    $cto :: forall a x. Rep (FromTextShow a) x -> FromTextShow a
    to :: forall x. Rep (FromTextShow a) x -> FromTextShow a
    Generic
               , (forall a. FromTextShow a -> Rep1 FromTextShow a)
    -> (forall a. Rep1 FromTextShow a -> FromTextShow a)
    -> Generic1 FromTextShow
    forall a. Rep1 FromTextShow a -> FromTextShow a
    forall a. FromTextShow a -> Rep1 FromTextShow a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall a. FromTextShow a -> Rep1 FromTextShow a
    from1 :: forall a. FromTextShow a -> Rep1 FromTextShow a
    $cto1 :: forall a. Rep1 FromTextShow a -> FromTextShow a
    to1 :: forall a. Rep1 FromTextShow a -> FromTextShow a
    Generic1
               , (forall (m :: * -> *). Quote m => FromTextShow a -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        FromTextShow a -> Code m (FromTextShow a))
    -> Lift (FromTextShow a)
    forall a (m :: * -> *).
    (Lift a, Quote m) =>
    FromTextShow a -> m Exp
    forall a (m :: * -> *).
    (Lift a, Quote m) =>
    FromTextShow a -> Code m (FromTextShow a)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => FromTextShow a -> m Exp
    forall (m :: * -> *).
    Quote m =>
    FromTextShow a -> Code m (FromTextShow a)
    $clift :: forall a (m :: * -> *).
    (Lift a, Quote m) =>
    FromTextShow a -> m Exp
    lift :: forall (m :: * -> *). Quote m => FromTextShow a -> m Exp
    $cliftTyped :: forall a (m :: * -> *).
    (Lift a, Quote m) =>
    FromTextShow a -> Code m (FromTextShow a)
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    FromTextShow a -> Code m (FromTextShow a)
    Lift
               , Eq (FromTextShow a)
    Eq (FromTextShow a) =>
    (FromTextShow a -> FromTextShow a -> Ordering)
    -> (FromTextShow a -> FromTextShow a -> Bool)
    -> (FromTextShow a -> FromTextShow a -> Bool)
    -> (FromTextShow a -> FromTextShow a -> Bool)
    -> (FromTextShow a -> FromTextShow a -> Bool)
    -> (FromTextShow a -> FromTextShow a -> FromTextShow a)
    -> (FromTextShow a -> FromTextShow a -> FromTextShow a)
    -> Ord (FromTextShow a)
    FromTextShow a -> FromTextShow a -> Bool
    FromTextShow a -> FromTextShow a -> Ordering
    FromTextShow a -> FromTextShow a -> FromTextShow a
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall a. Ord a => Eq (FromTextShow a)
    forall a. Ord a => FromTextShow a -> FromTextShow a -> Bool
    forall a. Ord a => FromTextShow a -> FromTextShow a -> Ordering
    forall a.
    Ord a =>
    FromTextShow a -> FromTextShow a -> FromTextShow a
    $ccompare :: forall a. Ord a => FromTextShow a -> FromTextShow a -> Ordering
    compare :: FromTextShow a -> FromTextShow a -> Ordering
    $c< :: forall a. Ord a => FromTextShow a -> FromTextShow a -> Bool
    < :: FromTextShow a -> FromTextShow a -> Bool
    $c<= :: forall a. Ord a => FromTextShow a -> FromTextShow a -> Bool
    <= :: FromTextShow a -> FromTextShow a -> Bool
    $c> :: forall a. Ord a => FromTextShow a -> FromTextShow a -> Bool
    > :: FromTextShow a -> FromTextShow a -> Bool
    $c>= :: forall a. Ord a => FromTextShow a -> FromTextShow a -> Bool
    >= :: FromTextShow a -> FromTextShow a -> Bool
    $cmax :: forall a.
    Ord a =>
    FromTextShow a -> FromTextShow a -> FromTextShow a
    max :: FromTextShow a -> FromTextShow a -> FromTextShow a
    $cmin :: forall a.
    Ord a =>
    FromTextShow a -> FromTextShow a -> FromTextShow a
    min :: FromTextShow a -> FromTextShow a -> FromTextShow a
    Ord
               , Int -> FromTextShow a -> Text
    Int -> FromTextShow a -> Text
    Int -> FromTextShow a -> Builder
    [FromTextShow a] -> Text
    [FromTextShow a] -> Text
    [FromTextShow a] -> Builder
    FromTextShow a -> Text
    FromTextShow a -> Text
    FromTextShow a -> Builder
    (Int -> FromTextShow a -> Builder)
    -> (FromTextShow a -> Builder)
    -> ([FromTextShow a] -> Builder)
    -> (Int -> FromTextShow a -> Text)
    -> (FromTextShow a -> Text)
    -> ([FromTextShow a] -> Text)
    -> (Int -> FromTextShow a -> Text)
    -> (FromTextShow a -> Text)
    -> ([FromTextShow a] -> Text)
    -> TextShow (FromTextShow a)
    forall a. TextShow a => Int -> FromTextShow a -> Text
    forall a. TextShow a => Int -> FromTextShow a -> Text
    forall a. TextShow a => Int -> FromTextShow a -> Builder
    forall a. TextShow a => [FromTextShow a] -> Text
    forall a. TextShow a => [FromTextShow a] -> Text
    forall a. TextShow a => [FromTextShow a] -> Builder
    forall a. TextShow a => FromTextShow a -> Text
    forall a. TextShow a => FromTextShow a -> Text
    forall a. TextShow a => FromTextShow a -> Builder
    forall a.
    (Int -> a -> Builder)
    -> (a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> a -> Text)
    -> (a -> Text)
    -> ([a] -> Text)
    -> (Int -> a -> Text)
    -> (a -> Text)
    -> ([a] -> Text)
    -> TextShow a
    $cshowbPrec :: forall a. TextShow a => Int -> FromTextShow a -> Builder
    showbPrec :: Int -> FromTextShow a -> Builder
    $cshowb :: forall a. TextShow a => FromTextShow a -> Builder
    showb :: FromTextShow a -> Builder
    $cshowbList :: forall a. TextShow a => [FromTextShow a] -> Builder
    showbList :: [FromTextShow a] -> Builder
    $cshowtPrec :: forall a. TextShow a => Int -> FromTextShow a -> Text
    showtPrec :: Int -> FromTextShow a -> Text
    $cshowt :: forall a. TextShow a => FromTextShow a -> Text
    showt :: FromTextShow a -> Text
    $cshowtList :: forall a. TextShow a => [FromTextShow a] -> Text
    showtList :: [FromTextShow a] -> Text
    $cshowtlPrec :: forall a. TextShow a => Int -> FromTextShow a -> Text
    showtlPrec :: Int -> FromTextShow a -> Text
    $cshowtl :: forall a. TextShow a => FromTextShow a -> Text
    showtl :: FromTextShow a -> Text
    $cshowtlList :: forall a. TextShow a => [FromTextShow a] -> Text
    showtlList :: [FromTextShow a] -> Text
    TextShow
               , Functor FromTextShow
    Foldable FromTextShow
    (Functor FromTextShow, Foldable FromTextShow) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> FromTextShow a -> f (FromTextShow b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        FromTextShow (f a) -> f (FromTextShow a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> FromTextShow a -> m (FromTextShow b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        FromTextShow (m a) -> m (FromTextShow a))
    -> Traversable FromTextShow
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    FromTextShow (m a) -> m (FromTextShow a)
    forall (f :: * -> *) a.
    Applicative f =>
    FromTextShow (f a) -> f (FromTextShow a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromTextShow a -> m (FromTextShow b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromTextShow a -> f (FromTextShow b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromTextShow a -> f (FromTextShow b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromTextShow a -> f (FromTextShow b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FromTextShow (f a) -> f (FromTextShow a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FromTextShow (f a) -> f (FromTextShow a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromTextShow a -> m (FromTextShow b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromTextShow a -> m (FromTextShow b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    FromTextShow (m a) -> m (FromTextShow a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    FromTextShow (m a) -> m (FromTextShow a)
    Traversable
               )

    instance Read a => Read (FromTextShow a) where
        readPrec :: ReadPrec (FromTextShow a)
    readPrec     = ReadPrec a -> ReadPrec (FromTextShow a)
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec a
    forall a. Read a => ReadPrec a
    readPrec     :: ReadPrec a)
        readsPrec :: Int -> ReadS (FromTextShow a)
    readsPrec    = (Int -> ReadS a) -> Int -> ReadS (FromTextShow a)
    forall a b. Coercible a b => a -> b
    coerce (Int -> ReadS a
    forall a. Read a => Int -> ReadS a
    readsPrec    :: Int -> ReadS a)
        readList :: ReadS [FromTextShow a]
    readList     = ReadS [a] -> ReadS [FromTextShow a]
    forall a b. Coercible a b => a -> b
    coerce (ReadS [a]
    forall a. Read a => ReadS [a]
    readList     :: ReadS [a])
        readListPrec :: ReadPrec [FromTextShow a]
    readListPrec = ReadPrec [a] -> ReadPrec [FromTextShow a]
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec [a]
    forall a. Read a => ReadPrec [a]
    readListPrec :: ReadPrec [a])

    instance TextShow a => Show (FromTextShow a) where
        showsPrec :: Int -> FromTextShow a -> ShowS
    showsPrec Int
    p = (Int -> a -> Builder) -> Int -> a -> ShowS
    forall a. (Int -> a -> Builder) -> Int -> a -> ShowS
    showbPrecToShowsPrec Int -> a -> Builder
    forall a. TextShow a => Int -> a -> Builder
    showbPrec Int
    p (a -> ShowS) -> (FromTextShow a -> a) -> FromTextShow a -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FromTextShow a -> a
    forall a. FromTextShow a -> a
    fromTextShow
        show :: FromTextShow a -> String
    show (FromTextShow a
    x) = (a -> Builder) -> a -> ShowS
    forall a. (a -> Builder) -> a -> ShowS
    showbToShows a -> Builder
    forall a. TextShow a => a -> Builder
    showb a
    x String
    ""
        showList :: [FromTextShow a] -> ShowS
    showList [FromTextShow a]
    l = ([a] -> Builder) -> [a] -> ShowS
    forall a. (a -> Builder) -> a -> ShowS
    showbToShows [a] -> Builder
    forall a. TextShow a => [a] -> Builder
    showbList ([FromTextShow a] -> [a]
    forall a b. Coercible a b => a -> b
    coerce [FromTextShow a]
    l :: [a])

    -------------------------------------------------------------------------------

    -- | An adapter newtype, suitable for @DerivingVia@.
    -- The 'TextShow1' instance for 'FromStringShow1' is based on its @String@
    -- 'Show1' instance. That is,
    --
    -- @
    -- 'liftShowbPrec' sp sl p ('FromStringShow1' x) =
    --     'showsPrecToShowbPrec' ('liftShowsPrec' ('showbPrecToShowsPrec' sp)
    --                                             ('showbToShows'         sl))
    --                            p x
    -- @
    --
    -- /Since: 3/
    newtype FromStringShow1 f a = FromStringShow1 { forall {k} (f :: k -> *) (a :: k). FromStringShow1 f a -> f a
    fromStringShow1 :: f a }
      deriving ( FromStringShow1 f a -> FromStringShow1 f a -> Bool
    (FromStringShow1 f a -> FromStringShow1 f a -> Bool)
    -> (FromStringShow1 f a -> FromStringShow1 f a -> Bool)
    -> Eq (FromStringShow1 f a)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (f :: k -> *) (a :: k).
    Eq (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> Bool
    $c== :: forall k (f :: k -> *) (a :: k).
    Eq (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> Bool
    == :: FromStringShow1 f a -> FromStringShow1 f a -> Bool
    $c/= :: forall k (f :: k -> *) (a :: k).
    Eq (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> Bool
    /= :: FromStringShow1 f a -> FromStringShow1 f a -> Bool
    Eq
               , Typeable (FromStringShow1 f a)
    Typeable (FromStringShow1 f a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> FromStringShow1 f a
     -> c (FromStringShow1 f a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (FromStringShow1 f a))
    -> (FromStringShow1 f a -> Constr)
    -> (FromStringShow1 f a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow1 f a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (FromStringShow1 f a)))
    -> ((forall b. Data b => b -> b)
        -> FromStringShow1 f a -> FromStringShow1 f a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FromStringShow1 f a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FromStringShow1 f a -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> FromStringShow1 f a -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FromStringShow1 f a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> FromStringShow1 f a -> m (FromStringShow1 f a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromStringShow1 f a -> m (FromStringShow1 f a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromStringShow1 f a -> m (FromStringShow1 f a))
    -> Data (FromStringShow1 f a)
    FromStringShow1 f a -> Constr
    FromStringShow1 f a -> DataType
    (forall b. Data b => b -> b)
    -> FromStringShow1 f a -> FromStringShow1 f a
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> FromStringShow1 f a -> u
    forall u.
    (forall d. Data d => d -> u) -> FromStringShow1 f a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow1 f a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow1 f a -> r
    forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    Typeable (FromStringShow1 f a)
    forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    FromStringShow1 f a -> Constr
    forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    FromStringShow1 f a -> DataType
    forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall b. Data b => b -> b)
    -> FromStringShow1 f a -> FromStringShow1 f a
    forall k (f :: k -> *) (a :: k) u.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    Int -> (forall d. Data d => d -> u) -> FromStringShow1 f a -> u
    forall k (f :: k -> *) (a :: k) u.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall d. Data d => d -> u) -> FromStringShow1 f a -> [u]
    forall k (f :: k -> *) (a :: k) r r'.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow1 f a -> r
    forall k (f :: k -> *) (a :: k) r r'.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow1 f a -> r
    forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow1 f a -> m (FromStringShow1 f a)
    forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow1 f a -> m (FromStringShow1 f a)
    forall k (f :: k -> *) (a :: k) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow1 f a)
    forall k (f :: k -> *) (a :: k) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromStringShow1 f a
    -> c (FromStringShow1 f a)
    forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow1 f a))
    forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow1 f a))
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow1 f a -> m (FromStringShow1 f a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow1 f a -> m (FromStringShow1 f a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow1 f a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromStringShow1 f a
    -> c (FromStringShow1 f a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow1 f a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow1 f a))
    $cgfoldl :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromStringShow1 f a
    -> c (FromStringShow1 f a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromStringShow1 f a
    -> c (FromStringShow1 f a)
    $cgunfold :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow1 f a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow1 f a)
    $ctoConstr :: forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    FromStringShow1 f a -> Constr
    toConstr :: FromStringShow1 f a -> Constr
    $cdataTypeOf :: forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    FromStringShow1 f a -> DataType
    dataTypeOf :: FromStringShow1 f a -> DataType
    $cdataCast1 :: forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow1 f a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow1 f a))
    $cdataCast2 :: forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow1 f a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow1 f a))
    $cgmapT :: forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall b. Data b => b -> b)
    -> FromStringShow1 f a -> FromStringShow1 f a
    gmapT :: (forall b. Data b => b -> b)
    -> FromStringShow1 f a -> FromStringShow1 f a
    $cgmapQl :: forall k (f :: k -> *) (a :: k) r r'.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow1 f a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow1 f a -> r
    $cgmapQr :: forall k (f :: k -> *) (a :: k) r r'.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow1 f a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow1 f a -> r
    $cgmapQ :: forall k (f :: k -> *) (a :: k) u.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall d. Data d => d -> u) -> FromStringShow1 f a -> [u]
    gmapQ :: forall u.
    (forall d. Data d => d -> u) -> FromStringShow1 f a -> [u]
    $cgmapQi :: forall k (f :: k -> *) (a :: k) u.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    Int -> (forall d. Data d => d -> u) -> FromStringShow1 f a -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> FromStringShow1 f a -> u
    $cgmapM :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow1 f a -> m (FromStringShow1 f a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow1 f a -> m (FromStringShow1 f a)
    $cgmapMp :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow1 f a -> m (FromStringShow1 f a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow1 f a -> m (FromStringShow1 f a)
    $cgmapMo :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow1 f a -> m (FromStringShow1 f a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow1 f a -> m (FromStringShow1 f a)
    Data
               , (forall m. Monoid m => FromStringShow1 f m -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromStringShow1 f a -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromStringShow1 f a -> m)
    -> (forall a b. (a -> b -> b) -> b -> FromStringShow1 f a -> b)
    -> (forall a b. (a -> b -> b) -> b -> FromStringShow1 f a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromStringShow1 f a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromStringShow1 f a -> b)
    -> (forall a. (a -> a -> a) -> FromStringShow1 f a -> a)
    -> (forall a. (a -> a -> a) -> FromStringShow1 f a -> a)
    -> (forall a. FromStringShow1 f a -> [a])
    -> (forall a. FromStringShow1 f a -> Bool)
    -> (forall a. FromStringShow1 f a -> Int)
    -> (forall a. Eq a => a -> FromStringShow1 f a -> Bool)
    -> (forall a. Ord a => FromStringShow1 f a -> a)
    -> (forall a. Ord a => FromStringShow1 f a -> a)
    -> (forall a. Num a => FromStringShow1 f a -> a)
    -> (forall a. Num a => FromStringShow1 f a -> a)
    -> Foldable (FromStringShow1 f)
    forall a. Eq a => a -> FromStringShow1 f a -> Bool
    forall a. Num a => FromStringShow1 f a -> a
    forall a. Ord a => FromStringShow1 f a -> a
    forall m. Monoid m => FromStringShow1 f m -> m
    forall a. FromStringShow1 f a -> Bool
    forall a. FromStringShow1 f a -> Int
    forall a. FromStringShow1 f a -> [a]
    forall a. (a -> a -> a) -> FromStringShow1 f a -> a
    forall m a. Monoid m => (a -> m) -> FromStringShow1 f a -> m
    forall b a. (b -> a -> b) -> b -> FromStringShow1 f a -> b
    forall a b. (a -> b -> b) -> b -> FromStringShow1 f a -> b
    forall (f :: * -> *) a.
    (Foldable f, Eq a) =>
    a -> FromStringShow1 f a -> Bool
    forall (f :: * -> *) a.
    (Foldable f, Num a) =>
    FromStringShow1 f a -> a
    forall (f :: * -> *) a.
    (Foldable f, Ord a) =>
    FromStringShow1 f a -> a
    forall (f :: * -> *) m.
    (Foldable f, Monoid m) =>
    FromStringShow1 f m -> m
    forall (f :: * -> *) a. Foldable f => FromStringShow1 f a -> Bool
    forall (f :: * -> *) a. Foldable f => FromStringShow1 f a -> Int
    forall (f :: * -> *) a. Foldable f => FromStringShow1 f a -> [a]
    forall (f :: * -> *) a.
    Foldable f =>
    (a -> a -> a) -> FromStringShow1 f a -> a
    forall (f :: * -> *) m a.
    (Foldable f, Monoid m) =>
    (a -> m) -> FromStringShow1 f a -> m
    forall (f :: * -> *) b a.
    Foldable f =>
    (b -> a -> b) -> b -> FromStringShow1 f a -> b
    forall (f :: * -> *) a b.
    Foldable f =>
    (a -> b -> b) -> b -> FromStringShow1 f a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall (f :: * -> *) m.
    (Foldable f, Monoid m) =>
    FromStringShow1 f m -> m
    fold :: forall m. Monoid m => FromStringShow1 f m -> m
    $cfoldMap :: forall (f :: * -> *) m a.
    (Foldable f, Monoid m) =>
    (a -> m) -> FromStringShow1 f a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> FromStringShow1 f a -> m
    $cfoldMap' :: forall (f :: * -> *) m a.
    (Foldable f, Monoid m) =>
    (a -> m) -> FromStringShow1 f a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> FromStringShow1 f a -> m
    $cfoldr :: forall (f :: * -> *) a b.
    Foldable f =>
    (a -> b -> b) -> b -> FromStringShow1 f a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> FromStringShow1 f a -> b
    $cfoldr' :: forall (f :: * -> *) a b.
    Foldable f =>
    (a -> b -> b) -> b -> FromStringShow1 f a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> FromStringShow1 f a -> b
    $cfoldl :: forall (f :: * -> *) b a.
    Foldable f =>
    (b -> a -> b) -> b -> FromStringShow1 f a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> FromStringShow1 f a -> b
    $cfoldl' :: forall (f :: * -> *) b a.
    Foldable f =>
    (b -> a -> b) -> b -> FromStringShow1 f a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> FromStringShow1 f a -> b
    $cfoldr1 :: forall (f :: * -> *) a.
    Foldable f =>
    (a -> a -> a) -> FromStringShow1 f a -> a
    foldr1 :: forall a. (a -> a -> a) -> FromStringShow1 f a -> a
    $cfoldl1 :: forall (f :: * -> *) a.
    Foldable f =>
    (a -> a -> a) -> FromStringShow1 f a -> a
    foldl1 :: forall a. (a -> a -> a) -> FromStringShow1 f a -> a
    $ctoList :: forall (f :: * -> *) a. Foldable f => FromStringShow1 f a -> [a]
    toList :: forall a. FromStringShow1 f a -> [a]
    $cnull :: forall (f :: * -> *) a. Foldable f => FromStringShow1 f a -> Bool
    null :: forall a. FromStringShow1 f a -> Bool
    $clength :: forall (f :: * -> *) a. Foldable f => FromStringShow1 f a -> Int
    length :: forall a. FromStringShow1 f a -> Int
    $celem :: forall (f :: * -> *) a.
    (Foldable f, Eq a) =>
    a -> FromStringShow1 f a -> Bool
    elem :: forall a. Eq a => a -> FromStringShow1 f a -> Bool
    $cmaximum :: forall (f :: * -> *) a.
    (Foldable f, Ord a) =>
    FromStringShow1 f a -> a
    maximum :: forall a. Ord a => FromStringShow1 f a -> a
    $cminimum :: forall (f :: * -> *) a.
    (Foldable f, Ord a) =>
    FromStringShow1 f a -> a
    minimum :: forall a. Ord a => FromStringShow1 f a -> a
    $csum :: forall (f :: * -> *) a.
    (Foldable f, Num a) =>
    FromStringShow1 f a -> a
    sum :: forall a. Num a => FromStringShow1 f a -> a
    $cproduct :: forall (f :: * -> *) a.
    (Foldable f, Num a) =>
    FromStringShow1 f a -> a
    product :: forall a. Num a => FromStringShow1 f a -> a
    Foldable
               , (forall a b.
     (a -> b) -> FromStringShow1 f a -> FromStringShow1 f b)
    -> (forall a b. a -> FromStringShow1 f b -> FromStringShow1 f a)
    -> Functor (FromStringShow1 f)
    forall a b. a -> FromStringShow1 f b -> FromStringShow1 f a
    forall a b. (a -> b) -> FromStringShow1 f a -> FromStringShow1 f b
    forall (f :: * -> *) a b.
    Functor f =>
    a -> FromStringShow1 f b -> FromStringShow1 f a
    forall (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> FromStringShow1 f a -> FromStringShow1 f b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> FromStringShow1 f a -> FromStringShow1 f b
    fmap :: forall a b. (a -> b) -> FromStringShow1 f a -> FromStringShow1 f b
    $c<$ :: forall (f :: * -> *) a b.
    Functor f =>
    a -> FromStringShow1 f b -> FromStringShow1 f a
    <$ :: forall a b. a -> FromStringShow1 f b -> FromStringShow1 f a
    Functor
               , (forall x. FromStringShow1 f a -> Rep (FromStringShow1 f a) x)
    -> (forall x. Rep (FromStringShow1 f a) x -> FromStringShow1 f a)
    -> Generic (FromStringShow1 f a)
    forall x. Rep (FromStringShow1 f a) x -> FromStringShow1 f a
    forall x. FromStringShow1 f a -> Rep (FromStringShow1 f a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (f :: k -> *) (a :: k) x.
    Rep (FromStringShow1 f a) x -> FromStringShow1 f a
    forall k (f :: k -> *) (a :: k) x.
    FromStringShow1 f a -> Rep (FromStringShow1 f a) x
    $cfrom :: forall k (f :: k -> *) (a :: k) x.
    FromStringShow1 f a -> Rep (FromStringShow1 f a) x
    from :: forall x. FromStringShow1 f a -> Rep (FromStringShow1 f a) x
    $cto :: forall k (f :: k -> *) (a :: k) x.
    Rep (FromStringShow1 f a) x -> FromStringShow1 f a
    to :: forall x. Rep (FromStringShow1 f a) x -> FromStringShow1 f a
    Generic
               , (forall (a :: k).
     FromStringShow1 f a -> Rep1 (FromStringShow1 f) a)
    -> (forall (a :: k).
        Rep1 (FromStringShow1 f) a -> FromStringShow1 f a)
    -> Generic1 (FromStringShow1 f)
    forall (a :: k). Rep1 (FromStringShow1 f) a -> FromStringShow1 f a
    forall (a :: k). FromStringShow1 f a -> Rep1 (FromStringShow1 f) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    forall k (f :: k -> *) (a :: k).
    Rep1 (FromStringShow1 f) a -> FromStringShow1 f a
    forall k (f :: k -> *) (a :: k).
    FromStringShow1 f a -> Rep1 (FromStringShow1 f) a
    $cfrom1 :: forall k (f :: k -> *) (a :: k).
    FromStringShow1 f a -> Rep1 (FromStringShow1 f) a
    from1 :: forall (a :: k). FromStringShow1 f a -> Rep1 (FromStringShow1 f) a
    $cto1 :: forall k (f :: k -> *) (a :: k).
    Rep1 (FromStringShow1 f) a -> FromStringShow1 f a
    to1 :: forall (a :: k). Rep1 (FromStringShow1 f) a -> FromStringShow1 f a
    Generic1
               , (forall (m :: * -> *). Quote m => FromStringShow1 f a -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        FromStringShow1 f a -> Code m (FromStringShow1 f a))
    -> Lift (FromStringShow1 f a)
    forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Lift (f a), Quote m) =>
    FromStringShow1 f a -> m Exp
    forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Lift (f a), Quote m) =>
    FromStringShow1 f a -> Code m (FromStringShow1 f a)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => FromStringShow1 f a -> m Exp
    forall (m :: * -> *).
    Quote m =>
    FromStringShow1 f a -> Code m (FromStringShow1 f a)
    $clift :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Lift (f a), Quote m) =>
    FromStringShow1 f a -> m Exp
    lift :: forall (m :: * -> *). Quote m => FromStringShow1 f a -> m Exp
    $cliftTyped :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Lift (f a), Quote m) =>
    FromStringShow1 f a -> Code m (FromStringShow1 f a)
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    FromStringShow1 f a -> Code m (FromStringShow1 f a)
    Lift
               , Eq (FromStringShow1 f a)
    Eq (FromStringShow1 f a) =>
    (FromStringShow1 f a -> FromStringShow1 f a -> Ordering)
    -> (FromStringShow1 f a -> FromStringShow1 f a -> Bool)
    -> (FromStringShow1 f a -> FromStringShow1 f a -> Bool)
    -> (FromStringShow1 f a -> FromStringShow1 f a -> Bool)
    -> (FromStringShow1 f a -> FromStringShow1 f a -> Bool)
    -> (FromStringShow1 f a
        -> FromStringShow1 f a -> FromStringShow1 f a)
    -> (FromStringShow1 f a
        -> FromStringShow1 f a -> FromStringShow1 f a)
    -> Ord (FromStringShow1 f a)
    FromStringShow1 f a -> FromStringShow1 f a -> Bool
    FromStringShow1 f a -> FromStringShow1 f a -> Ordering
    FromStringShow1 f a -> FromStringShow1 f a -> FromStringShow1 f a
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    Eq (FromStringShow1 f a)
    forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> Bool
    forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> Ordering
    forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> FromStringShow1 f a
    $ccompare :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> Ordering
    compare :: FromStringShow1 f a -> FromStringShow1 f a -> Ordering
    $c< :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> Bool
    < :: FromStringShow1 f a -> FromStringShow1 f a -> Bool
    $c<= :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> Bool
    <= :: FromStringShow1 f a -> FromStringShow1 f a -> Bool
    $c> :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> Bool
    > :: FromStringShow1 f a -> FromStringShow1 f a -> Bool
    $c>= :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> Bool
    >= :: FromStringShow1 f a -> FromStringShow1 f a -> Bool
    $cmax :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> FromStringShow1 f a
    max :: FromStringShow1 f a -> FromStringShow1 f a -> FromStringShow1 f a
    $cmin :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromStringShow1 f a -> FromStringShow1 f a -> FromStringShow1 f a
    min :: FromStringShow1 f a -> FromStringShow1 f a -> FromStringShow1 f a
    Ord
               , (forall a. Show a => Show (FromStringShow1 f a)) =>
    (forall a.
     (Int -> a -> ShowS)
     -> ([a] -> ShowS) -> Int -> FromStringShow1 f a -> ShowS)
    -> (forall a.
        (Int -> a -> ShowS)
        -> ([a] -> ShowS) -> [FromStringShow1 f a] -> ShowS)
    -> Show1 (FromStringShow1 f)
    forall a. Show a => Show (FromStringShow1 f a)
    forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> Int -> FromStringShow1 f a -> ShowS
    forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [FromStringShow1 f a] -> ShowS
    forall (f :: * -> *) a.
    (Show1 f, Show a) =>
    Show (FromStringShow1 f a)
    forall (f :: * -> *) a.
    Show1 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> Int -> FromStringShow1 f a -> ShowS
    forall (f :: * -> *) a.
    Show1 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [FromStringShow1 f a] -> ShowS
    forall (f :: * -> *).
    (forall a. Show a => Show (f a)) =>
    (forall a.
     (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS)
    -> (forall a.
        (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS)
    -> Show1 f
    $cliftShowsPrec :: forall (f :: * -> *) a.
    Show1 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> Int -> FromStringShow1 f a -> ShowS
    liftShowsPrec :: forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> Int -> FromStringShow1 f a -> ShowS
    $cliftShowList :: forall (f :: * -> *) a.
    Show1 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [FromStringShow1 f a] -> ShowS
    liftShowList :: forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [FromStringShow1 f a] -> ShowS
    Show1 -- TODO: Manually implement this when you
                       -- can derive Show1 (someday)
               , Functor (FromStringShow1 f)
    Foldable (FromStringShow1 f)
    (Functor (FromStringShow1 f), Foldable (FromStringShow1 f)) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> FromStringShow1 f a -> f (FromStringShow1 f b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        FromStringShow1 f (f a) -> f (FromStringShow1 f a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> FromStringShow1 f a -> m (FromStringShow1 f b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        FromStringShow1 f (m a) -> m (FromStringShow1 f a))
    -> Traversable (FromStringShow1 f)
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (f :: * -> *). Traversable f => Functor (FromStringShow1 f)
    forall (f :: * -> *). Traversable f => Foldable (FromStringShow1 f)
    forall (f :: * -> *) (m :: * -> *) a.
    (Traversable f, Monad m) =>
    FromStringShow1 f (m a) -> m (FromStringShow1 f a)
    forall (f :: * -> *) (f :: * -> *) a.
    (Traversable f, Applicative f) =>
    FromStringShow1 f (f a) -> f (FromStringShow1 f a)
    forall (f :: * -> *) (m :: * -> *) a b.
    (Traversable f, Monad m) =>
    (a -> m b) -> FromStringShow1 f a -> m (FromStringShow1 f b)
    forall (f :: * -> *) (f :: * -> *) a b.
    (Traversable f, Applicative f) =>
    (a -> f b) -> FromStringShow1 f a -> f (FromStringShow1 f b)
    forall (m :: * -> *) a.
    Monad m =>
    FromStringShow1 f (m a) -> m (FromStringShow1 f a)
    forall (f :: * -> *) a.
    Applicative f =>
    FromStringShow1 f (f a) -> f (FromStringShow1 f a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromStringShow1 f a -> m (FromStringShow1 f b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromStringShow1 f a -> f (FromStringShow1 f b)
    $ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
    (Traversable f, Applicative f) =>
    (a -> f b) -> FromStringShow1 f a -> f (FromStringShow1 f b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromStringShow1 f a -> f (FromStringShow1 f b)
    $csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
    (Traversable f, Applicative f) =>
    FromStringShow1 f (f a) -> f (FromStringShow1 f a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FromStringShow1 f (f a) -> f (FromStringShow1 f a)
    $cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
    (Traversable f, Monad m) =>
    (a -> m b) -> FromStringShow1 f a -> m (FromStringShow1 f b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromStringShow1 f a -> m (FromStringShow1 f b)
    $csequence :: forall (f :: * -> *) (m :: * -> *) a.
    (Traversable f, Monad m) =>
    FromStringShow1 f (m a) -> m (FromStringShow1 f a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    FromStringShow1 f (m a) -> m (FromStringShow1 f a)
    Traversable
               )

    instance Read (f a) => Read (FromStringShow1 f a) where
        readPrec :: ReadPrec (FromStringShow1 f a)
    readPrec     = ReadPrec (f a) -> ReadPrec (FromStringShow1 f a)
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec (f a)
    forall a. Read a => ReadPrec a
    readPrec     :: ReadPrec (f a))
        readsPrec :: Int -> ReadS (FromStringShow1 f a)
    readsPrec    = (Int -> ReadS (f a)) -> Int -> ReadS (FromStringShow1 f a)
    forall a b. Coercible a b => a -> b
    coerce (Int -> ReadS (f a)
    forall a. Read a => Int -> ReadS a
    readsPrec    :: Int -> ReadS (f a))
        readList :: ReadS [FromStringShow1 f a]
    readList     = ReadS [f a] -> ReadS [FromStringShow1 f a]
    forall a b. Coercible a b => a -> b
    coerce (ReadS [f a]
    forall a. Read a => ReadS [a]
    readList     :: ReadS [f a])
        readListPrec :: ReadPrec [FromStringShow1 f a]
    readListPrec = ReadPrec [f a] -> ReadPrec [FromStringShow1 f a]
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec [f a]
    forall a. Read a => ReadPrec [a]
    readListPrec :: ReadPrec [f a])

    -- | This instance is somewhat strange, as its instance context mixes a
    -- 'Show1' constraint with a 'TextShow' constraint. This is done for
    -- consistency with the 'Show' instance for 'FromTextShow1', which mixes
    -- constraints in a similar way to satisfy superclass constraints. See the
    -- Haddocks on the 'Show' instance for 'FromTextShow1' for more details.
    instance (Show1 f, TextShow a) => TextShow (FromStringShow1 f a) where
        showbPrec :: Int -> FromStringShow1 f a -> Builder
    showbPrec = Int -> FromStringShow1 f a -> Builder
    forall (f :: * -> *) a.
    (TextShow1 f, TextShow a) =>
    Int -> f a -> Builder
    showbPrec1

    instance Show1 f => TextShow1 (FromStringShow1 f) where
        liftShowbPrec :: forall a.
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> Int -> FromStringShow1 f a -> Builder
    liftShowbPrec Int -> a -> Builder
    sp [a] -> Builder
    sl Int
    p =
            (Int -> f a -> ShowS) -> Int -> f a -> Builder
    forall a. (Int -> a -> ShowS) -> Int -> a -> Builder
    showsPrecToShowbPrec ((Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS
    forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS
    forall (f :: * -> *) a.
    Show1 f =>
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS
    liftShowsPrec ((Int -> a -> Builder) -> Int -> a -> ShowS
    forall a. (Int -> a -> Builder) -> Int -> a -> ShowS
    showbPrecToShowsPrec Int -> a -> Builder
    sp)
                                                (([a] -> Builder) -> [a] -> ShowS
    forall a. (a -> Builder) -> a -> ShowS
    showbToShows         [a] -> Builder
    sl))
                                 Int
    p (f a -> Builder)
    -> (FromStringShow1 f a -> f a) -> FromStringShow1 f a -> Builder
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FromStringShow1 f a -> f a
    forall {k} (f :: k -> *) (a :: k). FromStringShow1 f a -> f a
    fromStringShow1
        liftShowbList :: forall a.
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> [FromStringShow1 f a] -> Builder
    liftShowbList Int -> a -> Builder
    sp [a] -> Builder
    sl =
            ([f a] -> ShowS) -> [f a] -> Builder
    forall a. (a -> ShowS) -> a -> Builder
    showsToShowb ((Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS
    forall a. (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS
    forall (f :: * -> *) a.
    Show1 f =>
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS
    liftShowList ((Int -> a -> Builder) -> Int -> a -> ShowS
    forall a. (Int -> a -> Builder) -> Int -> a -> ShowS
    showbPrecToShowsPrec Int -> a -> Builder
    sp)
                                       (([a] -> Builder) -> [a] -> ShowS
    forall a. (a -> Builder) -> a -> ShowS
    showbToShows         [a] -> Builder
    sl))
                         ([f a] -> Builder)
    -> ([FromStringShow1 f a] -> [f a])
    -> [FromStringShow1 f a]
    -> Builder
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [FromStringShow1 f a] -> [f a]
    forall a. [FromStringShow1 f a] -> [f a]
    coerceList
          where
            coerceList :: [FromStringShow1 f a] -> [f a]
            coerceList :: forall a. [FromStringShow1 f a] -> [f a]
    coerceList = [FromStringShow1 f a] -> [f a]
    forall a b. Coercible a b => a -> b
    coerce

    instance (Show1 f, Show a) => Show (FromStringShow1 f a) where
        showsPrec :: Int -> FromStringShow1 f a -> ShowS
    showsPrec = Int -> FromStringShow1 f a -> ShowS
    forall (f :: * -> *) a. (Show1 f, Show a) => Int -> f a -> ShowS
    showsPrec1
        showList :: [FromStringShow1 f a] -> ShowS
    showList  = (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [FromStringShow1 f a] -> ShowS
    forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [FromStringShow1 f a] -> ShowS
    forall (f :: * -> *) a.
    Show1 f =>
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS
    liftShowList Int -> a -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec [a] -> ShowS
    forall a. Show a => [a] -> ShowS
    showList

    -------------------------------------------------------------------------------

    -- | An adapter newtype, suitable for @DerivingVia@.
    -- The @String@ 'Show1' instance for 'FromTextShow1' is based on its
    -- 'TextShow1' instance. That is,
    --
    -- @
    -- 'liftShowsPrec' sp sl p ('FromTextShow1' x) =
    --     'showbPrecToShowsPrec' ('liftShowbPrec' ('showsPrecToShowbPrec' sp)
    --                                             ('showsToShowb'         sl))
    --                            p x
    -- @
    --
    -- /Since: 3/
    newtype FromTextShow1 f a = FromTextShow1 { forall {k} (f :: k -> *) (a :: k). FromTextShow1 f a -> f a
    fromTextShow1 :: f a }
      deriving ( FromTextShow1 f a -> FromTextShow1 f a -> Bool
    (FromTextShow1 f a -> FromTextShow1 f a -> Bool)
    -> (FromTextShow1 f a -> FromTextShow1 f a -> Bool)
    -> Eq (FromTextShow1 f a)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (f :: k -> *) (a :: k).
    Eq (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> Bool
    $c== :: forall k (f :: k -> *) (a :: k).
    Eq (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> Bool
    == :: FromTextShow1 f a -> FromTextShow1 f a -> Bool
    $c/= :: forall k (f :: k -> *) (a :: k).
    Eq (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> Bool
    /= :: FromTextShow1 f a -> FromTextShow1 f a -> Bool
    Eq
               , Typeable (FromTextShow1 f a)
    Typeable (FromTextShow1 f a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> FromTextShow1 f a
     -> c (FromTextShow1 f a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (FromTextShow1 f a))
    -> (FromTextShow1 f a -> Constr)
    -> (FromTextShow1 f a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow1 f a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (FromTextShow1 f a)))
    -> ((forall b. Data b => b -> b)
        -> FromTextShow1 f a -> FromTextShow1 f a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FromTextShow1 f a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FromTextShow1 f a -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> FromTextShow1 f a -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FromTextShow1 f a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> FromTextShow1 f a -> m (FromTextShow1 f a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromTextShow1 f a -> m (FromTextShow1 f a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromTextShow1 f a -> m (FromTextShow1 f a))
    -> Data (FromTextShow1 f a)
    FromTextShow1 f a -> Constr
    FromTextShow1 f a -> DataType
    (forall b. Data b => b -> b)
    -> FromTextShow1 f a -> FromTextShow1 f a
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> FromTextShow1 f a -> u
    forall u. (forall d. Data d => d -> u) -> FromTextShow1 f a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow1 f a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow1 f a -> r
    forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    Typeable (FromTextShow1 f a)
    forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    FromTextShow1 f a -> Constr
    forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    FromTextShow1 f a -> DataType
    forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall b. Data b => b -> b)
    -> FromTextShow1 f a -> FromTextShow1 f a
    forall k (f :: k -> *) (a :: k) u.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    Int -> (forall d. Data d => d -> u) -> FromTextShow1 f a -> u
    forall k (f :: k -> *) (a :: k) u.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall d. Data d => d -> u) -> FromTextShow1 f a -> [u]
    forall k (f :: k -> *) (a :: k) r r'.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow1 f a -> r
    forall k (f :: k -> *) (a :: k) r r'.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow1 f a -> r
    forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow1 f a -> m (FromTextShow1 f a)
    forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow1 f a -> m (FromTextShow1 f a)
    forall k (f :: k -> *) (a :: k) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow1 f a)
    forall k (f :: k -> *) (a :: k) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromTextShow1 f a
    -> c (FromTextShow1 f a)
    forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow1 f a))
    forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow1 f a))
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow1 f a -> m (FromTextShow1 f a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow1 f a -> m (FromTextShow1 f a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow1 f a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromTextShow1 f a
    -> c (FromTextShow1 f a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow1 f a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow1 f a))
    $cgfoldl :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromTextShow1 f a
    -> c (FromTextShow1 f a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromTextShow1 f a
    -> c (FromTextShow1 f a)
    $cgunfold :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow1 f a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow1 f a)
    $ctoConstr :: forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    FromTextShow1 f a -> Constr
    toConstr :: FromTextShow1 f a -> Constr
    $cdataTypeOf :: forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    FromTextShow1 f a -> DataType
    dataTypeOf :: FromTextShow1 f a -> DataType
    $cdataCast1 :: forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow1 f a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow1 f a))
    $cdataCast2 :: forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow1 f a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow1 f a))
    $cgmapT :: forall k (f :: k -> *) (a :: k).
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall b. Data b => b -> b)
    -> FromTextShow1 f a -> FromTextShow1 f a
    gmapT :: (forall b. Data b => b -> b)
    -> FromTextShow1 f a -> FromTextShow1 f a
    $cgmapQl :: forall k (f :: k -> *) (a :: k) r r'.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow1 f a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow1 f a -> r
    $cgmapQr :: forall k (f :: k -> *) (a :: k) r r'.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow1 f a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow1 f a -> r
    $cgmapQ :: forall k (f :: k -> *) (a :: k) u.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    (forall d. Data d => d -> u) -> FromTextShow1 f a -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> FromTextShow1 f a -> [u]
    $cgmapQi :: forall k (f :: k -> *) (a :: k) u.
    (Typeable a, Typeable f, Typeable k, Data (f a)) =>
    Int -> (forall d. Data d => d -> u) -> FromTextShow1 f a -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> FromTextShow1 f a -> u
    $cgmapM :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow1 f a -> m (FromTextShow1 f a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow1 f a -> m (FromTextShow1 f a)
    $cgmapMp :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow1 f a -> m (FromTextShow1 f a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow1 f a -> m (FromTextShow1 f a)
    $cgmapMo :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow1 f a -> m (FromTextShow1 f a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow1 f a -> m (FromTextShow1 f a)
    Data
               , (forall m. Monoid m => FromTextShow1 f m -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromTextShow1 f a -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromTextShow1 f a -> m)
    -> (forall a b. (a -> b -> b) -> b -> FromTextShow1 f a -> b)
    -> (forall a b. (a -> b -> b) -> b -> FromTextShow1 f a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromTextShow1 f a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromTextShow1 f a -> b)
    -> (forall a. (a -> a -> a) -> FromTextShow1 f a -> a)
    -> (forall a. (a -> a -> a) -> FromTextShow1 f a -> a)
    -> (forall a. FromTextShow1 f a -> [a])
    -> (forall a. FromTextShow1 f a -> Bool)
    -> (forall a. FromTextShow1 f a -> Int)
    -> (forall a. Eq a => a -> FromTextShow1 f a -> Bool)
    -> (forall a. Ord a => FromTextShow1 f a -> a)
    -> (forall a. Ord a => FromTextShow1 f a -> a)
    -> (forall a. Num a => FromTextShow1 f a -> a)
    -> (forall a. Num a => FromTextShow1 f a -> a)
    -> Foldable (FromTextShow1 f)
    forall a. Eq a => a -> FromTextShow1 f a -> Bool
    forall a. Num a => FromTextShow1 f a -> a
    forall a. Ord a => FromTextShow1 f a -> a
    forall m. Monoid m => FromTextShow1 f m -> m
    forall a. FromTextShow1 f a -> Bool
    forall a. FromTextShow1 f a -> Int
    forall a. FromTextShow1 f a -> [a]
    forall a. (a -> a -> a) -> FromTextShow1 f a -> a
    forall m a. Monoid m => (a -> m) -> FromTextShow1 f a -> m
    forall b a. (b -> a -> b) -> b -> FromTextShow1 f a -> b
    forall a b. (a -> b -> b) -> b -> FromTextShow1 f a -> b
    forall (f :: * -> *) a.
    (Foldable f, Eq a) =>
    a -> FromTextShow1 f a -> Bool
    forall (f :: * -> *) a.
    (Foldable f, Num a) =>
    FromTextShow1 f a -> a
    forall (f :: * -> *) a.
    (Foldable f, Ord a) =>
    FromTextShow1 f a -> a
    forall (f :: * -> *) m.
    (Foldable f, Monoid m) =>
    FromTextShow1 f m -> m
    forall (f :: * -> *) a. Foldable f => FromTextShow1 f a -> Bool
    forall (f :: * -> *) a. Foldable f => FromTextShow1 f a -> Int
    forall (f :: * -> *) a. Foldable f => FromTextShow1 f a -> [a]
    forall (f :: * -> *) a.
    Foldable f =>
    (a -> a -> a) -> FromTextShow1 f a -> a
    forall (f :: * -> *) m a.
    (Foldable f, Monoid m) =>
    (a -> m) -> FromTextShow1 f a -> m
    forall (f :: * -> *) b a.
    Foldable f =>
    (b -> a -> b) -> b -> FromTextShow1 f a -> b
    forall (f :: * -> *) a b.
    Foldable f =>
    (a -> b -> b) -> b -> FromTextShow1 f a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall (f :: * -> *) m.
    (Foldable f, Monoid m) =>
    FromTextShow1 f m -> m
    fold :: forall m. Monoid m => FromTextShow1 f m -> m
    $cfoldMap :: forall (f :: * -> *) m a.
    (Foldable f, Monoid m) =>
    (a -> m) -> FromTextShow1 f a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> FromTextShow1 f a -> m
    $cfoldMap' :: forall (f :: * -> *) m a.
    (Foldable f, Monoid m) =>
    (a -> m) -> FromTextShow1 f a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> FromTextShow1 f a -> m
    $cfoldr :: forall (f :: * -> *) a b.
    Foldable f =>
    (a -> b -> b) -> b -> FromTextShow1 f a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> FromTextShow1 f a -> b
    $cfoldr' :: forall (f :: * -> *) a b.
    Foldable f =>
    (a -> b -> b) -> b -> FromTextShow1 f a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> FromTextShow1 f a -> b
    $cfoldl :: forall (f :: * -> *) b a.
    Foldable f =>
    (b -> a -> b) -> b -> FromTextShow1 f a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> FromTextShow1 f a -> b
    $cfoldl' :: forall (f :: * -> *) b a.
    Foldable f =>
    (b -> a -> b) -> b -> FromTextShow1 f a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> FromTextShow1 f a -> b
    $cfoldr1 :: forall (f :: * -> *) a.
    Foldable f =>
    (a -> a -> a) -> FromTextShow1 f a -> a
    foldr1 :: forall a. (a -> a -> a) -> FromTextShow1 f a -> a
    $cfoldl1 :: forall (f :: * -> *) a.
    Foldable f =>
    (a -> a -> a) -> FromTextShow1 f a -> a
    foldl1 :: forall a. (a -> a -> a) -> FromTextShow1 f a -> a
    $ctoList :: forall (f :: * -> *) a. Foldable f => FromTextShow1 f a -> [a]
    toList :: forall a. FromTextShow1 f a -> [a]
    $cnull :: forall (f :: * -> *) a. Foldable f => FromTextShow1 f a -> Bool
    null :: forall a. FromTextShow1 f a -> Bool
    $clength :: forall (f :: * -> *) a. Foldable f => FromTextShow1 f a -> Int
    length :: forall a. FromTextShow1 f a -> Int
    $celem :: forall (f :: * -> *) a.
    (Foldable f, Eq a) =>
    a -> FromTextShow1 f a -> Bool
    elem :: forall a. Eq a => a -> FromTextShow1 f a -> Bool
    $cmaximum :: forall (f :: * -> *) a.
    (Foldable f, Ord a) =>
    FromTextShow1 f a -> a
    maximum :: forall a. Ord a => FromTextShow1 f a -> a
    $cminimum :: forall (f :: * -> *) a.
    (Foldable f, Ord a) =>
    FromTextShow1 f a -> a
    minimum :: forall a. Ord a => FromTextShow1 f a -> a
    $csum :: forall (f :: * -> *) a.
    (Foldable f, Num a) =>
    FromTextShow1 f a -> a
    sum :: forall a. Num a => FromTextShow1 f a -> a
    $cproduct :: forall (f :: * -> *) a.
    (Foldable f, Num a) =>
    FromTextShow1 f a -> a
    product :: forall a. Num a => FromTextShow1 f a -> a
    Foldable
               , (forall a b. (a -> b) -> FromTextShow1 f a -> FromTextShow1 f b)
    -> (forall a b. a -> FromTextShow1 f b -> FromTextShow1 f a)
    -> Functor (FromTextShow1 f)
    forall a b. a -> FromTextShow1 f b -> FromTextShow1 f a
    forall a b. (a -> b) -> FromTextShow1 f a -> FromTextShow1 f b
    forall (f :: * -> *) a b.
    Functor f =>
    a -> FromTextShow1 f b -> FromTextShow1 f a
    forall (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> FromTextShow1 f a -> FromTextShow1 f b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> FromTextShow1 f a -> FromTextShow1 f b
    fmap :: forall a b. (a -> b) -> FromTextShow1 f a -> FromTextShow1 f b
    $c<$ :: forall (f :: * -> *) a b.
    Functor f =>
    a -> FromTextShow1 f b -> FromTextShow1 f a
    <$ :: forall a b. a -> FromTextShow1 f b -> FromTextShow1 f a
    Functor
               , (forall x. FromTextShow1 f a -> Rep (FromTextShow1 f a) x)
    -> (forall x. Rep (FromTextShow1 f a) x -> FromTextShow1 f a)
    -> Generic (FromTextShow1 f a)
    forall x. Rep (FromTextShow1 f a) x -> FromTextShow1 f a
    forall x. FromTextShow1 f a -> Rep (FromTextShow1 f a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (f :: k -> *) (a :: k) x.
    Rep (FromTextShow1 f a) x -> FromTextShow1 f a
    forall k (f :: k -> *) (a :: k) x.
    FromTextShow1 f a -> Rep (FromTextShow1 f a) x
    $cfrom :: forall k (f :: k -> *) (a :: k) x.
    FromTextShow1 f a -> Rep (FromTextShow1 f a) x
    from :: forall x. FromTextShow1 f a -> Rep (FromTextShow1 f a) x
    $cto :: forall k (f :: k -> *) (a :: k) x.
    Rep (FromTextShow1 f a) x -> FromTextShow1 f a
    to :: forall x. Rep (FromTextShow1 f a) x -> FromTextShow1 f a
    Generic
               , (forall (a :: k). FromTextShow1 f a -> Rep1 (FromTextShow1 f) a)
    -> (forall (a :: k). Rep1 (FromTextShow1 f) a -> FromTextShow1 f a)
    -> Generic1 (FromTextShow1 f)
    forall (a :: k). Rep1 (FromTextShow1 f) a -> FromTextShow1 f a
    forall (a :: k). FromTextShow1 f a -> Rep1 (FromTextShow1 f) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    forall k (f :: k -> *) (a :: k).
    Rep1 (FromTextShow1 f) a -> FromTextShow1 f a
    forall k (f :: k -> *) (a :: k).
    FromTextShow1 f a -> Rep1 (FromTextShow1 f) a
    $cfrom1 :: forall k (f :: k -> *) (a :: k).
    FromTextShow1 f a -> Rep1 (FromTextShow1 f) a
    from1 :: forall (a :: k). FromTextShow1 f a -> Rep1 (FromTextShow1 f) a
    $cto1 :: forall k (f :: k -> *) (a :: k).
    Rep1 (FromTextShow1 f) a -> FromTextShow1 f a
    to1 :: forall (a :: k). Rep1 (FromTextShow1 f) a -> FromTextShow1 f a
    Generic1
               , (forall (m :: * -> *). Quote m => FromTextShow1 f a -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        FromTextShow1 f a -> Code m (FromTextShow1 f a))
    -> Lift (FromTextShow1 f a)
    forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Lift (f a), Quote m) =>
    FromTextShow1 f a -> m Exp
    forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Lift (f a), Quote m) =>
    FromTextShow1 f a -> Code m (FromTextShow1 f a)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => FromTextShow1 f a -> m Exp
    forall (m :: * -> *).
    Quote m =>
    FromTextShow1 f a -> Code m (FromTextShow1 f a)
    $clift :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Lift (f a), Quote m) =>
    FromTextShow1 f a -> m Exp
    lift :: forall (m :: * -> *). Quote m => FromTextShow1 f a -> m Exp
    $cliftTyped :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
    (Lift (f a), Quote m) =>
    FromTextShow1 f a -> Code m (FromTextShow1 f a)
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    FromTextShow1 f a -> Code m (FromTextShow1 f a)
    Lift
               , Eq (FromTextShow1 f a)
    Eq (FromTextShow1 f a) =>
    (FromTextShow1 f a -> FromTextShow1 f a -> Ordering)
    -> (FromTextShow1 f a -> FromTextShow1 f a -> Bool)
    -> (FromTextShow1 f a -> FromTextShow1 f a -> Bool)
    -> (FromTextShow1 f a -> FromTextShow1 f a -> Bool)
    -> (FromTextShow1 f a -> FromTextShow1 f a -> Bool)
    -> (FromTextShow1 f a -> FromTextShow1 f a -> FromTextShow1 f a)
    -> (FromTextShow1 f a -> FromTextShow1 f a -> FromTextShow1 f a)
    -> Ord (FromTextShow1 f a)
    FromTextShow1 f a -> FromTextShow1 f a -> Bool
    FromTextShow1 f a -> FromTextShow1 f a -> Ordering
    FromTextShow1 f a -> FromTextShow1 f a -> FromTextShow1 f a
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    Eq (FromTextShow1 f a)
    forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> Bool
    forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> Ordering
    forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> FromTextShow1 f a
    $ccompare :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> Ordering
    compare :: FromTextShow1 f a -> FromTextShow1 f a -> Ordering
    $c< :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> Bool
    < :: FromTextShow1 f a -> FromTextShow1 f a -> Bool
    $c<= :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> Bool
    <= :: FromTextShow1 f a -> FromTextShow1 f a -> Bool
    $c> :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> Bool
    > :: FromTextShow1 f a -> FromTextShow1 f a -> Bool
    $c>= :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> Bool
    >= :: FromTextShow1 f a -> FromTextShow1 f a -> Bool
    $cmax :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> FromTextShow1 f a
    max :: FromTextShow1 f a -> FromTextShow1 f a -> FromTextShow1 f a
    $cmin :: forall k (f :: k -> *) (a :: k).
    Ord (f a) =>
    FromTextShow1 f a -> FromTextShow1 f a -> FromTextShow1 f a
    min :: FromTextShow1 f a -> FromTextShow1 f a -> FromTextShow1 f a
    Ord
               , (forall a. TextShow a => TextShow (FromTextShow1 f a)) =>
    (forall a.
     (Int -> a -> Builder)
     -> ([a] -> Builder) -> Int -> FromTextShow1 f a -> Builder)
    -> (forall a.
        (Int -> a -> Builder)
        -> ([a] -> Builder) -> [FromTextShow1 f a] -> Builder)
    -> TextShow1 (FromTextShow1 f)
    forall a. TextShow a => TextShow (FromTextShow1 f a)
    forall a.
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> Int -> FromTextShow1 f a -> Builder
    forall a.
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> [FromTextShow1 f a] -> Builder
    forall (f :: * -> *) a.
    (TextShow1 f, TextShow a) =>
    TextShow (FromTextShow1 f a)
    forall (f :: * -> *) a.
    TextShow1 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> Int -> FromTextShow1 f a -> Builder
    forall (f :: * -> *) a.
    TextShow1 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> [FromTextShow1 f a] -> Builder
    forall (f :: * -> *).
    (forall a. TextShow a => TextShow (f a)) =>
    (forall a.
     (Int -> a -> Builder) -> ([a] -> Builder) -> Int -> f a -> Builder)
    -> (forall a.
        (Int -> a -> Builder) -> ([a] -> Builder) -> [f a] -> Builder)
    -> TextShow1 f
    $cliftShowbPrec :: forall (f :: * -> *) a.
    TextShow1 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> Int -> FromTextShow1 f a -> Builder
    liftShowbPrec :: forall a.
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> Int -> FromTextShow1 f a -> Builder
    $cliftShowbList :: forall (f :: * -> *) a.
    TextShow1 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> [FromTextShow1 f a] -> Builder
    liftShowbList :: forall a.
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> [FromTextShow1 f a] -> Builder
    TextShow1
               , Functor (FromTextShow1 f)
    Foldable (FromTextShow1 f)
    (Functor (FromTextShow1 f), Foldable (FromTextShow1 f)) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> FromTextShow1 f a -> f (FromTextShow1 f b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        FromTextShow1 f (f a) -> f (FromTextShow1 f a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> FromTextShow1 f a -> m (FromTextShow1 f b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        FromTextShow1 f (m a) -> m (FromTextShow1 f a))
    -> Traversable (FromTextShow1 f)
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (f :: * -> *). Traversable f => Functor (FromTextShow1 f)
    forall (f :: * -> *). Traversable f => Foldable (FromTextShow1 f)
    forall (f :: * -> *) (m :: * -> *) a.
    (Traversable f, Monad m) =>
    FromTextShow1 f (m a) -> m (FromTextShow1 f a)
    forall (f :: * -> *) (f :: * -> *) a.
    (Traversable f, Applicative f) =>
    FromTextShow1 f (f a) -> f (FromTextShow1 f a)
    forall (f :: * -> *) (m :: * -> *) a b.
    (Traversable f, Monad m) =>
    (a -> m b) -> FromTextShow1 f a -> m (FromTextShow1 f b)
    forall (f :: * -> *) (f :: * -> *) a b.
    (Traversable f, Applicative f) =>
    (a -> f b) -> FromTextShow1 f a -> f (FromTextShow1 f b)
    forall (m :: * -> *) a.
    Monad m =>
    FromTextShow1 f (m a) -> m (FromTextShow1 f a)
    forall (f :: * -> *) a.
    Applicative f =>
    FromTextShow1 f (f a) -> f (FromTextShow1 f a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromTextShow1 f a -> m (FromTextShow1 f b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromTextShow1 f a -> f (FromTextShow1 f b)
    $ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
    (Traversable f, Applicative f) =>
    (a -> f b) -> FromTextShow1 f a -> f (FromTextShow1 f b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromTextShow1 f a -> f (FromTextShow1 f b)
    $csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
    (Traversable f, Applicative f) =>
    FromTextShow1 f (f a) -> f (FromTextShow1 f a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FromTextShow1 f (f a) -> f (FromTextShow1 f a)
    $cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
    (Traversable f, Monad m) =>
    (a -> m b) -> FromTextShow1 f a -> m (FromTextShow1 f b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromTextShow1 f a -> m (FromTextShow1 f b)
    $csequence :: forall (f :: * -> *) (m :: * -> *) a.
    (Traversable f, Monad m) =>
    FromTextShow1 f (m a) -> m (FromTextShow1 f a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    FromTextShow1 f (m a) -> m (FromTextShow1 f a)
    Traversable
               )

    instance Read (f a) => Read (FromTextShow1 f a) where
        readPrec :: ReadPrec (FromTextShow1 f a)
    readPrec     = ReadPrec (f a) -> ReadPrec (FromTextShow1 f a)
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec (f a)
    forall a. Read a => ReadPrec a
    readPrec     :: ReadPrec (f a))
        readsPrec :: Int -> ReadS (FromTextShow1 f a)
    readsPrec    = (Int -> ReadS (f a)) -> Int -> ReadS (FromTextShow1 f a)
    forall a b. Coercible a b => a -> b
    coerce (Int -> ReadS (f a)
    forall a. Read a => Int -> ReadS a
    readsPrec    :: Int -> ReadS (f a))
        readList :: ReadS [FromTextShow1 f a]
    readList     = ReadS [f a] -> ReadS [FromTextShow1 f a]
    forall a b. Coercible a b => a -> b
    coerce (ReadS [f a]
    forall a. Read a => ReadS [a]
    readList     :: ReadS [f a])
        readListPrec :: ReadPrec [FromTextShow1 f a]
    readListPrec = ReadPrec [f a] -> ReadPrec [FromTextShow1 f a]
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec [f a]
    forall a. Read a => ReadPrec [a]
    readListPrec :: ReadPrec [f a])

    -- | This instance is somewhat strange, as its instance context mixes a
    -- 'TextShow1' constraint with a 'Show' constraint. The 'Show' constraint is
    -- necessary to satisfy the quantified 'Show' superclass in 'Show1'. Really,
    -- the 'Show' constraint ought to be a 'TextShow' constraint instead, but GHC
    -- has no way of knowing that the 'TextShow' constraint can be converted to a
    -- 'Show' constraint when checking superclasses.
    --
    -- This is all to say: this instance is almost surely not what you want if you
    -- are looking to derive a 'Show' instance only via 'TextShow'-related
    -- classes. If you wish to do this, derive via 'FromTextShow' instead.
    instance (TextShow1 f, Show a) => Show (FromTextShow1 f a) where
      showsPrec :: Int -> FromTextShow1 f a -> ShowS
    showsPrec = Int -> FromTextShow1 f a -> ShowS
    forall (f :: * -> *) a. (Show1 f, Show a) => Int -> f a -> ShowS
    showsPrec1

    instance TextShow1 f => Show1 (FromTextShow1 f) where
        liftShowList :: forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [FromTextShow1 f a] -> ShowS
    liftShowList Int -> a -> ShowS
    sp [a] -> ShowS
    sl =
            ([f a] -> Builder) -> [f a] -> ShowS
    forall a. (a -> Builder) -> a -> ShowS
    showbToShows ((Int -> a -> Builder) -> ([a] -> Builder) -> [f a] -> Builder
    forall a.
    (Int -> a -> Builder) -> ([a] -> Builder) -> [f a] -> Builder
    forall (f :: * -> *) a.
    TextShow1 f =>
    (Int -> a -> Builder) -> ([a] -> Builder) -> [f a] -> Builder
    liftShowbList ((Int -> a -> ShowS) -> Int -> a -> Builder
    forall a. (Int -> a -> ShowS) -> Int -> a -> Builder
    showsPrecToShowbPrec Int -> a -> ShowS
    sp)
                                        (([a] -> ShowS) -> [a] -> Builder
    forall a. (a -> ShowS) -> a -> Builder
    showsToShowb         [a] -> ShowS
    sl))
                         ([f a] -> ShowS)
    -> ([FromTextShow1 f a] -> [f a]) -> [FromTextShow1 f a] -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [FromTextShow1 f a] -> [f a]
    forall a. [FromTextShow1 f a] -> [f a]
    coerceList
          where
            coerceList :: [FromTextShow1 f a] -> [f a]
            coerceList :: forall a. [FromTextShow1 f a] -> [f a]
    coerceList = [FromTextShow1 f a] -> [f a]
    forall a b. Coercible a b => a -> b
    coerce
        liftShowsPrec :: forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> Int -> FromTextShow1 f a -> ShowS
    liftShowsPrec Int -> a -> ShowS
    sp [a] -> ShowS
    sl Int
    p =
            (Int -> f a -> Builder) -> Int -> f a -> ShowS
    forall a. (Int -> a -> Builder) -> Int -> a -> ShowS
    showbPrecToShowsPrec ((Int -> a -> Builder) -> ([a] -> Builder) -> Int -> f a -> Builder
    forall a.
    (Int -> a -> Builder) -> ([a] -> Builder) -> Int -> f a -> Builder
    forall (f :: * -> *) a.
    TextShow1 f =>
    (Int -> a -> Builder) -> ([a] -> Builder) -> Int -> f a -> Builder
    liftShowbPrec ((Int -> a -> ShowS) -> Int -> a -> Builder
    forall a. (Int -> a -> ShowS) -> Int -> a -> Builder
    showsPrecToShowbPrec Int -> a -> ShowS
    sp)
                                                (([a] -> ShowS) -> [a] -> Builder
    forall a. (a -> ShowS) -> a -> Builder
    showsToShowb         [a] -> ShowS
    sl))
                                 Int
    p (f a -> ShowS)
    -> (FromTextShow1 f a -> f a) -> FromTextShow1 f a -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FromTextShow1 f a -> f a
    forall {k} (f :: k -> *) (a :: k). FromTextShow1 f a -> f a
    fromTextShow1

    instance (TextShow1 f, TextShow a) => TextShow (FromTextShow1 f a) where
        showbPrec :: Int -> FromTextShow1 f a -> Builder
    showbPrec = Int -> FromTextShow1 f a -> Builder
    forall (f :: * -> *) a.
    (TextShow1 f, TextShow a) =>
    Int -> f a -> Builder
    showbPrec1
        showbList :: [FromTextShow1 f a] -> Builder
    showbList = (Int -> a -> Builder)
    -> ([a] -> Builder) -> [FromTextShow1 f a] -> Builder
    forall a.
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> [FromTextShow1 f a] -> Builder
    forall (f :: * -> *) a.
    TextShow1 f =>
    (Int -> a -> Builder) -> ([a] -> Builder) -> [f a] -> Builder
    liftShowbList Int -> a -> Builder
    forall a. TextShow a => Int -> a -> Builder
    showbPrec [a] -> Builder
    forall a. TextShow a => [a] -> Builder
    showbList

    -------------------------------------------------------------------------------

    -- | An adapter newtype, suitable for @DerivingVia@.
    -- The 'TextShow2' instance for 'FromStringShow2' is based on its @String@
    -- 'Show2' instance. That is,
    --
    -- @
    -- 'liftShowbPrec2' sp1 sl1 sp2 sl2 p ('FromStringShow2' x) =
    --     'showsPrecToShowbPrec' ('liftShowsPrec2' ('showbPrecToShowsPrec' sp1)
    --                                              ('showbToShows'         sl1)
    --                                              ('showbPrecToShowsPrec' sp2)
    --                                              ('showbToShows'         sl2))
    --                            p x
    -- @
    --
    -- /Since: 3/
    newtype FromStringShow2 f a b = FromStringShow2 { forall {k} {k} (f :: k -> k -> *) (a :: k) (b :: k).
    FromStringShow2 f a b -> f a b
    fromStringShow2 :: f a b }
      deriving ( FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    (FromStringShow2 f a b -> FromStringShow2 f a b -> Bool)
    -> (FromStringShow2 f a b -> FromStringShow2 f a b -> Bool)
    -> Eq (FromStringShow2 f a b)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Eq (f a b) =>
    FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    $c== :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Eq (f a b) =>
    FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    == :: FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    $c/= :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Eq (f a b) =>
    FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    /= :: FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    Eq
               , Typeable (FromStringShow2 f a b)
    Typeable (FromStringShow2 f a b) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> FromStringShow2 f a b
     -> c (FromStringShow2 f a b))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (FromStringShow2 f a b))
    -> (FromStringShow2 f a b -> Constr)
    -> (FromStringShow2 f a b -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow2 f a b)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (FromStringShow2 f a b)))
    -> ((forall b. Data b => b -> b)
        -> FromStringShow2 f a b -> FromStringShow2 f a b)
    -> (forall r r'.
        (r -> r' -> r)
        -> r
        -> (forall d. Data d => d -> r')
        -> FromStringShow2 f a b
        -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r
        -> (forall d. Data d => d -> r')
        -> FromStringShow2 f a b
        -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> FromStringShow2 f a b -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FromStringShow2 f a b -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> FromStringShow2 f a b -> m (FromStringShow2 f a b))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromStringShow2 f a b -> m (FromStringShow2 f a b))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromStringShow2 f a b -> m (FromStringShow2 f a b))
    -> Data (FromStringShow2 f a b)
    FromStringShow2 f a b -> Constr
    FromStringShow2 f a b -> DataType
    (forall b. Data b => b -> b)
    -> FromStringShow2 f a b -> FromStringShow2 f a b
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> FromStringShow2 f a b -> u
    forall u.
    (forall d. Data d => d -> u) -> FromStringShow2 f a b -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow2 f a b -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow2 f a b -> r
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    Typeable (FromStringShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    FromStringShow2 f a b -> Constr
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    FromStringShow2 f a b -> DataType
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall b. Data b => b -> b)
    -> FromStringShow2 f a b -> FromStringShow2 f a b
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) u.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    Int -> (forall d. Data d => d -> u) -> FromStringShow2 f a b -> u
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) u.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall d. Data d => d -> u) -> FromStringShow2 f a b -> [u]
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) r r'.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow2 f a b -> r
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) r r'.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow2 f a b -> r
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow2 f a b -> m (FromStringShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow2 f a b -> m (FromStringShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromStringShow2 f a b
    -> c (FromStringShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (t :: * -> *)
           (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow2 f a b))
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (t :: * -> * -> *)
           (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow2 f a b))
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow2 f a b -> m (FromStringShow2 f a b)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow2 f a b -> m (FromStringShow2 f a b)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow2 f a b)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromStringShow2 f a b
    -> c (FromStringShow2 f a b)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow2 f a b))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow2 f a b))
    $cgfoldl :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromStringShow2 f a b
    -> c (FromStringShow2 f a b)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromStringShow2 f a b
    -> c (FromStringShow2 f a b)
    $cgunfold :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow2 f a b)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromStringShow2 f a b)
    $ctoConstr :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    FromStringShow2 f a b -> Constr
    toConstr :: FromStringShow2 f a b -> Constr
    $cdataTypeOf :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    FromStringShow2 f a b -> DataType
    dataTypeOf :: FromStringShow2 f a b -> DataType
    $cdataCast1 :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (t :: * -> *)
           (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow2 f a b))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromStringShow2 f a b))
    $cdataCast2 :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (t :: * -> * -> *)
           (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow2 f a b))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromStringShow2 f a b))
    $cgmapT :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall b. Data b => b -> b)
    -> FromStringShow2 f a b -> FromStringShow2 f a b
    gmapT :: (forall b. Data b => b -> b)
    -> FromStringShow2 f a b -> FromStringShow2 f a b
    $cgmapQl :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) r r'.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow2 f a b -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow2 f a b -> r
    $cgmapQr :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) r r'.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow2 f a b -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromStringShow2 f a b -> r
    $cgmapQ :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) u.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall d. Data d => d -> u) -> FromStringShow2 f a b -> [u]
    gmapQ :: forall u.
    (forall d. Data d => d -> u) -> FromStringShow2 f a b -> [u]
    $cgmapQi :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) u.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    Int -> (forall d. Data d => d -> u) -> FromStringShow2 f a b -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> FromStringShow2 f a b -> u
    $cgmapM :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow2 f a b -> m (FromStringShow2 f a b)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow2 f a b -> m (FromStringShow2 f a b)
    $cgmapMp :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow2 f a b -> m (FromStringShow2 f a b)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow2 f a b -> m (FromStringShow2 f a b)
    $cgmapMo :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromStringShow2 f a b -> m (FromStringShow2 f a b)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromStringShow2 f a b -> m (FromStringShow2 f a b)
    Data
               , (forall m. Monoid m => FromStringShow2 f a m -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromStringShow2 f a a -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromStringShow2 f a a -> m)
    -> (forall a b. (a -> b -> b) -> b -> FromStringShow2 f a a -> b)
    -> (forall a b. (a -> b -> b) -> b -> FromStringShow2 f a a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromStringShow2 f a a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromStringShow2 f a a -> b)
    -> (forall a. (a -> a -> a) -> FromStringShow2 f a a -> a)
    -> (forall a. (a -> a -> a) -> FromStringShow2 f a a -> a)
    -> (forall a. FromStringShow2 f a a -> [a])
    -> (forall a. FromStringShow2 f a a -> Bool)
    -> (forall a. FromStringShow2 f a a -> Int)
    -> (forall a. Eq a => a -> FromStringShow2 f a a -> Bool)
    -> (forall a. Ord a => FromStringShow2 f a a -> a)
    -> (forall a. Ord a => FromStringShow2 f a a -> a)
    -> (forall a. Num a => FromStringShow2 f a a -> a)
    -> (forall a. Num a => FromStringShow2 f a a -> a)
    -> Foldable (FromStringShow2 f a)
    forall a. Eq a => a -> FromStringShow2 f a a -> Bool
    forall a. Num a => FromStringShow2 f a a -> a
    forall a. Ord a => FromStringShow2 f a a -> a
    forall m. Monoid m => FromStringShow2 f a m -> m
    forall a. FromStringShow2 f a a -> Bool
    forall a. FromStringShow2 f a a -> Int
    forall a. FromStringShow2 f a a -> [a]
    forall a. (a -> a -> a) -> FromStringShow2 f a a -> a
    forall m a. Monoid m => (a -> m) -> FromStringShow2 f a a -> m
    forall b a. (b -> a -> b) -> b -> FromStringShow2 f a a -> b
    forall a b. (a -> b -> b) -> b -> FromStringShow2 f a a -> b
    forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Eq a) =>
    a -> FromStringShow2 f a a -> Bool
    forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Num a) =>
    FromStringShow2 f a a -> a
    forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Ord a) =>
    FromStringShow2 f a a -> a
    forall k (f :: k -> * -> *) (a :: k) m.
    (Foldable (f a), Monoid m) =>
    FromStringShow2 f a m -> m
    forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromStringShow2 f a a -> Bool
    forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromStringShow2 f a a -> Int
    forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromStringShow2 f a a -> [a]
    forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    (a -> a -> a) -> FromStringShow2 f a a -> a
    forall k (f :: k -> * -> *) (a :: k) m a.
    (Foldable (f a), Monoid m) =>
    (a -> m) -> FromStringShow2 f a a -> m
    forall k (f :: k -> * -> *) (a :: k) b a.
    Foldable (f a) =>
    (b -> a -> b) -> b -> FromStringShow2 f a a -> b
    forall k (f :: k -> * -> *) (a :: k) a b.
    Foldable (f a) =>
    (a -> b -> b) -> b -> FromStringShow2 f a a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall k (f :: k -> * -> *) (a :: k) m.
    (Foldable (f a), Monoid m) =>
    FromStringShow2 f a m -> m
    fold :: forall m. Monoid m => FromStringShow2 f a m -> m
    $cfoldMap :: forall k (f :: k -> * -> *) (a :: k) m a.
    (Foldable (f a), Monoid m) =>
    (a -> m) -> FromStringShow2 f a a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> FromStringShow2 f a a -> m
    $cfoldMap' :: forall k (f :: k -> * -> *) (a :: k) m a.
    (Foldable (f a), Monoid m) =>
    (a -> m) -> FromStringShow2 f a a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> FromStringShow2 f a a -> m
    $cfoldr :: forall k (f :: k -> * -> *) (a :: k) a b.
    Foldable (f a) =>
    (a -> b -> b) -> b -> FromStringShow2 f a a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> FromStringShow2 f a a -> b
    $cfoldr' :: forall k (f :: k -> * -> *) (a :: k) a b.
    Foldable (f a) =>
    (a -> b -> b) -> b -> FromStringShow2 f a a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> FromStringShow2 f a a -> b
    $cfoldl :: forall k (f :: k -> * -> *) (a :: k) b a.
    Foldable (f a) =>
    (b -> a -> b) -> b -> FromStringShow2 f a a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> FromStringShow2 f a a -> b
    $cfoldl' :: forall k (f :: k -> * -> *) (a :: k) b a.
    Foldable (f a) =>
    (b -> a -> b) -> b -> FromStringShow2 f a a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> FromStringShow2 f a a -> b
    $cfoldr1 :: forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    (a -> a -> a) -> FromStringShow2 f a a -> a
    foldr1 :: forall a. (a -> a -> a) -> FromStringShow2 f a a -> a
    $cfoldl1 :: forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    (a -> a -> a) -> FromStringShow2 f a a -> a
    foldl1 :: forall a. (a -> a -> a) -> FromStringShow2 f a a -> a
    $ctoList :: forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromStringShow2 f a a -> [a]
    toList :: forall a. FromStringShow2 f a a -> [a]
    $cnull :: forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromStringShow2 f a a -> Bool
    null :: forall a. FromStringShow2 f a a -> Bool
    $clength :: forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromStringShow2 f a a -> Int
    length :: forall a. FromStringShow2 f a a -> Int
    $celem :: forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Eq a) =>
    a -> FromStringShow2 f a a -> Bool
    elem :: forall a. Eq a => a -> FromStringShow2 f a a -> Bool
    $cmaximum :: forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Ord a) =>
    FromStringShow2 f a a -> a
    maximum :: forall a. Ord a => FromStringShow2 f a a -> a
    $cminimum :: forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Ord a) =>
    FromStringShow2 f a a -> a
    minimum :: forall a. Ord a => FromStringShow2 f a a -> a
    $csum :: forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Num a) =>
    FromStringShow2 f a a -> a
    sum :: forall a. Num a => FromStringShow2 f a a -> a
    $cproduct :: forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Num a) =>
    FromStringShow2 f a a -> a
    product :: forall a. Num a => FromStringShow2 f a a -> a
    Foldable
               , (forall a b.
     (a -> b) -> FromStringShow2 f a a -> FromStringShow2 f a b)
    -> (forall a b.
        a -> FromStringShow2 f a b -> FromStringShow2 f a a)
    -> Functor (FromStringShow2 f a)
    forall a b. a -> FromStringShow2 f a b -> FromStringShow2 f a a
    forall a b.
    (a -> b) -> FromStringShow2 f a a -> FromStringShow2 f a b
    forall k (f :: k -> * -> *) (a :: k) a b.
    Functor (f a) =>
    a -> FromStringShow2 f a b -> FromStringShow2 f a a
    forall k (f :: k -> * -> *) (a :: k) a b.
    Functor (f a) =>
    (a -> b) -> FromStringShow2 f a a -> FromStringShow2 f a b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall k (f :: k -> * -> *) (a :: k) a b.
    Functor (f a) =>
    (a -> b) -> FromStringShow2 f a a -> FromStringShow2 f a b
    fmap :: forall a b.
    (a -> b) -> FromStringShow2 f a a -> FromStringShow2 f a b
    $c<$ :: forall k (f :: k -> * -> *) (a :: k) a b.
    Functor (f a) =>
    a -> FromStringShow2 f a b -> FromStringShow2 f a a
    <$ :: forall a b. a -> FromStringShow2 f a b -> FromStringShow2 f a a
    Functor
               , (forall x. FromStringShow2 f a b -> Rep (FromStringShow2 f a b) x)
    -> (forall x.
        Rep (FromStringShow2 f a b) x -> FromStringShow2 f a b)
    -> Generic (FromStringShow2 f a b)
    forall x. Rep (FromStringShow2 f a b) x -> FromStringShow2 f a b
    forall x. FromStringShow2 f a b -> Rep (FromStringShow2 f a b) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) x.
    Rep (FromStringShow2 f a b) x -> FromStringShow2 f a b
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) x.
    FromStringShow2 f a b -> Rep (FromStringShow2 f a b) x
    $cfrom :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) x.
    FromStringShow2 f a b -> Rep (FromStringShow2 f a b) x
    from :: forall x. FromStringShow2 f a b -> Rep (FromStringShow2 f a b) x
    $cto :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) x.
    Rep (FromStringShow2 f a b) x -> FromStringShow2 f a b
    to :: forall x. Rep (FromStringShow2 f a b) x -> FromStringShow2 f a b
    Generic
               , (forall (a :: k).
     FromStringShow2 f a a -> Rep1 (FromStringShow2 f a) a)
    -> (forall (a :: k).
        Rep1 (FromStringShow2 f a) a -> FromStringShow2 f a a)
    -> Generic1 (FromStringShow2 f a)
    forall (a :: k).
    Rep1 (FromStringShow2 f a) a -> FromStringShow2 f a a
    forall (a :: k).
    FromStringShow2 f a a -> Rep1 (FromStringShow2 f a) a
    forall k k (f :: k -> k -> *) (a :: k) (a :: k).
    Rep1 (FromStringShow2 f a) a -> FromStringShow2 f a a
    forall k k (f :: k -> k -> *) (a :: k) (a :: k).
    FromStringShow2 f a a -> Rep1 (FromStringShow2 f a) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall k k (f :: k -> k -> *) (a :: k) (a :: k).
    FromStringShow2 f a a -> Rep1 (FromStringShow2 f a) a
    from1 :: forall (a :: k).
    FromStringShow2 f a a -> Rep1 (FromStringShow2 f a) a
    $cto1 :: forall k k (f :: k -> k -> *) (a :: k) (a :: k).
    Rep1 (FromStringShow2 f a) a -> FromStringShow2 f a a
    to1 :: forall (a :: k).
    Rep1 (FromStringShow2 f a) a -> FromStringShow2 f a a
    Generic1
               , (forall (m :: * -> *). Quote m => FromStringShow2 f a b -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        FromStringShow2 f a b -> Code m (FromStringShow2 f a b))
    -> Lift (FromStringShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Lift (f a b), Quote m) =>
    FromStringShow2 f a b -> m Exp
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Lift (f a b), Quote m) =>
    FromStringShow2 f a b -> Code m (FromStringShow2 f a b)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => FromStringShow2 f a b -> m Exp
    forall (m :: * -> *).
    Quote m =>
    FromStringShow2 f a b -> Code m (FromStringShow2 f a b)
    $clift :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Lift (f a b), Quote m) =>
    FromStringShow2 f a b -> m Exp
    lift :: forall (m :: * -> *). Quote m => FromStringShow2 f a b -> m Exp
    $cliftTyped :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Lift (f a b), Quote m) =>
    FromStringShow2 f a b -> Code m (FromStringShow2 f a b)
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    FromStringShow2 f a b -> Code m (FromStringShow2 f a b)
    Lift
               , Eq (FromStringShow2 f a b)
    Eq (FromStringShow2 f a b) =>
    (FromStringShow2 f a b -> FromStringShow2 f a b -> Ordering)
    -> (FromStringShow2 f a b -> FromStringShow2 f a b -> Bool)
    -> (FromStringShow2 f a b -> FromStringShow2 f a b -> Bool)
    -> (FromStringShow2 f a b -> FromStringShow2 f a b -> Bool)
    -> (FromStringShow2 f a b -> FromStringShow2 f a b -> Bool)
    -> (FromStringShow2 f a b
        -> FromStringShow2 f a b -> FromStringShow2 f a b)
    -> (FromStringShow2 f a b
        -> FromStringShow2 f a b -> FromStringShow2 f a b)
    -> Ord (FromStringShow2 f a b)
    FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    FromStringShow2 f a b -> FromStringShow2 f a b -> Ordering
    FromStringShow2 f a b
    -> FromStringShow2 f a b -> FromStringShow2 f a b
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    Eq (FromStringShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromStringShow2 f a b -> FromStringShow2 f a b -> Ordering
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromStringShow2 f a b
    -> FromStringShow2 f a b -> FromStringShow2 f a b
    $ccompare :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromStringShow2 f a b -> FromStringShow2 f a b -> Ordering
    compare :: FromStringShow2 f a b -> FromStringShow2 f a b -> Ordering
    $c< :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    < :: FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    $c<= :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    <= :: FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    $c> :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    > :: FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    $c>= :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    >= :: FromStringShow2 f a b -> FromStringShow2 f a b -> Bool
    $cmax :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromStringShow2 f a b
    -> FromStringShow2 f a b -> FromStringShow2 f a b
    max :: FromStringShow2 f a b
    -> FromStringShow2 f a b -> FromStringShow2 f a b
    $cmin :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromStringShow2 f a b
    -> FromStringShow2 f a b -> FromStringShow2 f a b
    min :: FromStringShow2 f a b
    -> FromStringShow2 f a b -> FromStringShow2 f a b
    Ord
               , Functor (FromStringShow2 f a)
    Foldable (FromStringShow2 f a)
    (Functor (FromStringShow2 f a), Foldable (FromStringShow2 f a)) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> FromStringShow2 f a a -> f (FromStringShow2 f a b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        FromStringShow2 f a (f a) -> f (FromStringShow2 f a a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> FromStringShow2 f a a -> m (FromStringShow2 f a b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        FromStringShow2 f a (m a) -> m (FromStringShow2 f a a))
    -> Traversable (FromStringShow2 f a)
    forall k (f :: k -> * -> *) (a :: k).
    Traversable (f a) =>
    Functor (FromStringShow2 f a)
    forall k (f :: k -> * -> *) (a :: k).
    Traversable (f a) =>
    Foldable (FromStringShow2 f a)
    forall k (f :: k -> * -> *) (a :: k) (m :: * -> *) a.
    (Traversable (f a), Monad m) =>
    FromStringShow2 f a (m a) -> m (FromStringShow2 f a a)
    forall k (f :: k -> * -> *) (a :: k) (f :: * -> *) a.
    (Traversable (f a), Applicative f) =>
    FromStringShow2 f a (f a) -> f (FromStringShow2 f a a)
    forall k (f :: k -> * -> *) (a :: k) (m :: * -> *) a b.
    (Traversable (f a), Monad m) =>
    (a -> m b) -> FromStringShow2 f a a -> m (FromStringShow2 f a b)
    forall k (f :: k -> * -> *) (a :: k) (f :: * -> *) a b.
    (Traversable (f a), Applicative f) =>
    (a -> f b) -> FromStringShow2 f a a -> f (FromStringShow2 f a b)
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    FromStringShow2 f a (m a) -> m (FromStringShow2 f a a)
    forall (f :: * -> *) a.
    Applicative f =>
    FromStringShow2 f a (f a) -> f (FromStringShow2 f a a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromStringShow2 f a a -> m (FromStringShow2 f a b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromStringShow2 f a a -> f (FromStringShow2 f a b)
    $ctraverse :: forall k (f :: k -> * -> *) (a :: k) (f :: * -> *) a b.
    (Traversable (f a), Applicative f) =>
    (a -> f b) -> FromStringShow2 f a a -> f (FromStringShow2 f a b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromStringShow2 f a a -> f (FromStringShow2 f a b)
    $csequenceA :: forall k (f :: k -> * -> *) (a :: k) (f :: * -> *) a.
    (Traversable (f a), Applicative f) =>
    FromStringShow2 f a (f a) -> f (FromStringShow2 f a a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FromStringShow2 f a (f a) -> f (FromStringShow2 f a a)
    $cmapM :: forall k (f :: k -> * -> *) (a :: k) (m :: * -> *) a b.
    (Traversable (f a), Monad m) =>
    (a -> m b) -> FromStringShow2 f a a -> m (FromStringShow2 f a b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromStringShow2 f a a -> m (FromStringShow2 f a b)
    $csequence :: forall k (f :: k -> * -> *) (a :: k) (m :: * -> *) a.
    (Traversable (f a), Monad m) =>
    FromStringShow2 f a (m a) -> m (FromStringShow2 f a a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    FromStringShow2 f a (m a) -> m (FromStringShow2 f a a)
    Traversable
               )

    instance Read (f a b) => Read (FromStringShow2 f a b) where
        readPrec :: ReadPrec (FromStringShow2 f a b)
    readPrec     = ReadPrec (f a b) -> ReadPrec (FromStringShow2 f a b)
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec (f a b)
    forall a. Read a => ReadPrec a
    readPrec     :: ReadPrec (f a b))
        readsPrec :: Int -> ReadS (FromStringShow2 f a b)
    readsPrec    = (Int -> ReadS (f a b)) -> Int -> ReadS (FromStringShow2 f a b)
    forall a b. Coercible a b => a -> b
    coerce (Int -> ReadS (f a b)
    forall a. Read a => Int -> ReadS a
    readsPrec    :: Int -> ReadS (f a b))
        readList :: ReadS [FromStringShow2 f a b]
    readList     = ReadS [f a b] -> ReadS [FromStringShow2 f a b]
    forall a b. Coercible a b => a -> b
    coerce (ReadS [f a b]
    forall a. Read a => ReadS [a]
    readList     :: ReadS [f a b])
        readListPrec :: ReadPrec [FromStringShow2 f a b]
    readListPrec = ReadPrec [f a b] -> ReadPrec [FromStringShow2 f a b]
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec [f a b]
    forall a. Read a => ReadPrec [a]
    readListPrec :: ReadPrec [f a b])

    -- TODO: Manually implement this when you can derive Show2 (someday)
    deriving instance Show2 f => Show2 (FromStringShow2 f)

    -- | This instance is somewhat strange, as its instance context mixes a
    -- 'Show2' constraint with 'TextShow' constraints. This is done for consistency
    -- with the 'Show' instance for 'FromTextShow2', which mixes constraints in a
    -- similar way to satisfy superclass constraints. See the Haddocks on the
    -- 'Show' instance for 'FromTextShow2' for more details.
    instance (Show2 f, TextShow a, TextShow b) => TextShow (FromStringShow2 f a b) where
        showbPrec :: Int -> FromStringShow2 f a b -> Builder
    showbPrec = Int -> FromStringShow2 f a b -> Builder
    forall (f :: * -> * -> *) a b.
    (TextShow2 f, TextShow a, TextShow b) =>
    Int -> f a b -> Builder
    showbPrec2

    -- | This instance is somewhat strange, as its instance context mixes a
    -- 'Show2' constraint with a 'TextShow' constraint. This is done for
    -- consistency with the 'Show1' instance for 'FromTextShow2', which mixes
    -- constraints in a similar way to satisfy superclass constraints. See the
    -- Haddocks on the 'Show1' instance for 'FromTextShow2' for more details.
    instance (Show2 f, TextShow a) => TextShow1 (FromStringShow2 f a) where
        liftShowbPrec :: forall a.
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> Int -> FromStringShow2 f a a -> Builder
    liftShowbPrec = (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> Int
    -> FromStringShow2 f a a
    -> Builder
    forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> FromStringShow2 f a b
    -> Builder
    forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> f a b
    -> Builder
    liftShowbPrec2 Int -> a -> Builder
    forall a. TextShow a => Int -> a -> Builder
    showbPrec [a] -> Builder
    forall a. TextShow a => [a] -> Builder
    showbList
        liftShowbList :: forall a.
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> [FromStringShow2 f a a] -> Builder
    liftShowbList = (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> [FromStringShow2 f a a]
    -> Builder
    forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [FromStringShow2 f a b]
    -> Builder
    forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [f a b]
    -> Builder
    liftShowbList2 Int -> a -> Builder
    forall a. TextShow a => Int -> a -> Builder
    showbPrec [a] -> Builder
    forall a. TextShow a => [a] -> Builder
    showbList

    instance Show2 f => TextShow2 (FromStringShow2 f) where
        liftShowbPrec2 :: forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> FromStringShow2 f a b
    -> Builder
    liftShowbPrec2 Int -> a -> Builder
    sp1 [a] -> Builder
    sl1 Int -> b -> Builder
    sp2 [b] -> Builder
    sl2 Int
    p =
            (Int -> f a b -> ShowS) -> Int -> f a b -> Builder
    forall a. (Int -> a -> ShowS) -> Int -> a -> Builder
    showsPrecToShowbPrec ((Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> Int
    -> f a b
    -> ShowS
    forall a b.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> Int
    -> f a b
    -> ShowS
    forall (f :: * -> * -> *) a b.
    Show2 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> Int
    -> f a b
    -> ShowS
    liftShowsPrec2 ((Int -> a -> Builder) -> Int -> a -> ShowS
    forall a. (Int -> a -> Builder) -> Int -> a -> ShowS
    showbPrecToShowsPrec Int -> a -> Builder
    sp1)
                                                 (([a] -> Builder) -> [a] -> ShowS
    forall a. (a -> Builder) -> a -> ShowS
    showbToShows         [a] -> Builder
    sl1)
                                                 ((Int -> b -> Builder) -> Int -> b -> ShowS
    forall a. (Int -> a -> Builder) -> Int -> a -> ShowS
    showbPrecToShowsPrec Int -> b -> Builder
    sp2)
                                                 (([b] -> Builder) -> [b] -> ShowS
    forall a. (a -> Builder) -> a -> ShowS
    showbToShows         [b] -> Builder
    sl2))
                                 Int
    p (f a b -> Builder)
    -> (FromStringShow2 f a b -> f a b)
    -> FromStringShow2 f a b
    -> Builder
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FromStringShow2 f a b -> f a b
    forall {k} {k} (f :: k -> k -> *) (a :: k) (b :: k).
    FromStringShow2 f a b -> f a b
    fromStringShow2
        liftShowbList2 :: forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [FromStringShow2 f a b]
    -> Builder
    liftShowbList2 Int -> a -> Builder
    sp1 [a] -> Builder
    sl1 Int -> b -> Builder
    sp2 [b] -> Builder
    sl2 =
            ([f a b] -> ShowS) -> [f a b] -> Builder
    forall a. (a -> ShowS) -> a -> Builder
    showsToShowb ((Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> [f a b]
    -> ShowS
    forall a b.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> [f a b]
    -> ShowS
    forall (f :: * -> * -> *) a b.
    Show2 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> [f a b]
    -> ShowS
    liftShowList2 ((Int -> a -> Builder) -> Int -> a -> ShowS
    forall a. (Int -> a -> Builder) -> Int -> a -> ShowS
    showbPrecToShowsPrec Int -> a -> Builder
    sp1)
                                        (([a] -> Builder) -> [a] -> ShowS
    forall a. (a -> Builder) -> a -> ShowS
    showbToShows         [a] -> Builder
    sl1)
                                        ((Int -> b -> Builder) -> Int -> b -> ShowS
    forall a. (Int -> a -> Builder) -> Int -> a -> ShowS
    showbPrecToShowsPrec Int -> b -> Builder
    sp2)
                                        (([b] -> Builder) -> [b] -> ShowS
    forall a. (a -> Builder) -> a -> ShowS
    showbToShows         [b] -> Builder
    sl2))
                         ([f a b] -> Builder)
    -> ([FromStringShow2 f a b] -> [f a b])
    -> [FromStringShow2 f a b]
    -> Builder
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [FromStringShow2 f a b] -> [f a b]
    forall a b. [FromStringShow2 f a b] -> [f a b]
    coerceList
          where
            coerceList :: [FromStringShow2 f a b] -> [f a b]
            coerceList :: forall a b. [FromStringShow2 f a b] -> [f a b]
    coerceList = [FromStringShow2 f a b] -> [f a b]
    forall a b. Coercible a b => a -> b
    coerce

    instance (Show2 f, Show a, Show b) => Show (FromStringShow2 f a b) where
        showsPrec :: Int -> FromStringShow2 f a b -> ShowS
    showsPrec = Int -> FromStringShow2 f a b -> ShowS
    forall (f :: * -> * -> *) a b.
    (Show2 f, Show a, Show b) =>
    Int -> f a b -> ShowS
    showsPrec2
        showList :: [FromStringShow2 f a b] -> ShowS
    showList  = (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> [FromStringShow2 f a b]
    -> ShowS
    forall a b.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> [FromStringShow2 f a b]
    -> ShowS
    forall (f :: * -> * -> *) a b.
    Show2 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> [f a b]
    -> ShowS
    liftShowList2 Int -> a -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec [a] -> ShowS
    forall a. Show a => [a] -> ShowS
    showList Int -> b -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec [b] -> ShowS
    forall a. Show a => [a] -> ShowS
    showList

    instance (Show2 f, Show a) => Show1 (FromStringShow2 f a) where
        liftShowsPrec :: forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> Int -> FromStringShow2 f a a -> ShowS
    liftShowsPrec = (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> Int
    -> FromStringShow2 f a a
    -> ShowS
    forall a b.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> Int
    -> FromStringShow2 f a b
    -> ShowS
    forall (f :: * -> * -> *) a b.
    Show2 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> Int
    -> f a b
    -> ShowS
    liftShowsPrec2 Int -> a -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec [a] -> ShowS
    forall a. Show a => [a] -> ShowS
    showList
        liftShowList :: forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [FromStringShow2 f a a] -> ShowS
    liftShowList  = (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> [FromStringShow2 f a a]
    -> ShowS
    forall a b.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> [FromStringShow2 f a b]
    -> ShowS
    forall (f :: * -> * -> *) a b.
    Show2 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> [f a b]
    -> ShowS
    liftShowList2  Int -> a -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec [a] -> ShowS
    forall a. Show a => [a] -> ShowS
    showList

    -------------------------------------------------------------------------------

    -- | An adapter newtype, suitable for @DerivingVia@.
    -- The @String@ 'Show2' instance for 'FromTextShow2' is based on its
    -- 'TextShow2' instance. That is,
    --
    -- @
    -- liftShowsPrec2 sp1 sl1 sp2 sl2 p ('FromTextShow2' x) =
    --     'showbPrecToShowsPrec' ('liftShowbPrec2' ('showsPrecToShowbPrec' sp1)
    --                                              ('showsToShowb'         sl1)
    --                                              ('showsPrecToShowbPrec' sp2)
    --                                              ('showsToShowb'         sl2))
    --                            p x
    -- @
    --
    -- /Since: 3/
    newtype FromTextShow2 f a b = FromTextShow2 { forall {k} {k} (f :: k -> k -> *) (a :: k) (b :: k).
    FromTextShow2 f a b -> f a b
    fromTextShow2 :: f a b }
      deriving ( FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    (FromTextShow2 f a b -> FromTextShow2 f a b -> Bool)
    -> (FromTextShow2 f a b -> FromTextShow2 f a b -> Bool)
    -> Eq (FromTextShow2 f a b)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Eq (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    $c== :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Eq (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    == :: FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    $c/= :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Eq (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    /= :: FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    Eq
               , Typeable (FromTextShow2 f a b)
    Typeable (FromTextShow2 f a b) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> FromTextShow2 f a b
     -> c (FromTextShow2 f a b))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (FromTextShow2 f a b))
    -> (FromTextShow2 f a b -> Constr)
    -> (FromTextShow2 f a b -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow2 f a b)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (FromTextShow2 f a b)))
    -> ((forall b. Data b => b -> b)
        -> FromTextShow2 f a b -> FromTextShow2 f a b)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FromTextShow2 f a b -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FromTextShow2 f a b -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> FromTextShow2 f a b -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FromTextShow2 f a b -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> FromTextShow2 f a b -> m (FromTextShow2 f a b))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromTextShow2 f a b -> m (FromTextShow2 f a b))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FromTextShow2 f a b -> m (FromTextShow2 f a b))
    -> Data (FromTextShow2 f a b)
    FromTextShow2 f a b -> Constr
    FromTextShow2 f a b -> DataType
    (forall b. Data b => b -> b)
    -> FromTextShow2 f a b -> FromTextShow2 f a b
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> FromTextShow2 f a b -> u
    forall u.
    (forall d. Data d => d -> u) -> FromTextShow2 f a b -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow2 f a b -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow2 f a b -> r
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    Typeable (FromTextShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    FromTextShow2 f a b -> Constr
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    FromTextShow2 f a b -> DataType
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall b. Data b => b -> b)
    -> FromTextShow2 f a b -> FromTextShow2 f a b
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) u.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    Int -> (forall d. Data d => d -> u) -> FromTextShow2 f a b -> u
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) u.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall d. Data d => d -> u) -> FromTextShow2 f a b -> [u]
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) r r'.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow2 f a b -> r
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) r r'.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow2 f a b -> r
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow2 f a b -> m (FromTextShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow2 f a b -> m (FromTextShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromTextShow2 f a b
    -> c (FromTextShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (t :: * -> *)
           (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow2 f a b))
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (t :: * -> * -> *)
           (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow2 f a b))
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow2 f a b -> m (FromTextShow2 f a b)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow2 f a b -> m (FromTextShow2 f a b)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow2 f a b)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromTextShow2 f a b
    -> c (FromTextShow2 f a b)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow2 f a b))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow2 f a b))
    $cgfoldl :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromTextShow2 f a b
    -> c (FromTextShow2 f a b)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> FromTextShow2 f a b
    -> c (FromTextShow2 f a b)
    $cgunfold :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow2 f a b)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FromTextShow2 f a b)
    $ctoConstr :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    FromTextShow2 f a b -> Constr
    toConstr :: FromTextShow2 f a b -> Constr
    $cdataTypeOf :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    FromTextShow2 f a b -> DataType
    dataTypeOf :: FromTextShow2 f a b -> DataType
    $cdataCast1 :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (t :: * -> *)
           (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow2 f a b))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FromTextShow2 f a b))
    $cdataCast2 :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (t :: * -> * -> *)
           (c :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow2 f a b))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FromTextShow2 f a b))
    $cgmapT :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall b. Data b => b -> b)
    -> FromTextShow2 f a b -> FromTextShow2 f a b
    gmapT :: (forall b. Data b => b -> b)
    -> FromTextShow2 f a b -> FromTextShow2 f a b
    $cgmapQl :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) r r'.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow2 f a b -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow2 f a b -> r
    $cgmapQr :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) r r'.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow2 f a b -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FromTextShow2 f a b -> r
    $cgmapQ :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) u.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    (forall d. Data d => d -> u) -> FromTextShow2 f a b -> [u]
    gmapQ :: forall u.
    (forall d. Data d => d -> u) -> FromTextShow2 f a b -> [u]
    $cgmapQi :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) u.
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b)) =>
    Int -> (forall d. Data d => d -> u) -> FromTextShow2 f a b -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> FromTextShow2 f a b -> u
    $cgmapM :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), Monad m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow2 f a b -> m (FromTextShow2 f a b)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow2 f a b -> m (FromTextShow2 f a b)
    $cgmapMp :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow2 f a b -> m (FromTextShow2 f a b)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow2 f a b -> m (FromTextShow2 f a b)
    $cgmapMo :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Typeable a, Typeable b, Typeable f, Typeable k, Typeable k,
     Data (f a b), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FromTextShow2 f a b -> m (FromTextShow2 f a b)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FromTextShow2 f a b -> m (FromTextShow2 f a b)
    Data
               , Eq (FromTextShow2 f a b)
    Eq (FromTextShow2 f a b) =>
    (FromTextShow2 f a b -> FromTextShow2 f a b -> Ordering)
    -> (FromTextShow2 f a b -> FromTextShow2 f a b -> Bool)
    -> (FromTextShow2 f a b -> FromTextShow2 f a b -> Bool)
    -> (FromTextShow2 f a b -> FromTextShow2 f a b -> Bool)
    -> (FromTextShow2 f a b -> FromTextShow2 f a b -> Bool)
    -> (FromTextShow2 f a b
        -> FromTextShow2 f a b -> FromTextShow2 f a b)
    -> (FromTextShow2 f a b
        -> FromTextShow2 f a b -> FromTextShow2 f a b)
    -> Ord (FromTextShow2 f a b)
    FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    FromTextShow2 f a b -> FromTextShow2 f a b -> Ordering
    FromTextShow2 f a b -> FromTextShow2 f a b -> FromTextShow2 f a b
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    Eq (FromTextShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> Ordering
    forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> FromTextShow2 f a b
    $ccompare :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> Ordering
    compare :: FromTextShow2 f a b -> FromTextShow2 f a b -> Ordering
    $c< :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    < :: FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    $c<= :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    <= :: FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    $c> :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    > :: FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    $c>= :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    >= :: FromTextShow2 f a b -> FromTextShow2 f a b -> Bool
    $cmax :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> FromTextShow2 f a b
    max :: FromTextShow2 f a b -> FromTextShow2 f a b -> FromTextShow2 f a b
    $cmin :: forall k k (f :: k -> k -> *) (a :: k) (b :: k).
    Ord (f a b) =>
    FromTextShow2 f a b -> FromTextShow2 f a b -> FromTextShow2 f a b
    min :: FromTextShow2 f a b -> FromTextShow2 f a b -> FromTextShow2 f a b
    Ord
               , (forall m. Monoid m => FromTextShow2 f a m -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromTextShow2 f a a -> m)
    -> (forall m a. Monoid m => (a -> m) -> FromTextShow2 f a a -> m)
    -> (forall a b. (a -> b -> b) -> b -> FromTextShow2 f a a -> b)
    -> (forall a b. (a -> b -> b) -> b -> FromTextShow2 f a a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromTextShow2 f a a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FromTextShow2 f a a -> b)
    -> (forall a. (a -> a -> a) -> FromTextShow2 f a a -> a)
    -> (forall a. (a -> a -> a) -> FromTextShow2 f a a -> a)
    -> (forall a. FromTextShow2 f a a -> [a])
    -> (forall a. FromTextShow2 f a a -> Bool)
    -> (forall a. FromTextShow2 f a a -> Int)
    -> (forall a. Eq a => a -> FromTextShow2 f a a -> Bool)
    -> (forall a. Ord a => FromTextShow2 f a a -> a)
    -> (forall a. Ord a => FromTextShow2 f a a -> a)
    -> (forall a. Num a => FromTextShow2 f a a -> a)
    -> (forall a. Num a => FromTextShow2 f a a -> a)
    -> Foldable (FromTextShow2 f a)
    forall a. Eq a => a -> FromTextShow2 f a a -> Bool
    forall a. Num a => FromTextShow2 f a a -> a
    forall a. Ord a => FromTextShow2 f a a -> a
    forall m. Monoid m => FromTextShow2 f a m -> m
    forall a. FromTextShow2 f a a -> Bool
    forall a. FromTextShow2 f a a -> Int
    forall a. FromTextShow2 f a a -> [a]
    forall a. (a -> a -> a) -> FromTextShow2 f a a -> a
    forall m a. Monoid m => (a -> m) -> FromTextShow2 f a a -> m
    forall b a. (b -> a -> b) -> b -> FromTextShow2 f a a -> b
    forall a b. (a -> b -> b) -> b -> FromTextShow2 f a a -> b
    forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Eq a) =>
    a -> FromTextShow2 f a a -> Bool
    forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Num a) =>
    FromTextShow2 f a a -> a
    forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Ord a) =>
    FromTextShow2 f a a -> a
    forall k (f :: k -> * -> *) (a :: k) m.
    (Foldable (f a), Monoid m) =>
    FromTextShow2 f a m -> m
    forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromTextShow2 f a a -> Bool
    forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromTextShow2 f a a -> Int
    forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromTextShow2 f a a -> [a]
    forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    (a -> a -> a) -> FromTextShow2 f a a -> a
    forall k (f :: k -> * -> *) (a :: k) m a.
    (Foldable (f a), Monoid m) =>
    (a -> m) -> FromTextShow2 f a a -> m
    forall k (f :: k -> * -> *) (a :: k) b a.
    Foldable (f a) =>
    (b -> a -> b) -> b -> FromTextShow2 f a a -> b
    forall k (f :: k -> * -> *) (a :: k) a b.
    Foldable (f a) =>
    (a -> b -> b) -> b -> FromTextShow2 f a a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall k (f :: k -> * -> *) (a :: k) m.
    (Foldable (f a), Monoid m) =>
    FromTextShow2 f a m -> m
    fold :: forall m. Monoid m => FromTextShow2 f a m -> m
    $cfoldMap :: forall k (f :: k -> * -> *) (a :: k) m a.
    (Foldable (f a), Monoid m) =>
    (a -> m) -> FromTextShow2 f a a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> FromTextShow2 f a a -> m
    $cfoldMap' :: forall k (f :: k -> * -> *) (a :: k) m a.
    (Foldable (f a), Monoid m) =>
    (a -> m) -> FromTextShow2 f a a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> FromTextShow2 f a a -> m
    $cfoldr :: forall k (f :: k -> * -> *) (a :: k) a b.
    Foldable (f a) =>
    (a -> b -> b) -> b -> FromTextShow2 f a a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> FromTextShow2 f a a -> b
    $cfoldr' :: forall k (f :: k -> * -> *) (a :: k) a b.
    Foldable (f a) =>
    (a -> b -> b) -> b -> FromTextShow2 f a a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> FromTextShow2 f a a -> b
    $cfoldl :: forall k (f :: k -> * -> *) (a :: k) b a.
    Foldable (f a) =>
    (b -> a -> b) -> b -> FromTextShow2 f a a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> FromTextShow2 f a a -> b
    $cfoldl' :: forall k (f :: k -> * -> *) (a :: k) b a.
    Foldable (f a) =>
    (b -> a -> b) -> b -> FromTextShow2 f a a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> FromTextShow2 f a a -> b
    $cfoldr1 :: forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    (a -> a -> a) -> FromTextShow2 f a a -> a
    foldr1 :: forall a. (a -> a -> a) -> FromTextShow2 f a a -> a
    $cfoldl1 :: forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    (a -> a -> a) -> FromTextShow2 f a a -> a
    foldl1 :: forall a. (a -> a -> a) -> FromTextShow2 f a a -> a
    $ctoList :: forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromTextShow2 f a a -> [a]
    toList :: forall a. FromTextShow2 f a a -> [a]
    $cnull :: forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromTextShow2 f a a -> Bool
    null :: forall a. FromTextShow2 f a a -> Bool
    $clength :: forall k (f :: k -> * -> *) (a :: k) a.
    Foldable (f a) =>
    FromTextShow2 f a a -> Int
    length :: forall a. FromTextShow2 f a a -> Int
    $celem :: forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Eq a) =>
    a -> FromTextShow2 f a a -> Bool
    elem :: forall a. Eq a => a -> FromTextShow2 f a a -> Bool
    $cmaximum :: forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Ord a) =>
    FromTextShow2 f a a -> a
    maximum :: forall a. Ord a => FromTextShow2 f a a -> a
    $cminimum :: forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Ord a) =>
    FromTextShow2 f a a -> a
    minimum :: forall a. Ord a => FromTextShow2 f a a -> a
    $csum :: forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Num a) =>
    FromTextShow2 f a a -> a
    sum :: forall a. Num a => FromTextShow2 f a a -> a
    $cproduct :: forall k (f :: k -> * -> *) (a :: k) a.
    (Foldable (f a), Num a) =>
    FromTextShow2 f a a -> a
    product :: forall a. Num a => FromTextShow2 f a a -> a
    Foldable
               , (forall a b.
     (a -> b) -> FromTextShow2 f a a -> FromTextShow2 f a b)
    -> (forall a b. a -> FromTextShow2 f a b -> FromTextShow2 f a a)
    -> Functor (FromTextShow2 f a)
    forall a b. a -> FromTextShow2 f a b -> FromTextShow2 f a a
    forall a b. (a -> b) -> FromTextShow2 f a a -> FromTextShow2 f a b
    forall k (f :: k -> * -> *) (a :: k) a b.
    Functor (f a) =>
    a -> FromTextShow2 f a b -> FromTextShow2 f a a
    forall k (f :: k -> * -> *) (a :: k) a b.
    Functor (f a) =>
    (a -> b) -> FromTextShow2 f a a -> FromTextShow2 f a b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall k (f :: k -> * -> *) (a :: k) a b.
    Functor (f a) =>
    (a -> b) -> FromTextShow2 f a a -> FromTextShow2 f a b
    fmap :: forall a b. (a -> b) -> FromTextShow2 f a a -> FromTextShow2 f a b
    $c<$ :: forall k (f :: k -> * -> *) (a :: k) a b.
    Functor (f a) =>
    a -> FromTextShow2 f a b -> FromTextShow2 f a a
    <$ :: forall a b. a -> FromTextShow2 f a b -> FromTextShow2 f a a
    Functor
               , (forall x. FromTextShow2 f a b -> Rep (FromTextShow2 f a b) x)
    -> (forall x. Rep (FromTextShow2 f a b) x -> FromTextShow2 f a b)
    -> Generic (FromTextShow2 f a b)
    forall x. Rep (FromTextShow2 f a b) x -> FromTextShow2 f a b
    forall x. FromTextShow2 f a b -> Rep (FromTextShow2 f a b) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) x.
    Rep (FromTextShow2 f a b) x -> FromTextShow2 f a b
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) x.
    FromTextShow2 f a b -> Rep (FromTextShow2 f a b) x
    $cfrom :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) x.
    FromTextShow2 f a b -> Rep (FromTextShow2 f a b) x
    from :: forall x. FromTextShow2 f a b -> Rep (FromTextShow2 f a b) x
    $cto :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) x.
    Rep (FromTextShow2 f a b) x -> FromTextShow2 f a b
    to :: forall x. Rep (FromTextShow2 f a b) x -> FromTextShow2 f a b
    Generic
               , (forall (a :: k).
     FromTextShow2 f a a -> Rep1 (FromTextShow2 f a) a)
    -> (forall (a :: k).
        Rep1 (FromTextShow2 f a) a -> FromTextShow2 f a a)
    -> Generic1 (FromTextShow2 f a)
    forall (a :: k). Rep1 (FromTextShow2 f a) a -> FromTextShow2 f a a
    forall (a :: k). FromTextShow2 f a a -> Rep1 (FromTextShow2 f a) a
    forall k k (f :: k -> k -> *) (a :: k) (a :: k).
    Rep1 (FromTextShow2 f a) a -> FromTextShow2 f a a
    forall k k (f :: k -> k -> *) (a :: k) (a :: k).
    FromTextShow2 f a a -> Rep1 (FromTextShow2 f a) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall k k (f :: k -> k -> *) (a :: k) (a :: k).
    FromTextShow2 f a a -> Rep1 (FromTextShow2 f a) a
    from1 :: forall (a :: k). FromTextShow2 f a a -> Rep1 (FromTextShow2 f a) a
    $cto1 :: forall k k (f :: k -> k -> *) (a :: k) (a :: k).
    Rep1 (FromTextShow2 f a) a -> FromTextShow2 f a a
    to1 :: forall (a :: k). Rep1 (FromTextShow2 f a) a -> FromTextShow2 f a a
    Generic1
               , (forall (m :: * -> *). Quote m => FromTextShow2 f a b -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        FromTextShow2 f a b -> Code m (FromTextShow2 f a b))
    -> Lift (FromTextShow2 f a b)
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Lift (f a b), Quote m) =>
    FromTextShow2 f a b -> m Exp
    forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Lift (f a b), Quote m) =>
    FromTextShow2 f a b -> Code m (FromTextShow2 f a b)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => FromTextShow2 f a b -> m Exp
    forall (m :: * -> *).
    Quote m =>
    FromTextShow2 f a b -> Code m (FromTextShow2 f a b)
    $clift :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Lift (f a b), Quote m) =>
    FromTextShow2 f a b -> m Exp
    lift :: forall (m :: * -> *). Quote m => FromTextShow2 f a b -> m Exp
    $cliftTyped :: forall k k (f :: k -> k -> *) (a :: k) (b :: k) (m :: * -> *).
    (Lift (f a b), Quote m) =>
    FromTextShow2 f a b -> Code m (FromTextShow2 f a b)
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    FromTextShow2 f a b -> Code m (FromTextShow2 f a b)
    Lift
               , (forall a. TextShow a => TextShow1 (FromTextShow2 f a)) =>
    (forall a b.
     (Int -> a -> Builder)
     -> ([a] -> Builder)
     -> (Int -> b -> Builder)
     -> ([b] -> Builder)
     -> Int
     -> FromTextShow2 f a b
     -> Builder)
    -> (forall a b.
        (Int -> a -> Builder)
        -> ([a] -> Builder)
        -> (Int -> b -> Builder)
        -> ([b] -> Builder)
        -> [FromTextShow2 f a b]
        -> Builder)
    -> TextShow2 (FromTextShow2 f)
    forall a. TextShow a => TextShow1 (FromTextShow2 f a)
    forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> FromTextShow2 f a b
    -> Builder
    forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [FromTextShow2 f a b]
    -> Builder
    forall (f :: * -> * -> *) a.
    (TextShow2 f, TextShow a) =>
    TextShow1 (FromTextShow2 f a)
    forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> FromTextShow2 f a b
    -> Builder
    forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [FromTextShow2 f a b]
    -> Builder
    forall (f :: * -> * -> *).
    (forall a. TextShow a => TextShow1 (f a)) =>
    (forall a b.
     (Int -> a -> Builder)
     -> ([a] -> Builder)
     -> (Int -> b -> Builder)
     -> ([b] -> Builder)
     -> Int
     -> f a b
     -> Builder)
    -> (forall a b.
        (Int -> a -> Builder)
        -> ([a] -> Builder)
        -> (Int -> b -> Builder)
        -> ([b] -> Builder)
        -> [f a b]
        -> Builder)
    -> TextShow2 f
    $cliftShowbPrec2 :: forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> FromTextShow2 f a b
    -> Builder
    liftShowbPrec2 :: forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> FromTextShow2 f a b
    -> Builder
    $cliftShowbList2 :: forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [FromTextShow2 f a b]
    -> Builder
    liftShowbList2 :: forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [FromTextShow2 f a b]
    -> Builder
    TextShow2
               , Functor (FromTextShow2 f a)
    Foldable (FromTextShow2 f a)
    (Functor (FromTextShow2 f a), Foldable (FromTextShow2 f a)) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> FromTextShow2 f a a -> f (FromTextShow2 f a b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        FromTextShow2 f a (f a) -> f (FromTextShow2 f a a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> FromTextShow2 f a a -> m (FromTextShow2 f a b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        FromTextShow2 f a (m a) -> m (FromTextShow2 f a a))
    -> Traversable (FromTextShow2 f a)
    forall k (f :: k -> * -> *) (a :: k).
    Traversable (f a) =>
    Functor (FromTextShow2 f a)
    forall k (f :: k -> * -> *) (a :: k).
    Traversable (f a) =>
    Foldable (FromTextShow2 f a)
    forall k (f :: k -> * -> *) (a :: k) (m :: * -> *) a.
    (Traversable (f a), Monad m) =>
    FromTextShow2 f a (m a) -> m (FromTextShow2 f a a)
    forall k (f :: k -> * -> *) (a :: k) (f :: * -> *) a.
    (Traversable (f a), Applicative f) =>
    FromTextShow2 f a (f a) -> f (FromTextShow2 f a a)
    forall k (f :: k -> * -> *) (a :: k) (m :: * -> *) a b.
    (Traversable (f a), Monad m) =>
    (a -> m b) -> FromTextShow2 f a a -> m (FromTextShow2 f a b)
    forall k (f :: k -> * -> *) (a :: k) (f :: * -> *) a b.
    (Traversable (f a), Applicative f) =>
    (a -> f b) -> FromTextShow2 f a a -> f (FromTextShow2 f a b)
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    FromTextShow2 f a (m a) -> m (FromTextShow2 f a a)
    forall (f :: * -> *) a.
    Applicative f =>
    FromTextShow2 f a (f a) -> f (FromTextShow2 f a a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromTextShow2 f a a -> m (FromTextShow2 f a b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromTextShow2 f a a -> f (FromTextShow2 f a b)
    $ctraverse :: forall k (f :: k -> * -> *) (a :: k) (f :: * -> *) a b.
    (Traversable (f a), Applicative f) =>
    (a -> f b) -> FromTextShow2 f a a -> f (FromTextShow2 f a b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FromTextShow2 f a a -> f (FromTextShow2 f a b)
    $csequenceA :: forall k (f :: k -> * -> *) (a :: k) (f :: * -> *) a.
    (Traversable (f a), Applicative f) =>
    FromTextShow2 f a (f a) -> f (FromTextShow2 f a a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FromTextShow2 f a (f a) -> f (FromTextShow2 f a a)
    $cmapM :: forall k (f :: k -> * -> *) (a :: k) (m :: * -> *) a b.
    (Traversable (f a), Monad m) =>
    (a -> m b) -> FromTextShow2 f a a -> m (FromTextShow2 f a b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FromTextShow2 f a a -> m (FromTextShow2 f a b)
    $csequence :: forall k (f :: k -> * -> *) (a :: k) (m :: * -> *) a.
    (Traversable (f a), Monad m) =>
    FromTextShow2 f a (m a) -> m (FromTextShow2 f a a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    FromTextShow2 f a (m a) -> m (FromTextShow2 f a a)
    Traversable
               )

    instance Read (f a b) => Read (FromTextShow2 f a b) where
        readPrec :: ReadPrec (FromTextShow2 f a b)
    readPrec     = ReadPrec (f a b) -> ReadPrec (FromTextShow2 f a b)
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec (f a b)
    forall a. Read a => ReadPrec a
    readPrec     :: ReadPrec (f a b))
        readsPrec :: Int -> ReadS (FromTextShow2 f a b)
    readsPrec    = (Int -> ReadS (f a b)) -> Int -> ReadS (FromTextShow2 f a b)
    forall a b. Coercible a b => a -> b
    coerce (Int -> ReadS (f a b)
    forall a. Read a => Int -> ReadS a
    readsPrec    :: Int -> ReadS (f a b))
        readList :: ReadS [FromTextShow2 f a b]
    readList     = ReadS [f a b] -> ReadS [FromTextShow2 f a b]
    forall a b. Coercible a b => a -> b
    coerce (ReadS [f a b]
    forall a. Read a => ReadS [a]
    readList     :: ReadS [f a b])
        readListPrec :: ReadPrec [FromTextShow2 f a b]
    readListPrec = ReadPrec [f a b] -> ReadPrec [FromTextShow2 f a b]
    forall a b. Coercible a b => a -> b
    coerce (ReadPrec [f a b]
    forall a. Read a => ReadPrec [a]
    readListPrec :: ReadPrec [f a b])

    -- | This instance is somewhat strange, as its instance context mixes a
    -- 'TextShow2' constraint with 'Show' constraints. The 'Show' constraints are
    -- necessary to satisfy the quantified 'Show' superclass in 'Show2'. Really,
    -- the 'Show' constraints ought to be 'TextShow' constraints instead, but GHC
    -- has no way of knowing that the 'TextShow' constraints can be converted to
    -- 'Show' constraints when checking superclasses.
    --
    -- This is all to say: this instance is almost surely not what you want if you
    -- are looking to derive a 'Show' instance only via 'TextShow'-related
    -- classes. If you wish to do this, derive via 'FromTextShow' instead.
    instance (TextShow2 f, Show a, Show b) => Show (FromTextShow2 f a b) where
      showsPrec :: Int -> FromTextShow2 f a b -> ShowS
    showsPrec = Int -> FromTextShow2 f a b -> ShowS
    forall (f :: * -> * -> *) a b.
    (Show2 f, Show a, Show b) =>
    Int -> f a b -> ShowS
    showsPrec2

    -- | This instance is somewhat strange, as its instance context mixes a
    -- 'TextShow2' constraint with a 'Show' constraint. The 'Show' constraint is
    -- necessary to satisfy the quantified 'Show' superclass in 'Show2'. Really,
    -- the 'Show' constraint ought to be a 'TextShow' constraint instead, but GHC
    -- has no way of knowing that the 'TextShow' constraint can be converted to a
    -- 'Show' constraint when checking superclasses.
    --
    -- This is all to say: this instance is almost surely not what you want if you
    -- are looking to derive a 'Show1' instance only via 'TextShow'-related
    -- classes. If you wish to do this, derive via 'FromTextShow1' instead.
    instance (TextShow2 f, Show a) => Show1 (FromTextShow2 f a) where
        liftShowsPrec :: forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> Int -> FromTextShow2 f a a -> ShowS
    liftShowsPrec = (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> Int
    -> FromTextShow2 f a a
    -> ShowS
    forall a b.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> Int
    -> FromTextShow2 f a b
    -> ShowS
    forall (f :: * -> * -> *) a b.
    Show2 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> Int
    -> f a b
    -> ShowS
    liftShowsPrec2 Int -> a -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec [a] -> ShowS
    forall a. Show a => [a] -> ShowS
    showList
        liftShowList :: forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [FromTextShow2 f a a] -> ShowS
    liftShowList = (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> [FromTextShow2 f a a]
    -> ShowS
    forall a b.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> [FromTextShow2 f a b]
    -> ShowS
    forall (f :: * -> * -> *) a b.
    Show2 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> [f a b]
    -> ShowS
    liftShowList2 Int -> a -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec [a] -> ShowS
    forall a. Show a => [a] -> ShowS
    showList

    instance TextShow2 f => Show2 (FromTextShow2 f) where
        liftShowsPrec2 :: forall a b.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> Int
    -> FromTextShow2 f a b
    -> ShowS
    liftShowsPrec2 Int -> a -> ShowS
    sp1 [a] -> ShowS
    sl1 Int -> b -> ShowS
    sp2 [b] -> ShowS
    sl2 Int
    p =
            (Int -> f a b -> Builder) -> Int -> f a b -> ShowS
    forall a. (Int -> a -> Builder) -> Int -> a -> ShowS
    showbPrecToShowsPrec ((Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> f a b
    -> Builder
    forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> f a b
    -> Builder
    forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> f a b
    -> Builder
    liftShowbPrec2 ((Int -> a -> ShowS) -> Int -> a -> Builder
    forall a. (Int -> a -> ShowS) -> Int -> a -> Builder
    showsPrecToShowbPrec Int -> a -> ShowS
    sp1)
                                                 (([a] -> ShowS) -> [a] -> Builder
    forall a. (a -> ShowS) -> a -> Builder
    showsToShowb         [a] -> ShowS
    sl1)
                                                 ((Int -> b -> ShowS) -> Int -> b -> Builder
    forall a. (Int -> a -> ShowS) -> Int -> a -> Builder
    showsPrecToShowbPrec Int -> b -> ShowS
    sp2)
                                                 (([b] -> ShowS) -> [b] -> Builder
    forall a. (a -> ShowS) -> a -> Builder
    showsToShowb         [b] -> ShowS
    sl2))
                                 Int
    p (f a b -> ShowS)
    -> (FromTextShow2 f a b -> f a b) -> FromTextShow2 f a b -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FromTextShow2 f a b -> f a b
    forall {k} {k} (f :: k -> k -> *) (a :: k) (b :: k).
    FromTextShow2 f a b -> f a b
    fromTextShow2
        liftShowList2 :: forall a b.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> [FromTextShow2 f a b]
    -> ShowS
    liftShowList2 Int -> a -> ShowS
    sp1 [a] -> ShowS
    sl1 Int -> b -> ShowS
    sp2 [b] -> ShowS
    sl2 =
            ([f a b] -> Builder) -> [f a b] -> ShowS
    forall a. (a -> Builder) -> a -> ShowS
    showbToShows ((Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [f a b]
    -> Builder
    forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [f a b]
    -> Builder
    forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [f a b]
    -> Builder
    liftShowbList2 ((Int -> a -> ShowS) -> Int -> a -> Builder
    forall a. (Int -> a -> ShowS) -> Int -> a -> Builder
    showsPrecToShowbPrec Int -> a -> ShowS
    sp1)
                                         (([a] -> ShowS) -> [a] -> Builder
    forall a. (a -> ShowS) -> a -> Builder
    showsToShowb         [a] -> ShowS
    sl1)
                                         ((Int -> b -> ShowS) -> Int -> b -> Builder
    forall a. (Int -> a -> ShowS) -> Int -> a -> Builder
    showsPrecToShowbPrec Int -> b -> ShowS
    sp2)
                                         (([b] -> ShowS) -> [b] -> Builder
    forall a. (a -> ShowS) -> a -> Builder
    showsToShowb         [b] -> ShowS
    sl2))
                         ([f a b] -> ShowS)
    -> ([FromTextShow2 f a b] -> [f a b])
    -> [FromTextShow2 f a b]
    -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [FromTextShow2 f a b] -> [f a b]
    forall a b. [FromTextShow2 f a b] -> [f a b]
    coerceList
          where
            coerceList :: [FromTextShow2 f a b] -> [f a b]
            coerceList :: forall a b. [FromTextShow2 f a b] -> [f a b]
    coerceList = [FromTextShow2 f a b] -> [f a b]
    forall a b. Coercible a b => a -> b
    coerce

    instance (TextShow2 f, TextShow a, TextShow b) => TextShow (FromTextShow2 f a b) where
        showbPrec :: Int -> FromTextShow2 f a b -> Builder
    showbPrec = Int -> FromTextShow2 f a b -> Builder
    forall (f :: * -> * -> *) a b.
    (TextShow2 f, TextShow a, TextShow b) =>
    Int -> f a b -> Builder
    showbPrec2
        showbList :: [FromTextShow2 f a b] -> Builder
    showbList = (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [FromTextShow2 f a b]
    -> Builder
    forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [FromTextShow2 f a b]
    -> Builder
    forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [f a b]
    -> Builder
    liftShowbList2 Int -> a -> Builder
    forall a. TextShow a => Int -> a -> Builder
    showbPrec [a] -> Builder
    forall a. TextShow a => [a] -> Builder
    showbList Int -> b -> Builder
    forall a. TextShow a => Int -> a -> Builder
    showbPrec [b] -> Builder
    forall a. TextShow a => [a] -> Builder
    showbList

    instance (TextShow2 f, TextShow a) => TextShow1 (FromTextShow2 f a) where
        liftShowbPrec :: forall a.
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> Int -> FromTextShow2 f a a -> Builder
    liftShowbPrec = (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> Int
    -> FromTextShow2 f a a
    -> Builder
    forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> FromTextShow2 f a b
    -> Builder
    forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> Int
    -> f a b
    -> Builder
    liftShowbPrec2 Int -> a -> Builder
    forall a. TextShow a => Int -> a -> Builder
    showbPrec [a] -> Builder
    forall a. TextShow a => [a] -> Builder
    showbList
        liftShowbList :: forall a.
    (Int -> a -> Builder)
    -> ([a] -> Builder) -> [FromTextShow2 f a a] -> Builder
    liftShowbList = (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> [FromTextShow2 f a a]
    -> Builder
    forall a b.
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [FromTextShow2 f a b]
    -> Builder
    forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Builder)
    -> ([a] -> Builder)
    -> (Int -> b -> Builder)
    -> ([b] -> Builder)
    -> [f a b]
    -> Builder
    liftShowbList2 Int -> a -> Builder
    forall a. TextShow a => Int -> a -> Builder
    showbPrec [a] -> Builder
    forall a. TextShow a => [a] -> Builder
    showbList

    -------------------------------------------------------------------------------

    $(deriveBifunctor     ''FromStringShow2)
    $(deriveBifunctor     ''FromTextShow2)
    $(deriveBifoldable    ''FromStringShow2)
    $(deriveBifoldable    ''FromTextShow2)
    $(deriveBitraversable ''FromStringShow2)
    $(deriveBitraversable ''FromTextShow2)