    {-# LANGUAGE CPP                        #-}
    {-# LANGUAGE DeriveDataTypeable         #-}
    {-# LANGUAGE OverloadedStrings          #-}
    {-# LANGUAGE StandaloneDeriving         #-}

    #if __GLASGOW_HASKELL__ >= 806
    {-# LANGUAGE QuantifiedConstraints      #-}
    #endif

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

    The 'TextShow', 'TextShow1', and 'TextShow2' typeclasses.
    -}
    module TextShow.Classes where

    import           Data.Data (Typeable)
    import qualified Data.Text         as TS (Text, singleton)
    import qualified Data.Text.IO      as TS (putStrLn, hPutStrLn)
    import qualified Data.Text.Lazy    as TL (Text, singleton)
    import qualified Data.Text.Lazy.IO as TL (putStrLn, hPutStrLn)
    import           Data.Text.Lazy (toStrict)
    import           Data.Text.Lazy.Builder (Builder, fromLazyText, fromString,
                                             fromText, singleton, toLazyText)

    import           GHC.Show (appPrec, appPrec1)

    import           Prelude ()
    import           Prelude.Compat

    import           System.IO (Handle)

    import           TextShow.Utils (toString, toText)

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

    -- | Conversion of values to @Text@. Because there are both strict and lazy @Text@
    -- variants, the 'TextShow' class deliberately avoids using @Text@ in its functions.
    -- Instead, 'showbPrec', 'showb', and 'showbList' all return 'Builder', an
    -- efficient intermediate form that can be converted to either kind of @Text@.
    --
    -- 'Builder' is a 'Monoid', so it is useful to use the 'mappend' (or '<>') function
    -- to combine 'Builder's when creating 'TextShow' instances. As an example:
    --
    -- @
    -- import Data.Semigroup
    -- import TextShow
    --
    -- data Example = Example Int Int
    -- instance TextShow Example where
    --     showb (Example i1 i2) = showb i1 <> showbSpace <> showb i2
    -- @
    --
    -- If you do not want to create 'TextShow' instances manually, you can alternatively
    -- use the "TextShow.TH" module to automatically generate default 'TextShow'
    -- instances using Template Haskell, or the "TextShow.Generic" module to
    -- quickly define 'TextShow' instances using "GHC.Generics".
    --
    -- /Since: 2/
    class TextShow a where
        -- | Convert a value to a 'Builder' with the given predence.
        --
        -- /Since: 2/
        showbPrec :: Int -- ^ The operator precedence of the enclosing context (a number
                         -- from @0@ to @11@). Function application has precedence @10@.
                  -> a   -- ^ The value to be converted to a 'Builder'.
                  -> Builder
        showbPrec Int
    _ = a -> Builder
    forall a. TextShow a => a -> Builder
    showb

        -- | Converts a value to a strict 'TS.Text'. If you hand-define this, it should
        -- satisfy:
        --
        -- @
        -- 'showb' = 'showbPrec' 0
        -- @
        --
        -- /Since: 2/
        showb :: a -- ^ The value to be converted to a 'Builder'.
              -> Builder
        showb = Int -> a -> Builder
    forall a. TextShow a => Int -> a -> Builder
    showbPrec Int
    0

        -- | Converts a list of values to a 'Builder'. By default, this is defined as
        -- @'showbList = 'showbListWith' 'showb'@, but it can be overridden to allow
        -- for specialized displaying of lists (e.g., lists of 'Char's).
        --
        -- /Since: 2/
        showbList :: [a] -- ^ The list of values to be converted to a 'Builder'.
                  -> Builder
        showbList = (a -> Builder) -> [a] -> Builder
    forall a. (a -> Builder) -> [a] -> Builder
    showbListWith a -> Builder
    forall a. TextShow a => a -> Builder
    showb

        -- | Converts a value to a strict 'TS.Text' with the given precedence. This
        -- can be overridden for efficiency, but it should satisfy:
        --
        -- @
        -- 'showtPrec' p = 'toStrict' . 'showtlPrec' p
        -- @
        --
        -- /Since: 3/
        showtPrec :: Int -- ^ The operator precedence of the enclosing context (a number
                         -- from @0@ to @11@). Function application has precedence @10@.
                  -> a   -- ^ The value to be converted to a strict 'TS.Text'.
                  -> TS.Text
        showtPrec Int
    p = Text -> Text
    toStrict (Text -> Text) -> (a -> Text) -> a -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> Text
    forall a. TextShow a => Int -> a -> Text
    showtlPrec Int
    p

        -- | Converts a value to a strict 'TS.Text'. This can be overridden for
        -- efficiency, but it should satisfy:
        --
        -- @
        -- 'showt' = 'showtPrec' 0
        -- 'showt' = 'toStrict' . 'showtl'
        -- @
        --
        -- The first equation is the default definition of 'showt'.
        --
        -- /Since: 3/
        showt :: a -- ^ The value to be converted to a strict 'TS.Text'.
              -> TS.Text
        showt = Int -> a -> Text
    forall a. TextShow a => Int -> a -> Text
    showtPrec Int
    0

        -- | Converts a list of values to a strict 'TS.Text'. This can be overridden for
        -- efficiency, but it should satisfy:
        --
        -- @
        -- 'showtList' = 'toStrict' . 'showtlList'
        -- @
        --
        -- /Since: 3/
        showtList :: [a] -- ^ The list of values to be converted to a strict 'TS.Text'.
                  -> TS.Text
        showtList = Text -> Text
    toStrict (Text -> Text) -> ([a] -> Text) -> [a] -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [a] -> Text
    forall a. TextShow a => [a] -> Text
    showtlList

        -- | Converts a value to a lazy 'TL.Text' with the given precedence. This
        -- can be overridden for efficiency, but it should satisfy:
        --
        -- @
        -- 'showtlPrec' p = 'toLazyText' . 'showbPrec' p
        -- @
        --
        -- /Since: 3/
        showtlPrec :: Int -- ^ The operator precedence of the enclosing context (a number
                          -- from @0@ to @11@). Function application has precedence @10@.
                   -> a   -- ^ The value to be converted to a lazy 'TL.Text'.
                   -> TL.Text
        showtlPrec Int
    p = Builder -> Text
    toLazyText (Builder -> Text) -> (a -> Builder) -> a -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> Builder
    forall a. TextShow a => Int -> a -> Builder
    showbPrec Int
    p

        -- | Converts a value to a lazy 'TL.Text'. This can be overridden for
        -- efficiency, but it should satisfy:
        --
        -- @
        -- 'showtl' = 'showtlPrec' 0
        -- 'showtl' = 'toLazyText' . 'showb'
        -- @
        --
        -- The first equation is the default definition of 'showtl'.
        --
        -- /Since: 3/
        showtl :: a -- ^ The value to be converted to a lazy 'TL.Text'.
               -> TL.Text
        showtl = Int -> a -> Text
    forall a. TextShow a => Int -> a -> Text
    showtlPrec Int
    0

        -- | Converts a list of values to a lazy 'TL.Text'. This can be overridden for
        -- efficiency, but it should satisfy:
        --
        -- @
        -- 'showtlList' = 'toLazyText' . 'showbList'
        -- @
        --
        -- /Since: 3/
        showtlList :: [a] -- ^ The list of values to be converted to a lazy 'TL.Text'.
                   -> TL.Text
        showtlList = Builder -> Text
    toLazyText (Builder -> Text) -> ([a] -> Builder) -> [a] -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [a] -> Builder
    forall a. TextShow a => [a] -> Builder
    showbList

        {-# MINIMAL showbPrec | showb #-}

    deriving instance Typeable TextShow

    -- | Surrounds 'Builder' output with parentheses if the 'Bool' parameter is 'True'.
    --
    -- /Since: 2/
    showbParen :: Bool -> Builder -> Builder
    showbParen :: Bool -> Builder -> Builder
    showbParen Bool
    p Builder
    builder | Bool
    p         = Char -> Builder
    singleton Char
    '(' Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> Builder
    builder Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> Char -> Builder
    singleton Char
    ')'
                         | Bool
    otherwise = Builder
    builder

    -- | Construct a 'Builder' containing a comma followed by a space.
    --
    -- /Since: 3.6/
    showbCommaSpace :: Builder
    showbCommaSpace :: Builder
    showbCommaSpace = Builder
    ", "

    -- | Construct a 'Builder' containing a single space character.
    --
    -- /Since: 2/
    showbSpace :: Builder
    showbSpace :: Builder
    showbSpace = Char -> Builder
    singleton Char
    ' '

    -- | Converts a list of values into a 'Builder' in which the values are surrounded
    -- by square brackets and each value is separated by a comma. The function argument
    -- controls how each element is shown.
    --
    -- @'showbListWith' 'showb'@ is the default implementation of 'showbList' save for
    -- a few special cases (e.g., 'String').
    --
    -- /Since: 2/
    showbListWith :: (a -> Builder) -> [a] -> Builder
    showbListWith :: forall a. (a -> Builder) -> [a] -> Builder
    showbListWith a -> Builder
    _      []     = Builder
    "[]"
    showbListWith a -> Builder
    showbx (a
    x:[a]
    xs) = Char -> Builder
    singleton Char
    '[' Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> a -> Builder
    showbx a
    x Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> [a] -> Builder
    go [a]
    xs -- "[..
      where
        go :: [a] -> Builder
    go (a
    y:[a]
    ys) = Char -> Builder
    singleton Char
    ',' Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> a -> Builder
    showbx a
    y Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> [a] -> Builder
    go [a]
    ys               -- ..,..
        go []     = Char -> Builder
    singleton Char
    ']'                                    -- ..]"

    -- | Surrounds strict 'TS.Text' output with parentheses if the 'Bool' parameter is 'True'.
    --
    -- /Since: 3.4/
    showtParen :: Bool -> TS.Text -> TS.Text
    showtParen :: Bool -> Text -> Text
    showtParen Bool
    p Text
    t | Bool
    p         = Char -> Text
    TS.singleton Char
    '(' Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    t Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Char -> Text
    TS.singleton Char
    ')'
                   | Bool
    otherwise = Text
    t

    -- | Construct a strict 'TS.Text' containing a comma followed by a space.
    --
    -- /Since: 3.6/
    showtCommaSpace :: TS.Text
    showtCommaSpace :: Text
    showtCommaSpace = Text
    ", "

    -- | Construct a strict 'TS.Text' containing a single space character.
    --
    -- /Since: 3.4/
    showtSpace :: TS.Text
    showtSpace :: Text
    showtSpace = Char -> Text
    TS.singleton Char
    ' '

    -- | Converts a list of values into a strict 'TS.Text' in which the values are surrounded
    -- by square brackets and each value is separated by a comma. The function argument
    -- controls how each element is shown.
    --
    -- /Since: 3.4/
    showtListWith :: (a -> TS.Text) -> [a] -> TS.Text
    showtListWith :: forall a. (a -> Text) -> [a] -> Text
    showtListWith a -> Text
    _      []     = Text
    "[]"
    showtListWith a -> Text
    showtx (a
    x:[a]
    xs) = Char -> Text
    TS.singleton Char
    '[' Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> a -> Text
    showtx a
    x Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> [a] -> Text
    go [a]
    xs -- "[..
      where
        go :: [a] -> Text
    go (a
    y:[a]
    ys) = Char -> Text
    TS.singleton Char
    ',' Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> a -> Text
    showtx a
    y Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> [a] -> Text
    go [a]
    ys               -- ..,..
        go []     = Char -> Text
    TS.singleton Char
    ']'                                    -- ..]"

    -- | Surrounds lazy 'TL.Text' output with parentheses if the 'Bool' parameter is 'True'.
    --
    -- /Since: 3.4/
    showtlParen :: Bool -> TL.Text -> TL.Text
    showtlParen :: Bool -> Text -> Text
    showtlParen Bool
    p Text
    t | Bool
    p         = Char -> Text
    TL.singleton Char
    '(' Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    t Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Char -> Text
    TL.singleton Char
    ')'
                    | Bool
    otherwise = Text
    t
    {-# INLINE showtlParen #-}

    -- | Construct a lazy 'TL.Text' containing a comma followed by a space.
    --
    -- /Since: 3.6/
    showtlCommaSpace :: TL.Text
    showtlCommaSpace :: Text
    showtlCommaSpace = Text
    ", "

    -- | Construct a lazy 'TL.Text' containing a single space character.
    --
    -- /Since: 3.4/
    showtlSpace :: TL.Text
    showtlSpace :: Text
    showtlSpace = Char -> Text
    TL.singleton Char
    ' '

    -- | Converts a list of values into a lazy 'TL.Text' in which the values are surrounded
    -- by square brackets and each value is separated by a comma. The function argument
    -- controls how each element is shown.
    --
    -- /Since: 3.4/
    showtlListWith :: (a -> TL.Text) -> [a] -> TL.Text
    showtlListWith :: forall a. (a -> Text) -> [a] -> Text
    showtlListWith a -> Text
    _       []     = Text
    "[]"
    showtlListWith a -> Text
    showtlx (a
    x:[a]
    xs) = Char -> Text
    TL.singleton Char
    '[' Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> a -> Text
    showtlx a
    x Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> [a] -> Text
    go [a]
    xs -- "[..
      where
        go :: [a] -> Text
    go (a
    y:[a]
    ys) = Char -> Text
    TL.singleton Char
    ',' Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> a -> Text
    showtlx a
    y Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> [a] -> Text
    go [a]
    ys                 -- ..,..
        go []     = Char -> Text
    TL.singleton Char
    ']'                                       -- ..]"

    -- | Writes a value's strict 'TS.Text' representation to the standard output, followed
    --   by a newline.
    --
    -- /Since: 2/
    printT :: TextShow a => a -> IO ()
    printT :: forall a. TextShow a => a -> IO ()
    printT = Text -> IO ()
    TS.putStrLn (Text -> IO ()) -> (a -> Text) -> a -> IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Text
    forall a. TextShow a => a -> Text
    showt
    {-# INLINE printT #-}

    -- | Writes a value's lazy 'TL.Text' representation to the standard output, followed
    --   by a newline.
    --
    -- /Since: 2/
    printTL :: TextShow a => a -> IO ()
    printTL :: forall a. TextShow a => a -> IO ()
    printTL = Text -> IO ()
    TL.putStrLn (Text -> IO ()) -> (a -> Text) -> a -> IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Text
    forall a. TextShow a => a -> Text
    showtl
    {-# INLINE printTL #-}

    -- | Writes a value's strict 'TS.Text' representation to a file handle, followed
    --   by a newline.
    --
    -- /Since: 2/
    hPrintT :: TextShow a => Handle -> a -> IO ()
    hPrintT :: forall a. TextShow a => Handle -> a -> IO ()
    hPrintT Handle
    h = Handle -> Text -> IO ()
    TS.hPutStrLn Handle
    h (Text -> IO ()) -> (a -> Text) -> a -> IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Text
    forall a. TextShow a => a -> Text
    showt
    {-# INLINE hPrintT #-}

    -- | Writes a value's lazy 'TL.Text' representation to a file handle, followed
    --   by a newline.
    --
    -- /Since: 2/
    hPrintTL :: TextShow a => Handle -> a -> IO ()
    hPrintTL :: forall a. TextShow a => Handle -> a -> IO ()
    hPrintTL Handle
    h = Handle -> Text -> IO ()
    TL.hPutStrLn Handle
    h (Text -> IO ()) -> (a -> Text) -> a -> IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Text
    forall a. TextShow a => a -> Text
    showtl
    {-# INLINE hPrintTL #-}

    -- | Convert a precedence-aware 'ShowS'-based show function to a 'Builder'-based one.
    --
    -- /Since: 3/
    showsPrecToShowbPrec :: (Int -> a -> ShowS) -> Int -> a -> Builder
    showsPrecToShowbPrec :: forall a. (Int -> a -> ShowS) -> Int -> a -> Builder
    showsPrecToShowbPrec Int -> a -> ShowS
    sp Int
    p a
    x = String -> Builder
    fromString (String -> Builder) -> String -> Builder
    forall a b. (a -> b) -> a -> b
    $ Int -> a -> ShowS
    sp Int
    p a
    x String
    ""
    {-# INLINE showsPrecToShowbPrec #-}

    -- | Convert a precedence-aware, strict 'TS.Text'-based show function to a 'Builder'-based one.
    --
    -- /Since: 3.4/
    showtPrecToShowbPrec :: (Int -> a -> TS.Text) -> Int -> a -> Builder
    showtPrecToShowbPrec :: forall a. (Int -> a -> Text) -> Int -> a -> Builder
    showtPrecToShowbPrec Int -> a -> Text
    sp Int
    p = Text -> Builder
    fromText (Text -> Builder) -> (a -> Text) -> a -> Builder
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> Text
    sp Int
    p
    {-# INLINE showtPrecToShowbPrec #-}

    -- | Convert a precedence-aware, lazy 'TL.Text'-based show function to a 'Builder'-based one.
    --
    -- /Since: 3.4/
    showtlPrecToShowbPrec :: (Int -> a -> TL.Text) -> Int -> a -> Builder
    showtlPrecToShowbPrec :: forall a. (Int -> a -> Text) -> Int -> a -> Builder
    showtlPrecToShowbPrec Int -> a -> Text
    sp Int
    p = Text -> Builder
    fromLazyText (Text -> Builder) -> (a -> Text) -> a -> Builder
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> Text
    sp Int
    p
    {-# INLINE showtlPrecToShowbPrec #-}

    -- | Convert a 'ShowS'-based show function to a 'Builder'-based one.
    --
    -- /Since: 3/
    showsToShowb :: (a -> ShowS) -> a -> Builder
    showsToShowb :: forall a. (a -> ShowS) -> a -> Builder
    showsToShowb a -> ShowS
    sf a
    x = String -> Builder
    fromString (String -> Builder) -> String -> Builder
    forall a b. (a -> b) -> a -> b
    $ a -> ShowS
    sf a
    x String
    ""
    {-# INLINE showsToShowb #-}

    -- | Convert a strict 'TS.Text'-based show function to a 'Builder'-based one.
    --
    -- /Since: 3.4/
    showtToShowb :: (a -> TS.Text) -> a -> Builder
    showtToShowb :: forall a. (a -> Text) -> a -> Builder
    showtToShowb a -> Text
    sf = Text -> Builder
    fromText (Text -> Builder) -> (a -> Text) -> a -> Builder
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Text
    sf
    {-# INLINE showtToShowb #-}

    -- | Convert a lazy 'TL.Text'-based show function to a 'Builder'-based one.
    --
    -- /Since: 3.4/
    showtlToShowb :: (a -> TL.Text) -> a -> Builder
    showtlToShowb :: forall a. (a -> Text) -> a -> Builder
    showtlToShowb a -> Text
    sf = Text -> Builder
    fromLazyText (Text -> Builder) -> (a -> Text) -> a -> Builder
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Text
    sf
    {-# INLINE showtlToShowb #-}

    -- | Convert a precedence-aware 'Builder'-based show function to a 'ShowS'-based one.
    --
    -- /Since: 3/
    showbPrecToShowsPrec :: (Int -> a -> Builder) -> Int -> a -> ShowS
    showbPrecToShowsPrec :: forall a. (Int -> a -> Builder) -> Int -> a -> ShowS
    showbPrecToShowsPrec Int -> a -> Builder
    sp Int
    p = String -> ShowS
    showString (String -> ShowS) -> (a -> String) -> a -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Builder -> String
    toString (Builder -> String) -> (a -> Builder) -> a -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> Builder
    sp Int
    p
    {-# INLINE showbPrecToShowsPrec #-}

    -- | Convert a precedence-aware 'Builder'-based show function to a strict 'TS.Text'-based one.
    --
    -- /Since: 3.4/
    showbPrecToShowtPrec :: (Int -> a -> Builder) -> Int -> a -> TS.Text
    showbPrecToShowtPrec :: forall a. (Int -> a -> Builder) -> Int -> a -> Text
    showbPrecToShowtPrec Int -> a -> Builder
    sp Int
    p = Builder -> Text
    toText (Builder -> Text) -> (a -> Builder) -> a -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> Builder
    sp Int
    p
    {-# INLINE showbPrecToShowtPrec #-}

    -- | Convert a precedence-aware 'Builder'-based show function to a lazy 'TL.Text'-based one.
    --
    -- /Since: 3.4/
    showbPrecToShowtlPrec :: (Int -> a -> Builder) -> Int -> a -> TL.Text
    showbPrecToShowtlPrec :: forall a. (Int -> a -> Builder) -> Int -> a -> Text
    showbPrecToShowtlPrec Int -> a -> Builder
    sp Int
    p = Builder -> Text
    toLazyText (Builder -> Text) -> (a -> Builder) -> a -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> Builder
    sp Int
    p
    {-# INLINE showbPrecToShowtlPrec #-}

    -- | Convert a 'Builder'-based show function to a 'ShowS'-based one.
    --
    -- /Since: 3/
    showbToShows :: (a -> Builder) -> a -> ShowS
    showbToShows :: forall a. (a -> Builder) -> a -> ShowS
    showbToShows a -> Builder
    sf = String -> ShowS
    showString (String -> ShowS) -> (a -> String) -> a -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Builder -> String
    toString (Builder -> String) -> (a -> Builder) -> a -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Builder
    sf
    {-# INLINE showbToShows #-}

    -- | Convert a 'Builder'-based show function to a strict 'TS.Text'-based one.
    --
    -- /Since: 3/
    showbToShowt :: (a -> Builder) -> a -> TS.Text
    showbToShowt :: forall a. (a -> Builder) -> a -> Text
    showbToShowt a -> Builder
    sf = Builder -> Text
    toText (Builder -> Text) -> (a -> Builder) -> a -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Builder
    sf
    {-# INLINE showbToShowt #-}

    -- | Convert a 'Builder'-based show function to a lazy 'TL.Text'-based one.
    --
    -- /Since: 3/
    showbToShowtl :: (a -> Builder) -> a -> TL.Text
    showbToShowtl :: forall a. (a -> Builder) -> a -> Text
    showbToShowtl a -> Builder
    sf = Builder -> Text
    toLazyText (Builder -> Text) -> (a -> Builder) -> a -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Builder
    sf
    {-# INLINE showbToShowtl #-}

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

    -- | Lifting of the 'TextShow' class to unary type constructors.
    --
    -- /Since: 2/
    class
    #if __GLASGOW_HASKELL__ >= 806
          (forall a. TextShow a => TextShow (f a)) =>
    #endif
          TextShow1 f where
        -- | 'showbPrec' function for an application of the type constructor
        -- based on 'showbPrec' and 'showbList' functions for the argument type.
        --
        -- /Since: 3/
        liftShowbPrec :: (Int -> a -> Builder) -> ([a] -> Builder)
                      -> Int -> f a -> Builder

        -- | 'showbList' function for an application of the type constructor
        -- based on 'showbPrec' and 'showbList' functions for the argument type.
        -- The default implementation using standard list syntax is correct
        -- for most types.
        --
        -- /Since: 3/
        liftShowbList :: (Int -> a -> Builder) -> ([a] -> Builder)
                      -> [f a] -> Builder
        liftShowbList Int -> a -> Builder
    sp [a] -> Builder
    sl = (f a -> Builder) -> [f a] -> Builder
    forall a. (a -> Builder) -> [a] -> Builder
    showbListWith ((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 -> Builder
    sp [a] -> Builder
    sl Int
    0)

        {-# MINIMAL liftShowbPrec #-}

    deriving instance Typeable TextShow1

    -- | Lift the standard 'showbPrec' and 'showbList' functions through the
    -- type constructor.
    --
    -- /Since: 2/
    showbPrec1 :: (TextShow1 f, TextShow a) => Int -> f a -> Builder
    showbPrec1 :: forall (f :: * -> *) a.
    (TextShow1 f, TextShow a) =>
    Int -> f a -> Builder
    showbPrec1 = (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 -> Builder
    forall a. TextShow a => Int -> a -> Builder
    showbPrec [a] -> Builder
    forall a. TextShow a => [a] -> Builder
    showbList
    {-# INLINE showbPrec1 #-}

    -- | @'showbUnaryWith' sp n p x@ produces the 'Builder' representation of a unary data
    -- constructor with name @n@ and argument @x@, in precedence context @p@, using the
    -- function @sp@ to show occurrences of the type argument.
    --
    -- /Since: 2/
    showbUnaryWith :: (Int -> a -> Builder) -> Builder -> Int -> a -> Builder
    showbUnaryWith :: forall a. (Int -> a -> Builder) -> Builder -> Int -> a -> Builder
    showbUnaryWith Int -> a -> Builder
    sp Builder
    nameB Int
    p a
    x = Bool -> Builder -> Builder
    showbParen (Int
    p Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    appPrec) (Builder -> Builder) -> Builder -> Builder
    forall a b. (a -> b) -> a -> b
    $
        Builder
    nameB Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> Builder
    showbSpace Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> Int -> a -> Builder
    sp Int
    appPrec1 a
    x
    {-# INLINE showbUnaryWith #-}

    -- | 'showtPrec' function for an application of the type constructor
    -- based on 'showtPrec' and 'showtList' functions for the argument type.
    --
    -- The current implementation is based on `liftShowbPrec` internally.
    --
    -- /Since: 3.4/
    liftShowtPrec :: TextShow1 f => (Int -> a -> TS.Text) -> ([a] -> TS.Text)
                  -> Int -> f a -> TS.Text
    liftShowtPrec :: forall (f :: * -> *) a.
    TextShow1 f =>
    (Int -> a -> Text) -> ([a] -> Text) -> Int -> f a -> Text
    liftShowtPrec Int -> a -> Text
    sp [a] -> Text
    sl = (Int -> f a -> Builder) -> Int -> f a -> Text
    forall a. (Int -> a -> Builder) -> Int -> a -> Text
    showbPrecToShowtPrec ((Int -> f a -> Builder) -> Int -> f a -> Text)
    -> (Int -> f a -> Builder) -> Int -> f a -> Text
    forall a b. (a -> b) -> a -> b
    $ (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 -> Text) -> Int -> a -> Builder
    forall a. (Int -> a -> Text) -> Int -> a -> Builder
    showtPrecToShowbPrec Int -> a -> Text
    sp) (([a] -> Text) -> [a] -> Builder
    forall a. (a -> Text) -> a -> Builder
    showtToShowb [a] -> Text
    sl)

    -- | 'showtlPrec' function for an application of the type constructor
    -- based on 'showtlPrec' and 'showtlList' functions for the argument type.
    --
    -- The current implementation is based on `liftShowbPrec` internally.
    --
    -- /Since: 3.4/
    liftShowtlPrec :: TextShow1 f => (Int -> a -> TL.Text) -> ([a] -> TL.Text)
                   -> Int -> f a -> TL.Text
    liftShowtlPrec :: forall (f :: * -> *) a.
    TextShow1 f =>
    (Int -> a -> Text) -> ([a] -> Text) -> Int -> f a -> Text
    liftShowtlPrec Int -> a -> Text
    sp [a] -> Text
    sl = (Int -> f a -> Builder) -> Int -> f a -> Text
    forall a. (Int -> a -> Builder) -> Int -> a -> Text
    showbPrecToShowtlPrec ((Int -> f a -> Builder) -> Int -> f a -> Text)
    -> (Int -> f a -> Builder) -> Int -> f a -> Text
    forall a b. (a -> b) -> a -> b
    $ (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 -> Text) -> Int -> a -> Builder
    forall a. (Int -> a -> Text) -> Int -> a -> Builder
    showtlPrecToShowbPrec Int -> a -> Text
    sp) (([a] -> Text) -> [a] -> Builder
    forall a. (a -> Text) -> a -> Builder
    showtlToShowb [a] -> Text
    sl)

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

    -- | Lifting of the 'TextShow' class to binary type constructors.
    --
    -- /Since: 2/
    class
    #if __GLASGOW_HASKELL__ >= 806
          ( forall a. TextShow a => TextShow1 (f a)
    # if __GLASGOW_HASKELL__ < 900
          -- Sadly, pre-9.0 versions of GHC have difficulty inferring this
          -- superclass from the one above due to
          -- https://gitlab.haskell.org/ghc/ghc/-/issues/17202.
          -- As a workaround, we manually expand the superclass above to assist
          -- type inference. Without doing this, the text-show test suite would
          -- not compile on pre-9.0 versions of GHC.
          , forall a b. (TextShow a, TextShow b) => TextShow (f a b)
    # endif
          ) =>
    #endif
          TextShow2 f where
        -- | 'showbPrec' function for an application of the type constructor
        -- based on 'showbPrec' and 'showbList' functions for the argument types.
        --
        -- /Since: 3/
        liftShowbPrec2 :: (Int -> a -> Builder) -> ([a] -> Builder)
                       -> (Int -> b -> Builder) -> ([b] -> Builder)
                       -> Int -> f a b -> Builder

        -- | 'showbList' function for an application of the type constructor
        -- based on 'showbPrec' and 'showbList' functions for the argument types.
        -- The default implementation using standard list syntax is correct
        -- for most types.
        --
        -- /Since: 3/
        liftShowbList2 :: (Int -> a -> Builder) -> ([a] -> Builder)
                       -> (Int -> b -> Builder) -> ([b] -> Builder)
                       -> [f a b] -> Builder
        liftShowbList2 Int -> a -> Builder
    sp1 [a] -> Builder
    sl1 Int -> b -> Builder
    sp2 [b] -> Builder
    sl2 =
            (f a b -> Builder) -> [f a b] -> Builder
    forall a. (a -> Builder) -> [a] -> Builder
    showbListWith ((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 -> Builder
    sp1 [a] -> Builder
    sl1 Int -> b -> Builder
    sp2 [b] -> Builder
    sl2 Int
    0)

        {-# MINIMAL liftShowbPrec2 #-}

    deriving instance Typeable TextShow2

    -- | Lift two 'showbPrec' functions through the type constructor.
    --
    -- /Since: 2/
    showbPrec2 :: (TextShow2 f, TextShow a, TextShow b) => Int -> f a b -> Builder
    showbPrec2 :: forall (f :: * -> * -> *) a b.
    (TextShow2 f, TextShow a, TextShow b) =>
    Int -> f a b -> Builder
    showbPrec2 = (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 -> 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
    {-# INLINE showbPrec2 #-}

    -- | @'showbBinaryWith' sp n p x y@ produces the 'Builder' representation of a binary
    -- data constructor with name @n@ and arguments @x@ and @y@, in precedence context
    -- @p@, using the functions @sp1@ and @sp2@ to show occurrences of the type arguments.
    --
    -- /Since: 2/
    showbBinaryWith :: (Int -> a -> Builder) -> (Int -> b -> Builder) ->
        Builder -> Int -> a -> b -> Builder
    showbBinaryWith :: forall a b.
    (Int -> a -> Builder)
    -> (Int -> b -> Builder) -> Builder -> Int -> a -> b -> Builder
    showbBinaryWith Int -> a -> Builder
    sp1 Int -> b -> Builder
    sp2 Builder
    nameB Int
    p a
    x b
    y = Bool -> Builder -> Builder
    showbParen (Int
    p Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    appPrec) (Builder -> Builder) -> Builder -> Builder
    forall a b. (a -> b) -> a -> b
    $ Builder
    nameB
        Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> Builder
    showbSpace Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> Int -> a -> Builder
    sp1 Int
    appPrec1 a
    x
        Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> Builder
    showbSpace Builder -> Builder -> Builder
    forall a. Semigroup a => a -> a -> a
    <> Int -> b -> Builder
    sp2 Int
    appPrec1 b
    y
    {-# INLINE showbBinaryWith #-}

    -- | 'showtPrec' function for an application of the type constructor
    -- based on 'showtPrec' and 'showtList' functions for the argument type.
    --
    -- The current implementation is based on `liftShowbPrec2` internally.
    --
    -- /Since: 3.4/
    liftShowtPrec2 :: TextShow2 f
                   => (Int -> a -> TS.Text) -> ([a] -> TS.Text)
                   -> (Int -> b -> TS.Text) -> ([b] -> TS.Text)
                   -> Int -> f a b -> TS.Text
    liftShowtPrec2 :: forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Text)
    -> ([a] -> Text)
    -> (Int -> b -> Text)
    -> ([b] -> Text)
    -> Int
    -> f a b
    -> Text
    liftShowtPrec2 Int -> a -> Text
    sp1 [a] -> Text
    sl1 Int -> b -> Text
    sp2 [b] -> Text
    sl2 = (Int -> f a b -> Builder) -> Int -> f a b -> Text
    forall a. (Int -> a -> Builder) -> Int -> a -> Text
    showbPrecToShowtPrec ((Int -> f a b -> Builder) -> Int -> f a b -> Text)
    -> (Int -> f a b -> Builder) -> Int -> f a b -> Text
    forall a b. (a -> b) -> 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)
    -> 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 -> Text) -> Int -> a -> Builder
    forall a. (Int -> a -> Text) -> Int -> a -> Builder
    showtPrecToShowbPrec Int -> a -> Text
    sp1) (([a] -> Text) -> [a] -> Builder
    forall a. (a -> Text) -> a -> Builder
    showtToShowb [a] -> Text
    sl1)
                       ((Int -> b -> Text) -> Int -> b -> Builder
    forall a. (Int -> a -> Text) -> Int -> a -> Builder
    showtPrecToShowbPrec Int -> b -> Text
    sp2) (([b] -> Text) -> [b] -> Builder
    forall a. (a -> Text) -> a -> Builder
    showtToShowb [b] -> Text
    sl2)

    -- | 'showtlPrec' function for an application of the type constructor
    -- based on 'showtlPrec' and 'showtlList' functions for the argument type.
    --
    -- The current implementation is based on `liftShowbPrec2` internally.
    --
    -- /Since: 3.4/
    liftShowtlPrec2 :: TextShow2 f
                    => (Int -> a -> TL.Text) -> ([a] -> TL.Text)
                    -> (Int -> b -> TL.Text) -> ([b] -> TL.Text)
                    -> Int -> f a b -> TL.Text
    liftShowtlPrec2 :: forall (f :: * -> * -> *) a b.
    TextShow2 f =>
    (Int -> a -> Text)
    -> ([a] -> Text)
    -> (Int -> b -> Text)
    -> ([b] -> Text)
    -> Int
    -> f a b
    -> Text
    liftShowtlPrec2 Int -> a -> Text
    sp1 [a] -> Text
    sl1 Int -> b -> Text
    sp2 [b] -> Text
    sl2 = (Int -> f a b -> Builder) -> Int -> f a b -> Text
    forall a. (Int -> a -> Builder) -> Int -> a -> Text
    showbPrecToShowtlPrec ((Int -> f a b -> Builder) -> Int -> f a b -> Text)
    -> (Int -> f a b -> Builder) -> Int -> f a b -> Text
    forall a b. (a -> b) -> 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)
    -> 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 -> Text) -> Int -> a -> Builder
    forall a. (Int -> a -> Text) -> Int -> a -> Builder
    showtlPrecToShowbPrec Int -> a -> Text
    sp1) (([a] -> Text) -> [a] -> Builder
    forall a. (a -> Text) -> a -> Builder
    showtlToShowb [a] -> Text
    sl1)
                       ((Int -> b -> Text) -> Int -> b -> Builder
    forall a. (Int -> a -> Text) -> Int -> a -> Builder
    showtlPrecToShowbPrec Int -> b -> Text
    sp2) (([b] -> Text) -> [b] -> Builder
    forall a. (a -> Text) -> a -> Builder
    showtlToShowb [b] -> Text
    sl2)