    {-# LANGUAGE CPP, DeriveDataTypeable,
                 DeriveGeneric, FlexibleInstances, DefaultSignatures,
                 RankNTypes, RoleAnnotations, ScopedTypeVariables,
                 MagicHash, KindSignatures, PolyKinds, TypeApplications, DataKinds,
                 GADTs, UnboxedTuples, UnboxedSums, TypeInType,
                 Trustworthy, DeriveFunctor #-}

    {-# OPTIONS_GHC -fno-warn-inline-rule-shadowing #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Language.Haskell.Syntax
    -- Copyright   :  (c) The University of Glasgow 2003
    -- License     :  BSD-style (see the file libraries/base/LICENSE)
    --
    -- Maintainer  :  libraries@haskell.org
    -- Stability   :  experimental
    -- Portability :  portable
    --
    -- Abstract syntax definitions for Template Haskell.
    --
    -----------------------------------------------------------------------------

    module Language.Haskell.TH.Syntax
        ( module Language.Haskell.TH.Syntax
          -- * Language extensions
        , module Language.Haskell.TH.LanguageExtensions
        , ForeignSrcLang(..)
        ) where

    import Data.Data hiding (Fixity(..))
    import Data.IORef
    import System.IO.Unsafe ( unsafePerformIO )
    import GHC.IO.Unsafe    ( unsafeDupableInterleaveIO )
    import Control.Monad (liftM)
    import Control.Monad.IO.Class (MonadIO (..))
    import Control.Monad.Fix (MonadFix (..))
    import Control.Applicative (liftA2)
    import Control.Exception (BlockedIndefinitelyOnMVar (..), catch, throwIO)
    import Control.Exception.Base (FixIOException (..))
    import Control.Concurrent.MVar (newEmptyMVar, readMVar, putMVar)
    import System.IO        ( hPutStrLn, stderr )
    import Data.Char        ( isAlpha, isAlphaNum, isUpper, ord )
    import Data.Int
    import Data.List.NonEmpty ( NonEmpty(..) )
    import Data.Void        ( Void, absurd )
    import Data.Word
    import Data.Ratio
    import GHC.CString      ( unpackCString# )
    import GHC.Generics     ( Generic )
    import GHC.Types        ( Int(..), Word(..), Char(..), Double(..), Float(..),
                              TYPE, RuntimeRep(..) )
    import GHC.Prim         ( Int#, Word#, Char#, Double#, Float#, Addr# )
    import GHC.Ptr          ( Ptr, plusPtr )
    import GHC.Lexeme       ( startsVarSym, startsVarId )
    import GHC.ForeignSrcLang.Type
    import Language.Haskell.TH.LanguageExtensions
    import Numeric.Natural
    import Prelude
    import Foreign.ForeignPtr
    import Foreign.C.String
    import Foreign.C.Types

    -----------------------------------------------------
    --
    --              The Quasi class
    --
    -----------------------------------------------------

    class (MonadIO m, MonadFail m) => Quasi m where
      qNewName :: String -> m Name
            -- ^ Fresh names

            -- Error reporting and recovery
      qReport  :: Bool -> String -> m ()    -- ^ Report an error (True) or warning (False)
                                            -- ...but carry on; use 'fail' to stop
      qRecover :: m a -- ^ the error handler
               -> m a -- ^ action which may fail
               -> m a               -- ^ Recover from the monadic 'fail'

            -- Inspect the type-checker's environment
      qLookupName :: Bool -> String -> m (Maybe Name)
           -- True <=> type namespace, False <=> value namespace
      qReify          :: Name -> m Info
      qReifyFixity    :: Name -> m (Maybe Fixity)
      qReifyType      :: Name -> m Type
      qReifyInstances :: Name -> [Type] -> m [Dec]
           -- Is (n tys) an instance?
           -- Returns list of matching instance Decs
           --    (with empty sub-Decs)
           -- Works for classes and type functions
      qReifyRoles         :: Name -> m [Role]
      qReifyAnnotations   :: Data a => AnnLookup -> m [a]
      qReifyModule        :: Module -> m ModuleInfo
      qReifyConStrictness :: Name -> m [DecidedStrictness]

      qLocation :: m Loc

      qRunIO :: IO a -> m a
      qRunIO = IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO
      -- ^ Input/output (dangerous)

      qAddDependentFile :: FilePath -> m ()

      qAddTempFile :: String -> m FilePath

      qAddTopDecls :: [Dec] -> m ()

      qAddForeignFilePath :: ForeignSrcLang -> String -> m ()

      qAddModFinalizer :: Q () -> m ()

      qAddCorePlugin :: String -> m ()

      qGetQ :: Typeable a => m (Maybe a)

      qPutQ :: Typeable a => a -> m ()

      qIsExtEnabled :: Extension -> m Bool
      qExtsEnabled :: m [Extension]

    -----------------------------------------------------
    --      The IO instance of Quasi
    --
    --  This instance is used only when running a Q
    --  computation in the IO monad, usually just to
    --  print the result.  There is no interesting
    --  type environment, so reification isn't going to
    --  work.
    --
    -----------------------------------------------------

    instance Quasi IO where
      qNewName :: String -> IO Name
    qNewName = String -> IO Name
    newNameIO

      qReport :: Bool -> String -> IO ()
    qReport Bool
    True  String
    msg = Handle -> String -> IO ()
    hPutStrLn Handle
    stderr (String
    "Template Haskell error: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    msg)
      qReport Bool
    False String
    msg = Handle -> String -> IO ()
    hPutStrLn Handle
    stderr (String
    "Template Haskell error: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    msg)

      qLookupName :: Bool -> String -> IO (Maybe Name)
    qLookupName Bool
    _ String
    _       = String -> IO (Maybe Name)
    forall a. String -> IO a
    badIO String
    "lookupName"
      qReify :: Name -> IO Info
    qReify Name
    _              = String -> IO Info
    forall a. String -> IO a
    badIO String
    "reify"
      qReifyFixity :: Name -> IO (Maybe Fixity)
    qReifyFixity Name
    _        = String -> IO (Maybe Fixity)
    forall a. String -> IO a
    badIO String
    "reifyFixity"
      qReifyType :: Name -> IO Type
    qReifyType Name
    _          = String -> IO Type
    forall a. String -> IO a
    badIO String
    "reifyFixity"
      qReifyInstances :: Name -> [Type] -> IO [Dec]
    qReifyInstances Name
    _ [Type]
    _   = String -> IO [Dec]
    forall a. String -> IO a
    badIO String
    "reifyInstances"
      qReifyRoles :: Name -> IO [Role]
    qReifyRoles Name
    _         = String -> IO [Role]
    forall a. String -> IO a
    badIO String
    "reifyRoles"
      qReifyAnnotations :: forall a. Data a => AnnLookup -> IO [a]
    qReifyAnnotations AnnLookup
    _   = String -> IO [a]
    forall a. String -> IO a
    badIO String
    "reifyAnnotations"
      qReifyModule :: Module -> IO ModuleInfo
    qReifyModule Module
    _        = String -> IO ModuleInfo
    forall a. String -> IO a
    badIO String
    "reifyModule"
      qReifyConStrictness :: Name -> IO [DecidedStrictness]
    qReifyConStrictness Name
    _ = String -> IO [DecidedStrictness]
    forall a. String -> IO a
    badIO String
    "reifyConStrictness"
      qLocation :: IO Loc
    qLocation             = String -> IO Loc
    forall a. String -> IO a
    badIO String
    "currentLocation"
      qRecover :: forall a. IO a -> IO a -> IO a
    qRecover IO a
    _ IO a
    _          = String -> IO a
    forall a. String -> IO a
    badIO String
    "recover" -- Maybe we could fix this?
      qAddDependentFile :: String -> IO ()
    qAddDependentFile String
    _   = String -> IO ()
    forall a. String -> IO a
    badIO String
    "addDependentFile"
      qAddTempFile :: String -> IO String
    qAddTempFile String
    _        = String -> IO String
    forall a. String -> IO a
    badIO String
    "addTempFile"
      qAddTopDecls :: [Dec] -> IO ()
    qAddTopDecls [Dec]
    _        = String -> IO ()
    forall a. String -> IO a
    badIO String
    "addTopDecls"
      qAddForeignFilePath :: ForeignSrcLang -> String -> IO ()
    qAddForeignFilePath ForeignSrcLang
    _ String
    _ = String -> IO ()
    forall a. String -> IO a
    badIO String
    "addForeignFilePath"
      qAddModFinalizer :: Q () -> IO ()
    qAddModFinalizer Q ()
    _    = String -> IO ()
    forall a. String -> IO a
    badIO String
    "addModFinalizer"
      qAddCorePlugin :: String -> IO ()
    qAddCorePlugin String
    _      = String -> IO ()
    forall a. String -> IO a
    badIO String
    "addCorePlugin"
      qGetQ :: forall a. Typeable a => IO (Maybe a)
    qGetQ                 = String -> IO (Maybe a)
    forall a. String -> IO a
    badIO String
    "getQ"
      qPutQ :: forall a. Typeable a => a -> IO ()
    qPutQ a
    _               = String -> IO ()
    forall a. String -> IO a
    badIO String
    "putQ"
      qIsExtEnabled :: Extension -> IO Bool
    qIsExtEnabled Extension
    _       = String -> IO Bool
    forall a. String -> IO a
    badIO String
    "isExtEnabled"
      qExtsEnabled :: IO [Extension]
    qExtsEnabled          = String -> IO [Extension]
    forall a. String -> IO a
    badIO String
    "extsEnabled"

    instance Quote IO where
      newName :: String -> IO Name
    newName = String -> IO Name
    newNameIO

    newNameIO :: String -> IO Name
    newNameIO :: String -> IO Name
    newNameIO String
    s = do { Uniq
    n <- IORef Uniq -> (Uniq -> (Uniq, Uniq)) -> IO Uniq
    forall a b. IORef a -> (a -> (a, b)) -> IO b
    atomicModifyIORef' IORef Uniq
    counter (\Uniq
    x -> (Uniq
    x Uniq -> Uniq -> Uniq
    forall a. Num a => a -> a -> a
    + Uniq
    1, Uniq
    x))
                     ; Name -> IO Name
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (String -> Uniq -> Name
    mkNameU String
    s Uniq
    n) }

    badIO :: String -> IO a
    badIO :: forall a. String -> IO a
    badIO String
    op = do   { Bool -> String -> IO ()
    forall (m :: * -> *). Quasi m => Bool -> String -> m ()
    qReport Bool
    True (String
    "Can't do `" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    op String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "' in the IO monad")
                    ; String -> IO a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Template Haskell failure" }

    -- Global variable to generate unique symbols
    counter :: IORef Uniq
    {-# NOINLINE counter #-}
    counter :: IORef Uniq
    counter = IO (IORef Uniq) -> IORef Uniq
    forall a. IO a -> a
    unsafePerformIO (Uniq -> IO (IORef Uniq)
    forall a. a -> IO (IORef a)
    newIORef Uniq
    0)

    -----------------------------------------------------
    --
    --              The Q monad
    --
    -----------------------------------------------------

    newtype Q a = Q { forall a. Q a -> forall (m :: * -> *). Quasi m => m a
    unQ :: forall m. Quasi m => m a }

    -- \"Runs\" the 'Q' monad. Normal users of Template Haskell
    -- should not need this function, as the splice brackets @$( ... )@
    -- are the usual way of running a 'Q' computation.
    --
    -- This function is primarily used in GHC internals, and for debugging
    -- splices by running them in 'IO'.
    --
    -- Note that many functions in 'Q', such as 'reify' and other compiler
    -- queries, are not supported when running 'Q' in 'IO'; these operations
    -- simply fail at runtime. Indeed, the only operations guaranteed to succeed
    -- are 'newName', 'runIO', 'reportError' and 'reportWarning'.
    runQ :: Quasi m => Q a -> m a
    runQ :: forall (m :: * -> *) a. Quasi m => Q a -> m a
    runQ (Q forall (m :: * -> *). Quasi m => m a
    m) = m a
    forall (m :: * -> *). Quasi m => m a
    m

    instance Monad Q where
      Q forall (m :: * -> *). Quasi m => m a
    m >>= :: forall a b. Q a -> (a -> Q b) -> Q b
    >>= a -> Q b
    k  = (forall (m :: * -> *). Quasi m => m b) -> Q b
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (m a
    forall (m :: * -> *). Quasi m => m a
    m m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \a
    x -> Q b -> forall (m :: * -> *). Quasi m => m b
    forall a. Q a -> forall (m :: * -> *). Quasi m => m a
    unQ (a -> Q b
    k a
    x))
      >> :: forall a b. Q a -> Q b -> Q b
    (>>) = Q a -> Q b -> Q b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    (*>)

    instance MonadFail Q where
      fail :: forall a. String -> Q a
    fail String
    s     = Bool -> String -> Q ()
    report Bool
    True String
    s Q () -> Q a -> Q a
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> (forall (m :: * -> *). Quasi m => m a) -> Q a
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (String -> m a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Q monad failure")

    instance Functor Q where
      fmap :: forall a b. (a -> b) -> Q a -> Q b
    fmap a -> b
    f (Q forall (m :: * -> *). Quasi m => m a
    x) = (forall (m :: * -> *). Quasi m => m b) -> Q b
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q ((a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> b
    f m a
    forall (m :: * -> *). Quasi m => m a
    x)

    instance Applicative Q where
      pure :: forall a. a -> Q a
    pure a
    x = (forall (m :: * -> *). Quasi m => m a) -> Q a
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    x)
      Q forall (m :: * -> *). Quasi m => m (a -> b)
    f <*> :: forall a b. Q (a -> b) -> Q a -> Q b
    <*> Q forall (m :: * -> *). Quasi m => m a
    x = (forall (m :: * -> *). Quasi m => m b) -> Q b
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (m (a -> b)
    forall (m :: * -> *). Quasi m => m (a -> b)
    f m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m a
    forall (m :: * -> *). Quasi m => m a
    x)
      Q forall (m :: * -> *). Quasi m => m a
    m *> :: forall a b. Q a -> Q b -> Q b
    *> Q forall (m :: * -> *). Quasi m => m b
    n = (forall (m :: * -> *). Quasi m => m b) -> Q b
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (m a
    forall (m :: * -> *). Quasi m => m a
    m m a -> m b -> m b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> m b
    forall (m :: * -> *). Quasi m => m b
    n)

    -- | @since 2.17.0.0
    instance Semigroup a => Semigroup (Q a) where
      <> :: Q a -> Q a -> Q a
    (<>) = (a -> a -> a) -> Q a -> Q a -> Q a
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 a -> a -> a
    forall a. Semigroup a => a -> a -> a
    (<>)

    -- | @since 2.17.0.0
    instance Monoid a => Monoid (Q a) where
      mempty :: Q a
    mempty = a -> Q a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    forall a. Monoid a => a
    mempty

    -- | If the function passed to 'mfix' inspects its argument,
    -- the resulting action will throw a 'FixIOException'.
    --
    -- @since 2.17.0.0
    instance MonadFix Q where
      -- We use the same blackholing approach as in fixIO.
      -- See Note [Blackholing in fixIO] in System.IO in base.
      mfix :: forall a. (a -> Q a) -> Q a
    mfix a -> Q a
    k = do
        MVar a
    m <- IO (MVar a) -> Q (MVar a)
    forall a. IO a -> Q a
    runIO IO (MVar a)
    forall a. IO (MVar a)
    newEmptyMVar
        a
    ans <- IO a -> Q a
    forall a. IO a -> Q a
    runIO (IO a -> IO a
    forall a. IO a -> IO a
    unsafeDupableInterleaveIO
                 (MVar a -> IO a
    forall a. MVar a -> IO a
    readMVar MVar a
    m IO a -> (BlockedIndefinitelyOnMVar -> IO a) -> IO a
    forall e a. Exception e => IO a -> (e -> IO a) -> IO a
    `catch` \BlockedIndefinitelyOnMVar
    BlockedIndefinitelyOnMVar ->
                                        FixIOException -> IO a
    forall e a. Exception e => e -> IO a
    throwIO FixIOException
    FixIOException))
        a
    result <- a -> Q a
    k a
    ans
        IO () -> Q ()
    forall a. IO a -> Q a
    runIO (MVar a -> a -> IO ()
    forall a. MVar a -> a -> IO ()
    putMVar MVar a
    m a
    result)
        a -> Q a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    result

    -----------------------------------------------------
    --
    --              The Quote class
    --
    -----------------------------------------------------

    -- | The 'Quote' class implements the minimal interface which is necessary for
    -- desugaring quotations.
    --
    -- * The @Monad m@ superclass is needed to stitch together the different
    -- AST fragments.
    -- * 'newName' is used when desugaring binding structures such as lambdas
    -- to generate fresh names.
    --
    -- Therefore the type of an untyped quotation in GHC is `Quote m => m Exp`
    --
    -- For many years the type of a quotation was fixed to be `Q Exp` but by
    -- more precisely specifying the minimal interface it enables the `Exp` to
    -- be extracted purely from the quotation without interacting with `Q`.
    class Monad m => Quote m where
      {- |
      Generate a fresh name, which cannot be captured.

      For example, this:

      @f = $(do
        nm1 <- newName \"x\"
        let nm2 = 'mkName' \"x\"
        return ('LamE' ['VarP' nm1] (LamE [VarP nm2] ('VarE' nm1)))
       )@

      will produce the splice

      >f = \x0 -> \x -> x0

      In particular, the occurrence @VarE nm1@ refers to the binding @VarP nm1@,
      and is not captured by the binding @VarP nm2@.

      Although names generated by @newName@ cannot /be captured/, they can
      /capture/ other names. For example, this:

      >g = $(do
      >  nm1 <- newName "x"
      >  let nm2 = mkName "x"
      >  return (LamE [VarP nm2] (LamE [VarP nm1] (VarE nm2)))
      > )

      will produce the splice

      >g = \x -> \x0 -> x0

      since the occurrence @VarE nm2@ is captured by the innermost binding
      of @x@, namely @VarP nm1@.
      -}
      newName :: String -> m Name

    instance Quote Q where
      newName :: String -> Q Name
    newName String
    s = (forall (m :: * -> *). Quasi m => m Name) -> Q Name
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (String -> m Name
    forall (m :: * -> *). Quasi m => String -> m Name
    qNewName String
    s)

    -----------------------------------------------------
    --
    --              The TExp type
    --
    -----------------------------------------------------

    type role TExp nominal   -- See Note [Role of TExp]
    newtype TExp (a :: TYPE (r :: RuntimeRep)) = TExp
      { forall a. TExp a -> Exp
    unType :: Exp -- ^ Underlying untyped Template Haskell expression
      }
    -- ^ Represents an expression which has type @a@. Built on top of 'Exp', typed
    -- expressions allow for type-safe splicing via:
    --
    --   - typed quotes, written as @[|| ... ||]@ where @...@ is an expression; if
    --     that expression has type @a@, then the quotation has type
    --     @'Q' ('TExp' a)@
    --
    --   - typed splices inside of typed quotes, written as @$$(...)@ where @...@
    --     is an arbitrary expression of type @'Q' ('TExp' a)@
    --
    -- Traditional expression quotes and splices let us construct ill-typed
    -- expressions:
    --
    -- >>> fmap ppr $ runQ [| True == $( [| "foo" |] ) |]
    -- GHC.Types.True GHC.Classes.== "foo"
    -- >>> GHC.Types.True GHC.Classes.== "foo"
    -- <interactive> error:
    --     • Couldn't match expected type ‘Bool’ with actual type ‘[Char]’
    --     • In the second argument of ‘(==)’, namely ‘"foo"’
    --       In the expression: True == "foo"
    --       In an equation for ‘it’: it = True == "foo"
    --
    -- With typed expressions, the type error occurs when /constructing/ the
    -- Template Haskell expression:
    --
    -- >>> fmap ppr $ runQ [|| True == $$( [|| "foo" ||] ) ||]
    -- <interactive> error:
    --     • Couldn't match type ‘[Char]’ with ‘Bool’
    --       Expected type: Q (TExp Bool)
    --         Actual type: Q (TExp [Char])
    --     • In the Template Haskell quotation [|| "foo" ||]
    --       In the expression: [|| "foo" ||]
    --       In the Template Haskell splice $$([|| "foo" ||])
    --
    -- Levity-polymorphic since /template-haskell-2.16.0.0/.

    -- | Discard the type annotation and produce a plain Template Haskell
    -- expression
    --
    -- Levity-polymorphic since /template-haskell-2.16.0.0/.
    unTypeQ :: forall (r :: RuntimeRep) (a :: TYPE r) m . Quote m => m (TExp a) -> m Exp
    unTypeQ :: forall a (m :: * -> *). Quote m => m (TExp a) -> m Exp
    unTypeQ m (TExp a)
    m = do { TExp Exp
    e <- m (TExp a)
    m
                   ; Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return Exp
    e }

    -- | Annotate the Template Haskell expression with a type
    --
    -- This is unsafe because GHC cannot check for you that the expression
    -- really does have the type you claim it has.
    --
    -- Levity-polymorphic since /template-haskell-2.16.0.0/.
    unsafeTExpCoerce :: forall (r :: RuntimeRep) (a :: TYPE r) m .
                          Quote m => m Exp -> m (TExp a)
    unsafeTExpCoerce :: forall a (m :: * -> *). Quote m => m Exp -> m (TExp a)
    unsafeTExpCoerce m Exp
    m = do { Exp
    e <- m Exp
    m
                            ; TExp a -> m (TExp a)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Exp -> TExp a
    forall a. Exp -> TExp a
    TExp Exp
    e) }

    {- Note [Role of TExp]
    ~~~~~~~~~~~~~~~~~~~~~~
    TExp's argument must have a nominal role, not phantom as would
    be inferred (#8459).  Consider

      e :: TExp Age
      e = MkAge 3

      foo = $(coerce e) + 4::Int

    The splice will evaluate to (MkAge 3) and you can't add that to
    4::Int. So you can't coerce a (TExp Age) to a (TExp Int). -}

    -- Code constructor

    type role Code representational nominal   -- See Note [Role of TExp]
    newtype Code m (a :: TYPE (r :: RuntimeRep)) = Code
      { forall (m :: * -> *) a. Code m a -> m (TExp a)
    examineCode :: m (TExp a) -- ^ Underlying monadic value
      }

    -- | Unsafely convert an untyped code representation into a typed code
    -- representation.
    unsafeCodeCoerce :: forall (r :: RuntimeRep) (a :: TYPE r) m .
                          Quote m => m Exp -> Code m a
    unsafeCodeCoerce :: forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce m Exp
    m = m (TExp a) -> Code m a
    forall (m :: * -> *) a. m (TExp a) -> Code m a
    Code (m Exp -> m (TExp a)
    forall a (m :: * -> *). Quote m => m Exp -> m (TExp a)
    unsafeTExpCoerce m Exp
    m)

    -- | Lift a monadic action producing code into the typed 'Code'
    -- representation
    liftCode :: forall (r :: RuntimeRep) (a :: TYPE r) m . m (TExp a) -> Code m a
    liftCode :: forall a (m :: * -> *). m (TExp a) -> Code m a
    liftCode = m (TExp a) -> Code m a
    forall (m :: * -> *) a. m (TExp a) -> Code m a
    Code

    -- | Extract the untyped representation from the typed representation
    unTypeCode :: forall (r :: RuntimeRep) (a :: TYPE r) m . Quote m
               => Code m a -> m Exp
    unTypeCode :: forall a (m :: * -> *). Quote m => Code m a -> m Exp
    unTypeCode = m (TExp a) -> m Exp
    forall a (m :: * -> *). Quote m => m (TExp a) -> m Exp
    unTypeQ (m (TExp a) -> m Exp)
    -> (Code m a -> m (TExp a)) -> Code m a -> m Exp
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Code m a -> m (TExp a)
    forall (m :: * -> *) a. Code m a -> m (TExp a)
    examineCode

    -- | Modify the ambient monad used during code generation. For example, you
    -- can use `hoistCode` to handle a state effect:
    -- @
    --  handleState :: Code (StateT Int Q) a -> Code Q a
    --  handleState = hoistCode (flip runState 0)
    -- @
    hoistCode :: forall m n (r :: RuntimeRep) (a :: TYPE r) . Monad m
              => (forall x . m x -> n x) -> Code m a -> Code n a
    hoistCode :: forall (m :: * -> *) (n :: * -> *) a.
    Monad m =>
    (forall x. m x -> n x) -> Code m a -> Code n a
    hoistCode forall x. m x -> n x
    f (Code m (TExp a)
    a) = n (TExp a) -> Code n a
    forall (m :: * -> *) a. m (TExp a) -> Code m a
    Code (m (TExp a) -> n (TExp a)
    forall x. m x -> n x
    f m (TExp a)
    a)

    -- | Variant of (>>=) which allows effectful computations to be injected
    -- into code generation.
    bindCode :: forall m a (r :: RuntimeRep) (b :: TYPE r) . Monad m
             => m a -> (a -> Code m b) -> Code m b
    bindCode :: forall (m :: * -> *) a b.
    Monad m =>
    m a -> (a -> Code m b) -> Code m b
    bindCode m a
    q a -> Code m b
    k = m (TExp b) -> Code m b
    forall a (m :: * -> *). m (TExp a) -> Code m a
    liftCode (m a
    q m a -> (a -> m (TExp b)) -> m (TExp b)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= Code m b -> m (TExp b)
    forall (m :: * -> *) a. Code m a -> m (TExp a)
    examineCode (Code m b -> m (TExp b)) -> (a -> Code m b) -> a -> m (TExp b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Code m b
    k)

    -- | Variant of (>>) which allows effectful computations to be injected
    -- into code generation.
    bindCode_ :: forall m a (r :: RuntimeRep) (b :: TYPE r) . Monad m
              => m a -> Code m b -> Code m b
    bindCode_ :: forall (m :: * -> *) a b. Monad m => m a -> Code m b -> Code m b
    bindCode_ m a
    q Code m b
    c = m (TExp b) -> Code m b
    forall a (m :: * -> *). m (TExp a) -> Code m a
    liftCode ( m a
    q m a -> m (TExp b) -> m (TExp b)
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Code m b -> m (TExp b)
    forall (m :: * -> *) a. Code m a -> m (TExp a)
    examineCode Code m b
    c)

    -- | A useful combinator for embedding monadic actions into 'Code'
    -- @
    -- myCode :: ... => Code m a
    -- myCode = joinCode $ do
    --   x <- someSideEffect
    --   return (makeCodeWith x)
    -- @
    joinCode :: forall m (r :: RuntimeRep) (a :: TYPE r) . Monad m
             => m (Code m a) -> Code m a
    joinCode :: forall (m :: * -> *) a. Monad m => m (Code m a) -> Code m a
    joinCode = (m (Code m a) -> (Code m a -> Code m a) -> Code m a)
    -> (Code m a -> Code m a) -> m (Code m a) -> Code m a
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip m (Code m a) -> (Code m a -> Code m a) -> Code m a
    forall (m :: * -> *) a b.
    Monad m =>
    m a -> (a -> Code m b) -> Code m b
    bindCode Code m a -> Code m a
    forall a. a -> a
    id

    ----------------------------------------------------
    -- Packaged versions for the programmer, hiding the Quasi-ness

    -- | Report an error (True) or warning (False),
    -- but carry on; use 'fail' to stop.
    report  :: Bool -> String -> Q ()
    report :: Bool -> String -> Q ()
    report Bool
    b String
    s = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Bool -> String -> m ()
    forall (m :: * -> *). Quasi m => Bool -> String -> m ()
    qReport Bool
    b String
    s)
    {-# DEPRECATED report "Use reportError or reportWarning instead" #-} -- deprecated in 7.6

    -- | Report an error to the user, but allow the current splice's computation to carry on. To abort the computation, use 'fail'.
    reportError :: String -> Q ()
    reportError :: String -> Q ()
    reportError = Bool -> String -> Q ()
    report Bool
    True

    -- | Report a warning to the user, and carry on.
    reportWarning :: String -> Q ()
    reportWarning :: String -> Q ()
    reportWarning = Bool -> String -> Q ()
    report Bool
    False

    -- | Recover from errors raised by 'reportError' or 'fail'.
    recover :: Q a -- ^ handler to invoke on failure
            -> Q a -- ^ computation to run
            -> Q a
    recover :: forall a. Q a -> Q a -> Q a
    recover (Q forall (m :: * -> *). Quasi m => m a
    r) (Q forall (m :: * -> *). Quasi m => m a
    m) = (forall (m :: * -> *). Quasi m => m a) -> Q a
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (m a -> m a -> m a
    forall (m :: * -> *) a. Quasi m => m a -> m a -> m a
    qRecover m a
    forall (m :: * -> *). Quasi m => m a
    r m a
    forall (m :: * -> *). Quasi m => m a
    m)

    -- We don't export lookupName; the Bool isn't a great API
    -- Instead we export lookupTypeName, lookupValueName
    lookupName :: Bool -> String -> Q (Maybe Name)
    lookupName :: Bool -> String -> Q (Maybe Name)
    lookupName Bool
    ns String
    s = (forall (m :: * -> *). Quasi m => m (Maybe Name)) -> Q (Maybe Name)
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Bool -> String -> m (Maybe Name)
    forall (m :: * -> *). Quasi m => Bool -> String -> m (Maybe Name)
    qLookupName Bool
    ns String
    s)

    -- | Look up the given name in the (type namespace of the) current splice's scope. See "Language.Haskell.TH.Syntax#namelookup" for more details.
    lookupTypeName :: String -> Q (Maybe Name)
    lookupTypeName :: String -> Q (Maybe Name)
    lookupTypeName  String
    s = (forall (m :: * -> *). Quasi m => m (Maybe Name)) -> Q (Maybe Name)
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Bool -> String -> m (Maybe Name)
    forall (m :: * -> *). Quasi m => Bool -> String -> m (Maybe Name)
    qLookupName Bool
    True String
    s)

    -- | Look up the given name in the (value namespace of the) current splice's scope. See "Language.Haskell.TH.Syntax#namelookup" for more details.
    lookupValueName :: String -> Q (Maybe Name)
    lookupValueName :: String -> Q (Maybe Name)
    lookupValueName String
    s = (forall (m :: * -> *). Quasi m => m (Maybe Name)) -> Q (Maybe Name)
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Bool -> String -> m (Maybe Name)
    forall (m :: * -> *). Quasi m => Bool -> String -> m (Maybe Name)
    qLookupName Bool
    False String
    s)

    {-
    Note [Name lookup]
    ~~~~~~~~~~~~~~~~~~
    -}
    {- $namelookup #namelookup#
    The functions 'lookupTypeName' and 'lookupValueName' provide
    a way to query the current splice's context for what names
    are in scope. The function 'lookupTypeName' queries the type
    namespace, whereas 'lookupValueName' queries the value namespace,
    but the functions are otherwise identical.

    A call @lookupValueName s@ will check if there is a value
    with name @s@ in scope at the current splice's location. If
    there is, the @Name@ of this value is returned;
    if not, then @Nothing@ is returned.

    The returned name cannot be \"captured\".
    For example:

    > f = "global"
    > g = $( do
    >          Just nm <- lookupValueName "f"
    >          [| let f = "local" in $( varE nm ) |]

    In this case, @g = \"global\"@; the call to @lookupValueName@
    returned the global @f@, and this name was /not/ captured by
    the local definition of @f@.

    The lookup is performed in the context of the /top-level/ splice
    being run. For example:

    > f = "global"
    > g = $( [| let f = "local" in
    >            $(do
    >                Just nm <- lookupValueName "f"
    >                varE nm
    >             ) |] )

    Again in this example, @g = \"global\"@, because the call to
    @lookupValueName@ queries the context of the outer-most @$(...)@.

    Operators should be queried without any surrounding parentheses, like so:

    > lookupValueName "+"

    Qualified names are also supported, like so:

    > lookupValueName "Prelude.+"
    > lookupValueName "Prelude.map"

    -}

    {- | 'reify' looks up information about the 'Name'.

    It is sometimes useful to construct the argument name using 'lookupTypeName' or 'lookupValueName'
    to ensure that we are reifying from the right namespace. For instance, in this context:

    > data D = D

    which @D@ does @reify (mkName \"D\")@ return information about? (Answer: @D@-the-type, but don't rely on it.)
    To ensure we get information about @D@-the-value, use 'lookupValueName':

    > do
    >   Just nm <- lookupValueName "D"
    >   reify nm

    and to get information about @D@-the-type, use 'lookupTypeName'.
    -}
    reify :: Name -> Q Info
    reify :: Name -> Q Info
    reify Name
    v = (forall (m :: * -> *). Quasi m => m Info) -> Q Info
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Name -> m Info
    forall (m :: * -> *). Quasi m => Name -> m Info
    qReify Name
    v)

    {- | @reifyFixity nm@ attempts to find a fixity declaration for @nm@. For
    example, if the function @foo@ has the fixity declaration @infixr 7 foo@, then
    @reifyFixity 'foo@ would return @'Just' ('Fixity' 7 'InfixR')@. If the function
    @bar@ does not have a fixity declaration, then @reifyFixity 'bar@ returns
    'Nothing', so you may assume @bar@ has 'defaultFixity'.
    -}
    reifyFixity :: Name -> Q (Maybe Fixity)
    reifyFixity :: Name -> Q (Maybe Fixity)
    reifyFixity Name
    nm = (forall (m :: * -> *). Quasi m => m (Maybe Fixity))
    -> Q (Maybe Fixity)
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Name -> m (Maybe Fixity)
    forall (m :: * -> *). Quasi m => Name -> m (Maybe Fixity)
    qReifyFixity Name
    nm)

    {- | @reifyType nm@ attempts to find the type or kind of @nm@. For example,
    @reifyType 'not@   returns @Bool -> Bool@, and
    @reifyType ''Bool@ returns @Type@.
    This works even if there's no explicit signature and the type or kind is inferred.
    -}
    reifyType :: Name -> Q Type
    reifyType :: Name -> Q Type
    reifyType Name
    nm = (forall (m :: * -> *). Quasi m => m Type) -> Q Type
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Name -> m Type
    forall (m :: * -> *). Quasi m => Name -> m Type
    qReifyType Name
    nm)

    {- | @reifyInstances nm tys@ returns a list of visible instances of @nm tys@. That is,
    if @nm@ is the name of a type class, then all instances of this class at the types @tys@
    are returned. Alternatively, if @nm@ is the name of a data family or type family,
    all instances of this family at the types @tys@ are returned.

    Note that this is a \"shallow\" test; the declarations returned merely have
    instance heads which unify with @nm tys@, they need not actually be satisfiable.

      - @reifyInstances ''Eq [ 'TupleT' 2 \``AppT`\` 'ConT' ''A \``AppT`\` 'ConT' ''B ]@ contains
        the @instance (Eq a, Eq b) => Eq (a, b)@ regardless of whether @A@ and
        @B@ themselves implement 'Eq'

      - @reifyInstances ''Show [ 'VarT' ('mkName' "a") ]@ produces every available
        instance of 'Eq'

    There is one edge case: @reifyInstances ''Typeable tys@ currently always
    produces an empty list (no matter what @tys@ are given).
    -}
    reifyInstances :: Name -> [Type] -> Q [InstanceDec]
    reifyInstances :: Name -> [Type] -> Q [Dec]
    reifyInstances Name
    cls [Type]
    tys = (forall (m :: * -> *). Quasi m => m [Dec]) -> Q [Dec]
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Name -> [Type] -> m [Dec]
    forall (m :: * -> *). Quasi m => Name -> [Type] -> m [Dec]
    qReifyInstances Name
    cls [Type]
    tys)

    {- | @reifyRoles nm@ returns the list of roles associated with the parameters of
    the tycon @nm@. Fails if @nm@ cannot be found or is not a tycon.
    The returned list should never contain 'InferR'.
    -}
    reifyRoles :: Name -> Q [Role]
    reifyRoles :: Name -> Q [Role]
    reifyRoles Name
    nm = (forall (m :: * -> *). Quasi m => m [Role]) -> Q [Role]
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Name -> m [Role]
    forall (m :: * -> *). Quasi m => Name -> m [Role]
    qReifyRoles Name
    nm)

    -- | @reifyAnnotations target@ returns the list of annotations
    -- associated with @target@.  Only the annotations that are
    -- appropriately typed is returned.  So if you have @Int@ and @String@
    -- annotations for the same target, you have to call this function twice.
    reifyAnnotations :: Data a => AnnLookup -> Q [a]
    reifyAnnotations :: forall a. Data a => AnnLookup -> Q [a]
    reifyAnnotations AnnLookup
    an = (forall (m :: * -> *). Quasi m => m [a]) -> Q [a]
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (AnnLookup -> m [a]
    forall (m :: * -> *) a. (Quasi m, Data a) => AnnLookup -> m [a]
    qReifyAnnotations AnnLookup
    an)

    -- | @reifyModule mod@ looks up information about module @mod@.  To
    -- look up the current module, call this function with the return
    -- value of 'Language.Haskell.TH.Lib.thisModule'.
    reifyModule :: Module -> Q ModuleInfo
    reifyModule :: Module -> Q ModuleInfo
    reifyModule Module
    m = (forall (m :: * -> *). Quasi m => m ModuleInfo) -> Q ModuleInfo
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Module -> m ModuleInfo
    forall (m :: * -> *). Quasi m => Module -> m ModuleInfo
    qReifyModule Module
    m)

    -- | @reifyConStrictness nm@ looks up the strictness information for the fields
    -- of the constructor with the name @nm@. Note that the strictness information
    -- that 'reifyConStrictness' returns may not correspond to what is written in
    -- the source code. For example, in the following data declaration:
    --
    -- @
    -- data Pair a = Pair a a
    -- @
    --
    -- 'reifyConStrictness' would return @['DecidedLazy', DecidedLazy]@ under most
    -- circumstances, but it would return @['DecidedStrict', DecidedStrict]@ if the
    -- @-XStrictData@ language extension was enabled.
    reifyConStrictness :: Name -> Q [DecidedStrictness]
    reifyConStrictness :: Name -> Q [DecidedStrictness]
    reifyConStrictness Name
    n = (forall (m :: * -> *). Quasi m => m [DecidedStrictness])
    -> Q [DecidedStrictness]
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Name -> m [DecidedStrictness]
    forall (m :: * -> *). Quasi m => Name -> m [DecidedStrictness]
    qReifyConStrictness Name
    n)

    -- | Is the list of instances returned by 'reifyInstances' nonempty?
    isInstance :: Name -> [Type] -> Q Bool
    isInstance :: Name -> [Type] -> Q Bool
    isInstance Name
    nm [Type]
    tys = do { [Dec]
    decs <- Name -> [Type] -> Q [Dec]
    reifyInstances Name
    nm [Type]
    tys
                           ; Bool -> Q Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Bool -> Bool
    not ([Dec] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Dec]
    decs)) }

    -- | The location at which this computation is spliced.
    location :: Q Loc
    location :: Q Loc
    location = (forall (m :: * -> *). Quasi m => m Loc) -> Q Loc
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q forall (m :: * -> *). Quasi m => m Loc
    qLocation

    -- |The 'runIO' function lets you run an I\/O computation in the 'Q' monad.
    -- Take care: you are guaranteed the ordering of calls to 'runIO' within
    -- a single 'Q' computation, but not about the order in which splices are run.
    --
    -- Note: for various murky reasons, stdout and stderr handles are not
    -- necessarily flushed when the compiler finishes running, so you should
    -- flush them yourself.
    runIO :: IO a -> Q a
    runIO :: forall a. IO a -> Q a
    runIO IO a
    m = (forall (m :: * -> *). Quasi m => m a) -> Q a
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (IO a -> m a
    forall (m :: * -> *) a. Quasi m => IO a -> m a
    qRunIO IO a
    m)

    -- | Record external files that runIO is using (dependent upon).
    -- The compiler can then recognize that it should re-compile the Haskell file
    -- when an external file changes.
    --
    -- Expects an absolute file path.
    --
    -- Notes:
    --
    --   * ghc -M does not know about these dependencies - it does not execute TH.
    --
    --   * The dependency is based on file content, not a modification time
    addDependentFile :: FilePath -> Q ()
    addDependentFile :: String -> Q ()
    addDependentFile String
    fp = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (String -> m ()
    forall (m :: * -> *). Quasi m => String -> m ()
    qAddDependentFile String
    fp)

    -- | Obtain a temporary file path with the given suffix. The compiler will
    -- delete this file after compilation.
    addTempFile :: String -> Q FilePath
    addTempFile :: String -> Q String
    addTempFile String
    suffix = (forall (m :: * -> *). Quasi m => m String) -> Q String
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (String -> m String
    forall (m :: * -> *). Quasi m => String -> m String
    qAddTempFile String
    suffix)

    -- | Add additional top-level declarations. The added declarations will be type
    -- checked along with the current declaration group.
    addTopDecls :: [Dec] -> Q ()
    addTopDecls :: [Dec] -> Q ()
    addTopDecls [Dec]
    ds = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q ([Dec] -> m ()
    forall (m :: * -> *). Quasi m => [Dec] -> m ()
    qAddTopDecls [Dec]
    ds)

    -- |
    addForeignFile :: ForeignSrcLang -> String -> Q ()
    addForeignFile :: ForeignSrcLang -> String -> Q ()
    addForeignFile = ForeignSrcLang -> String -> Q ()
    addForeignSource
    {-# DEPRECATED addForeignFile
                   "Use 'Language.Haskell.TH.Syntax.addForeignSource' instead"
      #-} -- deprecated in 8.6

    -- | Emit a foreign file which will be compiled and linked to the object for
    -- the current module. Currently only languages that can be compiled with
    -- the C compiler are supported, and the flags passed as part of -optc will
    -- be also applied to the C compiler invocation that will compile them.
    --
    -- Note that for non-C languages (for example C++) @extern "C"@ directives
    -- must be used to get symbols that we can access from Haskell.
    --
    -- To get better errors, it is recommended to use #line pragmas when
    -- emitting C files, e.g.
    --
    -- > {-# LANGUAGE CPP #-}
    -- > ...
    -- > addForeignSource LangC $ unlines
    -- >   [ "#line " ++ show (__LINE__ + 1) ++ " " ++ show __FILE__
    -- >   , ...
    -- >   ]
    addForeignSource :: ForeignSrcLang -> String -> Q ()
    addForeignSource :: ForeignSrcLang -> String -> Q ()
    addForeignSource ForeignSrcLang
    lang String
    src = do
      let suffix :: String
    suffix = case ForeignSrcLang
    lang of
                     ForeignSrcLang
    LangC      -> String
    "c"
                     ForeignSrcLang
    LangCxx    -> String
    "cpp"
                     ForeignSrcLang
    LangObjc   -> String
    "m"
                     ForeignSrcLang
    LangObjcxx -> String
    "mm"
                     ForeignSrcLang
    LangAsm    -> String
    "s"
                     ForeignSrcLang
    RawObject  -> String
    "a"
      String
    path <- String -> Q String
    addTempFile String
    suffix
      IO () -> Q ()
    forall a. IO a -> Q a
    runIO (IO () -> Q ()) -> IO () -> Q ()
    forall a b. (a -> b) -> a -> b
    $ String -> String -> IO ()
    writeFile String
    path String
    src
      ForeignSrcLang -> String -> Q ()
    addForeignFilePath ForeignSrcLang
    lang String
    path

    -- | Same as 'addForeignSource', but expects to receive a path pointing to the
    -- foreign file instead of a 'String' of its contents. Consider using this in
    -- conjunction with 'addTempFile'.
    --
    -- This is a good alternative to 'addForeignSource' when you are trying to
    -- directly link in an object file.
    addForeignFilePath :: ForeignSrcLang -> FilePath -> Q ()
    addForeignFilePath :: ForeignSrcLang -> String -> Q ()
    addForeignFilePath ForeignSrcLang
    lang String
    fp = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (ForeignSrcLang -> String -> m ()
    forall (m :: * -> *). Quasi m => ForeignSrcLang -> String -> m ()
    qAddForeignFilePath ForeignSrcLang
    lang String
    fp)

    -- | Add a finalizer that will run in the Q monad after the current module has
    -- been type checked. This only makes sense when run within a top-level splice.
    --
    -- The finalizer is given the local type environment at the splice point. Thus
    -- 'reify' is able to find the local definitions when executed inside the
    -- finalizer.
    addModFinalizer :: Q () -> Q ()
    addModFinalizer :: Q () -> Q ()
    addModFinalizer Q ()
    act = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Q () -> m ()
    forall (m :: * -> *). Quasi m => Q () -> m ()
    qAddModFinalizer (Q () -> forall (m :: * -> *). Quasi m => m ()
    forall a. Q a -> forall (m :: * -> *). Quasi m => m a
    unQ Q ()
    act))

    -- | Adds a core plugin to the compilation pipeline.
    --
    -- @addCorePlugin m@ has almost the same effect as passing @-fplugin=m@ to ghc
    -- in the command line. The major difference is that the plugin module @m@
    -- must not belong to the current package. When TH executes, it is too late
    -- to tell the compiler that we needed to compile first a plugin module in the
    -- current package.
    addCorePlugin :: String -> Q ()
    addCorePlugin :: String -> Q ()
    addCorePlugin String
    plugin = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (String -> m ()
    forall (m :: * -> *). Quasi m => String -> m ()
    qAddCorePlugin String
    plugin)

    -- | Get state from the 'Q' monad. Note that the state is local to the
    -- Haskell module in which the Template Haskell expression is executed.
    getQ :: Typeable a => Q (Maybe a)
    getQ :: forall a. Typeable a => Q (Maybe a)
    getQ = (forall (m :: * -> *). Quasi m => m (Maybe a)) -> Q (Maybe a)
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q forall (m :: * -> *). Quasi m => m (Maybe a)
    forall (m :: * -> *) a. (Quasi m, Typeable a) => m (Maybe a)
    qGetQ

    -- | Replace the state in the 'Q' monad. Note that the state is local to the
    -- Haskell module in which the Template Haskell expression is executed.
    putQ :: Typeable a => a -> Q ()
    putQ :: forall a. Typeable a => a -> Q ()
    putQ a
    x = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (a -> m ()
    forall (m :: * -> *) a. (Quasi m, Typeable a) => a -> m ()
    qPutQ a
    x)

    -- | Determine whether the given language extension is enabled in the 'Q' monad.
    isExtEnabled :: Extension -> Q Bool
    isExtEnabled :: Extension -> Q Bool
    isExtEnabled Extension
    ext = (forall (m :: * -> *). Quasi m => m Bool) -> Q Bool
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q (Extension -> m Bool
    forall (m :: * -> *). Quasi m => Extension -> m Bool
    qIsExtEnabled Extension
    ext)

    -- | List all enabled language extensions.
    extsEnabled :: Q [Extension]
    extsEnabled :: Q [Extension]
    extsEnabled = (forall (m :: * -> *). Quasi m => m [Extension]) -> Q [Extension]
    forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
    Q forall (m :: * -> *). Quasi m => m [Extension]
    qExtsEnabled

    instance MonadIO Q where
      liftIO :: forall a. IO a -> Q a
    liftIO = IO a -> Q a
    forall a. IO a -> Q a
    runIO

    instance Quasi Q where
      qNewName :: String -> Q Name
    qNewName            = String -> Q Name
    forall (m :: * -> *). Quote m => String -> m Name
    newName
      qReport :: Bool -> String -> Q ()
    qReport             = Bool -> String -> Q ()
    report
      qRecover :: forall a. Q a -> Q a -> Q a
    qRecover            = Q a -> Q a -> Q a
    forall a. Q a -> Q a -> Q a
    recover
      qReify :: Name -> Q Info
    qReify              = Name -> Q Info
    reify
      qReifyFixity :: Name -> Q (Maybe Fixity)
    qReifyFixity        = Name -> Q (Maybe Fixity)
    reifyFixity
      qReifyType :: Name -> Q Type
    qReifyType          = Name -> Q Type
    reifyType
      qReifyInstances :: Name -> [Type] -> Q [Dec]
    qReifyInstances     = Name -> [Type] -> Q [Dec]
    reifyInstances
      qReifyRoles :: Name -> Q [Role]
    qReifyRoles         = Name -> Q [Role]
    reifyRoles
      qReifyAnnotations :: forall a. Data a => AnnLookup -> Q [a]
    qReifyAnnotations   = AnnLookup -> Q [a]
    forall a. Data a => AnnLookup -> Q [a]
    reifyAnnotations
      qReifyModule :: Module -> Q ModuleInfo
    qReifyModule        = Module -> Q ModuleInfo
    reifyModule
      qReifyConStrictness :: Name -> Q [DecidedStrictness]
    qReifyConStrictness = Name -> Q [DecidedStrictness]
    reifyConStrictness
      qLookupName :: Bool -> String -> Q (Maybe Name)
    qLookupName         = Bool -> String -> Q (Maybe Name)
    lookupName
      qLocation :: Q Loc
    qLocation           = Q Loc
    location
      qAddDependentFile :: String -> Q ()
    qAddDependentFile   = String -> Q ()
    addDependentFile
      qAddTempFile :: String -> Q String
    qAddTempFile        = String -> Q String
    addTempFile
      qAddTopDecls :: [Dec] -> Q ()
    qAddTopDecls        = [Dec] -> Q ()
    addTopDecls
      qAddForeignFilePath :: ForeignSrcLang -> String -> Q ()
    qAddForeignFilePath = ForeignSrcLang -> String -> Q ()
    addForeignFilePath
      qAddModFinalizer :: Q () -> Q ()
    qAddModFinalizer    = Q () -> Q ()
    addModFinalizer
      qAddCorePlugin :: String -> Q ()
    qAddCorePlugin      = String -> Q ()
    addCorePlugin
      qGetQ :: forall a. Typeable a => Q (Maybe a)
    qGetQ               = Q (Maybe a)
    forall a. Typeable a => Q (Maybe a)
    getQ
      qPutQ :: forall a. Typeable a => a -> Q ()
    qPutQ               = a -> Q ()
    forall a. Typeable a => a -> Q ()
    putQ
      qIsExtEnabled :: Extension -> Q Bool
    qIsExtEnabled       = Extension -> Q Bool
    isExtEnabled
      qExtsEnabled :: Q [Extension]
    qExtsEnabled        = Q [Extension]
    extsEnabled

    ----------------------------------------------------
    -- The following operations are used solely in GHC.HsToCore.Quote when
    -- desugaring brackets. They are not necessary for the user, who can use
    -- ordinary return and (>>=) etc

    sequenceQ :: forall m . Monad m => forall a . [m a] -> m [a]
    sequenceQ :: forall (m :: * -> *) a. Monad m => [m a] -> m [a]
    sequenceQ = [m a] -> m [a]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence

    -----------------------------------------------------
    --
    --              The Lift class
    --
    -----------------------------------------------------

    -- | A 'Lift' instance can have any of its values turned into a Template
    -- Haskell expression. This is needed when a value used within a Template
    -- Haskell quotation is bound outside the Oxford brackets (@[| ... |]@ or
    -- @[|| ... ||]@) but not at the top level. As an example:
    --
    -- > add1 :: Int -> Q (TExp Int)
    -- > add1 x = [|| x + 1 ||]
    --
    -- Template Haskell has no way of knowing what value @x@ will take on at
    -- splice-time, so it requires the type of @x@ to be an instance of 'Lift'.
    --
    -- A 'Lift' instance must satisfy @$(lift x) ≡ x@ and @$$(liftTyped x) ≡ x@
    -- for all @x@, where @$(...)@ and @$$(...)@ are Template Haskell splices.
    -- It is additionally expected that @'lift' x ≡ 'unTypeQ' ('liftTyped' x)@.
    --
    -- 'Lift' instances can be derived automatically by use of the @-XDeriveLift@
    -- GHC language extension:
    --
    -- > {-# LANGUAGE DeriveLift #-}
    -- > module Foo where
    -- >
    -- > import Language.Haskell.TH.Syntax
    -- >
    -- > data Bar a = Bar1 a (Bar a) | Bar2 String
    -- >   deriving Lift
    --
    -- Levity-polymorphic since /template-haskell-2.16.0.0/.
    class Lift (t :: TYPE r) where
      -- | Turn a value into a Template Haskell expression, suitable for use in
      -- a splice.
      lift :: Quote m => t -> m Exp
      default lift :: (r ~ 'LiftedRep, Quote m) => t -> m Exp
      lift = Code m t -> m Exp
    forall a (m :: * -> *). Quote m => Code m a -> m Exp
    unTypeCode (Code m t -> m Exp) -> (t -> Code m t) -> t -> m Exp
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . t -> Code m t
    forall t (m :: * -> *). (Lift t, Quote m) => t -> Code m t
    liftTyped

      -- | Turn a value into a Template Haskell typed expression, suitable for use
      -- in a typed splice.
      --
      -- @since 2.16.0.0
      liftTyped :: Quote m => t -> Code m t

    -- If you add any instances here, consider updating test th/TH_Lift
    instance Lift Integer where
      liftTyped :: forall (m :: * -> *). Quote m => Uniq -> Code m Uniq
    liftTyped Uniq
    x = m Exp -> Code m Uniq
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Uniq -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Uniq
    x)
      lift :: forall (m :: * -> *). Quote m => Uniq -> m Exp
    lift Uniq
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL Uniq
    x))

    instance Lift Int where
      liftTyped :: forall (m :: * -> *). Quote m => Int -> Code m Int
    liftTyped Int
    x = m Exp -> Code m Int
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Int -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Int
    x)
      lift :: forall (m :: * -> *). Quote m => Int -> m Exp
    lift Int
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL (Int -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    x)))

    -- | @since 2.16.0.0
    instance Lift Int# where
      liftTyped :: forall (m :: * -> *). Quote m => Int# -> Code m Int#
    liftTyped Int#
    x = m Exp -> Code m Int#
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Int# -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Int#
    x)
      lift :: forall (m :: * -> *). Quote m => Int# -> m Exp
    lift Int#
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntPrimL (Int -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int# -> Int
    I# Int#
    x))))

    instance Lift Int8 where
      liftTyped :: forall (m :: * -> *). Quote m => Int8 -> Code m Int8
    liftTyped Int8
    x = m Exp -> Code m Int8
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Int8 -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Int8
    x)
      lift :: forall (m :: * -> *). Quote m => Int8 -> m Exp
    lift Int8
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL (Int8 -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int8
    x)))

    instance Lift Int16 where
      liftTyped :: forall (m :: * -> *). Quote m => Int16 -> Code m Int16
    liftTyped Int16
    x = m Exp -> Code m Int16
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Int16 -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Int16
    x)
      lift :: forall (m :: * -> *). Quote m => Int16 -> m Exp
    lift Int16
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL (Int16 -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int16
    x)))

    instance Lift Int32 where
      liftTyped :: forall (m :: * -> *). Quote m => Int32 -> Code m Int32
    liftTyped Int32
    x = m Exp -> Code m Int32
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Int32 -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Int32
    x)
      lift :: forall (m :: * -> *). Quote m => Int32 -> m Exp
    lift Int32
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL (Int32 -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int32
    x)))

    instance Lift Int64 where
      liftTyped :: forall (m :: * -> *). Quote m => Int64 -> Code m Int64
    liftTyped Int64
    x = m Exp -> Code m Int64
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Int64 -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Int64
    x)
      lift :: forall (m :: * -> *). Quote m => Int64 -> m Exp
    lift Int64
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL (Int64 -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int64
    x)))

    -- | @since 2.16.0.0
    instance Lift Word# where
      liftTyped :: forall (m :: * -> *). Quote m => Word# -> Code m Word#
    liftTyped Word#
    x = m Exp -> Code m Word#
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Word# -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Word#
    x)
      lift :: forall (m :: * -> *). Quote m => Word# -> m Exp
    lift Word#
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    WordPrimL (Word -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word# -> Word
    W# Word#
    x))))

    instance Lift Word where
      liftTyped :: forall (m :: * -> *). Quote m => Word -> Code m Word
    liftTyped Word
    x = m Exp -> Code m Word
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Word -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Word
    x)
      lift :: forall (m :: * -> *). Quote m => Word -> m Exp
    lift Word
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL (Word -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word
    x)))

    instance Lift Word8 where
      liftTyped :: forall (m :: * -> *). Quote m => Word8 -> Code m Word8
    liftTyped Word8
    x = m Exp -> Code m Word8
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Word8 -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Word8
    x)
      lift :: forall (m :: * -> *). Quote m => Word8 -> m Exp
    lift Word8
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL (Word8 -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    x)))

    instance Lift Word16 where
      liftTyped :: forall (m :: * -> *). Quote m => Word16 -> Code m Word16
    liftTyped Word16
    x = m Exp -> Code m Word16
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Word16 -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Word16
    x)
      lift :: forall (m :: * -> *). Quote m => Word16 -> m Exp
    lift Word16
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL (Word16 -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word16
    x)))

    instance Lift Word32 where
      liftTyped :: forall (m :: * -> *). Quote m => Word32 -> Code m Word32
    liftTyped Word32
    x = m Exp -> Code m Word32
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Word32 -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Word32
    x)
      lift :: forall (m :: * -> *). Quote m => Word32 -> m Exp
    lift Word32
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL (Word32 -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word32
    x)))

    instance Lift Word64 where
      liftTyped :: forall (m :: * -> *). Quote m => Word64 -> Code m Word64
    liftTyped Word64
    x = m Exp -> Code m Word64
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Word64 -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Word64
    x)
      lift :: forall (m :: * -> *). Quote m => Word64 -> m Exp
    lift Word64
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL (Word64 -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word64
    x)))

    instance Lift Natural where
      liftTyped :: forall (m :: * -> *). Quote m => Natural -> Code m Natural
    liftTyped Natural
    x = m Exp -> Code m Natural
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Natural -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Natural
    x)
      lift :: forall (m :: * -> *). Quote m => Natural -> m Exp
    lift Natural
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Uniq -> Lit
    IntegerL (Natural -> Uniq
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Natural
    x)))

    instance Integral a => Lift (Ratio a) where
      liftTyped :: forall (m :: * -> *). Quote m => Ratio a -> Code m (Ratio a)
    liftTyped Ratio a
    x = m Exp -> Code m (Ratio a)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Ratio a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Ratio a
    x)
      lift :: forall (m :: * -> *). Quote m => Ratio a -> m Exp
    lift Ratio a
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Rational -> Lit
    RationalL (Ratio a -> Rational
    forall a. Real a => a -> Rational
    toRational Ratio a
    x)))

    instance Lift Float where
      liftTyped :: forall (m :: * -> *). Quote m => Float -> Code m Float
    liftTyped Float
    x = m Exp -> Code m Float
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Float -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Float
    x)
      lift :: forall (m :: * -> *). Quote m => Float -> m Exp
    lift Float
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Rational -> Lit
    RationalL (Float -> Rational
    forall a. Real a => a -> Rational
    toRational Float
    x)))

    -- | @since 2.16.0.0
    instance Lift Float# where
      liftTyped :: forall (m :: * -> *). Quote m => Float# -> Code m Float#
    liftTyped Float#
    x = m Exp -> Code m Float#
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Float# -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Float#
    x)
      lift :: forall (m :: * -> *). Quote m => Float# -> m Exp
    lift Float#
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Rational -> Lit
    FloatPrimL (Float -> Rational
    forall a. Real a => a -> Rational
    toRational (Float# -> Float
    F# Float#
    x))))

    instance Lift Double where
      liftTyped :: forall (m :: * -> *). Quote m => Double -> Code m Double
    liftTyped Double
    x = m Exp -> Code m Double
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Double -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Double
    x)
      lift :: forall (m :: * -> *). Quote m => Double -> m Exp
    lift Double
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Rational -> Lit
    RationalL (Double -> Rational
    forall a. Real a => a -> Rational
    toRational Double
    x)))

    -- | @since 2.16.0.0
    instance Lift Double# where
      liftTyped :: forall (m :: * -> *). Quote m => Double# -> Code m Double#
    liftTyped Double#
    x = m Exp -> Code m Double#
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Double# -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Double#
    x)
      lift :: forall (m :: * -> *). Quote m => Double# -> m Exp
    lift Double#
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Rational -> Lit
    DoublePrimL (Double -> Rational
    forall a. Real a => a -> Rational
    toRational (Double# -> Double
    D# Double#
    x))))

    instance Lift Char where
      liftTyped :: forall (m :: * -> *). Quote m => Char -> Code m Char
    liftTyped Char
    x = m Exp -> Code m Char
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Char -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Char
    x)
      lift :: forall (m :: * -> *). Quote m => Char -> m Exp
    lift Char
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Char -> Lit
    CharL Char
    x))

    -- | @since 2.16.0.0
    instance Lift Char# where
      liftTyped :: forall (m :: * -> *). Quote m => Char# -> Code m Char#
    liftTyped Char#
    x = m Exp -> Code m Char#
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Char# -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Char#
    x)
      lift :: forall (m :: * -> *). Quote m => Char# -> m Exp
    lift Char#
    x = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (Char -> Lit
    CharPrimL (Char# -> Char
    C# Char#
    x)))

    instance Lift Bool where
      liftTyped :: forall (m :: * -> *). Quote m => Bool -> Code m Bool
    liftTyped Bool
    x = m Exp -> Code m Bool
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Bool -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Bool
    x)

      lift :: forall (m :: * -> *). Quote m => Bool -> m Exp
    lift Bool
    True  = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> Exp
    ConE Name
    trueName)
      lift Bool
    False = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> Exp
    ConE Name
    falseName)

    -- | Produces an 'Addr#' literal from the NUL-terminated C-string starting at
    -- the given memory address.
    --
    -- @since 2.16.0.0
    instance Lift Addr# where
      liftTyped :: forall (m :: * -> *). Quote m => Addr# -> Code m Addr#
    liftTyped Addr#
    x = m Exp -> Code m Addr#
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Addr# -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Addr#
    x)
      lift :: forall (m :: * -> *). Quote m => Addr# -> m Exp
    lift Addr#
    x
        = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE ([Word8] -> Lit
    StringPrimL ((Char -> Word8) -> String -> [Word8]
    forall a b. (a -> b) -> [a] -> [b]
    map (Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> (Char -> Int) -> Char -> Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    ord) (Addr# -> String
    unpackCString# Addr#
    x))))

    instance Lift a => Lift (Maybe a) where
      liftTyped :: forall (m :: * -> *). Quote m => Maybe a -> Code m (Maybe a)
    liftTyped Maybe a
    x = m Exp -> Code m (Maybe a)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Maybe a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Maybe a
    x)

      lift :: forall (m :: * -> *). Quote m => Maybe a -> m Exp
    lift Maybe a
    Nothing  = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> Exp
    ConE Name
    nothingName)
      lift (Just a
    x) = (Exp -> Exp) -> m Exp -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Name -> Exp
    ConE Name
    justName Exp -> Exp -> Exp
    `AppE`) (a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    x)

    instance (Lift a, Lift b) => Lift (Either a b) where
      liftTyped :: forall (m :: * -> *). Quote m => Either a b -> Code m (Either a b)
    liftTyped Either a b
    x = m Exp -> Code m (Either a b)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (Either a b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift Either a b
    x)

      lift :: forall (m :: * -> *). Quote m => Either a b -> m Exp
    lift (Left a
    x)  = (Exp -> Exp) -> m Exp -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Name -> Exp
    ConE Name
    leftName  Exp -> Exp -> Exp
    `AppE`) (a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    x)
      lift (Right b
    y) = (Exp -> Exp) -> m Exp -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Name -> Exp
    ConE Name
    rightName Exp -> Exp -> Exp
    `AppE`) (b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    y)

    instance Lift a => Lift [a] where
      liftTyped :: forall (m :: * -> *). Quote m => [a] -> Code m [a]
    liftTyped [a]
    x = m Exp -> Code m [a]
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ([a] -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift [a]
    x)
      lift :: forall (m :: * -> *). Quote m => [a] -> m Exp
    lift [a]
    xs = do { [Exp]
    xs' <- (a -> m Exp) -> [a] -> m [Exp]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift [a]
    xs; Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Exp] -> Exp
    ListE [Exp]
    xs') }

    liftString :: Quote m => String -> m Exp
    -- Used in GHC.Tc.Gen.Expr to short-circuit the lifting for strings
    liftString :: forall (m :: * -> *). Quote m => String -> m Exp
    liftString String
    s = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE (String -> Lit
    StringL String
    s))

    -- | @since 2.15.0.0
    instance Lift a => Lift (NonEmpty a) where
      liftTyped :: forall (m :: * -> *). Quote m => NonEmpty a -> Code m (NonEmpty a)
    liftTyped NonEmpty a
    x = m Exp -> Code m (NonEmpty a)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (NonEmpty a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift NonEmpty a
    x)

      lift :: forall (m :: * -> *). Quote m => NonEmpty a -> m Exp
    lift (a
    x :| [a]
    xs) = do
        Exp
    x' <- a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    x
        Exp
    xs' <- [a] -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift [a]
    xs
        Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe Exp -> Exp -> Maybe Exp -> Exp
    InfixE (Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just Exp
    x') (Name -> Exp
    ConE Name
    nonemptyName) (Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just Exp
    xs'))

    -- | @since 2.15.0.0
    instance Lift Void where
      liftTyped :: forall (m :: * -> *). Quote m => Void -> Code m Void
    liftTyped = m (TExp Void) -> Code m Void
    forall a (m :: * -> *). m (TExp a) -> Code m a
    liftCode (m (TExp Void) -> Code m Void)
    -> (Void -> m (TExp Void)) -> Void -> Code m Void
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Void -> m (TExp Void)
    forall a. Void -> a
    absurd
      lift :: forall (m :: * -> *). Quote m => Void -> m Exp
    lift = Exp -> m Exp
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Exp -> m Exp) -> (Void -> Exp) -> Void -> m Exp
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Void -> Exp
    forall a. Void -> a
    absurd

    instance Lift () where
      liftTyped :: forall (m :: * -> *). Quote m => () -> Code m ()
    liftTyped ()
    x = m Exp -> Code m ()
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce (() -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift ()
    x)
      lift :: forall (m :: * -> *). Quote m => () -> m Exp
    lift () = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> Exp
    ConE (Int -> Name
    tupleDataName Int
    0))

    instance (Lift a, Lift b) => Lift (a, b) where
      liftTyped :: forall (m :: * -> *). Quote m => (a, b) -> Code m (a, b)
    liftTyped (a, b)
    x = m Exp -> Code m (a, b)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((a, b) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (a, b)
    x)
      lift :: forall (m :: * -> *). Quote m => (a, b) -> m Exp
    lift (a
    a, b
    b)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    TupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b]

    instance (Lift a, Lift b, Lift c) => Lift (a, b, c) where
      liftTyped :: forall (m :: * -> *). Quote m => (a, b, c) -> Code m (a, b, c)
    liftTyped (a, b, c)
    x = m Exp -> Code m (a, b, c)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((a, b, c) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (a, b, c)
    x)
      lift :: forall (m :: * -> *). Quote m => (a, b, c) -> m Exp
    lift (a
    a, b
    b, c
    c)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    TupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b, c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    c]

    instance (Lift a, Lift b, Lift c, Lift d) => Lift (a, b, c, d) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (a, b, c, d) -> Code m (a, b, c, d)
    liftTyped (a, b, c, d)
    x = m Exp -> Code m (a, b, c, d)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((a, b, c, d) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (a, b, c, d)
    x)
      lift :: forall (m :: * -> *). Quote m => (a, b, c, d) -> m Exp
    lift (a
    a, b
    b, c
    c, d
    d)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    TupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b, c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    c, d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    d]

    instance (Lift a, Lift b, Lift c, Lift d, Lift e)
          => Lift (a, b, c, d, e) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (a, b, c, d, e) -> Code m (a, b, c, d, e)
    liftTyped (a, b, c, d, e)
    x = m Exp -> Code m (a, b, c, d, e)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((a, b, c, d, e) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (a, b, c, d, e)
    x)
      lift :: forall (m :: * -> *). Quote m => (a, b, c, d, e) -> m Exp
    lift (a
    a, b
    b, c
    c, d
    d, e
    e)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    TupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [ a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b
                                                  , c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    c, d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    d, e -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift e
    e ]

    instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
          => Lift (a, b, c, d, e, f) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (a, b, c, d, e, f) -> Code m (a, b, c, d, e, f)
    liftTyped (a, b, c, d, e, f)
    x = m Exp -> Code m (a, b, c, d, e, f)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((a, b, c, d, e, f) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (a, b, c, d, e, f)
    x)
      lift :: forall (m :: * -> *). Quote m => (a, b, c, d, e, f) -> m Exp
    lift (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    TupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [ a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b, c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    c
                                                  , d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    d, e -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift e
    e, f -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift f
    f ]

    instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
          => Lift (a, b, c, d, e, f, g) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (a, b, c, d, e, f, g) -> Code m (a, b, c, d, e, f, g)
    liftTyped (a, b, c, d, e, f, g)
    x = m Exp -> Code m (a, b, c, d, e, f, g)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((a, b, c, d, e, f, g) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (a, b, c, d, e, f, g)
    x)
      lift :: forall (m :: * -> *). Quote m => (a, b, c, d, e, f, g) -> m Exp
    lift (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f, g
    g)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    TupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [ a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b, c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    c
                                                  , d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    d, e -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift e
    e, f -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift f
    f, g -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift g
    g ]

    -- | @since 2.16.0.0
    instance Lift (# #) where
      liftTyped :: forall (m :: * -> *). Quote m => (# #) -> Code m (# #)
    liftTyped (# #)
    x = m Exp -> Code m (# #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# #) -> m Exp
    lift (# #) = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> Exp
    ConE (Int -> Name
    unboxedTupleTypeName Int
    0))

    -- | @since 2.16.0.0
    instance (Lift a) => Lift (# a #) where
      liftTyped :: forall (m :: * -> *). Quote m => (# a #) -> Code m (# a #)
    liftTyped (# a #)
    x = m Exp -> Code m (# a #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# a #) -> m Exp
    lift (# a
    a #)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    UnboxedTupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a]

    -- | @since 2.16.0.0
    instance (Lift a, Lift b) => Lift (# a, b #) where
      liftTyped :: forall (m :: * -> *). Quote m => (# a, b #) -> Code m (# a, b #)
    liftTyped (# a, b #)
    x = m Exp -> Code m (# a, b #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a, b #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a, b #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# a, b #) -> m Exp
    lift (# a
    a, b
    b #)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    UnboxedTupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b]

    -- | @since 2.16.0.0
    instance (Lift a, Lift b, Lift c)
          => Lift (# a, b, c #) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (# a, b, c #) -> Code m (# a, b, c #)
    liftTyped (# a, b, c #)
    x = m Exp -> Code m (# a, b, c #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a, b, c #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a, b, c #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# a, b, c #) -> m Exp
    lift (# a
    a, b
    b, c
    c #)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    UnboxedTupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b, c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    c]

    -- | @since 2.16.0.0
    instance (Lift a, Lift b, Lift c, Lift d)
          => Lift (# a, b, c, d #) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (# a, b, c, d #) -> Code m (# a, b, c, d #)
    liftTyped (# a, b, c, d #)
    x = m Exp -> Code m (# a, b, c, d #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a, b, c, d #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a, b, c, d #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# a, b, c, d #) -> m Exp
    lift (# a
    a, b
    b, c
    c, d
    d #)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    UnboxedTupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [ a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b
                                                         , c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    c, d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    d ]

    -- | @since 2.16.0.0
    instance (Lift a, Lift b, Lift c, Lift d, Lift e)
          => Lift (# a, b, c, d, e #) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (# a, b, c, d, e #) -> Code m (# a, b, c, d, e #)
    liftTyped (# a, b, c, d, e #)
    x = m Exp -> Code m (# a, b, c, d, e #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a, b, c, d, e #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a, b, c, d, e #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# a, b, c, d, e #) -> m Exp
    lift (# a
    a, b
    b, c
    c, d
    d, e
    e #)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    UnboxedTupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [ a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b
                                                         , c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    c, d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    d, e -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift e
    e ]

    -- | @since 2.16.0.0
    instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
          => Lift (# a, b, c, d, e, f #) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (# a, b, c, d, e, f #) -> Code m (# a, b, c, d, e, f #)
    liftTyped (# a, b, c, d, e, f #)
    x = m Exp -> Code m (# a, b, c, d, e, f #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a, b, c, d, e, f #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a, b, c, d, e, f #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# a, b, c, d, e, f #) -> m Exp
    lift (# a
    a, b
    b, c
    c, d
    d, e
    e, f
    f #)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    UnboxedTupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [ a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b, c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    c
                                                         , d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    d, e -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift e
    e, f -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift f
    f ]

    -- | @since 2.16.0.0
    instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
          => Lift (# a, b, c, d, e, f, g #) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (# a, b, c, d, e, f, g #) -> Code m (# a, b, c, d, e, f, g #)
    liftTyped (# a, b, c, d, e, f, g #)
    x = m Exp -> Code m (# a, b, c, d, e, f, g #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a, b, c, d, e, f, g #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a, b, c, d, e, f, g #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# a, b, c, d, e, f, g #) -> m Exp
    lift (# a
    a, b
    b, c
    c, d
    d, e
    e, f
    f, g
    g #)
        = ([Maybe Exp] -> Exp) -> m [Maybe Exp] -> m Exp
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Maybe Exp] -> Exp
    UnboxedTupE (m [Maybe Exp] -> m Exp) -> m [Maybe Exp] -> m Exp
    forall a b. (a -> b) -> a -> b
    $ [m (Maybe Exp)] -> m [Maybe Exp]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([m (Maybe Exp)] -> m [Maybe Exp])
    -> [m (Maybe Exp)] -> m [Maybe Exp]
    forall a b. (a -> b) -> a -> b
    $ (m Exp -> m (Maybe Exp)) -> [m Exp] -> [m (Maybe Exp)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Exp -> Maybe Exp) -> m Exp -> m (Maybe Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just) [ a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    a, b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    b, c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    c
                                                         , d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    d, e -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift e
    e, f -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift f
    f
                                                         , g -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift g
    g ]

    -- | @since 2.16.0.0
    instance (Lift a, Lift b) => Lift (# a | b #) where
      liftTyped :: forall (m :: * -> *). Quote m => (# a | b #) -> Code m (# a | b #)
    liftTyped (# a | b #)
    x = m Exp -> Code m (# a | b #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a | b #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a | b #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# a | b #) -> m Exp
    lift (# a | b #)
    x
        = case (# a | b #)
    x of
            (# a
    y | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    1 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    2
            (# | b
    y #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    2 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    2

    -- | @since 2.16.0.0
    instance (Lift a, Lift b, Lift c)
          => Lift (# a | b | c #) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (# a | b | c #) -> Code m (# a | b | c #)
    liftTyped (# a | b | c #)
    x = m Exp -> Code m (# a | b | c #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a | b | c #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a | b | c #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# a | b | c #) -> m Exp
    lift (# a | b | c #)
    x
        = case (# a | b | c #)
    x of
            (# a
    y | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    1 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    3
            (# | b
    y | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    2 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    3
            (# | | c
    y #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    3 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    3

    -- | @since 2.16.0.0
    instance (Lift a, Lift b, Lift c, Lift d)
          => Lift (# a | b | c | d #) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (# a | b | c | d #) -> Code m (# a | b | c | d #)
    liftTyped (# a | b | c | d #)
    x = m Exp -> Code m (# a | b | c | d #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a | b | c | d #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a | b | c | d #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# a | b | c | d #) -> m Exp
    lift (# a | b | c | d #)
    x
        = case (# a | b | c | d #)
    x of
            (# a
    y | | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    1 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    4
            (# | b
    y | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    2 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    4
            (# | | c
    y | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    3 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    4
            (# | | | d
    y #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    4 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    4

    -- | @since 2.16.0.0
    instance (Lift a, Lift b, Lift c, Lift d, Lift e)
          => Lift (# a | b | c | d | e #) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (# a | b | c | d | e #) -> Code m (# a | b | c | d | e #)
    liftTyped (# a | b | c | d | e #)
    x = m Exp -> Code m (# a | b | c | d | e #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a | b | c | d | e #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a | b | c | d | e #)
    x)
      lift :: forall (m :: * -> *). Quote m => (# a | b | c | d | e #) -> m Exp
    lift (# a | b | c | d | e #)
    x
        = case (# a | b | c | d | e #)
    x of
            (# a
    y | | | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    1 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    5
            (# | b
    y | | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    2 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    5
            (# | | c
    y | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    3 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    5
            (# | | | d
    y | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    4 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    5
            (# | | | | e
    y #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> e -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift e
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    5 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    5

    -- | @since 2.16.0.0
    instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
          => Lift (# a | b | c | d | e | f #) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (# a | b | c | d | e | f #) -> Code m (# a | b | c | d | e | f #)
    liftTyped (# a | b | c | d | e | f #)
    x = m Exp -> Code m (# a | b | c | d | e | f #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a | b | c | d | e | f #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a | b | c | d | e | f #)
    x)
      lift :: forall (m :: * -> *).
    Quote m =>
    (# a | b | c | d | e | f #) -> m Exp
    lift (# a | b | c | d | e | f #)
    x
        = case (# a | b | c | d | e | f #)
    x of
            (# a
    y | | | | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    1 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    6
            (# | b
    y | | | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    2 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    6
            (# | | c
    y | | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    3 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    6
            (# | | | d
    y | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    4 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    6
            (# | | | | e
    y | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> e -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift e
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    5 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    6
            (# | | | | | f
    y #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift f
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    6 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    6

    -- | @since 2.16.0.0
    instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
          => Lift (# a | b | c | d | e | f | g #) where
      liftTyped :: forall (m :: * -> *).
    Quote m =>
    (# a | b | c | d | e | f | g #)
    -> Code m (# a | b | c | d | e | f | g #)
    liftTyped (# a | b | c | d | e | f | g #)
    x = m Exp -> Code m (# a | b | c | d | e | f | g #)
    forall a (m :: * -> *). Quote m => m Exp -> Code m a
    unsafeCodeCoerce ((# a | b | c | d | e | f | g #) -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift (# a | b | c | d | e | f | g #)
    x)
      lift :: forall (m :: * -> *).
    Quote m =>
    (# a | b | c | d | e | f | g #) -> m Exp
    lift (# a | b | c | d | e | f | g #)
    x
        = case (# a | b | c | d | e | f | g #)
    x of
            (# a
    y | | | | | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift a
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    1 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    7
            (# | b
    y | | | | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> b -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift b
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    2 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    7
            (# | | c
    y | | | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> c -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift c
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    3 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    7
            (# | | | d
    y | | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> d -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift d
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    4 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    7
            (# | | | | e
    y | | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> e -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift e
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    5 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    7
            (# | | | | | f
    y | #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift f
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    6 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    7
            (# | | | | | | g
    y #) -> Exp -> Int -> Int -> Exp
    UnboxedSumE (Exp -> Int -> Int -> Exp) -> m Exp -> m (Int -> Int -> Exp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> g -> m Exp
    forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
    lift g
    y m (Int -> Int -> Exp) -> m Int -> m (Int -> Exp)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    7 m (Int -> Exp) -> m Int -> m Exp
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Int -> m Int
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Int
    7

    -- TH has a special form for literal strings,
    -- which we should take advantage of.
    -- NB: the lhs of the rule has no args, so that
    --     the rule will apply to a 'lift' all on its own
    --     which happens to be the way the type checker
    --     creates it.
    {-# RULES "TH:liftString" lift = \s -> return (LitE (StringL s)) #-}

    trueName, falseName :: Name
    trueName :: Name
    trueName  = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    DataName String
    "ghc-prim" String
    "GHC.Types" String
    "True"
    falseName :: Name
    falseName = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    DataName String
    "ghc-prim" String
    "GHC.Types" String
    "False"

    nothingName, justName :: Name
    nothingName :: Name
    nothingName = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    DataName String
    "base" String
    "GHC.Maybe" String
    "Nothing"
    justName :: Name
    justName    = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    DataName String
    "base" String
    "GHC.Maybe" String
    "Just"

    leftName, rightName :: Name
    leftName :: Name
    leftName  = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    DataName String
    "base" String
    "Data.Either" String
    "Left"
    rightName :: Name
    rightName = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    DataName String
    "base" String
    "Data.Either" String
    "Right"

    nonemptyName :: Name
    nonemptyName :: Name
    nonemptyName = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    DataName String
    "base" String
    "GHC.Base" String
    ":|"

    oneName, manyName :: Name
    oneName :: Name
    oneName  = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    DataName String
    "ghc-prim" String
    "GHC.Types" String
    "One"
    manyName :: Name
    manyName = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    DataName String
    "ghc-prim" String
    "GHC.Types" String
    "Many"
    -----------------------------------------------------
    --
    --              Generic Lift implementations
    --
    -----------------------------------------------------

    -- | 'dataToQa' is an internal utility function for constructing generic
    -- conversion functions from types with 'Data' instances to various
    -- quasi-quoting representations.  See the source of 'dataToExpQ' and
    -- 'dataToPatQ' for two example usages: @mkCon@, @mkLit@
    -- and @appQ@ are overloadable to account for different syntax for
    -- expressions and patterns; @antiQ@ allows you to override type-specific
    -- cases, a common usage is just @const Nothing@, which results in
    -- no overloading.
    dataToQa  ::  forall m a k q. (Quote m, Data a)
              =>  (Name -> k)
              ->  (Lit -> m q)
              ->  (k -> [m q] -> m q)
              ->  (forall b . Data b => b -> Maybe (m q))
              ->  a
              ->  m q
    dataToQa :: forall (m :: * -> *) a k q.
    (Quote m, Data a) =>
    (Name -> k)
    -> (Lit -> m q)
    -> (k -> [m q] -> m q)
    -> (forall b. Data b => b -> Maybe (m q))
    -> a
    -> m q
    dataToQa Name -> k
    mkCon Lit -> m q
    mkLit k -> [m q] -> m q
    appCon forall b. Data b => b -> Maybe (m q)
    antiQ a
    t =
        case a -> Maybe (m q)
    forall b. Data b => b -> Maybe (m q)
    antiQ a
    t of
          Maybe (m q)
    Nothing ->
              case Constr -> ConstrRep
    constrRep Constr
    constr of
                AlgConstr Int
    _ ->
                    k -> [m q] -> m q
    appCon (Name -> k
    mkCon Name
    funOrConName) [m q]
    conArgs
                  where
                    funOrConName :: Name
                    funOrConName :: Name
    funOrConName =
                        case Constr -> String
    showConstr Constr
    constr of
                          String
    "(:)"       -> OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    ":")
                                              (NameSpace -> PkgName -> ModName -> NameFlavour
    NameG NameSpace
    DataName
                                                    (String -> PkgName
    mkPkgName String
    "ghc-prim")
                                                    (String -> ModName
    mkModName String
    "GHC.Types"))
                          con :: String
    con@String
    "[]"    -> OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    con)
                                              (NameSpace -> PkgName -> ModName -> NameFlavour
    NameG NameSpace
    DataName
                                                    (String -> PkgName
    mkPkgName String
    "ghc-prim")
                                                    (String -> ModName
    mkModName String
    "GHC.Types"))
                          con :: String
    con@(Char
    '(':String
    _) -> OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    con)
                                              (NameSpace -> PkgName -> ModName -> NameFlavour
    NameG NameSpace
    DataName
                                                    (String -> PkgName
    mkPkgName String
    "ghc-prim")
                                                    (String -> ModName
    mkModName String
    "GHC.Tuple"))

                          -- Tricky case: see Note [Data for non-algebraic types]
                          fun :: String
    fun@(Char
    x:String
    _)   | Char -> Bool
    startsVarSym Char
    x Bool -> Bool -> Bool
    || Char -> Bool
    startsVarId Char
    x
                                      -> String -> String -> String -> Name
    mkNameG_v String
    tyconPkg String
    tyconMod String
    fun
                          String
    con         -> String -> String -> String -> Name
    mkNameG_d String
    tyconPkg String
    tyconMod String
    con

                      where
                        tycon :: TyCon
                        tycon :: TyCon
    tycon = (TypeRep -> TyCon
    typeRepTyCon (TypeRep -> TyCon) -> (a -> TypeRep) -> a -> TyCon
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> TypeRep
    forall a. Typeable a => a -> TypeRep
    typeOf) a
    t

                        tyconPkg, tyconMod :: String
                        tyconPkg :: String
    tyconPkg = TyCon -> String
    tyConPackage TyCon
    tycon
                        tyconMod :: String
    tyconMod = TyCon -> String
    tyConModule  TyCon
    tycon

                    conArgs :: [m q]
                    conArgs :: [m q]
    conArgs = (forall d. Data d => d -> m q) -> a -> [m q]
    forall a u. Data a => (forall d. Data d => d -> u) -> a -> [u]
    gmapQ ((Name -> k)
    -> (Lit -> m q)
    -> (k -> [m q] -> m q)
    -> (forall b. Data b => b -> Maybe (m q))
    -> d
    -> m q
    forall (m :: * -> *) a k q.
    (Quote m, Data a) =>
    (Name -> k)
    -> (Lit -> m q)
    -> (k -> [m q] -> m q)
    -> (forall b. Data b => b -> Maybe (m q))
    -> a
    -> m q
    dataToQa Name -> k
    mkCon Lit -> m q
    mkLit k -> [m q] -> m q
    appCon forall b. Data b => b -> Maybe (m q)
    antiQ) a
    t
                IntConstr Uniq
    n ->
                    Lit -> m q
    mkLit (Lit -> m q) -> Lit -> m q
    forall a b. (a -> b) -> a -> b
    $ Uniq -> Lit
    IntegerL Uniq
    n
                FloatConstr Rational
    n ->
                    Lit -> m q
    mkLit (Lit -> m q) -> Lit -> m q
    forall a b. (a -> b) -> a -> b
    $ Rational -> Lit
    RationalL Rational
    n
                CharConstr Char
    c ->
                    Lit -> m q
    mkLit (Lit -> m q) -> Lit -> m q
    forall a b. (a -> b) -> a -> b
    $ Char -> Lit
    CharL Char
    c
            where
              constr :: Constr
              constr :: Constr
    constr = a -> Constr
    forall a. Data a => a -> Constr
    toConstr a
    t

          Just m q
    y -> m q
    y

    {- Note [Data for non-algebraic types]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Class Data was originally intended for algebraic data types.  But
    it is possible to use it for abstract types too.  For example, in
    package `text` we find

      instance Data Text where
        ...
        toConstr _ = packConstr

      packConstr :: Constr
      packConstr = mkConstr textDataType "pack" [] Prefix

    Here `packConstr` isn't a real data constructor, it's an ordinary
    function.  Two complications

    * In such a case, we must take care to build the Name using
      mkNameG_v (for values), not mkNameG_d (for data constructors).
      See #10796.

    * The pseudo-constructor is named only by its string, here "pack".
      But 'dataToQa' needs the TyCon of its defining module, and has
      to assume it's defined in the same module as the TyCon itself.
      But nothing enforces that; #12596 shows what goes wrong if
      "pack" is defined in a different module than the data type "Text".
      -}

    -- | 'dataToExpQ' converts a value to a 'Exp' representation of the
    -- same value, in the SYB style. It is generalized to take a function
    -- override type-specific cases; see 'liftData' for a more commonly
    -- used variant.
    dataToExpQ  ::  (Quote m, Data a)
                =>  (forall b . Data b => b -> Maybe (m Exp))
                ->  a
                ->  m Exp
    dataToExpQ :: forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ = (Name -> m Exp)
    -> (Lit -> m Exp)
    -> (m Exp -> [m Exp] -> m Exp)
    -> (forall b. Data b => b -> Maybe (m Exp))
    -> a
    -> m Exp
    forall (m :: * -> *) a k q.
    (Quote m, Data a) =>
    (Name -> k)
    -> (Lit -> m q)
    -> (k -> [m q] -> m q)
    -> (forall b. Data b => b -> Maybe (m q))
    -> a
    -> m q
    dataToQa Name -> m Exp
    forall {m :: * -> *}. Monad m => Name -> m Exp
    varOrConE Lit -> m Exp
    forall {m :: * -> *}. Monad m => Lit -> m Exp
    litE ((m Exp -> m Exp -> m Exp) -> m Exp -> [m Exp] -> m Exp
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl m Exp -> m Exp -> m Exp
    forall {m :: * -> *}. Monad m => m Exp -> m Exp -> m Exp
    appE)
        where
              -- Make sure that VarE is used if the Constr value relies on a
              -- function underneath the surface (instead of a constructor).
              -- See #10796.
              varOrConE :: Name -> m Exp
    varOrConE Name
    s =
                case Name -> Maybe NameSpace
    nameSpace Name
    s of
                     Just NameSpace
    VarName  -> Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> Exp
    VarE Name
    s)
                     Just NameSpace
    DataName -> Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> Exp
    ConE Name
    s)
                     Maybe NameSpace
    _ -> String -> m Exp
    forall a. HasCallStack => String -> a
    error (String -> m Exp) -> String -> m Exp
    forall a b. (a -> b) -> a -> b
    $ String
    "Can't construct an expression from name "
                               String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Name -> String
    showName Name
    s
              appE :: m Exp -> m Exp -> m Exp
    appE m Exp
    x m Exp
    y = do { Exp
    a <- m Exp
    x; Exp
    b <- m Exp
    y; Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Exp -> Exp -> Exp
    AppE Exp
    a Exp
    b)}
              litE :: Lit -> m Exp
    litE Lit
    c = Exp -> m Exp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Exp
    LitE Lit
    c)

    -- | 'liftData' is a variant of 'lift' in the 'Lift' type class which
    -- works for any type with a 'Data' instance.
    liftData :: (Quote m, Data a) => a -> m Exp
    liftData :: forall (m :: * -> *) a. (Quote m, Data a) => a -> m Exp
    liftData = (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ (Maybe (m Exp) -> b -> Maybe (m Exp)
    forall a b. a -> b -> a
    const Maybe (m Exp)
    forall a. Maybe a
    Nothing)

    -- | 'dataToPatQ' converts a value to a 'Pat' representation of the same
    -- value, in the SYB style. It takes a function to handle type-specific cases,
    -- alternatively, pass @const Nothing@ to get default behavior.
    dataToPatQ  ::  (Quote m, Data a)
                =>  (forall b . Data b => b -> Maybe (m Pat))
                ->  a
                ->  m Pat
    dataToPatQ :: forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ = (Name -> Name)
    -> (Lit -> m Pat)
    -> (Name -> [m Pat] -> m Pat)
    -> (forall b. Data b => b -> Maybe (m Pat))
    -> a
    -> m Pat
    forall (m :: * -> *) a k q.
    (Quote m, Data a) =>
    (Name -> k)
    -> (Lit -> m q)
    -> (k -> [m q] -> m q)
    -> (forall b. Data b => b -> Maybe (m q))
    -> a
    -> m q
    dataToQa Name -> Name
    forall a. a -> a
    id Lit -> m Pat
    forall {m :: * -> *}. Monad m => Lit -> m Pat
    litP Name -> [m Pat] -> m Pat
    forall {m :: * -> *}. Monad m => Name -> [m Pat] -> m Pat
    conP
        where litP :: Lit -> m Pat
    litP Lit
    l = Pat -> m Pat
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Lit -> Pat
    LitP Lit
    l)
              conP :: Name -> [m Pat] -> m Pat
    conP Name
    n [m Pat]
    ps =
                case Name -> Maybe NameSpace
    nameSpace Name
    n of
                    Just NameSpace
    DataName -> do
                        [Pat]
    ps' <- [m Pat] -> m [Pat]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence [m Pat]
    ps
                        Pat -> m Pat
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> [Pat] -> Pat
    ConP Name
    n [Pat]
    ps')
                    Maybe NameSpace
    _ -> String -> m Pat
    forall a. HasCallStack => String -> a
    error (String -> m Pat) -> String -> m Pat
    forall a b. (a -> b) -> a -> b
    $ String
    "Can't construct a pattern from name "
                              String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Name -> String
    showName Name
    n

    -----------------------------------------------------
    --              Names and uniques
    -----------------------------------------------------

    newtype ModName = ModName String        -- Module name
     deriving (Int -> ModName -> String -> String
    [ModName] -> String -> String
    ModName -> String
    (Int -> ModName -> String -> String)
    -> (ModName -> String)
    -> ([ModName] -> String -> String)
    -> Show ModName
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [ModName] -> String -> String
    $cshowList :: [ModName] -> String -> String
    show :: ModName -> String
    $cshow :: ModName -> String
    showsPrec :: Int -> ModName -> String -> String
    $cshowsPrec :: Int -> ModName -> String -> String
    Show,ModName -> ModName -> Bool
    (ModName -> ModName -> Bool)
    -> (ModName -> ModName -> Bool) -> Eq ModName
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: ModName -> ModName -> Bool
    $c/= :: ModName -> ModName -> Bool
    == :: ModName -> ModName -> Bool
    $c== :: ModName -> ModName -> Bool
    Eq,Eq ModName
    Eq ModName
    -> (ModName -> ModName -> Ordering)
    -> (ModName -> ModName -> Bool)
    -> (ModName -> ModName -> Bool)
    -> (ModName -> ModName -> Bool)
    -> (ModName -> ModName -> Bool)
    -> (ModName -> ModName -> ModName)
    -> (ModName -> ModName -> ModName)
    -> Ord ModName
    ModName -> ModName -> Bool
    ModName -> ModName -> Ordering
    ModName -> ModName -> ModName
    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
    min :: ModName -> ModName -> ModName
    $cmin :: ModName -> ModName -> ModName
    max :: ModName -> ModName -> ModName
    $cmax :: ModName -> ModName -> ModName
    >= :: ModName -> ModName -> Bool
    $c>= :: ModName -> ModName -> Bool
    > :: ModName -> ModName -> Bool
    $c> :: ModName -> ModName -> Bool
    <= :: ModName -> ModName -> Bool
    $c<= :: ModName -> ModName -> Bool
    < :: ModName -> ModName -> Bool
    $c< :: ModName -> ModName -> Bool
    compare :: ModName -> ModName -> Ordering
    $ccompare :: ModName -> ModName -> Ordering
    Ord,Typeable ModName
    Typeable ModName
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> ModName -> c ModName)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ModName)
    -> (ModName -> Constr)
    -> (ModName -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ModName))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName))
    -> ((forall b. Data b => b -> b) -> ModName -> ModName)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ModName -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ModName -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ModName -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> ModName -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ModName -> m ModName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ModName -> m ModName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ModName -> m ModName)
    -> Data ModName
    ModName -> DataType
    ModName -> Constr
    (forall b. Data b => b -> b) -> ModName -> ModName
    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) -> ModName -> u
    forall u. (forall d. Data d => d -> u) -> ModName -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModName -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModName -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModName -> m ModName
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModName -> m ModName
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModName
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModName -> c ModName
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModName)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModName -> m ModName
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModName -> m ModName
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModName -> m ModName
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModName -> m ModName
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModName -> m ModName
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModName -> m ModName
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModName -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModName -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ModName -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModName -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModName -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModName -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModName -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModName -> r
    gmapT :: (forall b. Data b => b -> b) -> ModName -> ModName
    $cgmapT :: (forall b. Data b => b -> b) -> ModName -> ModName
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModName)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModName)
    dataTypeOf :: ModName -> DataType
    $cdataTypeOf :: ModName -> DataType
    toConstr :: ModName -> Constr
    $ctoConstr :: ModName -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModName
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModName
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModName -> c ModName
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModName -> c ModName
    Data,(forall x. ModName -> Rep ModName x)
    -> (forall x. Rep ModName x -> ModName) -> Generic ModName
    forall x. Rep ModName x -> ModName
    forall x. ModName -> Rep ModName x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ModName x -> ModName
    $cfrom :: forall x. ModName -> Rep ModName x
    Generic)

    newtype PkgName = PkgName String        -- package name
     deriving (Int -> PkgName -> String -> String
    [PkgName] -> String -> String
    PkgName -> String
    (Int -> PkgName -> String -> String)
    -> (PkgName -> String)
    -> ([PkgName] -> String -> String)
    -> Show PkgName
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [PkgName] -> String -> String
    $cshowList :: [PkgName] -> String -> String
    show :: PkgName -> String
    $cshow :: PkgName -> String
    showsPrec :: Int -> PkgName -> String -> String
    $cshowsPrec :: Int -> PkgName -> String -> String
    Show,PkgName -> PkgName -> Bool
    (PkgName -> PkgName -> Bool)
    -> (PkgName -> PkgName -> Bool) -> Eq PkgName
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: PkgName -> PkgName -> Bool
    $c/= :: PkgName -> PkgName -> Bool
    == :: PkgName -> PkgName -> Bool
    $c== :: PkgName -> PkgName -> Bool
    Eq,Eq PkgName
    Eq PkgName
    -> (PkgName -> PkgName -> Ordering)
    -> (PkgName -> PkgName -> Bool)
    -> (PkgName -> PkgName -> Bool)
    -> (PkgName -> PkgName -> Bool)
    -> (PkgName -> PkgName -> Bool)
    -> (PkgName -> PkgName -> PkgName)
    -> (PkgName -> PkgName -> PkgName)
    -> Ord PkgName
    PkgName -> PkgName -> Bool
    PkgName -> PkgName -> Ordering
    PkgName -> PkgName -> PkgName
    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
    min :: PkgName -> PkgName -> PkgName
    $cmin :: PkgName -> PkgName -> PkgName
    max :: PkgName -> PkgName -> PkgName
    $cmax :: PkgName -> PkgName -> PkgName
    >= :: PkgName -> PkgName -> Bool
    $c>= :: PkgName -> PkgName -> Bool
    > :: PkgName -> PkgName -> Bool
    $c> :: PkgName -> PkgName -> Bool
    <= :: PkgName -> PkgName -> Bool
    $c<= :: PkgName -> PkgName -> Bool
    < :: PkgName -> PkgName -> Bool
    $c< :: PkgName -> PkgName -> Bool
    compare :: PkgName -> PkgName -> Ordering
    $ccompare :: PkgName -> PkgName -> Ordering
    Ord,Typeable PkgName
    Typeable PkgName
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> PkgName -> c PkgName)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c PkgName)
    -> (PkgName -> Constr)
    -> (PkgName -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c PkgName))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName))
    -> ((forall b. Data b => b -> b) -> PkgName -> PkgName)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> PkgName -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> PkgName -> r)
    -> (forall u. (forall d. Data d => d -> u) -> PkgName -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> PkgName -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> PkgName -> m PkgName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PkgName -> m PkgName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PkgName -> m PkgName)
    -> Data PkgName
    PkgName -> DataType
    PkgName -> Constr
    (forall b. Data b => b -> b) -> PkgName -> PkgName
    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) -> PkgName -> u
    forall u. (forall d. Data d => d -> u) -> PkgName -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PkgName -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PkgName -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PkgName -> m PkgName
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PkgName -> m PkgName
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PkgName
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PkgName -> c PkgName
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PkgName)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PkgName -> m PkgName
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PkgName -> m PkgName
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PkgName -> m PkgName
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PkgName -> m PkgName
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PkgName -> m PkgName
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PkgName -> m PkgName
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PkgName -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PkgName -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> PkgName -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> PkgName -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PkgName -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PkgName -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PkgName -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PkgName -> r
    gmapT :: (forall b. Data b => b -> b) -> PkgName -> PkgName
    $cgmapT :: (forall b. Data b => b -> b) -> PkgName -> PkgName
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PkgName)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PkgName)
    dataTypeOf :: PkgName -> DataType
    $cdataTypeOf :: PkgName -> DataType
    toConstr :: PkgName -> Constr
    $ctoConstr :: PkgName -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PkgName
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PkgName
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PkgName -> c PkgName
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PkgName -> c PkgName
    Data,(forall x. PkgName -> Rep PkgName x)
    -> (forall x. Rep PkgName x -> PkgName) -> Generic PkgName
    forall x. Rep PkgName x -> PkgName
    forall x. PkgName -> Rep PkgName x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep PkgName x -> PkgName
    $cfrom :: forall x. PkgName -> Rep PkgName x
    Generic)

    -- | Obtained from 'reifyModule' and 'Language.Haskell.TH.Lib.thisModule'.
    data Module = Module PkgName ModName -- package qualified module name
     deriving (Int -> Module -> String -> String
    [Module] -> String -> String
    Module -> String
    (Int -> Module -> String -> String)
    -> (Module -> String)
    -> ([Module] -> String -> String)
    -> Show Module
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Module] -> String -> String
    $cshowList :: [Module] -> String -> String
    show :: Module -> String
    $cshow :: Module -> String
    showsPrec :: Int -> Module -> String -> String
    $cshowsPrec :: Int -> Module -> String -> String
    Show,Module -> Module -> Bool
    (Module -> Module -> Bool)
    -> (Module -> Module -> Bool) -> Eq Module
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Module -> Module -> Bool
    $c/= :: Module -> Module -> Bool
    == :: Module -> Module -> Bool
    $c== :: Module -> Module -> Bool
    Eq,Eq Module
    Eq Module
    -> (Module -> Module -> Ordering)
    -> (Module -> Module -> Bool)
    -> (Module -> Module -> Bool)
    -> (Module -> Module -> Bool)
    -> (Module -> Module -> Bool)
    -> (Module -> Module -> Module)
    -> (Module -> Module -> Module)
    -> Ord Module
    Module -> Module -> Bool
    Module -> Module -> Ordering
    Module -> Module -> Module
    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
    min :: Module -> Module -> Module
    $cmin :: Module -> Module -> Module
    max :: Module -> Module -> Module
    $cmax :: Module -> Module -> Module
    >= :: Module -> Module -> Bool
    $c>= :: Module -> Module -> Bool
    > :: Module -> Module -> Bool
    $c> :: Module -> Module -> Bool
    <= :: Module -> Module -> Bool
    $c<= :: Module -> Module -> Bool
    < :: Module -> Module -> Bool
    $c< :: Module -> Module -> Bool
    compare :: Module -> Module -> Ordering
    $ccompare :: Module -> Module -> Ordering
    Ord,Typeable Module
    Typeable Module
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Module -> c Module)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Module)
    -> (Module -> Constr)
    -> (Module -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Module))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module))
    -> ((forall b. Data b => b -> b) -> Module -> Module)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Module -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Module -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Module -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Module -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Module -> m Module)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Module -> m Module)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Module -> m Module)
    -> Data Module
    Module -> DataType
    Module -> Constr
    (forall b. Data b => b -> b) -> Module -> Module
    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) -> Module -> u
    forall u. (forall d. Data d => d -> u) -> Module -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module -> c Module
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Module)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    gmapT :: (forall b. Data b => b -> b) -> Module -> Module
    $cgmapT :: (forall b. Data b => b -> b) -> Module -> Module
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Module)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Module)
    dataTypeOf :: Module -> DataType
    $cdataTypeOf :: Module -> DataType
    toConstr :: Module -> Constr
    $ctoConstr :: Module -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module -> c Module
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module -> c Module
    Data,(forall x. Module -> Rep Module x)
    -> (forall x. Rep Module x -> Module) -> Generic Module
    forall x. Rep Module x -> Module
    forall x. Module -> Rep Module x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Module x -> Module
    $cfrom :: forall x. Module -> Rep Module x
    Generic)

    newtype OccName = OccName String
     deriving (Int -> OccName -> String -> String
    [OccName] -> String -> String
    OccName -> String
    (Int -> OccName -> String -> String)
    -> (OccName -> String)
    -> ([OccName] -> String -> String)
    -> Show OccName
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [OccName] -> String -> String
    $cshowList :: [OccName] -> String -> String
    show :: OccName -> String
    $cshow :: OccName -> String
    showsPrec :: Int -> OccName -> String -> String
    $cshowsPrec :: Int -> OccName -> String -> String
    Show,OccName -> OccName -> Bool
    (OccName -> OccName -> Bool)
    -> (OccName -> OccName -> Bool) -> Eq OccName
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: OccName -> OccName -> Bool
    $c/= :: OccName -> OccName -> Bool
    == :: OccName -> OccName -> Bool
    $c== :: OccName -> OccName -> Bool
    Eq,Eq OccName
    Eq OccName
    -> (OccName -> OccName -> Ordering)
    -> (OccName -> OccName -> Bool)
    -> (OccName -> OccName -> Bool)
    -> (OccName -> OccName -> Bool)
    -> (OccName -> OccName -> Bool)
    -> (OccName -> OccName -> OccName)
    -> (OccName -> OccName -> OccName)
    -> Ord OccName
    OccName -> OccName -> Bool
    OccName -> OccName -> Ordering
    OccName -> OccName -> OccName
    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
    min :: OccName -> OccName -> OccName
    $cmin :: OccName -> OccName -> OccName
    max :: OccName -> OccName -> OccName
    $cmax :: OccName -> OccName -> OccName
    >= :: OccName -> OccName -> Bool
    $c>= :: OccName -> OccName -> Bool
    > :: OccName -> OccName -> Bool
    $c> :: OccName -> OccName -> Bool
    <= :: OccName -> OccName -> Bool
    $c<= :: OccName -> OccName -> Bool
    < :: OccName -> OccName -> Bool
    $c< :: OccName -> OccName -> Bool
    compare :: OccName -> OccName -> Ordering
    $ccompare :: OccName -> OccName -> Ordering
    Ord,Typeable OccName
    Typeable OccName
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> OccName -> c OccName)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c OccName)
    -> (OccName -> Constr)
    -> (OccName -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c OccName))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName))
    -> ((forall b. Data b => b -> b) -> OccName -> OccName)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> OccName -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> OccName -> r)
    -> (forall u. (forall d. Data d => d -> u) -> OccName -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> OccName -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> OccName -> m OccName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> OccName -> m OccName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> OccName -> m OccName)
    -> Data OccName
    OccName -> DataType
    OccName -> Constr
    (forall b. Data b => b -> b) -> OccName -> OccName
    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) -> OccName -> u
    forall u. (forall d. Data d => d -> u) -> OccName -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OccName -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OccName -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OccName -> m OccName
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OccName -> m OccName
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OccName
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> OccName -> c OccName
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OccName)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OccName -> m OccName
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OccName -> m OccName
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OccName -> m OccName
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OccName -> m OccName
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OccName -> m OccName
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OccName -> m OccName
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OccName -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OccName -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> OccName -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> OccName -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OccName -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OccName -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OccName -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OccName -> r
    gmapT :: (forall b. Data b => b -> b) -> OccName -> OccName
    $cgmapT :: (forall b. Data b => b -> b) -> OccName -> OccName
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OccName)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OccName)
    dataTypeOf :: OccName -> DataType
    $cdataTypeOf :: OccName -> DataType
    toConstr :: OccName -> Constr
    $ctoConstr :: OccName -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OccName
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OccName
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> OccName -> c OccName
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> OccName -> c OccName
    Data,(forall x. OccName -> Rep OccName x)
    -> (forall x. Rep OccName x -> OccName) -> Generic OccName
    forall x. Rep OccName x -> OccName
    forall x. OccName -> Rep OccName x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep OccName x -> OccName
    $cfrom :: forall x. OccName -> Rep OccName x
    Generic)

    mkModName :: String -> ModName
    mkModName :: String -> ModName
    mkModName String
    s = String -> ModName
    ModName String
    s

    modString :: ModName -> String
    modString :: ModName -> String
    modString (ModName String
    m) = String
    m

    mkPkgName :: String -> PkgName
    mkPkgName :: String -> PkgName
    mkPkgName String
    s = String -> PkgName
    PkgName String
    s

    pkgString :: PkgName -> String
    pkgString :: PkgName -> String
    pkgString (PkgName String
    m) = String
    m

    -----------------------------------------------------
    --              OccName
    -----------------------------------------------------

    mkOccName :: String -> OccName
    mkOccName :: String -> OccName
    mkOccName String
    s = String -> OccName
    OccName String
    s

    occString :: OccName -> String
    occString :: OccName -> String
    occString (OccName String
    occ) = String
    occ

    -----------------------------------------------------
    --               Names
    -----------------------------------------------------
    --
    -- For "global" names ('NameG') we need a totally unique name,
    -- so we must include the name-space of the thing
    --
    -- For unique-numbered things ('NameU'), we've got a unique reference
    -- anyway, so no need for name space
    --
    -- For dynamically bound thing ('NameS') we probably want them to
    -- in a context-dependent way, so again we don't want the name
    -- space.  For example:
    --
    -- > let v = mkName "T" in [| data $v = $v |]
    --
    -- Here we use the same Name for both type constructor and data constructor
    --
    --
    -- NameL and NameG are bound *outside* the TH syntax tree
    -- either globally (NameG) or locally (NameL). Ex:
    --
    -- > f x = $(h [| (map, x) |])
    --
    -- The 'map' will be a NameG, and 'x' wil be a NameL
    --
    -- These Names should never appear in a binding position in a TH syntax tree

    {- $namecapture #namecapture#
    Much of 'Name' API is concerned with the problem of /name capture/, which
    can be seen in the following example.

    > f expr = [| let x = 0 in $expr |]
    > ...
    > g x = $( f [| x |] )
    > h y = $( f [| y |] )

    A naive desugaring of this would yield:

    > g x = let x = 0 in x
    > h y = let x = 0 in y

    All of a sudden, @g@ and @h@ have different meanings! In this case,
    we say that the @x@ in the RHS of @g@ has been /captured/
    by the binding of @x@ in @f@.

    What we actually want is for the @x@ in @f@ to be distinct from the
    @x@ in @g@, so we get the following desugaring:

    > g x = let x' = 0 in x
    > h y = let x' = 0 in y

    which avoids name capture as desired.

    In the general case, we say that a @Name@ can be captured if
    the thing it refers to can be changed by adding new declarations.
    -}

    {- |
    An abstract type representing names in the syntax tree.

    'Name's can be constructed in several ways, which come with different
    name-capture guarantees (see "Language.Haskell.TH.Syntax#namecapture" for
    an explanation of name capture):

      * the built-in syntax @'f@ and @''T@ can be used to construct names,
        The expression @'f@ gives a @Name@ which refers to the value @f@
        currently in scope, and @''T@ gives a @Name@ which refers to the
        type @T@ currently in scope. These names can never be captured.

      * 'lookupValueName' and 'lookupTypeName' are similar to @'f@ and
         @''T@ respectively, but the @Name@s are looked up at the point
         where the current splice is being run. These names can never be
         captured.

      * 'newName' monadically generates a new name, which can never
         be captured.

      * 'mkName' generates a capturable name.

    Names constructed using @newName@ and @mkName@ may be used in bindings
    (such as @let x = ...@ or @\x -> ...@), but names constructed using
    @lookupValueName@, @lookupTypeName@, @'f@, @''T@ may not.
    -}
    data Name = Name OccName NameFlavour deriving (Typeable Name
    Typeable Name
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Name -> c Name)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Name)
    -> (Name -> Constr)
    -> (Name -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Name))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name))
    -> ((forall b. Data b => b -> b) -> Name -> Name)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Name -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Name -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Name -> m Name)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Name -> m Name)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Name -> m Name)
    -> Data Name
    Name -> DataType
    Name -> Constr
    (forall b. Data b => b -> b) -> Name -> Name
    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) -> Name -> u
    forall u. (forall d. Data d => d -> u) -> Name -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name -> m Name
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Name
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Name -> c Name
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Name)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name -> m Name
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name -> m Name
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
    gmapT :: (forall b. Data b => b -> b) -> Name -> Name
    $cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Name)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Name)
    dataTypeOf :: Name -> DataType
    $cdataTypeOf :: Name -> DataType
    toConstr :: Name -> Constr
    $ctoConstr :: Name -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Name
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Name
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Name -> c Name
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Name -> c Name
    Data, Name -> Name -> Bool
    (Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Name -> Name -> Bool
    $c/= :: Name -> Name -> Bool
    == :: Name -> Name -> Bool
    $c== :: Name -> Name -> Bool
    Eq, (forall x. Name -> Rep Name x)
    -> (forall x. Rep Name x -> Name) -> Generic Name
    forall x. Rep Name x -> Name
    forall x. Name -> Rep Name x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Name x -> Name
    $cfrom :: forall x. Name -> Rep Name x
    Generic)

    instance Ord Name where
        -- check if unique is different before looking at strings
      (Name OccName
    o1 NameFlavour
    f1) compare :: Name -> Name -> Ordering
    `compare` (Name OccName
    o2 NameFlavour
    f2) = (NameFlavour
    f1 NameFlavour -> NameFlavour -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` NameFlavour
    f2)   Ordering -> Ordering -> Ordering
    `thenCmp`
                                            (OccName
    o1 OccName -> OccName -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` OccName
    o2)

    data NameFlavour
      = NameS           -- ^ An unqualified name; dynamically bound
      | NameQ ModName   -- ^ A qualified name; dynamically bound
      | NameU !Uniq     -- ^ A unique local name
      | NameL !Uniq     -- ^ Local name bound outside of the TH AST
      | NameG NameSpace PkgName ModName -- ^ Global name bound outside of the TH AST:
                    -- An original name (occurrences only, not binders)
                    -- Need the namespace too to be sure which
                    -- thing we are naming
      deriving ( Typeable NameFlavour
    Typeable NameFlavour
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> NameFlavour -> c NameFlavour)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c NameFlavour)
    -> (NameFlavour -> Constr)
    -> (NameFlavour -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c NameFlavour))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c NameFlavour))
    -> ((forall b. Data b => b -> b) -> NameFlavour -> NameFlavour)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r)
    -> (forall u. (forall d. Data d => d -> u) -> NameFlavour -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> NameFlavour -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour)
    -> Data NameFlavour
    NameFlavour -> DataType
    NameFlavour -> Constr
    (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour
    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) -> NameFlavour -> u
    forall u. (forall d. Data d => d -> u) -> NameFlavour -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameFlavour
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameFlavour -> c NameFlavour
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameFlavour)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NameFlavour)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameFlavour -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameFlavour -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> NameFlavour -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameFlavour -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
    gmapT :: (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour
    $cgmapT :: (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NameFlavour)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NameFlavour)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameFlavour)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameFlavour)
    dataTypeOf :: NameFlavour -> DataType
    $cdataTypeOf :: NameFlavour -> DataType
    toConstr :: NameFlavour -> Constr
    $ctoConstr :: NameFlavour -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameFlavour
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameFlavour
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameFlavour -> c NameFlavour
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameFlavour -> c NameFlavour
    Data, NameFlavour -> NameFlavour -> Bool
    (NameFlavour -> NameFlavour -> Bool)
    -> (NameFlavour -> NameFlavour -> Bool) -> Eq NameFlavour
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: NameFlavour -> NameFlavour -> Bool
    $c/= :: NameFlavour -> NameFlavour -> Bool
    == :: NameFlavour -> NameFlavour -> Bool
    $c== :: NameFlavour -> NameFlavour -> Bool
    Eq, Eq NameFlavour
    Eq NameFlavour
    -> (NameFlavour -> NameFlavour -> Ordering)
    -> (NameFlavour -> NameFlavour -> Bool)
    -> (NameFlavour -> NameFlavour -> Bool)
    -> (NameFlavour -> NameFlavour -> Bool)
    -> (NameFlavour -> NameFlavour -> Bool)
    -> (NameFlavour -> NameFlavour -> NameFlavour)
    -> (NameFlavour -> NameFlavour -> NameFlavour)
    -> Ord NameFlavour
    NameFlavour -> NameFlavour -> Bool
    NameFlavour -> NameFlavour -> Ordering
    NameFlavour -> NameFlavour -> NameFlavour
    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
    min :: NameFlavour -> NameFlavour -> NameFlavour
    $cmin :: NameFlavour -> NameFlavour -> NameFlavour
    max :: NameFlavour -> NameFlavour -> NameFlavour
    $cmax :: NameFlavour -> NameFlavour -> NameFlavour
    >= :: NameFlavour -> NameFlavour -> Bool
    $c>= :: NameFlavour -> NameFlavour -> Bool
    > :: NameFlavour -> NameFlavour -> Bool
    $c> :: NameFlavour -> NameFlavour -> Bool
    <= :: NameFlavour -> NameFlavour -> Bool
    $c<= :: NameFlavour -> NameFlavour -> Bool
    < :: NameFlavour -> NameFlavour -> Bool
    $c< :: NameFlavour -> NameFlavour -> Bool
    compare :: NameFlavour -> NameFlavour -> Ordering
    $ccompare :: NameFlavour -> NameFlavour -> Ordering
    Ord, Int -> NameFlavour -> String -> String
    [NameFlavour] -> String -> String
    NameFlavour -> String
    (Int -> NameFlavour -> String -> String)
    -> (NameFlavour -> String)
    -> ([NameFlavour] -> String -> String)
    -> Show NameFlavour
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [NameFlavour] -> String -> String
    $cshowList :: [NameFlavour] -> String -> String
    show :: NameFlavour -> String
    $cshow :: NameFlavour -> String
    showsPrec :: Int -> NameFlavour -> String -> String
    $cshowsPrec :: Int -> NameFlavour -> String -> String
    Show, (forall x. NameFlavour -> Rep NameFlavour x)
    -> (forall x. Rep NameFlavour x -> NameFlavour)
    -> Generic NameFlavour
    forall x. Rep NameFlavour x -> NameFlavour
    forall x. NameFlavour -> Rep NameFlavour x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep NameFlavour x -> NameFlavour
    $cfrom :: forall x. NameFlavour -> Rep NameFlavour x
    Generic )

    data NameSpace = VarName        -- ^ Variables
                   | DataName       -- ^ Data constructors
                   | TcClsName      -- ^ Type constructors and classes; Haskell has them
                                    -- in the same name space for now.
                   deriving( NameSpace -> NameSpace -> Bool
    (NameSpace -> NameSpace -> Bool)
    -> (NameSpace -> NameSpace -> Bool) -> Eq NameSpace
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: NameSpace -> NameSpace -> Bool
    $c/= :: NameSpace -> NameSpace -> Bool
    == :: NameSpace -> NameSpace -> Bool
    $c== :: NameSpace -> NameSpace -> Bool
    Eq, Eq NameSpace
    Eq NameSpace
    -> (NameSpace -> NameSpace -> Ordering)
    -> (NameSpace -> NameSpace -> Bool)
    -> (NameSpace -> NameSpace -> Bool)
    -> (NameSpace -> NameSpace -> Bool)
    -> (NameSpace -> NameSpace -> Bool)
    -> (NameSpace -> NameSpace -> NameSpace)
    -> (NameSpace -> NameSpace -> NameSpace)
    -> Ord NameSpace
    NameSpace -> NameSpace -> Bool
    NameSpace -> NameSpace -> Ordering
    NameSpace -> NameSpace -> NameSpace
    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
    min :: NameSpace -> NameSpace -> NameSpace
    $cmin :: NameSpace -> NameSpace -> NameSpace
    max :: NameSpace -> NameSpace -> NameSpace
    $cmax :: NameSpace -> NameSpace -> NameSpace
    >= :: NameSpace -> NameSpace -> Bool
    $c>= :: NameSpace -> NameSpace -> Bool
    > :: NameSpace -> NameSpace -> Bool
    $c> :: NameSpace -> NameSpace -> Bool
    <= :: NameSpace -> NameSpace -> Bool
    $c<= :: NameSpace -> NameSpace -> Bool
    < :: NameSpace -> NameSpace -> Bool
    $c< :: NameSpace -> NameSpace -> Bool
    compare :: NameSpace -> NameSpace -> Ordering
    $ccompare :: NameSpace -> NameSpace -> Ordering
    Ord, Int -> NameSpace -> String -> String
    [NameSpace] -> String -> String
    NameSpace -> String
    (Int -> NameSpace -> String -> String)
    -> (NameSpace -> String)
    -> ([NameSpace] -> String -> String)
    -> Show NameSpace
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [NameSpace] -> String -> String
    $cshowList :: [NameSpace] -> String -> String
    show :: NameSpace -> String
    $cshow :: NameSpace -> String
    showsPrec :: Int -> NameSpace -> String -> String
    $cshowsPrec :: Int -> NameSpace -> String -> String
    Show, Typeable NameSpace
    Typeable NameSpace
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> NameSpace -> c NameSpace)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c NameSpace)
    -> (NameSpace -> Constr)
    -> (NameSpace -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c NameSpace))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace))
    -> ((forall b. Data b => b -> b) -> NameSpace -> NameSpace)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> NameSpace -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> NameSpace -> r)
    -> (forall u. (forall d. Data d => d -> u) -> NameSpace -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> NameSpace -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace)
    -> Data NameSpace
    NameSpace -> DataType
    NameSpace -> Constr
    (forall b. Data b => b -> b) -> NameSpace -> NameSpace
    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) -> NameSpace -> u
    forall u. (forall d. Data d => d -> u) -> NameSpace -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameSpace -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameSpace -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameSpace
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameSpace -> c NameSpace
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameSpace)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameSpace -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameSpace -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> NameSpace -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameSpace -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameSpace -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameSpace -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameSpace -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameSpace -> r
    gmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace
    $cgmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameSpace)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameSpace)
    dataTypeOf :: NameSpace -> DataType
    $cdataTypeOf :: NameSpace -> DataType
    toConstr :: NameSpace -> Constr
    $ctoConstr :: NameSpace -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameSpace
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameSpace
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameSpace -> c NameSpace
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameSpace -> c NameSpace
    Data, (forall x. NameSpace -> Rep NameSpace x)
    -> (forall x. Rep NameSpace x -> NameSpace) -> Generic NameSpace
    forall x. Rep NameSpace x -> NameSpace
    forall x. NameSpace -> Rep NameSpace x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep NameSpace x -> NameSpace
    $cfrom :: forall x. NameSpace -> Rep NameSpace x
    Generic )

    -- | @Uniq@ is used by GHC to distinguish names from each other.
    type Uniq = Integer

    -- | The name without its module prefix.
    --
    -- ==== __Examples__
    --
    -- >>> nameBase ''Data.Either.Either
    -- "Either"
    -- >>> nameBase (mkName "foo")
    -- "foo"
    -- >>> nameBase (mkName "Module.foo")
    -- "foo"
    nameBase :: Name -> String
    nameBase :: Name -> String
    nameBase (Name OccName
    occ NameFlavour
    _) = OccName -> String
    occString OccName
    occ

    -- | Module prefix of a name, if it exists.
    --
    -- ==== __Examples__
    --
    -- >>> nameModule ''Data.Either.Either
    -- Just "Data.Either"
    -- >>> nameModule (mkName "foo")
    -- Nothing
    -- >>> nameModule (mkName "Module.foo")
    -- Just "Module"
    nameModule :: Name -> Maybe String
    nameModule :: Name -> Maybe String
    nameModule (Name OccName
    _ (NameQ ModName
    m))     = String -> Maybe String
    forall a. a -> Maybe a
    Just (ModName -> String
    modString ModName
    m)
    nameModule (Name OccName
    _ (NameG NameSpace
    _ PkgName
    _ ModName
    m)) = String -> Maybe String
    forall a. a -> Maybe a
    Just (ModName -> String
    modString ModName
    m)
    nameModule Name
    _                      = Maybe String
    forall a. Maybe a
    Nothing

    -- | A name's package, if it exists.
    --
    -- ==== __Examples__
    --
    -- >>> namePackage ''Data.Either.Either
    -- Just "base"
    -- >>> namePackage (mkName "foo")
    -- Nothing
    -- >>> namePackage (mkName "Module.foo")
    -- Nothing
    namePackage :: Name -> Maybe String
    namePackage :: Name -> Maybe String
    namePackage (Name OccName
    _ (NameG NameSpace
    _ PkgName
    p ModName
    _)) = String -> Maybe String
    forall a. a -> Maybe a
    Just (PkgName -> String
    pkgString PkgName
    p)
    namePackage Name
    _                      = Maybe String
    forall a. Maybe a
    Nothing

    -- | Returns whether a name represents an occurrence of a top-level variable
    -- ('VarName'), data constructor ('DataName'), type constructor, or type class
    -- ('TcClsName'). If we can't be sure, it returns 'Nothing'.
    --
    -- ==== __Examples__
    --
    -- >>> nameSpace 'Prelude.id
    -- Just VarName
    -- >>> nameSpace (mkName "id")
    -- Nothing -- only works for top-level variable names
    -- >>> nameSpace 'Data.Maybe.Just
    -- Just DataName
    -- >>> nameSpace ''Data.Maybe.Maybe
    -- Just TcClsName
    -- >>> nameSpace ''Data.Ord.Ord
    -- Just TcClsName
    nameSpace :: Name -> Maybe NameSpace
    nameSpace :: Name -> Maybe NameSpace
    nameSpace (Name OccName
    _ (NameG NameSpace
    ns PkgName
    _ ModName
    _)) = NameSpace -> Maybe NameSpace
    forall a. a -> Maybe a
    Just NameSpace
    ns
    nameSpace Name
    _                       = Maybe NameSpace
    forall a. Maybe a
    Nothing

    {- |
    Generate a capturable name. Occurrences of such names will be
    resolved according to the Haskell scoping rules at the occurrence
    site.

    For example:

    > f = [| pi + $(varE (mkName "pi")) |]
    > ...
    > g = let pi = 3 in $f

    In this case, @g@ is desugared to

    > g = Prelude.pi + 3

    Note that @mkName@ may be used with qualified names:

    > mkName "Prelude.pi"

    See also 'Language.Haskell.TH.Lib.dyn' for a useful combinator. The above example could
    be rewritten using 'Language.Haskell.TH.Lib.dyn' as

    > f = [| pi + $(dyn "pi") |]
    -}
    mkName :: String -> Name
    -- The string can have a '.', thus "Foo.baz",
    -- giving a dynamically-bound qualified name,
    -- in which case we want to generate a NameQ
    --
    -- Parse the string to see if it has a "." in it
    -- so we know whether to generate a qualified or unqualified name
    -- It's a bit tricky because we need to parse
    --
    -- > Foo.Baz.x   as    Qual Foo.Baz x
    --
    -- So we parse it from back to front
    mkName :: String -> Name
    mkName String
    str
      = String -> String -> Name
    split [] (String -> String
    forall a. [a] -> [a]
    reverse String
    str)
      where
        split :: String -> String -> Name
    split String
    occ []        = OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    occ) NameFlavour
    NameS
        split String
    occ (Char
    '.':String
    rev) | Bool -> Bool
    not (String -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null String
    occ)
                            , String -> Bool
    is_rev_mod_name String
    rev
                            = OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    occ) (ModName -> NameFlavour
    NameQ (String -> ModName
    mkModName (String -> String
    forall a. [a] -> [a]
    reverse String
    rev)))
            -- The 'not (null occ)' guard ensures that
            --      mkName "&." = Name "&." NameS
            -- The 'is_rev_mod' guards ensure that
            --      mkName ".&" = Name ".&" NameS
            --      mkName "^.." = Name "^.." NameS      -- #8633
            --      mkName "Data.Bits..&" = Name ".&" (NameQ "Data.Bits")
            -- This rather bizarre case actually happened; (.&.) is in Data.Bits
        split String
    occ (Char
    c:String
    rev)   = String -> String -> Name
    split (Char
    cChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    occ) String
    rev

        -- Recognises a reversed module name xA.yB.C,
        -- with at least one component,
        -- and each component looks like a module name
        --   (i.e. non-empty, starts with capital, all alpha)
        is_rev_mod_name :: String -> Bool
    is_rev_mod_name String
    rev_mod_str
          | (String
    compt, String
    rest) <- (Char -> Bool) -> String -> (String, String)
    forall a. (a -> Bool) -> [a] -> ([a], [a])
    break (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '.') String
    rev_mod_str
          , Bool -> Bool
    not (String -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null String
    compt), Char -> Bool
    isUpper (String -> Char
    forall a. [a] -> a
    last String
    compt), (Char -> Bool) -> String -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all Char -> Bool
    is_mod_char String
    compt
          = case String
    rest of
              []             -> Bool
    True
              (Char
    _dot : String
    rest') -> String -> Bool
    is_rev_mod_name String
    rest'
          | Bool
    otherwise
          = Bool
    False

        is_mod_char :: Char -> Bool
    is_mod_char Char
    c = Char -> Bool
    isAlphaNum Char
    c Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '_' Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '\''

    -- | Only used internally
    mkNameU :: String -> Uniq -> Name
    mkNameU :: String -> Uniq -> Name
    mkNameU String
    s Uniq
    u = OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    s) (Uniq -> NameFlavour
    NameU Uniq
    u)

    -- | Only used internally
    mkNameL :: String -> Uniq -> Name
    mkNameL :: String -> Uniq -> Name
    mkNameL String
    s Uniq
    u = OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    s) (Uniq -> NameFlavour
    NameL Uniq
    u)

    -- | Used for 'x etc, but not available to the programmer
    mkNameG :: NameSpace -> String -> String -> String -> Name
    mkNameG :: NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    ns String
    pkg String
    modu String
    occ
      = OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    occ) (NameSpace -> PkgName -> ModName -> NameFlavour
    NameG NameSpace
    ns (String -> PkgName
    mkPkgName String
    pkg) (String -> ModName
    mkModName String
    modu))

    mkNameS :: String -> Name
    mkNameS :: String -> Name
    mkNameS String
    n = OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    n) NameFlavour
    NameS

    mkNameG_v, mkNameG_tc, mkNameG_d :: String -> String -> String -> Name
    mkNameG_v :: String -> String -> String -> Name
    mkNameG_v  = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    VarName
    mkNameG_tc :: String -> String -> String -> Name
    mkNameG_tc = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    TcClsName
    mkNameG_d :: String -> String -> String -> Name
    mkNameG_d  = NameSpace -> String -> String -> String -> Name
    mkNameG NameSpace
    DataName

    data NameIs = Alone | Applied | Infix

    showName :: Name -> String
    showName :: Name -> String
    showName = NameIs -> Name -> String
    showName' NameIs
    Alone

    showName' :: NameIs -> Name -> String
    showName' :: NameIs -> Name -> String
    showName' NameIs
    ni Name
    nm
     = case NameIs
    ni of
           NameIs
    Alone        -> String
    nms
           NameIs
    Applied
            | Bool
    pnam      -> String
    nms
            | Bool
    otherwise -> String
    "(" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    nms String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ")"
           NameIs
    Infix
            | Bool
    pnam      -> String
    "`" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    nms String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "`"
            | Bool
    otherwise -> String
    nms
        where
            -- For now, we make the NameQ and NameG print the same, even though
            -- NameQ is a qualified name (so what it means depends on what the
            -- current scope is), and NameG is an original name (so its meaning
            -- should be independent of what's in scope.
            -- We may well want to distinguish them in the end.
            -- Ditto NameU and NameL
            nms :: String
    nms = case Name
    nm of
                        Name OccName
    occ NameFlavour
    NameS         -> OccName -> String
    occString OccName
    occ
                        Name OccName
    occ (NameQ ModName
    m)     -> ModName -> String
    modString ModName
    m String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "." String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ OccName -> String
    occString OccName
    occ
                        Name OccName
    occ (NameG NameSpace
    _ PkgName
    _ ModName
    m) -> ModName -> String
    modString ModName
    m String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "." String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ OccName -> String
    occString OccName
    occ
                        Name OccName
    occ (NameU Uniq
    u)     -> OccName -> String
    occString OccName
    occ String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "_" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Uniq -> String
    forall a. Show a => a -> String
    show Uniq
    u
                        Name OccName
    occ (NameL Uniq
    u)     -> OccName -> String
    occString OccName
    occ String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "_" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Uniq -> String
    forall a. Show a => a -> String
    show Uniq
    u

            pnam :: Bool
    pnam = String -> Bool
    classify String
    nms

            -- True if we are function style, e.g. f, [], (,)
            -- False if we are operator style, e.g. +, :+
            classify :: String -> Bool
    classify String
    "" = Bool
    False -- shouldn't happen; . operator is handled below
            classify (Char
    x:String
    xs) | Char -> Bool
    isAlpha Char
    x Bool -> Bool -> Bool
    || (Char
    x Char -> String -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` String
    "_[]()") =
                                case (Char -> Bool) -> String -> String
    forall a. (a -> Bool) -> [a] -> [a]
    dropWhile (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /=Char
    '.') String
    xs of
                                      (Char
    _:String
    xs') -> String -> Bool
    classify String
    xs'
                                      []      -> Bool
    True
                            | Bool
    otherwise = Bool
    False

    instance Show Name where
      show :: Name -> String
    show = Name -> String
    showName

    -- Tuple data and type constructors
    -- | Tuple data constructor
    tupleDataName :: Int -> Name
    -- | Tuple type constructor
    tupleTypeName :: Int -> Name

    tupleDataName :: Int -> Name
    tupleDataName Int
    n = Int -> NameSpace -> Bool -> Name
    mk_tup_name Int
    n NameSpace
    DataName  Bool
    True
    tupleTypeName :: Int -> Name
    tupleTypeName Int
    n = Int -> NameSpace -> Bool -> Name
    mk_tup_name Int
    n NameSpace
    TcClsName Bool
    True

    -- Unboxed tuple data and type constructors
    -- | Unboxed tuple data constructor
    unboxedTupleDataName :: Int -> Name
    -- | Unboxed tuple type constructor
    unboxedTupleTypeName :: Int -> Name

    unboxedTupleDataName :: Int -> Name
    unboxedTupleDataName Int
    n = Int -> NameSpace -> Bool -> Name
    mk_tup_name Int
    n NameSpace
    DataName  Bool
    False
    unboxedTupleTypeName :: Int -> Name
    unboxedTupleTypeName Int
    n = Int -> NameSpace -> Bool -> Name
    mk_tup_name Int
    n NameSpace
    TcClsName Bool
    False

    mk_tup_name :: Int -> NameSpace -> Bool -> Name
    mk_tup_name :: Int -> NameSpace -> Bool -> Name
    mk_tup_name Int
    n NameSpace
    space Bool
    boxed
      = OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    tup_occ) (NameSpace -> PkgName -> ModName -> NameFlavour
    NameG NameSpace
    space (String -> PkgName
    mkPkgName String
    "ghc-prim") ModName
    tup_mod)
      where
        withParens :: String -> String
    withParens String
    thing
          | Bool
    boxed     = String
    "("  String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    thing String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ")"
          | Bool
    otherwise = String
    "(#" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    thing String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "#)"
        tup_occ :: String
    tup_occ | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1    = if Bool
    boxed then String
    "Solo" else String
    "Solo#"
                | Bool
    otherwise = String -> String
    withParens (Int -> Char -> String
    forall a. Int -> a -> [a]
    replicate Int
    n_commas Char
    ',')
        n_commas :: Int
    n_commas = Int
    n Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1
        tup_mod :: ModName
    tup_mod  = String -> ModName
    mkModName String
    "GHC.Tuple"

    -- Unboxed sum data and type constructors
    -- | Unboxed sum data constructor
    unboxedSumDataName :: SumAlt -> SumArity -> Name
    -- | Unboxed sum type constructor
    unboxedSumTypeName :: SumArity -> Name

    unboxedSumDataName :: Int -> Int -> Name
    unboxedSumDataName Int
    alt Int
    arity
      | Int
    alt Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    arity
      = String -> Name
    forall a. HasCallStack => String -> a
    error (String -> Name) -> String -> Name
    forall a b. (a -> b) -> a -> b
    $ String
    prefix String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "Index out of bounds." String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    debug_info

      | Int
    alt Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    0
      = String -> Name
    forall a. HasCallStack => String -> a
    error (String -> Name) -> String -> Name
    forall a b. (a -> b) -> a -> b
    $ String
    prefix String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "Alt must be > 0." String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    debug_info

      | Int
    arity Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    2
      = String -> Name
    forall a. HasCallStack => String -> a
    error (String -> Name) -> String -> Name
    forall a b. (a -> b) -> a -> b
    $ String
    prefix String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "Arity must be >= 2." String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    debug_info

      | Bool
    otherwise
      = OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    sum_occ)
             (NameSpace -> PkgName -> ModName -> NameFlavour
    NameG NameSpace
    DataName (String -> PkgName
    mkPkgName String
    "ghc-prim") (String -> ModName
    mkModName String
    "GHC.Prim"))

      where
        prefix :: String
    prefix     = String
    "unboxedSumDataName: "
        debug_info :: String
    debug_info = String
    " (alt: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    alt String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ", arity: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    arity String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ")"

        -- Synced with the definition of mkSumDataConOcc in GHC.Builtin.Types
        sum_occ :: String
    sum_occ = Char
    '(' Char -> String -> String
    forall a. a -> [a] -> [a]
    : Char
    '#' Char -> String -> String
    forall a. a -> [a] -> [a]
    : Int -> String
    bars Int
    nbars_before String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Char
    '_' Char -> String -> String
    forall a. a -> [a] -> [a]
    : Int -> String
    bars Int
    nbars_after String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "#)"
        bars :: Int -> String
    bars Int
    i = Int -> Char -> String
    forall a. Int -> a -> [a]
    replicate Int
    i Char
    '|'
        nbars_before :: Int
    nbars_before = Int
    alt Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1
        nbars_after :: Int
    nbars_after  = Int
    arity Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    alt

    unboxedSumTypeName :: Int -> Name
    unboxedSumTypeName Int
    arity
      | Int
    arity Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    2
      = String -> Name
    forall a. HasCallStack => String -> a
    error (String -> Name) -> String -> Name
    forall a b. (a -> b) -> a -> b
    $ String
    "unboxedSumTypeName: Arity must be >= 2."
             String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    " (arity: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    arity String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ")"

      | Bool
    otherwise
      = OccName -> NameFlavour -> Name
    Name (String -> OccName
    mkOccName String
    sum_occ)
             (NameSpace -> PkgName -> ModName -> NameFlavour
    NameG NameSpace
    TcClsName (String -> PkgName
    mkPkgName String
    "ghc-prim") (String -> ModName
    mkModName String
    "GHC.Prim"))

      where
        -- Synced with the definition of mkSumTyConOcc in GHC.Builtin.Types
        sum_occ :: String
    sum_occ = Char
    '(' Char -> String -> String
    forall a. a -> [a] -> [a]
    : Char
    '#' Char -> String -> String
    forall a. a -> [a] -> [a]
    : Int -> Char -> String
    forall a. Int -> a -> [a]
    replicate (Int
    arity Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1) Char
    '|' String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "#)"

    -----------------------------------------------------
    --              Locations
    -----------------------------------------------------

    data Loc
      = Loc { Loc -> String
    loc_filename :: String
            , Loc -> String
    loc_package  :: String
            , Loc -> String
    loc_module   :: String
            , Loc -> CharPos
    loc_start    :: CharPos
            , Loc -> CharPos
    loc_end      :: CharPos }
       deriving( Int -> Loc -> String -> String
    [Loc] -> String -> String
    Loc -> String
    (Int -> Loc -> String -> String)
    -> (Loc -> String) -> ([Loc] -> String -> String) -> Show Loc
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Loc] -> String -> String
    $cshowList :: [Loc] -> String -> String
    show :: Loc -> String
    $cshow :: Loc -> String
    showsPrec :: Int -> Loc -> String -> String
    $cshowsPrec :: Int -> Loc -> String -> String
    Show, Loc -> Loc -> Bool
    (Loc -> Loc -> Bool) -> (Loc -> Loc -> Bool) -> Eq Loc
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Loc -> Loc -> Bool
    $c/= :: Loc -> Loc -> Bool
    == :: Loc -> Loc -> Bool
    $c== :: Loc -> Loc -> Bool
    Eq, Eq Loc
    Eq Loc
    -> (Loc -> Loc -> Ordering)
    -> (Loc -> Loc -> Bool)
    -> (Loc -> Loc -> Bool)
    -> (Loc -> Loc -> Bool)
    -> (Loc -> Loc -> Bool)
    -> (Loc -> Loc -> Loc)
    -> (Loc -> Loc -> Loc)
    -> Ord Loc
    Loc -> Loc -> Bool
    Loc -> Loc -> Ordering
    Loc -> Loc -> Loc
    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
    min :: Loc -> Loc -> Loc
    $cmin :: Loc -> Loc -> Loc
    max :: Loc -> Loc -> Loc
    $cmax :: Loc -> Loc -> Loc
    >= :: Loc -> Loc -> Bool
    $c>= :: Loc -> Loc -> Bool
    > :: Loc -> Loc -> Bool
    $c> :: Loc -> Loc -> Bool
    <= :: Loc -> Loc -> Bool
    $c<= :: Loc -> Loc -> Bool
    < :: Loc -> Loc -> Bool
    $c< :: Loc -> Loc -> Bool
    compare :: Loc -> Loc -> Ordering
    $ccompare :: Loc -> Loc -> Ordering
    Ord, Typeable Loc
    Typeable Loc
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Loc -> c Loc)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Loc)
    -> (Loc -> Constr)
    -> (Loc -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Loc))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc))
    -> ((forall b. Data b => b -> b) -> Loc -> Loc)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Loc -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Loc -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Loc -> m Loc)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Loc -> m Loc)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Loc -> m Loc)
    -> Data Loc
    Loc -> DataType
    Loc -> Constr
    (forall b. Data b => b -> b) -> Loc -> Loc
    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) -> Loc -> u
    forall u. (forall d. Data d => d -> u) -> Loc -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Loc -> m Loc
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Loc -> m Loc
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Loc
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Loc -> c Loc
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Loc)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Loc -> m Loc
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Loc -> m Loc
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Loc -> m Loc
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Loc -> m Loc
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Loc -> m Loc
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Loc -> m Loc
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Loc -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Loc -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Loc -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Loc -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
    gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc
    $cgmapT :: (forall b. Data b => b -> b) -> Loc -> Loc
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Loc)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Loc)
    dataTypeOf :: Loc -> DataType
    $cdataTypeOf :: Loc -> DataType
    toConstr :: Loc -> Constr
    $ctoConstr :: Loc -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Loc
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Loc
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Loc -> c Loc
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Loc -> c Loc
    Data, (forall x. Loc -> Rep Loc x)
    -> (forall x. Rep Loc x -> Loc) -> Generic Loc
    forall x. Rep Loc x -> Loc
    forall x. Loc -> Rep Loc x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Loc x -> Loc
    $cfrom :: forall x. Loc -> Rep Loc x
    Generic )

    type CharPos = (Int, Int)       -- ^ Line and character position

    -----------------------------------------------------
    --
    --      The Info returned by reification
    --
    -----------------------------------------------------

    -- | Obtained from 'reify' in the 'Q' Monad.
    data Info
      =
      -- | A class, with a list of its visible instances
      ClassI
          Dec
          [InstanceDec]

      -- | A class method
      | ClassOpI
           Name
           Type
           ParentName

      -- | A \"plain\" type constructor. \"Fancier\" type constructors are returned
      -- using 'PrimTyConI' or 'FamilyI' as appropriate. At present, this reified
      -- declaration will never have derived instances attached to it (if you wish
      -- to check for an instance, see 'reifyInstances').
      | TyConI
            Dec

      -- | A type or data family, with a list of its visible instances. A closed
      -- type family is returned with 0 instances.
      | FamilyI
            Dec
            [InstanceDec]

      -- | A \"primitive\" type constructor, which can't be expressed with a 'Dec'.
      -- Examples: @(->)@, @Int#@.
      | PrimTyConI
           Name
           Arity
           Unlifted

      -- | A data constructor
      | DataConI
           Name
           Type
           ParentName

      -- | A pattern synonym
      | PatSynI
           Name
           PatSynType

      {- |
      A \"value\" variable (as opposed to a type variable, see 'TyVarI').

      The @Maybe Dec@ field contains @Just@ the declaration which
      defined the variable - including the RHS of the declaration -
      or else @Nothing@, in the case where the RHS is unavailable to
      the compiler. At present, this value is /always/ @Nothing@:
      returning the RHS has not yet been implemented because of
      lack of interest.
      -}
      | VarI
           Name
           Type
           (Maybe Dec)

      {- |
      A type variable.

      The @Type@ field contains the type which underlies the variable.
      At present, this is always @'VarT' theName@, but future changes
      may permit refinement of this.
      -}
      | TyVarI      -- Scoped type variable
            Name
            Type    -- What it is bound to
      deriving( Int -> Info -> String -> String
    [Info] -> String -> String
    Info -> String
    (Int -> Info -> String -> String)
    -> (Info -> String) -> ([Info] -> String -> String) -> Show Info
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Info] -> String -> String
    $cshowList :: [Info] -> String -> String
    show :: Info -> String
    $cshow :: Info -> String
    showsPrec :: Int -> Info -> String -> String
    $cshowsPrec :: Int -> Info -> String -> String
    Show, Info -> Info -> Bool
    (Info -> Info -> Bool) -> (Info -> Info -> Bool) -> Eq Info
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Info -> Info -> Bool
    $c/= :: Info -> Info -> Bool
    == :: Info -> Info -> Bool
    $c== :: Info -> Info -> Bool
    Eq, Eq Info
    Eq Info
    -> (Info -> Info -> Ordering)
    -> (Info -> Info -> Bool)
    -> (Info -> Info -> Bool)
    -> (Info -> Info -> Bool)
    -> (Info -> Info -> Bool)
    -> (Info -> Info -> Info)
    -> (Info -> Info -> Info)
    -> Ord Info
    Info -> Info -> Bool
    Info -> Info -> Ordering
    Info -> Info -> Info
    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
    min :: Info -> Info -> Info
    $cmin :: Info -> Info -> Info
    max :: Info -> Info -> Info
    $cmax :: Info -> Info -> Info
    >= :: Info -> Info -> Bool
    $c>= :: Info -> Info -> Bool
    > :: Info -> Info -> Bool
    $c> :: Info -> Info -> Bool
    <= :: Info -> Info -> Bool
    $c<= :: Info -> Info -> Bool
    < :: Info -> Info -> Bool
    $c< :: Info -> Info -> Bool
    compare :: Info -> Info -> Ordering
    $ccompare :: Info -> Info -> Ordering
    Ord, Typeable Info
    Typeable Info
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Info -> c Info)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Info)
    -> (Info -> Constr)
    -> (Info -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Info))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info))
    -> ((forall b. Data b => b -> b) -> Info -> Info)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Info -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Info -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Info -> m Info)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Info -> m Info)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Info -> m Info)
    -> Data Info
    Info -> DataType
    Info -> Constr
    (forall b. Data b => b -> b) -> Info -> Info
    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) -> Info -> u
    forall u. (forall d. Data d => d -> u) -> Info -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Info -> m Info
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Info -> m Info
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Info
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Info -> c Info
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Info)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Info -> m Info
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Info -> m Info
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Info -> m Info
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Info -> m Info
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Info -> m Info
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Info -> m Info
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Info -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Info -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Info -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Info -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
    gmapT :: (forall b. Data b => b -> b) -> Info -> Info
    $cgmapT :: (forall b. Data b => b -> b) -> Info -> Info
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Info)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Info)
    dataTypeOf :: Info -> DataType
    $cdataTypeOf :: Info -> DataType
    toConstr :: Info -> Constr
    $ctoConstr :: Info -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Info
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Info
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Info -> c Info
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Info -> c Info
    Data, (forall x. Info -> Rep Info x)
    -> (forall x. Rep Info x -> Info) -> Generic Info
    forall x. Rep Info x -> Info
    forall x. Info -> Rep Info x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Info x -> Info
    $cfrom :: forall x. Info -> Rep Info x
    Generic )

    -- | Obtained from 'reifyModule' in the 'Q' Monad.
    data ModuleInfo =
      -- | Contains the import list of the module.
      ModuleInfo [Module]
      deriving( Int -> ModuleInfo -> String -> String
    [ModuleInfo] -> String -> String
    ModuleInfo -> String
    (Int -> ModuleInfo -> String -> String)
    -> (ModuleInfo -> String)
    -> ([ModuleInfo] -> String -> String)
    -> Show ModuleInfo
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [ModuleInfo] -> String -> String
    $cshowList :: [ModuleInfo] -> String -> String
    show :: ModuleInfo -> String
    $cshow :: ModuleInfo -> String
    showsPrec :: Int -> ModuleInfo -> String -> String
    $cshowsPrec :: Int -> ModuleInfo -> String -> String
    Show, ModuleInfo -> ModuleInfo -> Bool
    (ModuleInfo -> ModuleInfo -> Bool)
    -> (ModuleInfo -> ModuleInfo -> Bool) -> Eq ModuleInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: ModuleInfo -> ModuleInfo -> Bool
    $c/= :: ModuleInfo -> ModuleInfo -> Bool
    == :: ModuleInfo -> ModuleInfo -> Bool
    $c== :: ModuleInfo -> ModuleInfo -> Bool
    Eq, Eq ModuleInfo
    Eq ModuleInfo
    -> (ModuleInfo -> ModuleInfo -> Ordering)
    -> (ModuleInfo -> ModuleInfo -> Bool)
    -> (ModuleInfo -> ModuleInfo -> Bool)
    -> (ModuleInfo -> ModuleInfo -> Bool)
    -> (ModuleInfo -> ModuleInfo -> Bool)
    -> (ModuleInfo -> ModuleInfo -> ModuleInfo)
    -> (ModuleInfo -> ModuleInfo -> ModuleInfo)
    -> Ord ModuleInfo
    ModuleInfo -> ModuleInfo -> Bool
    ModuleInfo -> ModuleInfo -> Ordering
    ModuleInfo -> ModuleInfo -> ModuleInfo
    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
    min :: ModuleInfo -> ModuleInfo -> ModuleInfo
    $cmin :: ModuleInfo -> ModuleInfo -> ModuleInfo
    max :: ModuleInfo -> ModuleInfo -> ModuleInfo
    $cmax :: ModuleInfo -> ModuleInfo -> ModuleInfo
    >= :: ModuleInfo -> ModuleInfo -> Bool
    $c>= :: ModuleInfo -> ModuleInfo -> Bool
    > :: ModuleInfo -> ModuleInfo -> Bool
    $c> :: ModuleInfo -> ModuleInfo -> Bool
    <= :: ModuleInfo -> ModuleInfo -> Bool
    $c<= :: ModuleInfo -> ModuleInfo -> Bool
    < :: ModuleInfo -> ModuleInfo -> Bool
    $c< :: ModuleInfo -> ModuleInfo -> Bool
    compare :: ModuleInfo -> ModuleInfo -> Ordering
    $ccompare :: ModuleInfo -> ModuleInfo -> Ordering
    Ord, Typeable ModuleInfo
    Typeable ModuleInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ModuleInfo)
    -> (ModuleInfo -> Constr)
    -> (ModuleInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ModuleInfo))
    -> ((forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
    -> Data ModuleInfo
    ModuleInfo -> DataType
    ModuleInfo -> Constr
    (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
    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) -> ModuleInfo -> u
    forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
    $cgmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
    dataTypeOf :: ModuleInfo -> DataType
    $cdataTypeOf :: ModuleInfo -> DataType
    toConstr :: ModuleInfo -> Constr
    $ctoConstr :: ModuleInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
    Data, (forall x. ModuleInfo -> Rep ModuleInfo x)
    -> (forall x. Rep ModuleInfo x -> ModuleInfo) -> Generic ModuleInfo
    forall x. Rep ModuleInfo x -> ModuleInfo
    forall x. ModuleInfo -> Rep ModuleInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ModuleInfo x -> ModuleInfo
    $cfrom :: forall x. ModuleInfo -> Rep ModuleInfo x
    Generic )

    {- |
    In 'ClassOpI' and 'DataConI', name of the parent class or type
    -}
    type ParentName = Name

    -- | In 'UnboxedSumE' and 'UnboxedSumP', the number associated with a
    -- particular data constructor. 'SumAlt's are one-indexed and should never
    -- exceed the value of its corresponding 'SumArity'. For example:
    --
    -- * @(\#_|\#)@ has 'SumAlt' 1 (out of a total 'SumArity' of 2)
    --
    -- * @(\#|_\#)@ has 'SumAlt' 2 (out of a total 'SumArity' of 2)
    type SumAlt = Int

    -- | In 'UnboxedSumE', 'UnboxedSumT', and 'UnboxedSumP', the total number of
    -- 'SumAlt's. For example, @(\#|\#)@ has a 'SumArity' of 2.
    type SumArity = Int

    -- | In 'PrimTyConI', arity of the type constructor
    type Arity = Int

    -- | In 'PrimTyConI', is the type constructor unlifted?
    type Unlifted = Bool

    -- | 'InstanceDec' describes a single instance of a class or type function.
    -- It is just a 'Dec', but guaranteed to be one of the following:
    --
    --   * 'InstanceD' (with empty @['Dec']@)
    --
    --   * 'DataInstD' or 'NewtypeInstD' (with empty derived @['Name']@)
    --
    --   * 'TySynInstD'
    type InstanceDec = Dec

    data Fixity          = Fixity Int FixityDirection
        deriving( Fixity -> Fixity -> Bool
    (Fixity -> Fixity -> Bool)
    -> (Fixity -> Fixity -> Bool) -> Eq Fixity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Fixity -> Fixity -> Bool
    $c/= :: Fixity -> Fixity -> Bool
    == :: Fixity -> Fixity -> Bool
    $c== :: Fixity -> Fixity -> Bool
    Eq, Eq Fixity
    Eq Fixity
    -> (Fixity -> Fixity -> Ordering)
    -> (Fixity -> Fixity -> Bool)
    -> (Fixity -> Fixity -> Bool)
    -> (Fixity -> Fixity -> Bool)
    -> (Fixity -> Fixity -> Bool)
    -> (Fixity -> Fixity -> Fixity)
    -> (Fixity -> Fixity -> Fixity)
    -> Ord Fixity
    Fixity -> Fixity -> Bool
    Fixity -> Fixity -> Ordering
    Fixity -> Fixity -> Fixity
    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
    min :: Fixity -> Fixity -> Fixity
    $cmin :: Fixity -> Fixity -> Fixity
    max :: Fixity -> Fixity -> Fixity
    $cmax :: Fixity -> Fixity -> Fixity
    >= :: Fixity -> Fixity -> Bool
    $c>= :: Fixity -> Fixity -> Bool
    > :: Fixity -> Fixity -> Bool
    $c> :: Fixity -> Fixity -> Bool
    <= :: Fixity -> Fixity -> Bool
    $c<= :: Fixity -> Fixity -> Bool
    < :: Fixity -> Fixity -> Bool
    $c< :: Fixity -> Fixity -> Bool
    compare :: Fixity -> Fixity -> Ordering
    $ccompare :: Fixity -> Fixity -> Ordering
    Ord, Int -> Fixity -> String -> String
    [Fixity] -> String -> String
    Fixity -> String
    (Int -> Fixity -> String -> String)
    -> (Fixity -> String)
    -> ([Fixity] -> String -> String)
    -> Show Fixity
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Fixity] -> String -> String
    $cshowList :: [Fixity] -> String -> String
    show :: Fixity -> String
    $cshow :: Fixity -> String
    showsPrec :: Int -> Fixity -> String -> String
    $cshowsPrec :: Int -> Fixity -> String -> String
    Show, Typeable Fixity
    Typeable Fixity
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Fixity -> c Fixity)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Fixity)
    -> (Fixity -> Constr)
    -> (Fixity -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Fixity))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity))
    -> ((forall b. Data b => b -> b) -> Fixity -> Fixity)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Fixity -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Fixity -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Fixity -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Fixity -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Fixity -> m Fixity)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Fixity -> m Fixity)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Fixity -> m Fixity)
    -> Data Fixity
    Fixity -> DataType
    Fixity -> Constr
    (forall b. Data b => b -> b) -> Fixity -> Fixity
    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) -> Fixity -> u
    forall u. (forall d. Data d => d -> u) -> Fixity -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Fixity -> m Fixity
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fixity -> m Fixity
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Fixity
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Fixity -> c Fixity
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Fixity)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fixity -> m Fixity
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fixity -> m Fixity
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fixity -> m Fixity
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fixity -> m Fixity
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Fixity -> m Fixity
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Fixity -> m Fixity
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Fixity -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Fixity -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Fixity -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Fixity -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
    gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity
    $cgmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Fixity)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Fixity)
    dataTypeOf :: Fixity -> DataType
    $cdataTypeOf :: Fixity -> DataType
    toConstr :: Fixity -> Constr
    $ctoConstr :: Fixity -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Fixity
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Fixity
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Fixity -> c Fixity
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Fixity -> c Fixity
    Data, (forall x. Fixity -> Rep Fixity x)
    -> (forall x. Rep Fixity x -> Fixity) -> Generic Fixity
    forall x. Rep Fixity x -> Fixity
    forall x. Fixity -> Rep Fixity x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Fixity x -> Fixity
    $cfrom :: forall x. Fixity -> Rep Fixity x
    Generic )
    data FixityDirection = InfixL | InfixR | InfixN
        deriving( FixityDirection -> FixityDirection -> Bool
    (FixityDirection -> FixityDirection -> Bool)
    -> (FixityDirection -> FixityDirection -> Bool)
    -> Eq FixityDirection
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: FixityDirection -> FixityDirection -> Bool
    $c/= :: FixityDirection -> FixityDirection -> Bool
    == :: FixityDirection -> FixityDirection -> Bool
    $c== :: FixityDirection -> FixityDirection -> Bool
    Eq, Eq FixityDirection
    Eq FixityDirection
    -> (FixityDirection -> FixityDirection -> Ordering)
    -> (FixityDirection -> FixityDirection -> Bool)
    -> (FixityDirection -> FixityDirection -> Bool)
    -> (FixityDirection -> FixityDirection -> Bool)
    -> (FixityDirection -> FixityDirection -> Bool)
    -> (FixityDirection -> FixityDirection -> FixityDirection)
    -> (FixityDirection -> FixityDirection -> FixityDirection)
    -> Ord FixityDirection
    FixityDirection -> FixityDirection -> Bool
    FixityDirection -> FixityDirection -> Ordering
    FixityDirection -> FixityDirection -> FixityDirection
    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
    min :: FixityDirection -> FixityDirection -> FixityDirection
    $cmin :: FixityDirection -> FixityDirection -> FixityDirection
    max :: FixityDirection -> FixityDirection -> FixityDirection
    $cmax :: FixityDirection -> FixityDirection -> FixityDirection
    >= :: FixityDirection -> FixityDirection -> Bool
    $c>= :: FixityDirection -> FixityDirection -> Bool
    > :: FixityDirection -> FixityDirection -> Bool
    $c> :: FixityDirection -> FixityDirection -> Bool
    <= :: FixityDirection -> FixityDirection -> Bool
    $c<= :: FixityDirection -> FixityDirection -> Bool
    < :: FixityDirection -> FixityDirection -> Bool
    $c< :: FixityDirection -> FixityDirection -> Bool
    compare :: FixityDirection -> FixityDirection -> Ordering
    $ccompare :: FixityDirection -> FixityDirection -> Ordering
    Ord, Int -> FixityDirection -> String -> String
    [FixityDirection] -> String -> String
    FixityDirection -> String
    (Int -> FixityDirection -> String -> String)
    -> (FixityDirection -> String)
    -> ([FixityDirection] -> String -> String)
    -> Show FixityDirection
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [FixityDirection] -> String -> String
    $cshowList :: [FixityDirection] -> String -> String
    show :: FixityDirection -> String
    $cshow :: FixityDirection -> String
    showsPrec :: Int -> FixityDirection -> String -> String
    $cshowsPrec :: Int -> FixityDirection -> String -> String
    Show, Typeable FixityDirection
    Typeable FixityDirection
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c FixityDirection)
    -> (FixityDirection -> Constr)
    -> (FixityDirection -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c FixityDirection))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c FixityDirection))
    -> ((forall b. Data b => b -> b)
        -> FixityDirection -> FixityDirection)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> FixityDirection -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FixityDirection -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> FixityDirection -> m FixityDirection)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FixityDirection -> m FixityDirection)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FixityDirection -> m FixityDirection)
    -> Data FixityDirection
    FixityDirection -> DataType
    FixityDirection -> Constr
    (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection
    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) -> FixityDirection -> u
    forall u. (forall d. Data d => d -> u) -> FixityDirection -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FixityDirection -> m FixityDirection
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FixityDirection -> m FixityDirection
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FixityDirection
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FixityDirection)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FixityDirection)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FixityDirection -> m FixityDirection
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FixityDirection -> m FixityDirection
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FixityDirection -> m FixityDirection
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FixityDirection -> m FixityDirection
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FixityDirection -> m FixityDirection
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FixityDirection -> m FixityDirection
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> FixityDirection -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> FixityDirection -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> FixityDirection -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> FixityDirection -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
    gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection
    $cgmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FixityDirection)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FixityDirection)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FixityDirection)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FixityDirection)
    dataTypeOf :: FixityDirection -> DataType
    $cdataTypeOf :: FixityDirection -> DataType
    toConstr :: FixityDirection -> Constr
    $ctoConstr :: FixityDirection -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FixityDirection
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FixityDirection
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection
    Data, (forall x. FixityDirection -> Rep FixityDirection x)
    -> (forall x. Rep FixityDirection x -> FixityDirection)
    -> Generic FixityDirection
    forall x. Rep FixityDirection x -> FixityDirection
    forall x. FixityDirection -> Rep FixityDirection x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep FixityDirection x -> FixityDirection
    $cfrom :: forall x. FixityDirection -> Rep FixityDirection x
    Generic )

    -- | Highest allowed operator precedence for 'Fixity' constructor (answer: 9)
    maxPrecedence :: Int
    maxPrecedence :: Int
    maxPrecedence = (Int
    9::Int)

    -- | Default fixity: @infixl 9@
    defaultFixity :: Fixity
    defaultFixity :: Fixity
    defaultFixity = Int -> FixityDirection -> Fixity
    Fixity Int
    maxPrecedence FixityDirection
    InfixL

    {-
    Note [Unresolved infix]
    ~~~~~~~~~~~~~~~~~~~~~~~
    -}
    {- $infix #infix#
    When implementing antiquotation for quasiquoters, one often wants
    to parse strings into expressions:

    > parse :: String -> Maybe Exp

    But how should we parse @a + b * c@? If we don't know the fixities of
    @+@ and @*@, we don't know whether to parse it as @a + (b * c)@ or @(a
    + b) * c@.

    In cases like this, use 'UInfixE', 'UInfixP', or 'UInfixT', which stand for
    \"unresolved infix expression/pattern/type\", respectively. When the compiler
    is given a splice containing a tree of @UInfixE@ applications such as

    > UInfixE
    >   (UInfixE e1 op1 e2)
    >   op2
    >   (UInfixE e3 op3 e4)

    it will look up and the fixities of the relevant operators and
    reassociate the tree as necessary.

      * trees will not be reassociated across 'ParensE', 'ParensP', or 'ParensT',
        which are of use for parsing expressions like

        > (a + b * c) + d * e

      * 'InfixE', 'InfixP', and 'InfixT' expressions are never reassociated.

      * The 'UInfixE' constructor doesn't support sections. Sections
        such as @(a *)@ have no ambiguity, so 'InfixE' suffices. For longer
        sections such as @(a + b * c -)@, use an 'InfixE' constructor for the
        outer-most section, and use 'UInfixE' constructors for all
        other operators:

        > InfixE
        >   Just (UInfixE ...a + b * c...)
        >   op
        >   Nothing

        Sections such as @(a + b +)@ and @((a + b) +)@ should be rendered
        into 'Exp's differently:

        > (+ a + b)   ---> InfixE Nothing + (Just $ UInfixE a + b)
        >                    -- will result in a fixity error if (+) is left-infix
        > (+ (a + b)) ---> InfixE Nothing + (Just $ ParensE $ UInfixE a + b)
        >                    -- no fixity errors

      * Quoted expressions such as

        > [| a * b + c |] :: Q Exp
        > [p| a : b : c |] :: Q Pat
        > [t| T + T |] :: Q Type

        will never contain 'UInfixE', 'UInfixP', 'UInfixT', 'InfixT', 'ParensE',
        'ParensP', or 'ParensT' constructors.

    -}

    -----------------------------------------------------
    --
    --      The main syntax data types
    --
    -----------------------------------------------------

    data Lit = CharL Char
             | StringL String
             | IntegerL Integer     -- ^ Used for overloaded and non-overloaded
                                    -- literals. We don't have a good way to
                                    -- represent non-overloaded literals at
                                    -- the moment. Maybe that doesn't matter?
             | RationalL Rational   -- Ditto
             | IntPrimL Integer
             | WordPrimL Integer
             | FloatPrimL Rational
             | DoublePrimL Rational
             | StringPrimL [Word8]  -- ^ A primitive C-style string, type 'Addr#'
             | BytesPrimL Bytes     -- ^ Some raw bytes, type 'Addr#':
             | CharPrimL Char
        deriving( Int -> Lit -> String -> String
    [Lit] -> String -> String
    Lit -> String
    (Int -> Lit -> String -> String)
    -> (Lit -> String) -> ([Lit] -> String -> String) -> Show Lit
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Lit] -> String -> String
    $cshowList :: [Lit] -> String -> String
    show :: Lit -> String
    $cshow :: Lit -> String
    showsPrec :: Int -> Lit -> String -> String
    $cshowsPrec :: Int -> Lit -> String -> String
    Show, Lit -> Lit -> Bool
    (Lit -> Lit -> Bool) -> (Lit -> Lit -> Bool) -> Eq Lit
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Lit -> Lit -> Bool
    $c/= :: Lit -> Lit -> Bool
    == :: Lit -> Lit -> Bool
    $c== :: Lit -> Lit -> Bool
    Eq, Eq Lit
    Eq Lit
    -> (Lit -> Lit -> Ordering)
    -> (Lit -> Lit -> Bool)
    -> (Lit -> Lit -> Bool)
    -> (Lit -> Lit -> Bool)
    -> (Lit -> Lit -> Bool)
    -> (Lit -> Lit -> Lit)
    -> (Lit -> Lit -> Lit)
    -> Ord Lit
    Lit -> Lit -> Bool
    Lit -> Lit -> Ordering
    Lit -> Lit -> Lit
    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
    min :: Lit -> Lit -> Lit
    $cmin :: Lit -> Lit -> Lit
    max :: Lit -> Lit -> Lit
    $cmax :: Lit -> Lit -> Lit
    >= :: Lit -> Lit -> Bool
    $c>= :: Lit -> Lit -> Bool
    > :: Lit -> Lit -> Bool
    $c> :: Lit -> Lit -> Bool
    <= :: Lit -> Lit -> Bool
    $c<= :: Lit -> Lit -> Bool
    < :: Lit -> Lit -> Bool
    $c< :: Lit -> Lit -> Bool
    compare :: Lit -> Lit -> Ordering
    $ccompare :: Lit -> Lit -> Ordering
    Ord, Typeable Lit
    Typeable Lit
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Lit -> c Lit)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Lit)
    -> (Lit -> Constr)
    -> (Lit -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Lit))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit))
    -> ((forall b. Data b => b -> b) -> Lit -> Lit)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Lit -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Lit -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Lit -> m Lit)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Lit -> m Lit)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Lit -> m Lit)
    -> Data Lit
    Lit -> DataType
    Lit -> Constr
    (forall b. Data b => b -> b) -> Lit -> Lit
    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) -> Lit -> u
    forall u. (forall d. Data d => d -> u) -> Lit -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Lit -> m Lit
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lit -> m Lit
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Lit
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Lit -> c Lit
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Lit)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lit -> m Lit
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lit -> m Lit
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lit -> m Lit
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lit -> m Lit
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Lit -> m Lit
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Lit -> m Lit
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Lit -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Lit -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Lit -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Lit -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
    gmapT :: (forall b. Data b => b -> b) -> Lit -> Lit
    $cgmapT :: (forall b. Data b => b -> b) -> Lit -> Lit
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Lit)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Lit)
    dataTypeOf :: Lit -> DataType
    $cdataTypeOf :: Lit -> DataType
    toConstr :: Lit -> Constr
    $ctoConstr :: Lit -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Lit
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Lit
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Lit -> c Lit
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Lit -> c Lit
    Data, (forall x. Lit -> Rep Lit x)
    -> (forall x. Rep Lit x -> Lit) -> Generic Lit
    forall x. Rep Lit x -> Lit
    forall x. Lit -> Rep Lit x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Lit x -> Lit
    $cfrom :: forall x. Lit -> Rep Lit x
    Generic )

        -- We could add Int, Float, Double etc, as we do in HsLit,
        -- but that could complicate the
        -- supposedly-simple TH.Syntax literal type

    -- | Raw bytes embedded into the binary.
    --
    -- Avoid using Bytes constructor directly as it is likely to change in the
    -- future. Use helpers such as `mkBytes` in Language.Haskell.TH.Lib instead.
    data Bytes = Bytes
       { Bytes -> ForeignPtr Word8
    bytesPtr    :: ForeignPtr Word8 -- ^ Pointer to the data
       , Bytes -> Word
    bytesOffset :: Word             -- ^ Offset from the pointer
       , Bytes -> Word
    bytesSize   :: Word             -- ^ Number of bytes
       -- Maybe someday:
       -- , bytesAlignement  :: Word -- ^ Alignement constraint
       -- , bytesReadOnly    :: Bool -- ^ Shall we embed into a read-only
       --                            --   section or not
       -- , bytesInitialized :: Bool -- ^ False: only use `bytesSize` to allocate
       --                            --   an uninitialized region
       }
       deriving (Typeable Bytes
    Typeable Bytes
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Bytes -> c Bytes)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Bytes)
    -> (Bytes -> Constr)
    -> (Bytes -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Bytes))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes))
    -> ((forall b. Data b => b -> b) -> Bytes -> Bytes)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Bytes -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Bytes -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Bytes -> m Bytes)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Bytes -> m Bytes)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Bytes -> m Bytes)
    -> Data Bytes
    Bytes -> DataType
    Bytes -> Constr
    (forall b. Data b => b -> b) -> Bytes -> Bytes
    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) -> Bytes -> u
    forall u. (forall d. Data d => d -> u) -> Bytes -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bytes
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bytes -> c Bytes
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bytes)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bytes -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bytes -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Bytes -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Bytes -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
    gmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes
    $cgmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bytes)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bytes)
    dataTypeOf :: Bytes -> DataType
    $cdataTypeOf :: Bytes -> DataType
    toConstr :: Bytes -> Constr
    $ctoConstr :: Bytes -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bytes
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bytes
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bytes -> c Bytes
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bytes -> c Bytes
    Data,(forall x. Bytes -> Rep Bytes x)
    -> (forall x. Rep Bytes x -> Bytes) -> Generic Bytes
    forall x. Rep Bytes x -> Bytes
    forall x. Bytes -> Rep Bytes x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Bytes x -> Bytes
    $cfrom :: forall x. Bytes -> Rep Bytes x
    Generic)

    -- We can't derive Show instance for Bytes because we don't want to show the
    -- pointer value but the actual bytes (similarly to what ByteString does). See
    -- #16457.
    instance Show Bytes where
       show :: Bytes -> String
    show Bytes
    b = IO String -> String
    forall a. IO a -> a
    unsafePerformIO (IO String -> String) -> IO String -> String
    forall a b. (a -> b) -> a -> b
    $ ForeignPtr Word8 -> (Ptr Word8 -> IO String) -> IO String
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr (Bytes -> ForeignPtr Word8
    bytesPtr Bytes
    b) ((Ptr Word8 -> IO String) -> IO String)
    -> (Ptr Word8 -> IO String) -> IO String
    forall a b. (a -> b) -> a -> b
    $ \Ptr Word8
    ptr ->
                   CStringLen -> IO String
    peekCStringLen ( Ptr Word8
    ptr Ptr Word8 -> Int -> Ptr CChar
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Word -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Bytes -> Word
    bytesOffset Bytes
    b)
                                  , Word -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Bytes -> Word
    bytesSize Bytes
    b)
                                  )

    -- We can't derive Eq and Ord instances for Bytes because we don't want to
    -- compare pointer values but the actual bytes (similarly to what ByteString
    -- does).  See #16457
    instance Eq Bytes where
       == :: Bytes -> Bytes -> Bool
    (==) = Bytes -> Bytes -> Bool
    eqBytes

    instance Ord Bytes where
       compare :: Bytes -> Bytes -> Ordering
    compare = Bytes -> Bytes -> Ordering
    compareBytes

    eqBytes :: Bytes -> Bytes -> Bool
    eqBytes :: Bytes -> Bytes -> Bool
    eqBytes a :: Bytes
    a@(Bytes ForeignPtr Word8
    fp Word
    off Word
    len) b :: Bytes
    b@(Bytes ForeignPtr Word8
    fp' Word
    off' Word
    len')
      | Word
    len Word -> Word -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Word
    len'              = Bool
    False    -- short cut on length
      | ForeignPtr Word8
    fp ForeignPtr Word8 -> ForeignPtr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == ForeignPtr Word8
    fp' Bool -> Bool -> Bool
    && Word
    off Word -> Word -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word
    off' = Bool
    True     -- short cut for the same bytes
      | Bool
    otherwise                = Bytes -> Bytes -> Ordering
    compareBytes Bytes
    a Bytes
    b Ordering -> Ordering -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ordering
    EQ

    compareBytes :: Bytes -> Bytes -> Ordering
    compareBytes :: Bytes -> Bytes -> Ordering
    compareBytes (Bytes ForeignPtr Word8
    _   Word
    _    Word
    0)    (Bytes ForeignPtr Word8
    _   Word
    _    Word
    0)    = Ordering
    EQ  -- short cut for empty Bytes
    compareBytes (Bytes ForeignPtr Word8
    fp1 Word
    off1 Word
    len1) (Bytes ForeignPtr Word8
    fp2 Word
    off2 Word
    len2) =
        IO Ordering -> Ordering
    forall a. IO a -> a
    unsafePerformIO (IO Ordering -> Ordering) -> IO Ordering -> Ordering
    forall a b. (a -> b) -> a -> b
    $
          ForeignPtr Word8 -> (Ptr Word8 -> IO Ordering) -> IO Ordering
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Word8
    fp1 ((Ptr Word8 -> IO Ordering) -> IO Ordering)
    -> (Ptr Word8 -> IO Ordering) -> IO Ordering
    forall a b. (a -> b) -> a -> b
    $ \Ptr Word8
    p1 ->
          ForeignPtr Word8 -> (Ptr Word8 -> IO Ordering) -> IO Ordering
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Word8
    fp2 ((Ptr Word8 -> IO Ordering) -> IO Ordering)
    -> (Ptr Word8 -> IO Ordering) -> IO Ordering
    forall a b. (a -> b) -> a -> b
    $ \Ptr Word8
    p2 -> do
            CInt
    i <- Ptr Any -> Ptr Any -> CSize -> IO CInt
    forall a b. Ptr a -> Ptr b -> CSize -> IO CInt
    memcmp (Ptr Word8
    p1 Ptr Word8 -> Int -> Ptr Any
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Word -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word
    off1)
                        (Ptr Word8
    p2 Ptr Word8 -> Int -> Ptr Any
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Word -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word
    off2)
                        (Word -> CSize
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word -> Word -> Word
    forall a. Ord a => a -> a -> a
    min Word
    len1 Word
    len2))
            Ordering -> IO Ordering
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Ordering -> IO Ordering) -> Ordering -> IO Ordering
    forall a b. (a -> b) -> a -> b
    $! (CInt
    i CInt -> CInt -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` CInt
    0) Ordering -> Ordering -> Ordering
    forall a. Semigroup a => a -> a -> a
    <> (Word
    len1 Word -> Word -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` Word
    len2)

    foreign import ccall unsafe "memcmp"
      memcmp :: Ptr a -> Ptr b -> CSize -> IO CInt

    -- | Pattern in Haskell given in @{}@
    data Pat
      = LitP Lit                        -- ^ @{ 5 or \'c\' }@
      | VarP Name                       -- ^ @{ x }@
      | TupP [Pat]                      -- ^ @{ (p1,p2) }@
      | UnboxedTupP [Pat]               -- ^ @{ (\# p1,p2 \#) }@
      | UnboxedSumP Pat SumAlt SumArity -- ^ @{ (\#|p|\#) }@
      | ConP Name [Pat]                 -- ^ @data T1 = C1 t1 t2; {C1 p1 p1} = e@
      | InfixP Pat Name Pat             -- ^ @foo ({x :+ y}) = e@
      | UInfixP Pat Name Pat            -- ^ @foo ({x :+ y}) = e@
                                        --
                                        -- See "Language.Haskell.TH.Syntax#infix"
      | ParensP Pat                     -- ^ @{(p)}@
                                        --
                                        -- See "Language.Haskell.TH.Syntax#infix"
      | TildeP Pat                      -- ^ @{ ~p }@
      | BangP Pat                       -- ^ @{ !p }@
      | AsP Name Pat                    -- ^ @{ x \@ p }@
      | WildP                           -- ^ @{ _ }@
      | RecP Name [FieldPat]            -- ^ @f (Pt { pointx = x }) = g x@
      | ListP [ Pat ]                   -- ^ @{ [1,2,3] }@
      | SigP Pat Type                   -- ^ @{ p :: t }@
      | ViewP Exp Pat                   -- ^ @{ e -> p }@
      deriving( Int -> Pat -> String -> String
    [Pat] -> String -> String
    Pat -> String
    (Int -> Pat -> String -> String)
    -> (Pat -> String) -> ([Pat] -> String -> String) -> Show Pat
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Pat] -> String -> String
    $cshowList :: [Pat] -> String -> String
    show :: Pat -> String
    $cshow :: Pat -> String
    showsPrec :: Int -> Pat -> String -> String
    $cshowsPrec :: Int -> Pat -> String -> String
    Show, Pat -> Pat -> Bool
    (Pat -> Pat -> Bool) -> (Pat -> Pat -> Bool) -> Eq Pat
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Pat -> Pat -> Bool
    $c/= :: Pat -> Pat -> Bool
    == :: Pat -> Pat -> Bool
    $c== :: Pat -> Pat -> Bool
    Eq, Eq Pat
    Eq Pat
    -> (Pat -> Pat -> Ordering)
    -> (Pat -> Pat -> Bool)
    -> (Pat -> Pat -> Bool)
    -> (Pat -> Pat -> Bool)
    -> (Pat -> Pat -> Bool)
    -> (Pat -> Pat -> Pat)
    -> (Pat -> Pat -> Pat)
    -> Ord Pat
    Pat -> Pat -> Bool
    Pat -> Pat -> Ordering
    Pat -> Pat -> Pat
    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
    min :: Pat -> Pat -> Pat
    $cmin :: Pat -> Pat -> Pat
    max :: Pat -> Pat -> Pat
    $cmax :: Pat -> Pat -> Pat
    >= :: Pat -> Pat -> Bool
    $c>= :: Pat -> Pat -> Bool
    > :: Pat -> Pat -> Bool
    $c> :: Pat -> Pat -> Bool
    <= :: Pat -> Pat -> Bool
    $c<= :: Pat -> Pat -> Bool
    < :: Pat -> Pat -> Bool
    $c< :: Pat -> Pat -> Bool
    compare :: Pat -> Pat -> Ordering
    $ccompare :: Pat -> Pat -> Ordering
    Ord, Typeable Pat
    Typeable Pat
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Pat -> c Pat)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Pat)
    -> (Pat -> Constr)
    -> (Pat -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Pat))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat))
    -> ((forall b. Data b => b -> b) -> Pat -> Pat)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Pat -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Pat -> m Pat)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Pat -> m Pat)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Pat -> m Pat)
    -> Data Pat
    Pat -> DataType
    Pat -> Constr
    (forall b. Data b => b -> b) -> Pat -> Pat
    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) -> Pat -> u
    forall u. (forall d. Data d => d -> u) -> Pat -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pat
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pat -> c Pat
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pat)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Pat -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pat -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
    gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat
    $cgmapT :: (forall b. Data b => b -> b) -> Pat -> Pat
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pat)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pat)
    dataTypeOf :: Pat -> DataType
    $cdataTypeOf :: Pat -> DataType
    toConstr :: Pat -> Constr
    $ctoConstr :: Pat -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pat
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pat
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pat -> c Pat
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pat -> c Pat
    Data, (forall x. Pat -> Rep Pat x)
    -> (forall x. Rep Pat x -> Pat) -> Generic Pat
    forall x. Rep Pat x -> Pat
    forall x. Pat -> Rep Pat x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Pat x -> Pat
    $cfrom :: forall x. Pat -> Rep Pat x
    Generic )

    type FieldPat = (Name,Pat)

    data Match = Match Pat Body [Dec] -- ^ @case e of { pat -> body where decs }@
        deriving( Int -> Match -> String -> String
    [Match] -> String -> String
    Match -> String
    (Int -> Match -> String -> String)
    -> (Match -> String) -> ([Match] -> String -> String) -> Show Match
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Match] -> String -> String
    $cshowList :: [Match] -> String -> String
    show :: Match -> String
    $cshow :: Match -> String
    showsPrec :: Int -> Match -> String -> String
    $cshowsPrec :: Int -> Match -> String -> String
    Show, Match -> Match -> Bool
    (Match -> Match -> Bool) -> (Match -> Match -> Bool) -> Eq Match
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Match -> Match -> Bool
    $c/= :: Match -> Match -> Bool
    == :: Match -> Match -> Bool
    $c== :: Match -> Match -> Bool
    Eq, Eq Match
    Eq Match
    -> (Match -> Match -> Ordering)
    -> (Match -> Match -> Bool)
    -> (Match -> Match -> Bool)
    -> (Match -> Match -> Bool)
    -> (Match -> Match -> Bool)
    -> (Match -> Match -> Match)
    -> (Match -> Match -> Match)
    -> Ord Match
    Match -> Match -> Bool
    Match -> Match -> Ordering
    Match -> Match -> Match
    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
    min :: Match -> Match -> Match
    $cmin :: Match -> Match -> Match
    max :: Match -> Match -> Match
    $cmax :: Match -> Match -> Match
    >= :: Match -> Match -> Bool
    $c>= :: Match -> Match -> Bool
    > :: Match -> Match -> Bool
    $c> :: Match -> Match -> Bool
    <= :: Match -> Match -> Bool
    $c<= :: Match -> Match -> Bool
    < :: Match -> Match -> Bool
    $c< :: Match -> Match -> Bool
    compare :: Match -> Match -> Ordering
    $ccompare :: Match -> Match -> Ordering
    Ord, Typeable Match
    Typeable Match
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Match -> c Match)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Match)
    -> (Match -> Constr)
    -> (Match -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Match))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match))
    -> ((forall b. Data b => b -> b) -> Match -> Match)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Match -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Match -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Match -> m Match)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Match -> m Match)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Match -> m Match)
    -> Data Match
    Match -> DataType
    Match -> Constr
    (forall b. Data b => b -> b) -> Match -> Match
    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) -> Match -> u
    forall u. (forall d. Data d => d -> u) -> Match -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Match -> m Match
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match -> m Match
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Match
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Match -> c Match
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Match)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match -> m Match
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match -> m Match
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match -> m Match
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match -> m Match
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Match -> m Match
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Match -> m Match
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Match -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Match -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Match -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Match -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
    gmapT :: (forall b. Data b => b -> b) -> Match -> Match
    $cgmapT :: (forall b. Data b => b -> b) -> Match -> Match
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Match)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Match)
    dataTypeOf :: Match -> DataType
    $cdataTypeOf :: Match -> DataType
    toConstr :: Match -> Constr
    $ctoConstr :: Match -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Match
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Match
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Match -> c Match
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Match -> c Match
    Data, (forall x. Match -> Rep Match x)
    -> (forall x. Rep Match x -> Match) -> Generic Match
    forall x. Rep Match x -> Match
    forall x. Match -> Rep Match x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Match x -> Match
    $cfrom :: forall x. Match -> Rep Match x
    Generic )
    data Clause = Clause [Pat] Body [Dec]
                                      -- ^ @f { p1 p2 = body where decs }@
        deriving( Int -> Clause -> String -> String
    [Clause] -> String -> String
    Clause -> String
    (Int -> Clause -> String -> String)
    -> (Clause -> String)
    -> ([Clause] -> String -> String)
    -> Show Clause
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Clause] -> String -> String
    $cshowList :: [Clause] -> String -> String
    show :: Clause -> String
    $cshow :: Clause -> String
    showsPrec :: Int -> Clause -> String -> String
    $cshowsPrec :: Int -> Clause -> String -> String
    Show, Clause -> Clause -> Bool
    (Clause -> Clause -> Bool)
    -> (Clause -> Clause -> Bool) -> Eq Clause
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Clause -> Clause -> Bool
    $c/= :: Clause -> Clause -> Bool
    == :: Clause -> Clause -> Bool
    $c== :: Clause -> Clause -> Bool
    Eq, Eq Clause
    Eq Clause
    -> (Clause -> Clause -> Ordering)
    -> (Clause -> Clause -> Bool)
    -> (Clause -> Clause -> Bool)
    -> (Clause -> Clause -> Bool)
    -> (Clause -> Clause -> Bool)
    -> (Clause -> Clause -> Clause)
    -> (Clause -> Clause -> Clause)
    -> Ord Clause
    Clause -> Clause -> Bool
    Clause -> Clause -> Ordering
    Clause -> Clause -> Clause
    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
    min :: Clause -> Clause -> Clause
    $cmin :: Clause -> Clause -> Clause
    max :: Clause -> Clause -> Clause
    $cmax :: Clause -> Clause -> Clause
    >= :: Clause -> Clause -> Bool
    $c>= :: Clause -> Clause -> Bool
    > :: Clause -> Clause -> Bool
    $c> :: Clause -> Clause -> Bool
    <= :: Clause -> Clause -> Bool
    $c<= :: Clause -> Clause -> Bool
    < :: Clause -> Clause -> Bool
    $c< :: Clause -> Clause -> Bool
    compare :: Clause -> Clause -> Ordering
    $ccompare :: Clause -> Clause -> Ordering
    Ord, Typeable Clause
    Typeable Clause
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Clause -> c Clause)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Clause)
    -> (Clause -> Constr)
    -> (Clause -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Clause))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause))
    -> ((forall b. Data b => b -> b) -> Clause -> Clause)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Clause -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Clause -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Clause -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Clause -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Clause -> m Clause)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Clause -> m Clause)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Clause -> m Clause)
    -> Data Clause
    Clause -> DataType
    Clause -> Constr
    (forall b. Data b => b -> b) -> Clause -> Clause
    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) -> Clause -> u
    forall u. (forall d. Data d => d -> u) -> Clause -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Clause -> m Clause
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Clause -> m Clause
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Clause
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Clause -> c Clause
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Clause)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Clause -> m Clause
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Clause -> m Clause
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Clause -> m Clause
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Clause -> m Clause
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Clause -> m Clause
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Clause -> m Clause
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Clause -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Clause -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Clause -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Clause -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
    gmapT :: (forall b. Data b => b -> b) -> Clause -> Clause
    $cgmapT :: (forall b. Data b => b -> b) -> Clause -> Clause
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Clause)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Clause)
    dataTypeOf :: Clause -> DataType
    $cdataTypeOf :: Clause -> DataType
    toConstr :: Clause -> Constr
    $ctoConstr :: Clause -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Clause
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Clause
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Clause -> c Clause
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Clause -> c Clause
    Data, (forall x. Clause -> Rep Clause x)
    -> (forall x. Rep Clause x -> Clause) -> Generic Clause
    forall x. Rep Clause x -> Clause
    forall x. Clause -> Rep Clause x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Clause x -> Clause
    $cfrom :: forall x. Clause -> Rep Clause x
    Generic )

    data Exp
      = VarE Name                          -- ^ @{ x }@
      | ConE Name                          -- ^ @data T1 = C1 t1 t2; p = {C1} e1 e2  @
      | LitE Lit                           -- ^ @{ 5 or \'c\'}@
      | AppE Exp Exp                       -- ^ @{ f x }@
      | AppTypeE Exp Type                  -- ^ @{ f \@Int }@

      | InfixE (Maybe Exp) Exp (Maybe Exp) -- ^ @{x + y} or {(x+)} or {(+ x)} or {(+)}@

        -- It's a bit gruesome to use an Exp as the operator when a Name
        -- would suffice. Historically, Exp was used to make it easier to
        -- distinguish between infix constructors and non-constructors.
        -- This is a bit overkill, since one could just as well call
        -- `startsConId` or `startsConSym` (from `GHC.Lexeme`) on a Name.
        -- Unfortunately, changing this design now would involve lots of
        -- code churn for consumers of the TH API, so we continue to use
        -- an Exp as the operator and perform an extra check during conversion
        -- to ensure that the Exp is a constructor or a variable (#16895).

      | UInfixE Exp Exp Exp                -- ^ @{x + y}@
                                           --
                                           -- See "Language.Haskell.TH.Syntax#infix"
      | ParensE Exp                        -- ^ @{ (e) }@
                                           --
                                           -- See "Language.Haskell.TH.Syntax#infix"
      | LamE [Pat] Exp                     -- ^ @{ \\ p1 p2 -> e }@
      | LamCaseE [Match]                   -- ^ @{ \\case m1; m2 }@
      | TupE [Maybe Exp]                   -- ^ @{ (e1,e2) }  @
                                           --
                                           -- The 'Maybe' is necessary for handling
                                           -- tuple sections.
                                           --
                                           -- > (1,)
                                           --
                                           -- translates to
                                           --
                                           -- > TupE [Just (LitE (IntegerL 1)),Nothing]

      | UnboxedTupE [Maybe Exp]            -- ^ @{ (\# e1,e2 \#) }  @
                                           --
                                           -- The 'Maybe' is necessary for handling
                                           -- tuple sections.
                                           --
                                           -- > (# 'c', #)
                                           --
                                           -- translates to
                                           --
                                           -- > UnboxedTupE [Just (LitE (CharL 'c')),Nothing]

      | UnboxedSumE Exp SumAlt SumArity    -- ^ @{ (\#|e|\#) }@
      | CondE Exp Exp Exp                  -- ^ @{ if e1 then e2 else e3 }@
      | MultiIfE [(Guard, Exp)]            -- ^ @{ if | g1 -> e1 | g2 -> e2 }@
      | LetE [Dec] Exp                     -- ^ @{ let { x=e1; y=e2 } in e3 }@
      | CaseE Exp [Match]                  -- ^ @{ case e of m1; m2 }@
      | DoE (Maybe ModName) [Stmt]         -- ^ @{ do { p <- e1; e2 }  }@ or a qualified do if
                                           -- the module name is present
      | MDoE (Maybe ModName) [Stmt]        -- ^ @{ mdo { x <- e1 y; y <- e2 x; } }@ or a qualified
                                           -- mdo if the module name is present
      | CompE [Stmt]                       -- ^ @{ [ (x,y) | x <- xs, y <- ys ] }@
          --
          -- The result expression of the comprehension is
          -- the /last/ of the @'Stmt'@s, and should be a 'NoBindS'.
          --
          -- E.g. translation:
          --
          -- > [ f x | x <- xs ]
          --
          -- > CompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))]

      | ArithSeqE Range                    -- ^ @{ [ 1 ,2 .. 10 ] }@
      | ListE [ Exp ]                      -- ^ @{ [1,2,3] }@
      | SigE Exp Type                      -- ^ @{ e :: t }@
      | RecConE Name [FieldExp]            -- ^ @{ T { x = y, z = w } }@
      | RecUpdE Exp [FieldExp]             -- ^ @{ (f x) { z = w } }@
      | StaticE Exp                        -- ^ @{ static e }@
      | UnboundVarE Name                   -- ^ @{ _x }@
                                           --
                                           -- This is used for holes or unresolved
                                           -- identifiers in AST quotes. Note that
                                           -- it could either have a variable name
                                           -- or constructor name.
      | LabelE String                      -- ^ @{ #x }@ ( Overloaded label )
      | ImplicitParamVarE String           -- ^ @{ ?x }@ ( Implicit parameter )
      deriving( Int -> Exp -> String -> String
    [Exp] -> String -> String
    Exp -> String
    (Int -> Exp -> String -> String)
    -> (Exp -> String) -> ([Exp] -> String -> String) -> Show Exp
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Exp] -> String -> String
    $cshowList :: [Exp] -> String -> String
    show :: Exp -> String
    $cshow :: Exp -> String
    showsPrec :: Int -> Exp -> String -> String
    $cshowsPrec :: Int -> Exp -> String -> String
    Show, Exp -> Exp -> Bool
    (Exp -> Exp -> Bool) -> (Exp -> Exp -> Bool) -> Eq Exp
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Exp -> Exp -> Bool
    $c/= :: Exp -> Exp -> Bool
    == :: Exp -> Exp -> Bool
    $c== :: Exp -> Exp -> Bool
    Eq, Eq Exp
    Eq Exp
    -> (Exp -> Exp -> Ordering)
    -> (Exp -> Exp -> Bool)
    -> (Exp -> Exp -> Bool)
    -> (Exp -> Exp -> Bool)
    -> (Exp -> Exp -> Bool)
    -> (Exp -> Exp -> Exp)
    -> (Exp -> Exp -> Exp)
    -> Ord Exp
    Exp -> Exp -> Bool
    Exp -> Exp -> Ordering
    Exp -> Exp -> Exp
    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
    min :: Exp -> Exp -> Exp
    $cmin :: Exp -> Exp -> Exp
    max :: Exp -> Exp -> Exp
    $cmax :: Exp -> Exp -> Exp
    >= :: Exp -> Exp -> Bool
    $c>= :: Exp -> Exp -> Bool
    > :: Exp -> Exp -> Bool
    $c> :: Exp -> Exp -> Bool
    <= :: Exp -> Exp -> Bool
    $c<= :: Exp -> Exp -> Bool
    < :: Exp -> Exp -> Bool
    $c< :: Exp -> Exp -> Bool
    compare :: Exp -> Exp -> Ordering
    $ccompare :: Exp -> Exp -> Ordering
    Ord, Typeable Exp
    Typeable Exp
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Exp -> c Exp)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Exp)
    -> (Exp -> Constr)
    -> (Exp -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Exp))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp))
    -> ((forall b. Data b => b -> b) -> Exp -> Exp)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Exp -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Exp -> m Exp)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Exp -> m Exp)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Exp -> m Exp)
    -> Data Exp
    Exp -> DataType
    Exp -> Constr
    (forall b. Data b => b -> b) -> Exp -> Exp
    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) -> Exp -> u
    forall u. (forall d. Data d => d -> u) -> Exp -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Exp
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Exp -> c Exp
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Exp)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Exp -> m Exp
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Exp -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Exp -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
    gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp
    $cgmapT :: (forall b. Data b => b -> b) -> Exp -> Exp
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Exp)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Exp)
    dataTypeOf :: Exp -> DataType
    $cdataTypeOf :: Exp -> DataType
    toConstr :: Exp -> Constr
    $ctoConstr :: Exp -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Exp
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Exp
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Exp -> c Exp
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Exp -> c Exp
    Data, (forall x. Exp -> Rep Exp x)
    -> (forall x. Rep Exp x -> Exp) -> Generic Exp
    forall x. Rep Exp x -> Exp
    forall x. Exp -> Rep Exp x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Exp x -> Exp
    $cfrom :: forall x. Exp -> Rep Exp x
    Generic )

    type FieldExp = (Name,Exp)

    -- Omitted: implicit parameters

    data Body
      = GuardedB [(Guard,Exp)]   -- ^ @f p { | e1 = e2
                                     --      | e3 = e4 }
                                     -- where ds@
      | NormalB Exp              -- ^ @f p { = e } where ds@
      deriving( Int -> Body -> String -> String
    [Body] -> String -> String
    Body -> String
    (Int -> Body -> String -> String)
    -> (Body -> String) -> ([Body] -> String -> String) -> Show Body
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Body] -> String -> String
    $cshowList :: [Body] -> String -> String
    show :: Body -> String
    $cshow :: Body -> String
    showsPrec :: Int -> Body -> String -> String
    $cshowsPrec :: Int -> Body -> String -> String
    Show, Body -> Body -> Bool
    (Body -> Body -> Bool) -> (Body -> Body -> Bool) -> Eq Body
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Body -> Body -> Bool
    $c/= :: Body -> Body -> Bool
    == :: Body -> Body -> Bool
    $c== :: Body -> Body -> Bool
    Eq, Eq Body
    Eq Body
    -> (Body -> Body -> Ordering)
    -> (Body -> Body -> Bool)
    -> (Body -> Body -> Bool)
    -> (Body -> Body -> Bool)
    -> (Body -> Body -> Bool)
    -> (Body -> Body -> Body)
    -> (Body -> Body -> Body)
    -> Ord Body
    Body -> Body -> Bool
    Body -> Body -> Ordering
    Body -> Body -> Body
    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
    min :: Body -> Body -> Body
    $cmin :: Body -> Body -> Body
    max :: Body -> Body -> Body
    $cmax :: Body -> Body -> Body
    >= :: Body -> Body -> Bool
    $c>= :: Body -> Body -> Bool
    > :: Body -> Body -> Bool
    $c> :: Body -> Body -> Bool
    <= :: Body -> Body -> Bool
    $c<= :: Body -> Body -> Bool
    < :: Body -> Body -> Bool
    $c< :: Body -> Body -> Bool
    compare :: Body -> Body -> Ordering
    $ccompare :: Body -> Body -> Ordering
    Ord, Typeable Body
    Typeable Body
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Body -> c Body)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Body)
    -> (Body -> Constr)
    -> (Body -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Body))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body))
    -> ((forall b. Data b => b -> b) -> Body -> Body)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Body -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Body -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Body -> m Body)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Body -> m Body)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Body -> m Body)
    -> Data Body
    Body -> DataType
    Body -> Constr
    (forall b. Data b => b -> b) -> Body -> Body
    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) -> Body -> u
    forall u. (forall d. Data d => d -> u) -> Body -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Body -> m Body
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Body -> m Body
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Body
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Body -> c Body
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Body)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Body -> m Body
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Body -> m Body
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Body -> m Body
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Body -> m Body
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Body -> m Body
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Body -> m Body
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Body -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Body -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Body -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Body -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
    gmapT :: (forall b. Data b => b -> b) -> Body -> Body
    $cgmapT :: (forall b. Data b => b -> b) -> Body -> Body
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Body)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Body)
    dataTypeOf :: Body -> DataType
    $cdataTypeOf :: Body -> DataType
    toConstr :: Body -> Constr
    $ctoConstr :: Body -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Body
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Body
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Body -> c Body
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Body -> c Body
    Data, (forall x. Body -> Rep Body x)
    -> (forall x. Rep Body x -> Body) -> Generic Body
    forall x. Rep Body x -> Body
    forall x. Body -> Rep Body x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Body x -> Body
    $cfrom :: forall x. Body -> Rep Body x
    Generic )

    data Guard
      = NormalG Exp -- ^ @f x { | odd x } = x@
      | PatG [Stmt] -- ^ @f x { | Just y <- x, Just z <- y } = z@
      deriving( Int -> Guard -> String -> String
    [Guard] -> String -> String
    Guard -> String
    (Int -> Guard -> String -> String)
    -> (Guard -> String) -> ([Guard] -> String -> String) -> Show Guard
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Guard] -> String -> String
    $cshowList :: [Guard] -> String -> String
    show :: Guard -> String
    $cshow :: Guard -> String
    showsPrec :: Int -> Guard -> String -> String
    $cshowsPrec :: Int -> Guard -> String -> String
    Show, Guard -> Guard -> Bool
    (Guard -> Guard -> Bool) -> (Guard -> Guard -> Bool) -> Eq Guard
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Guard -> Guard -> Bool
    $c/= :: Guard -> Guard -> Bool
    == :: Guard -> Guard -> Bool
    $c== :: Guard -> Guard -> Bool
    Eq, Eq Guard
    Eq Guard
    -> (Guard -> Guard -> Ordering)
    -> (Guard -> Guard -> Bool)
    -> (Guard -> Guard -> Bool)
    -> (Guard -> Guard -> Bool)
    -> (Guard -> Guard -> Bool)
    -> (Guard -> Guard -> Guard)
    -> (Guard -> Guard -> Guard)
    -> Ord Guard
    Guard -> Guard -> Bool
    Guard -> Guard -> Ordering
    Guard -> Guard -> Guard
    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
    min :: Guard -> Guard -> Guard
    $cmin :: Guard -> Guard -> Guard
    max :: Guard -> Guard -> Guard
    $cmax :: Guard -> Guard -> Guard
    >= :: Guard -> Guard -> Bool
    $c>= :: Guard -> Guard -> Bool
    > :: Guard -> Guard -> Bool
    $c> :: Guard -> Guard -> Bool
    <= :: Guard -> Guard -> Bool
    $c<= :: Guard -> Guard -> Bool
    < :: Guard -> Guard -> Bool
    $c< :: Guard -> Guard -> Bool
    compare :: Guard -> Guard -> Ordering
    $ccompare :: Guard -> Guard -> Ordering
    Ord, Typeable Guard
    Typeable Guard
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Guard -> c Guard)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Guard)
    -> (Guard -> Constr)
    -> (Guard -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Guard))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard))
    -> ((forall b. Data b => b -> b) -> Guard -> Guard)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Guard -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Guard -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Guard -> m Guard)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Guard -> m Guard)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Guard -> m Guard)
    -> Data Guard
    Guard -> DataType
    Guard -> Constr
    (forall b. Data b => b -> b) -> Guard -> Guard
    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) -> Guard -> u
    forall u. (forall d. Data d => d -> u) -> Guard -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Guard -> m Guard
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Guard -> m Guard
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Guard
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Guard -> c Guard
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Guard)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Guard -> m Guard
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Guard -> m Guard
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Guard -> m Guard
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Guard -> m Guard
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Guard -> m Guard
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Guard -> m Guard
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Guard -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Guard -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Guard -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Guard -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
    gmapT :: (forall b. Data b => b -> b) -> Guard -> Guard
    $cgmapT :: (forall b. Data b => b -> b) -> Guard -> Guard
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Guard)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Guard)
    dataTypeOf :: Guard -> DataType
    $cdataTypeOf :: Guard -> DataType
    toConstr :: Guard -> Constr
    $ctoConstr :: Guard -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Guard
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Guard
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Guard -> c Guard
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Guard -> c Guard
    Data, (forall x. Guard -> Rep Guard x)
    -> (forall x. Rep Guard x -> Guard) -> Generic Guard
    forall x. Rep Guard x -> Guard
    forall x. Guard -> Rep Guard x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Guard x -> Guard
    $cfrom :: forall x. Guard -> Rep Guard x
    Generic )

    data Stmt
      = BindS Pat Exp -- ^ @p <- e@
      | LetS [ Dec ]  -- ^ @{ let { x=e1; y=e2 } }@
      | NoBindS Exp   -- ^ @e@
      | ParS [[Stmt]] -- ^ @x <- e1 | s2, s3 | s4@ (in 'CompE')
      | RecS [Stmt]   -- ^ @rec { s1; s2 }@
      deriving( Int -> Stmt -> String -> String
    [Stmt] -> String -> String
    Stmt -> String
    (Int -> Stmt -> String -> String)
    -> (Stmt -> String) -> ([Stmt] -> String -> String) -> Show Stmt
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Stmt] -> String -> String
    $cshowList :: [Stmt] -> String -> String
    show :: Stmt -> String
    $cshow :: Stmt -> String
    showsPrec :: Int -> Stmt -> String -> String
    $cshowsPrec :: Int -> Stmt -> String -> String
    Show, Stmt -> Stmt -> Bool
    (Stmt -> Stmt -> Bool) -> (Stmt -> Stmt -> Bool) -> Eq Stmt
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Stmt -> Stmt -> Bool
    $c/= :: Stmt -> Stmt -> Bool
    == :: Stmt -> Stmt -> Bool
    $c== :: Stmt -> Stmt -> Bool
    Eq, Eq Stmt
    Eq Stmt
    -> (Stmt -> Stmt -> Ordering)
    -> (Stmt -> Stmt -> Bool)
    -> (Stmt -> Stmt -> Bool)
    -> (Stmt -> Stmt -> Bool)
    -> (Stmt -> Stmt -> Bool)
    -> (Stmt -> Stmt -> Stmt)
    -> (Stmt -> Stmt -> Stmt)
    -> Ord Stmt
    Stmt -> Stmt -> Bool
    Stmt -> Stmt -> Ordering
    Stmt -> Stmt -> Stmt
    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
    min :: Stmt -> Stmt -> Stmt
    $cmin :: Stmt -> Stmt -> Stmt
    max :: Stmt -> Stmt -> Stmt
    $cmax :: Stmt -> Stmt -> Stmt
    >= :: Stmt -> Stmt -> Bool
    $c>= :: Stmt -> Stmt -> Bool
    > :: Stmt -> Stmt -> Bool
    $c> :: Stmt -> Stmt -> Bool
    <= :: Stmt -> Stmt -> Bool
    $c<= :: Stmt -> Stmt -> Bool
    < :: Stmt -> Stmt -> Bool
    $c< :: Stmt -> Stmt -> Bool
    compare :: Stmt -> Stmt -> Ordering
    $ccompare :: Stmt -> Stmt -> Ordering
    Ord, Typeable Stmt
    Typeable Stmt
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Stmt -> c Stmt)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Stmt)
    -> (Stmt -> Constr)
    -> (Stmt -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Stmt))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt))
    -> ((forall b. Data b => b -> b) -> Stmt -> Stmt)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Stmt -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Stmt -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Stmt -> m Stmt)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Stmt -> m Stmt)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Stmt -> m Stmt)
    -> Data Stmt
    Stmt -> DataType
    Stmt -> Constr
    (forall b. Data b => b -> b) -> Stmt -> Stmt
    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) -> Stmt -> u
    forall u. (forall d. Data d => d -> u) -> Stmt -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Stmt -> m Stmt
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt -> m Stmt
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Stmt
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Stmt -> c Stmt
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Stmt)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt -> m Stmt
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt -> m Stmt
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt -> m Stmt
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt -> m Stmt
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Stmt -> m Stmt
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Stmt -> m Stmt
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stmt -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stmt -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Stmt -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Stmt -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
    gmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt
    $cgmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Stmt)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Stmt)
    dataTypeOf :: Stmt -> DataType
    $cdataTypeOf :: Stmt -> DataType
    toConstr :: Stmt -> Constr
    $ctoConstr :: Stmt -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Stmt
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Stmt
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Stmt -> c Stmt
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Stmt -> c Stmt
    Data, (forall x. Stmt -> Rep Stmt x)
    -> (forall x. Rep Stmt x -> Stmt) -> Generic Stmt
    forall x. Rep Stmt x -> Stmt
    forall x. Stmt -> Rep Stmt x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Stmt x -> Stmt
    $cfrom :: forall x. Stmt -> Rep Stmt x
    Generic )

    data Range = FromR Exp | FromThenR Exp Exp
               | FromToR Exp Exp | FromThenToR Exp Exp Exp
              deriving( Int -> Range -> String -> String
    [Range] -> String -> String
    Range -> String
    (Int -> Range -> String -> String)
    -> (Range -> String) -> ([Range] -> String -> String) -> Show Range
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Range] -> String -> String
    $cshowList :: [Range] -> String -> String
    show :: Range -> String
    $cshow :: Range -> String
    showsPrec :: Int -> Range -> String -> String
    $cshowsPrec :: Int -> Range -> String -> String
    Show, Range -> Range -> Bool
    (Range -> Range -> Bool) -> (Range -> Range -> Bool) -> Eq Range
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Range -> Range -> Bool
    $c/= :: Range -> Range -> Bool
    == :: Range -> Range -> Bool
    $c== :: Range -> Range -> Bool
    Eq, Eq Range
    Eq Range
    -> (Range -> Range -> Ordering)
    -> (Range -> Range -> Bool)
    -> (Range -> Range -> Bool)
    -> (Range -> Range -> Bool)
    -> (Range -> Range -> Bool)
    -> (Range -> Range -> Range)
    -> (Range -> Range -> Range)
    -> Ord Range
    Range -> Range -> Bool
    Range -> Range -> Ordering
    Range -> Range -> Range
    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
    min :: Range -> Range -> Range
    $cmin :: Range -> Range -> Range
    max :: Range -> Range -> Range
    $cmax :: Range -> Range -> Range
    >= :: Range -> Range -> Bool
    $c>= :: Range -> Range -> Bool
    > :: Range -> Range -> Bool
    $c> :: Range -> Range -> Bool
    <= :: Range -> Range -> Bool
    $c<= :: Range -> Range -> Bool
    < :: Range -> Range -> Bool
    $c< :: Range -> Range -> Bool
    compare :: Range -> Range -> Ordering
    $ccompare :: Range -> Range -> Ordering
    Ord, Typeable Range
    Typeable Range
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Range -> c Range)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Range)
    -> (Range -> Constr)
    -> (Range -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Range))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range))
    -> ((forall b. Data b => b -> b) -> Range -> Range)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Range -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Range -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Range -> m Range)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Range -> m Range)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Range -> m Range)
    -> Data Range
    Range -> DataType
    Range -> Constr
    (forall b. Data b => b -> b) -> Range -> Range
    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) -> Range -> u
    forall u. (forall d. Data d => d -> u) -> Range -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Range -> m Range
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Range -> m Range
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Range
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Range -> c Range
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Range)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Range -> m Range
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Range -> m Range
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Range -> m Range
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Range -> m Range
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Range -> m Range
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Range -> m Range
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Range -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Range -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Range -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Range -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
    gmapT :: (forall b. Data b => b -> b) -> Range -> Range
    $cgmapT :: (forall b. Data b => b -> b) -> Range -> Range
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Range)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Range)
    dataTypeOf :: Range -> DataType
    $cdataTypeOf :: Range -> DataType
    toConstr :: Range -> Constr
    $ctoConstr :: Range -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Range
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Range
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Range -> c Range
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Range -> c Range
    Data, (forall x. Range -> Rep Range x)
    -> (forall x. Rep Range x -> Range) -> Generic Range
    forall x. Rep Range x -> Range
    forall x. Range -> Rep Range x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Range x -> Range
    $cfrom :: forall x. Range -> Rep Range x
    Generic )

    data Dec
      = FunD Name [Clause]            -- ^ @{ f p1 p2 = b where decs }@
      | ValD Pat Body [Dec]           -- ^ @{ p = b where decs }@
      | DataD Cxt Name [TyVarBndr ()]
              (Maybe Kind)            -- Kind signature (allowed only for GADTs)
              [Con] [DerivClause]
                                      -- ^ @{ data Cxt x => T x = A x | B (T x)
                                      --       deriving (Z,W)
                                      --       deriving stock Eq }@
      | NewtypeD Cxt Name [TyVarBndr ()]
                 (Maybe Kind)         -- Kind signature
                 Con [DerivClause]    -- ^ @{ newtype Cxt x => T x = A (B x)
                                      --       deriving (Z,W Q)
                                      --       deriving stock Eq }@
      | TySynD Name [TyVarBndr ()] Type -- ^ @{ type T x = (x,x) }@
      | ClassD Cxt Name [TyVarBndr ()]
             [FunDep] [Dec]           -- ^ @{ class Eq a => Ord a where ds }@
      | InstanceD (Maybe Overlap) Cxt Type [Dec]
                                      -- ^ @{ instance {\-\# OVERLAPS \#-\}
                                      --        Show w => Show [w] where ds }@
      | SigD Name Type                -- ^ @{ length :: [a] -> Int }@
      | KiSigD Name Kind              -- ^ @{ type TypeRep :: k -> Type }@
      | ForeignD Foreign              -- ^ @{ foreign import ... }
                                      --{ foreign export ... }@

      | InfixD Fixity Name            -- ^ @{ infix 3 foo }@

      -- | pragmas
      | PragmaD Pragma                -- ^ @{ {\-\# INLINE [1] foo \#-\} }@

      -- | data families (may also appear in [Dec] of 'ClassD' and 'InstanceD')
      | DataFamilyD Name [TyVarBndr ()]
                   (Maybe Kind)
             -- ^ @{ data family T a b c :: * }@

      | DataInstD Cxt (Maybe [TyVarBndr ()]) Type
                 (Maybe Kind)         -- Kind signature
                 [Con] [DerivClause]  -- ^ @{ data instance Cxt x => T [x]
                                      --       = A x | B (T x)
                                      --       deriving (Z,W)
                                      --       deriving stock Eq }@

      | NewtypeInstD Cxt (Maybe [TyVarBndr ()]) Type -- Quantified type vars
                     (Maybe Kind)      -- Kind signature
                     Con [DerivClause] -- ^ @{ newtype instance Cxt x => T [x]
                                       --        = A (B x)
                                       --        deriving (Z,W)
                                       --        deriving stock Eq }@
      | TySynInstD TySynEqn            -- ^ @{ type instance ... }@

      -- | open type families (may also appear in [Dec] of 'ClassD' and 'InstanceD')
      | OpenTypeFamilyD TypeFamilyHead
             -- ^ @{ type family T a b c = (r :: *) | r -> a b }@

      | ClosedTypeFamilyD TypeFamilyHead [TySynEqn]
           -- ^ @{ type family F a b = (r :: *) | r -> a where ... }@

      | RoleAnnotD Name [Role]     -- ^ @{ type role T nominal representational }@
      | StandaloneDerivD (Maybe DerivStrategy) Cxt Type
           -- ^ @{ deriving stock instance Ord a => Ord (Foo a) }@
      | DefaultSigD Name Type      -- ^ @{ default size :: Data a => a -> Int }@

      -- | Pattern Synonyms
      | PatSynD Name PatSynArgs PatSynDir Pat
          -- ^ @{ pattern P v1 v2 .. vn <- p }@  unidirectional           or
          --   @{ pattern P v1 v2 .. vn = p  }@  implicit bidirectional   or
          --   @{ pattern P v1 v2 .. vn <- p
          --        where P v1 v2 .. vn = e  }@  explicit bidirectional
          --
          -- also, besides prefix pattern synonyms, both infix and record
          -- pattern synonyms are supported. See 'PatSynArgs' for details

      | PatSynSigD Name PatSynType  -- ^ A pattern synonym's type signature.

      | ImplicitParamBindD String Exp
          -- ^ @{ ?x = expr }@
          --
          -- Implicit parameter binding declaration. Can only be used in let
          -- and where clauses which consist entirely of implicit bindings.
      deriving( Int -> Dec -> String -> String
    [Dec] -> String -> String
    Dec -> String
    (Int -> Dec -> String -> String)
    -> (Dec -> String) -> ([Dec] -> String -> String) -> Show Dec
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Dec] -> String -> String
    $cshowList :: [Dec] -> String -> String
    show :: Dec -> String
    $cshow :: Dec -> String
    showsPrec :: Int -> Dec -> String -> String
    $cshowsPrec :: Int -> Dec -> String -> String
    Show, Dec -> Dec -> Bool
    (Dec -> Dec -> Bool) -> (Dec -> Dec -> Bool) -> Eq Dec
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Dec -> Dec -> Bool
    $c/= :: Dec -> Dec -> Bool
    == :: Dec -> Dec -> Bool
    $c== :: Dec -> Dec -> Bool
    Eq, Eq Dec
    Eq Dec
    -> (Dec -> Dec -> Ordering)
    -> (Dec -> Dec -> Bool)
    -> (Dec -> Dec -> Bool)
    -> (Dec -> Dec -> Bool)
    -> (Dec -> Dec -> Bool)
    -> (Dec -> Dec -> Dec)
    -> (Dec -> Dec -> Dec)
    -> Ord Dec
    Dec -> Dec -> Bool
    Dec -> Dec -> Ordering
    Dec -> Dec -> Dec
    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
    min :: Dec -> Dec -> Dec
    $cmin :: Dec -> Dec -> Dec
    max :: Dec -> Dec -> Dec
    $cmax :: Dec -> Dec -> Dec
    >= :: Dec -> Dec -> Bool
    $c>= :: Dec -> Dec -> Bool
    > :: Dec -> Dec -> Bool
    $c> :: Dec -> Dec -> Bool
    <= :: Dec -> Dec -> Bool
    $c<= :: Dec -> Dec -> Bool
    < :: Dec -> Dec -> Bool
    $c< :: Dec -> Dec -> Bool
    compare :: Dec -> Dec -> Ordering
    $ccompare :: Dec -> Dec -> Ordering
    Ord, Typeable Dec
    Typeable Dec
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Dec -> c Dec)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Dec)
    -> (Dec -> Constr)
    -> (Dec -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Dec))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec))
    -> ((forall b. Data b => b -> b) -> Dec -> Dec)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Dec -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Dec -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Dec -> m Dec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Dec -> m Dec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Dec -> m Dec)
    -> Data Dec
    Dec -> DataType
    Dec -> Constr
    (forall b. Data b => b -> b) -> Dec -> Dec
    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) -> Dec -> u
    forall u. (forall d. Data d => d -> u) -> Dec -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Dec -> m Dec
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Dec -> m Dec
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Dec
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Dec -> c Dec
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Dec)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Dec -> m Dec
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Dec -> m Dec
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Dec -> m Dec
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Dec -> m Dec
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Dec -> m Dec
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Dec -> m Dec
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Dec -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Dec -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Dec -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Dec -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
    gmapT :: (forall b. Data b => b -> b) -> Dec -> Dec
    $cgmapT :: (forall b. Data b => b -> b) -> Dec -> Dec
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Dec)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Dec)
    dataTypeOf :: Dec -> DataType
    $cdataTypeOf :: Dec -> DataType
    toConstr :: Dec -> Constr
    $ctoConstr :: Dec -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Dec
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Dec
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Dec -> c Dec
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Dec -> c Dec
    Data, (forall x. Dec -> Rep Dec x)
    -> (forall x. Rep Dec x -> Dec) -> Generic Dec
    forall x. Rep Dec x -> Dec
    forall x. Dec -> Rep Dec x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Dec x -> Dec
    $cfrom :: forall x. Dec -> Rep Dec x
    Generic )

    -- | Varieties of allowed instance overlap.
    data Overlap = Overlappable   -- ^ May be overlapped by more specific instances
                 | Overlapping    -- ^ May overlap a more general instance
                 | Overlaps       -- ^ Both 'Overlapping' and 'Overlappable'
                 | Incoherent     -- ^ Both 'Overlappable' and 'Overlappable', and
                                  -- pick an arbitrary one if multiple choices are
                                  -- available.
      deriving( Int -> Overlap -> String -> String
    [Overlap] -> String -> String
    Overlap -> String
    (Int -> Overlap -> String -> String)
    -> (Overlap -> String)
    -> ([Overlap] -> String -> String)
    -> Show Overlap
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Overlap] -> String -> String
    $cshowList :: [Overlap] -> String -> String
    show :: Overlap -> String
    $cshow :: Overlap -> String
    showsPrec :: Int -> Overlap -> String -> String
    $cshowsPrec :: Int -> Overlap -> String -> String
    Show, Overlap -> Overlap -> Bool
    (Overlap -> Overlap -> Bool)
    -> (Overlap -> Overlap -> Bool) -> Eq Overlap
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Overlap -> Overlap -> Bool
    $c/= :: Overlap -> Overlap -> Bool
    == :: Overlap -> Overlap -> Bool
    $c== :: Overlap -> Overlap -> Bool
    Eq, Eq Overlap
    Eq Overlap
    -> (Overlap -> Overlap -> Ordering)
    -> (Overlap -> Overlap -> Bool)
    -> (Overlap -> Overlap -> Bool)
    -> (Overlap -> Overlap -> Bool)
    -> (Overlap -> Overlap -> Bool)
    -> (Overlap -> Overlap -> Overlap)
    -> (Overlap -> Overlap -> Overlap)
    -> Ord Overlap
    Overlap -> Overlap -> Bool
    Overlap -> Overlap -> Ordering
    Overlap -> Overlap -> Overlap
    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
    min :: Overlap -> Overlap -> Overlap
    $cmin :: Overlap -> Overlap -> Overlap
    max :: Overlap -> Overlap -> Overlap
    $cmax :: Overlap -> Overlap -> Overlap
    >= :: Overlap -> Overlap -> Bool
    $c>= :: Overlap -> Overlap -> Bool
    > :: Overlap -> Overlap -> Bool
    $c> :: Overlap -> Overlap -> Bool
    <= :: Overlap -> Overlap -> Bool
    $c<= :: Overlap -> Overlap -> Bool
    < :: Overlap -> Overlap -> Bool
    $c< :: Overlap -> Overlap -> Bool
    compare :: Overlap -> Overlap -> Ordering
    $ccompare :: Overlap -> Overlap -> Ordering
    Ord, Typeable Overlap
    Typeable Overlap
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Overlap -> c Overlap)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Overlap)
    -> (Overlap -> Constr)
    -> (Overlap -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Overlap))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap))
    -> ((forall b. Data b => b -> b) -> Overlap -> Overlap)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Overlap -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Overlap -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Overlap -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Overlap -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Overlap -> m Overlap)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Overlap -> m Overlap)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Overlap -> m Overlap)
    -> Data Overlap
    Overlap -> DataType
    Overlap -> Constr
    (forall b. Data b => b -> b) -> Overlap -> Overlap
    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) -> Overlap -> u
    forall u. (forall d. Data d => d -> u) -> Overlap -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Overlap -> m Overlap
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overlap -> m Overlap
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Overlap
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Overlap -> c Overlap
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Overlap)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overlap -> m Overlap
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overlap -> m Overlap
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overlap -> m Overlap
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overlap -> m Overlap
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Overlap -> m Overlap
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Overlap -> m Overlap
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Overlap -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Overlap -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Overlap -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Overlap -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap -> r
    gmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap
    $cgmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Overlap)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Overlap)
    dataTypeOf :: Overlap -> DataType
    $cdataTypeOf :: Overlap -> DataType
    toConstr :: Overlap -> Constr
    $ctoConstr :: Overlap -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Overlap
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Overlap
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Overlap -> c Overlap
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Overlap -> c Overlap
    Data, (forall x. Overlap -> Rep Overlap x)
    -> (forall x. Rep Overlap x -> Overlap) -> Generic Overlap
    forall x. Rep Overlap x -> Overlap
    forall x. Overlap -> Rep Overlap x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Overlap x -> Overlap
    $cfrom :: forall x. Overlap -> Rep Overlap x
    Generic )

    -- | A single @deriving@ clause at the end of a datatype.
    data DerivClause = DerivClause (Maybe DerivStrategy) Cxt
        -- ^ @{ deriving stock (Eq, Ord) }@
      deriving( Int -> DerivClause -> String -> String
    [DerivClause] -> String -> String
    DerivClause -> String
    (Int -> DerivClause -> String -> String)
    -> (DerivClause -> String)
    -> ([DerivClause] -> String -> String)
    -> Show DerivClause
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [DerivClause] -> String -> String
    $cshowList :: [DerivClause] -> String -> String
    show :: DerivClause -> String
    $cshow :: DerivClause -> String
    showsPrec :: Int -> DerivClause -> String -> String
    $cshowsPrec :: Int -> DerivClause -> String -> String
    Show, DerivClause -> DerivClause -> Bool
    (DerivClause -> DerivClause -> Bool)
    -> (DerivClause -> DerivClause -> Bool) -> Eq DerivClause
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: DerivClause -> DerivClause -> Bool
    $c/= :: DerivClause -> DerivClause -> Bool
    == :: DerivClause -> DerivClause -> Bool
    $c== :: DerivClause -> DerivClause -> Bool
    Eq, Eq DerivClause
    Eq DerivClause
    -> (DerivClause -> DerivClause -> Ordering)
    -> (DerivClause -> DerivClause -> Bool)
    -> (DerivClause -> DerivClause -> Bool)
    -> (DerivClause -> DerivClause -> Bool)
    -> (DerivClause -> DerivClause -> Bool)
    -> (DerivClause -> DerivClause -> DerivClause)
    -> (DerivClause -> DerivClause -> DerivClause)
    -> Ord DerivClause
    DerivClause -> DerivClause -> Bool
    DerivClause -> DerivClause -> Ordering
    DerivClause -> DerivClause -> DerivClause
    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
    min :: DerivClause -> DerivClause -> DerivClause
    $cmin :: DerivClause -> DerivClause -> DerivClause
    max :: DerivClause -> DerivClause -> DerivClause
    $cmax :: DerivClause -> DerivClause -> DerivClause
    >= :: DerivClause -> DerivClause -> Bool
    $c>= :: DerivClause -> DerivClause -> Bool
    > :: DerivClause -> DerivClause -> Bool
    $c> :: DerivClause -> DerivClause -> Bool
    <= :: DerivClause -> DerivClause -> Bool
    $c<= :: DerivClause -> DerivClause -> Bool
    < :: DerivClause -> DerivClause -> Bool
    $c< :: DerivClause -> DerivClause -> Bool
    compare :: DerivClause -> DerivClause -> Ordering
    $ccompare :: DerivClause -> DerivClause -> Ordering
    Ord, Typeable DerivClause
    Typeable DerivClause
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> DerivClause -> c DerivClause)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DerivClause)
    -> (DerivClause -> Constr)
    -> (DerivClause -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DerivClause))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DerivClause))
    -> ((forall b. Data b => b -> b) -> DerivClause -> DerivClause)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DerivClause -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DerivClause -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DerivClause -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DerivClause -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause)
    -> Data DerivClause
    DerivClause -> DataType
    DerivClause -> Constr
    (forall b. Data b => b -> b) -> DerivClause -> DerivClause
    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) -> DerivClause -> u
    forall u. (forall d. Data d => d -> u) -> DerivClause -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivClause -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivClause -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivClause
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivClause -> c DerivClause
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivClause)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivClause)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DerivClause -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DerivClause -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DerivClause -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DerivClause -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivClause -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivClause -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivClause -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivClause -> r
    gmapT :: (forall b. Data b => b -> b) -> DerivClause -> DerivClause
    $cgmapT :: (forall b. Data b => b -> b) -> DerivClause -> DerivClause
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivClause)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivClause)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivClause)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivClause)
    dataTypeOf :: DerivClause -> DataType
    $cdataTypeOf :: DerivClause -> DataType
    toConstr :: DerivClause -> Constr
    $ctoConstr :: DerivClause -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivClause
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivClause
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivClause -> c DerivClause
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivClause -> c DerivClause
    Data, (forall x. DerivClause -> Rep DerivClause x)
    -> (forall x. Rep DerivClause x -> DerivClause)
    -> Generic DerivClause
    forall x. Rep DerivClause x -> DerivClause
    forall x. DerivClause -> Rep DerivClause x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep DerivClause x -> DerivClause
    $cfrom :: forall x. DerivClause -> Rep DerivClause x
    Generic )

    -- | What the user explicitly requests when deriving an instance.
    data DerivStrategy = StockStrategy    -- ^ A \"standard\" derived instance
                       | AnyclassStrategy -- ^ @-XDeriveAnyClass@
                       | NewtypeStrategy  -- ^ @-XGeneralizedNewtypeDeriving@
                       | ViaStrategy Type -- ^ @-XDerivingVia@
      deriving( Int -> DerivStrategy -> String -> String
    [DerivStrategy] -> String -> String
    DerivStrategy -> String
    (Int -> DerivStrategy -> String -> String)
    -> (DerivStrategy -> String)
    -> ([DerivStrategy] -> String -> String)
    -> Show DerivStrategy
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [DerivStrategy] -> String -> String
    $cshowList :: [DerivStrategy] -> String -> String
    show :: DerivStrategy -> String
    $cshow :: DerivStrategy -> String
    showsPrec :: Int -> DerivStrategy -> String -> String
    $cshowsPrec :: Int -> DerivStrategy -> String -> String
    Show, DerivStrategy -> DerivStrategy -> Bool
    (DerivStrategy -> DerivStrategy -> Bool)
    -> (DerivStrategy -> DerivStrategy -> Bool) -> Eq DerivStrategy
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: DerivStrategy -> DerivStrategy -> Bool
    $c/= :: DerivStrategy -> DerivStrategy -> Bool
    == :: DerivStrategy -> DerivStrategy -> Bool
    $c== :: DerivStrategy -> DerivStrategy -> Bool
    Eq, Eq DerivStrategy
    Eq DerivStrategy
    -> (DerivStrategy -> DerivStrategy -> Ordering)
    -> (DerivStrategy -> DerivStrategy -> Bool)
    -> (DerivStrategy -> DerivStrategy -> Bool)
    -> (DerivStrategy -> DerivStrategy -> Bool)
    -> (DerivStrategy -> DerivStrategy -> Bool)
    -> (DerivStrategy -> DerivStrategy -> DerivStrategy)
    -> (DerivStrategy -> DerivStrategy -> DerivStrategy)
    -> Ord DerivStrategy
    DerivStrategy -> DerivStrategy -> Bool
    DerivStrategy -> DerivStrategy -> Ordering
    DerivStrategy -> DerivStrategy -> DerivStrategy
    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
    min :: DerivStrategy -> DerivStrategy -> DerivStrategy
    $cmin :: DerivStrategy -> DerivStrategy -> DerivStrategy
    max :: DerivStrategy -> DerivStrategy -> DerivStrategy
    $cmax :: DerivStrategy -> DerivStrategy -> DerivStrategy
    >= :: DerivStrategy -> DerivStrategy -> Bool
    $c>= :: DerivStrategy -> DerivStrategy -> Bool
    > :: DerivStrategy -> DerivStrategy -> Bool
    $c> :: DerivStrategy -> DerivStrategy -> Bool
    <= :: DerivStrategy -> DerivStrategy -> Bool
    $c<= :: DerivStrategy -> DerivStrategy -> Bool
    < :: DerivStrategy -> DerivStrategy -> Bool
    $c< :: DerivStrategy -> DerivStrategy -> Bool
    compare :: DerivStrategy -> DerivStrategy -> Ordering
    $ccompare :: DerivStrategy -> DerivStrategy -> Ordering
    Ord, Typeable DerivStrategy
    Typeable DerivStrategy
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DerivStrategy)
    -> (DerivStrategy -> Constr)
    -> (DerivStrategy -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DerivStrategy))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DerivStrategy))
    -> ((forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DerivStrategy -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy)
    -> Data DerivStrategy
    DerivStrategy -> DataType
    DerivStrategy -> Constr
    (forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy
    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) -> DerivStrategy -> u
    forall u. (forall d. Data d => d -> u) -> DerivStrategy -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivStrategy
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivStrategy)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivStrategy)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DerivStrategy -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DerivStrategy -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
    gmapT :: (forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy
    $cgmapT :: (forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivStrategy)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivStrategy)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivStrategy)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivStrategy)
    dataTypeOf :: DerivStrategy -> DataType
    $cdataTypeOf :: DerivStrategy -> DataType
    toConstr :: DerivStrategy -> Constr
    $ctoConstr :: DerivStrategy -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivStrategy
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivStrategy
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy
    Data, (forall x. DerivStrategy -> Rep DerivStrategy x)
    -> (forall x. Rep DerivStrategy x -> DerivStrategy)
    -> Generic DerivStrategy
    forall x. Rep DerivStrategy x -> DerivStrategy
    forall x. DerivStrategy -> Rep DerivStrategy x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep DerivStrategy x -> DerivStrategy
    $cfrom :: forall x. DerivStrategy -> Rep DerivStrategy x
    Generic )

    -- | A pattern synonym's type. Note that a pattern synonym's /fully/
    -- specified type has a peculiar shape coming with two forall
    -- quantifiers and two constraint contexts. For example, consider the
    -- pattern synonym
    --
    -- > pattern P x1 x2 ... xn = <some-pattern>
    --
    -- P's complete type is of the following form
    --
    -- > pattern P :: forall universals.   required constraints
    -- >           => forall existentials. provided constraints
    -- >           => t1 -> t2 -> ... -> tn -> t
    --
    -- consisting of four parts:
    --
    --   1. the (possibly empty lists of) universally quantified type
    --      variables and required constraints on them.
    --   2. the (possibly empty lists of) existentially quantified
    --      type variables and the provided constraints on them.
    --   3. the types @t1@, @t2@, .., @tn@ of @x1@, @x2@, .., @xn@, respectively
    --   4. the type @t@ of @\<some-pattern\>@, mentioning only universals.
    --
    -- Pattern synonym types interact with TH when (a) reifying a pattern
    -- synonym, (b) pretty printing, or (c) specifying a pattern synonym's
    -- type signature explicitly:
    --
    --   * Reification always returns a pattern synonym's /fully/ specified
    --     type in abstract syntax.
    --
    --   * Pretty printing via 'Language.Haskell.TH.Ppr.pprPatSynType' abbreviates
    --     a pattern synonym's type unambiguously in concrete syntax: The rule of
    --     thumb is to print initial empty universals and the required
    --     context as @() =>@, if existentials and a provided context
    --     follow. If only universals and their required context, but no
    --     existentials are specified, only the universals and their
    --     required context are printed. If both or none are specified, so
    --     both (or none) are printed.
    --
    --   * When specifying a pattern synonym's type explicitly with
    --     'PatSynSigD' either one of the universals, the existentials, or
    --     their contexts may be left empty.
    --
    -- See the GHC user's guide for more information on pattern synonyms
    -- and their types:
    -- <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms>.
    type PatSynType = Type

    -- | Common elements of 'OpenTypeFamilyD' and 'ClosedTypeFamilyD'. By
    -- analogy with "head" for type classes and type class instances as
    -- defined in /Type classes: an exploration of the design space/, the
    -- @TypeFamilyHead@ is defined to be the elements of the declaration
    -- between @type family@ and @where@.
    data TypeFamilyHead =
      TypeFamilyHead Name [TyVarBndr ()] FamilyResultSig (Maybe InjectivityAnn)
      deriving( Int -> TypeFamilyHead -> String -> String
    [TypeFamilyHead] -> String -> String
    TypeFamilyHead -> String
    (Int -> TypeFamilyHead -> String -> String)
    -> (TypeFamilyHead -> String)
    -> ([TypeFamilyHead] -> String -> String)
    -> Show TypeFamilyHead
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [TypeFamilyHead] -> String -> String
    $cshowList :: [TypeFamilyHead] -> String -> String
    show :: TypeFamilyHead -> String
    $cshow :: TypeFamilyHead -> String
    showsPrec :: Int -> TypeFamilyHead -> String -> String
    $cshowsPrec :: Int -> TypeFamilyHead -> String -> String
    Show, TypeFamilyHead -> TypeFamilyHead -> Bool
    (TypeFamilyHead -> TypeFamilyHead -> Bool)
    -> (TypeFamilyHead -> TypeFamilyHead -> Bool) -> Eq TypeFamilyHead
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: TypeFamilyHead -> TypeFamilyHead -> Bool
    $c/= :: TypeFamilyHead -> TypeFamilyHead -> Bool
    == :: TypeFamilyHead -> TypeFamilyHead -> Bool
    $c== :: TypeFamilyHead -> TypeFamilyHead -> Bool
    Eq, Eq TypeFamilyHead
    Eq TypeFamilyHead
    -> (TypeFamilyHead -> TypeFamilyHead -> Ordering)
    -> (TypeFamilyHead -> TypeFamilyHead -> Bool)
    -> (TypeFamilyHead -> TypeFamilyHead -> Bool)
    -> (TypeFamilyHead -> TypeFamilyHead -> Bool)
    -> (TypeFamilyHead -> TypeFamilyHead -> Bool)
    -> (TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead)
    -> (TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead)
    -> Ord TypeFamilyHead
    TypeFamilyHead -> TypeFamilyHead -> Bool
    TypeFamilyHead -> TypeFamilyHead -> Ordering
    TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead
    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
    min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead
    $cmin :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead
    max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead
    $cmax :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead
    >= :: TypeFamilyHead -> TypeFamilyHead -> Bool
    $c>= :: TypeFamilyHead -> TypeFamilyHead -> Bool
    > :: TypeFamilyHead -> TypeFamilyHead -> Bool
    $c> :: TypeFamilyHead -> TypeFamilyHead -> Bool
    <= :: TypeFamilyHead -> TypeFamilyHead -> Bool
    $c<= :: TypeFamilyHead -> TypeFamilyHead -> Bool
    < :: TypeFamilyHead -> TypeFamilyHead -> Bool
    $c< :: TypeFamilyHead -> TypeFamilyHead -> Bool
    compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering
    $ccompare :: TypeFamilyHead -> TypeFamilyHead -> Ordering
    Ord, Typeable TypeFamilyHead
    Typeable TypeFamilyHead
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TypeFamilyHead)
    -> (TypeFamilyHead -> Constr)
    -> (TypeFamilyHead -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c TypeFamilyHead))
    -> ((forall b. Data b => b -> b)
        -> TypeFamilyHead -> TypeFamilyHead)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> TypeFamilyHead -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> TypeFamilyHead -> m TypeFamilyHead)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> TypeFamilyHead -> m TypeFamilyHead)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> TypeFamilyHead -> m TypeFamilyHead)
    -> Data TypeFamilyHead
    TypeFamilyHead -> DataType
    TypeFamilyHead -> Constr
    (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead
    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) -> TypeFamilyHead -> u
    forall u. (forall d. Data d => d -> u) -> TypeFamilyHead -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TypeFamilyHead -> m TypeFamilyHead
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TypeFamilyHead -> m TypeFamilyHead
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeFamilyHead
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TypeFamilyHead)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TypeFamilyHead -> m TypeFamilyHead
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TypeFamilyHead -> m TypeFamilyHead
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TypeFamilyHead -> m TypeFamilyHead
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TypeFamilyHead -> m TypeFamilyHead
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TypeFamilyHead -> m TypeFamilyHead
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TypeFamilyHead -> m TypeFamilyHead
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TypeFamilyHead -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeFamilyHead -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
    gmapT :: (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead
    $cgmapT :: (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TypeFamilyHead)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TypeFamilyHead)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead)
    dataTypeOf :: TypeFamilyHead -> DataType
    $cdataTypeOf :: TypeFamilyHead -> DataType
    toConstr :: TypeFamilyHead -> Constr
    $ctoConstr :: TypeFamilyHead -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeFamilyHead
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeFamilyHead
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead
    Data, (forall x. TypeFamilyHead -> Rep TypeFamilyHead x)
    -> (forall x. Rep TypeFamilyHead x -> TypeFamilyHead)
    -> Generic TypeFamilyHead
    forall x. Rep TypeFamilyHead x -> TypeFamilyHead
    forall x. TypeFamilyHead -> Rep TypeFamilyHead x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TypeFamilyHead x -> TypeFamilyHead
    $cfrom :: forall x. TypeFamilyHead -> Rep TypeFamilyHead x
    Generic )

    -- | One equation of a type family instance or closed type family. The
    -- arguments are the left-hand-side type and the right-hand-side result.
    --
    -- For instance, if you had the following type family:
    --
    -- @
    -- type family Foo (a :: k) :: k where
    --   forall k (a :: k). Foo \@k a = a
    -- @
    --
    -- The @Foo \@k a = a@ equation would be represented as follows:
    --
    -- @
    -- 'TySynEqn' ('Just' ['PlainTV' k, 'KindedTV' a ('VarT' k)])
    --            ('AppT' ('AppKindT' ('ConT' ''Foo) ('VarT' k)) ('VarT' a))
    --            ('VarT' a)
    -- @
    data TySynEqn = TySynEqn (Maybe [TyVarBndr ()]) Type Type
      deriving( Int -> TySynEqn -> String -> String
    [TySynEqn] -> String -> String
    TySynEqn -> String
    (Int -> TySynEqn -> String -> String)
    -> (TySynEqn -> String)
    -> ([TySynEqn] -> String -> String)
    -> Show TySynEqn
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [TySynEqn] -> String -> String
    $cshowList :: [TySynEqn] -> String -> String
    show :: TySynEqn -> String
    $cshow :: TySynEqn -> String
    showsPrec :: Int -> TySynEqn -> String -> String
    $cshowsPrec :: Int -> TySynEqn -> String -> String
    Show, TySynEqn -> TySynEqn -> Bool
    (TySynEqn -> TySynEqn -> Bool)
    -> (TySynEqn -> TySynEqn -> Bool) -> Eq TySynEqn
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: TySynEqn -> TySynEqn -> Bool
    $c/= :: TySynEqn -> TySynEqn -> Bool
    == :: TySynEqn -> TySynEqn -> Bool
    $c== :: TySynEqn -> TySynEqn -> Bool
    Eq, Eq TySynEqn
    Eq TySynEqn
    -> (TySynEqn -> TySynEqn -> Ordering)
    -> (TySynEqn -> TySynEqn -> Bool)
    -> (TySynEqn -> TySynEqn -> Bool)
    -> (TySynEqn -> TySynEqn -> Bool)
    -> (TySynEqn -> TySynEqn -> Bool)
    -> (TySynEqn -> TySynEqn -> TySynEqn)
    -> (TySynEqn -> TySynEqn -> TySynEqn)
    -> Ord TySynEqn
    TySynEqn -> TySynEqn -> Bool
    TySynEqn -> TySynEqn -> Ordering
    TySynEqn -> TySynEqn -> TySynEqn
    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
    min :: TySynEqn -> TySynEqn -> TySynEqn
    $cmin :: TySynEqn -> TySynEqn -> TySynEqn
    max :: TySynEqn -> TySynEqn -> TySynEqn
    $cmax :: TySynEqn -> TySynEqn -> TySynEqn
    >= :: TySynEqn -> TySynEqn -> Bool
    $c>= :: TySynEqn -> TySynEqn -> Bool
    > :: TySynEqn -> TySynEqn -> Bool
    $c> :: TySynEqn -> TySynEqn -> Bool
    <= :: TySynEqn -> TySynEqn -> Bool
    $c<= :: TySynEqn -> TySynEqn -> Bool
    < :: TySynEqn -> TySynEqn -> Bool
    $c< :: TySynEqn -> TySynEqn -> Bool
    compare :: TySynEqn -> TySynEqn -> Ordering
    $ccompare :: TySynEqn -> TySynEqn -> Ordering
    Ord, Typeable TySynEqn
    Typeable TySynEqn
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TySynEqn)
    -> (TySynEqn -> Constr)
    -> (TySynEqn -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TySynEqn))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn))
    -> ((forall b. Data b => b -> b) -> TySynEqn -> TySynEqn)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TySynEqn -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> TySynEqn -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn)
    -> Data TySynEqn
    TySynEqn -> DataType
    TySynEqn -> Constr
    (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn
    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) -> TySynEqn -> u
    forall u. (forall d. Data d => d -> u) -> TySynEqn -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TySynEqn
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TySynEqn)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TySynEqn -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TySynEqn -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TySynEqn -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TySynEqn -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
    gmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn
    $cgmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TySynEqn)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TySynEqn)
    dataTypeOf :: TySynEqn -> DataType
    $cdataTypeOf :: TySynEqn -> DataType
    toConstr :: TySynEqn -> Constr
    $ctoConstr :: TySynEqn -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TySynEqn
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TySynEqn
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn
    Data, (forall x. TySynEqn -> Rep TySynEqn x)
    -> (forall x. Rep TySynEqn x -> TySynEqn) -> Generic TySynEqn
    forall x. Rep TySynEqn x -> TySynEqn
    forall x. TySynEqn -> Rep TySynEqn x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TySynEqn x -> TySynEqn
    $cfrom :: forall x. TySynEqn -> Rep TySynEqn x
    Generic )

    data FunDep = FunDep [Name] [Name]
      deriving( Int -> FunDep -> String -> String
    [FunDep] -> String -> String
    FunDep -> String
    (Int -> FunDep -> String -> String)
    -> (FunDep -> String)
    -> ([FunDep] -> String -> String)
    -> Show FunDep
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [FunDep] -> String -> String
    $cshowList :: [FunDep] -> String -> String
    show :: FunDep -> String
    $cshow :: FunDep -> String
    showsPrec :: Int -> FunDep -> String -> String
    $cshowsPrec :: Int -> FunDep -> String -> String
    Show, FunDep -> FunDep -> Bool
    (FunDep -> FunDep -> Bool)
    -> (FunDep -> FunDep -> Bool) -> Eq FunDep
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: FunDep -> FunDep -> Bool
    $c/= :: FunDep -> FunDep -> Bool
    == :: FunDep -> FunDep -> Bool
    $c== :: FunDep -> FunDep -> Bool
    Eq, Eq FunDep
    Eq FunDep
    -> (FunDep -> FunDep -> Ordering)
    -> (FunDep -> FunDep -> Bool)
    -> (FunDep -> FunDep -> Bool)
    -> (FunDep -> FunDep -> Bool)
    -> (FunDep -> FunDep -> Bool)
    -> (FunDep -> FunDep -> FunDep)
    -> (FunDep -> FunDep -> FunDep)
    -> Ord FunDep
    FunDep -> FunDep -> Bool
    FunDep -> FunDep -> Ordering
    FunDep -> FunDep -> FunDep
    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
    min :: FunDep -> FunDep -> FunDep
    $cmin :: FunDep -> FunDep -> FunDep
    max :: FunDep -> FunDep -> FunDep
    $cmax :: FunDep -> FunDep -> FunDep
    >= :: FunDep -> FunDep -> Bool
    $c>= :: FunDep -> FunDep -> Bool
    > :: FunDep -> FunDep -> Bool
    $c> :: FunDep -> FunDep -> Bool
    <= :: FunDep -> FunDep -> Bool
    $c<= :: FunDep -> FunDep -> Bool
    < :: FunDep -> FunDep -> Bool
    $c< :: FunDep -> FunDep -> Bool
    compare :: FunDep -> FunDep -> Ordering
    $ccompare :: FunDep -> FunDep -> Ordering
    Ord, Typeable FunDep
    Typeable FunDep
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> FunDep -> c FunDep)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c FunDep)
    -> (FunDep -> Constr)
    -> (FunDep -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c FunDep))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep))
    -> ((forall b. Data b => b -> b) -> FunDep -> FunDep)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FunDep -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FunDep -> r)
    -> (forall u. (forall d. Data d => d -> u) -> FunDep -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> FunDep -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> FunDep -> m FunDep)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> FunDep -> m FunDep)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> FunDep -> m FunDep)
    -> Data FunDep
    FunDep -> DataType
    FunDep -> Constr
    (forall b. Data b => b -> b) -> FunDep -> FunDep
    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) -> FunDep -> u
    forall u. (forall d. Data d => d -> u) -> FunDep -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FunDep -> m FunDep
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunDep -> m FunDep
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FunDep
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FunDep -> c FunDep
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FunDep)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunDep -> m FunDep
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunDep -> m FunDep
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunDep -> m FunDep
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunDep -> m FunDep
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FunDep -> m FunDep
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FunDep -> m FunDep
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FunDep -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FunDep -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> FunDep -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> FunDep -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
    gmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDep
    $cgmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDep
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FunDep)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FunDep)
    dataTypeOf :: FunDep -> DataType
    $cdataTypeOf :: FunDep -> DataType
    toConstr :: FunDep -> Constr
    $ctoConstr :: FunDep -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FunDep
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FunDep
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FunDep -> c FunDep
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FunDep -> c FunDep
    Data, (forall x. FunDep -> Rep FunDep x)
    -> (forall x. Rep FunDep x -> FunDep) -> Generic FunDep
    forall x. Rep FunDep x -> FunDep
    forall x. FunDep -> Rep FunDep x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep FunDep x -> FunDep
    $cfrom :: forall x. FunDep -> Rep FunDep x
    Generic )

    data Foreign = ImportF Callconv Safety String Name Type
                 | ExportF Callconv        String Name Type
             deriving( Int -> Foreign -> String -> String
    [Foreign] -> String -> String
    Foreign -> String
    (Int -> Foreign -> String -> String)
    -> (Foreign -> String)
    -> ([Foreign] -> String -> String)
    -> Show Foreign
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Foreign] -> String -> String
    $cshowList :: [Foreign] -> String -> String
    show :: Foreign -> String
    $cshow :: Foreign -> String
    showsPrec :: Int -> Foreign -> String -> String
    $cshowsPrec :: Int -> Foreign -> String -> String
    Show, Foreign -> Foreign -> Bool
    (Foreign -> Foreign -> Bool)
    -> (Foreign -> Foreign -> Bool) -> Eq Foreign
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Foreign -> Foreign -> Bool
    $c/= :: Foreign -> Foreign -> Bool
    == :: Foreign -> Foreign -> Bool
    $c== :: Foreign -> Foreign -> Bool
    Eq, Eq Foreign
    Eq Foreign
    -> (Foreign -> Foreign -> Ordering)
    -> (Foreign -> Foreign -> Bool)
    -> (Foreign -> Foreign -> Bool)
    -> (Foreign -> Foreign -> Bool)
    -> (Foreign -> Foreign -> Bool)
    -> (Foreign -> Foreign -> Foreign)
    -> (Foreign -> Foreign -> Foreign)
    -> Ord Foreign
    Foreign -> Foreign -> Bool
    Foreign -> Foreign -> Ordering
    Foreign -> Foreign -> Foreign
    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
    min :: Foreign -> Foreign -> Foreign
    $cmin :: Foreign -> Foreign -> Foreign
    max :: Foreign -> Foreign -> Foreign
    $cmax :: Foreign -> Foreign -> Foreign
    >= :: Foreign -> Foreign -> Bool
    $c>= :: Foreign -> Foreign -> Bool
    > :: Foreign -> Foreign -> Bool
    $c> :: Foreign -> Foreign -> Bool
    <= :: Foreign -> Foreign -> Bool
    $c<= :: Foreign -> Foreign -> Bool
    < :: Foreign -> Foreign -> Bool
    $c< :: Foreign -> Foreign -> Bool
    compare :: Foreign -> Foreign -> Ordering
    $ccompare :: Foreign -> Foreign -> Ordering
    Ord, Typeable Foreign
    Typeable Foreign
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Foreign -> c Foreign)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Foreign)
    -> (Foreign -> Constr)
    -> (Foreign -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Foreign))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign))
    -> ((forall b. Data b => b -> b) -> Foreign -> Foreign)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Foreign -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Foreign -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Foreign -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Foreign -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Foreign -> m Foreign)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Foreign -> m Foreign)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Foreign -> m Foreign)
    -> Data Foreign
    Foreign -> DataType
    Foreign -> Constr
    (forall b. Data b => b -> b) -> Foreign -> Foreign
    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) -> Foreign -> u
    forall u. (forall d. Data d => d -> u) -> Foreign -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Foreign -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Foreign -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Foreign -> m Foreign
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Foreign -> m Foreign
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Foreign
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Foreign -> c Foreign
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Foreign)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Foreign -> m Foreign
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Foreign -> m Foreign
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Foreign -> m Foreign
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Foreign -> m Foreign
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Foreign -> m Foreign
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Foreign -> m Foreign
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Foreign -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Foreign -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Foreign -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Foreign -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Foreign -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Foreign -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Foreign -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Foreign -> r
    gmapT :: (forall b. Data b => b -> b) -> Foreign -> Foreign
    $cgmapT :: (forall b. Data b => b -> b) -> Foreign -> Foreign
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Foreign)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Foreign)
    dataTypeOf :: Foreign -> DataType
    $cdataTypeOf :: Foreign -> DataType
    toConstr :: Foreign -> Constr
    $ctoConstr :: Foreign -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Foreign
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Foreign
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Foreign -> c Foreign
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Foreign -> c Foreign
    Data, (forall x. Foreign -> Rep Foreign x)
    -> (forall x. Rep Foreign x -> Foreign) -> Generic Foreign
    forall x. Rep Foreign x -> Foreign
    forall x. Foreign -> Rep Foreign x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Foreign x -> Foreign
    $cfrom :: forall x. Foreign -> Rep Foreign x
    Generic )

    -- keep Callconv in sync with module ForeignCall in ghc/compiler/GHC/Types/ForeignCall.hs
    data Callconv = CCall | StdCall | CApi | Prim | JavaScript
              deriving( Int -> Callconv -> String -> String
    [Callconv] -> String -> String
    Callconv -> String
    (Int -> Callconv -> String -> String)
    -> (Callconv -> String)
    -> ([Callconv] -> String -> String)
    -> Show Callconv
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Callconv] -> String -> String
    $cshowList :: [Callconv] -> String -> String
    show :: Callconv -> String
    $cshow :: Callconv -> String
    showsPrec :: Int -> Callconv -> String -> String
    $cshowsPrec :: Int -> Callconv -> String -> String
    Show, Callconv -> Callconv -> Bool
    (Callconv -> Callconv -> Bool)
    -> (Callconv -> Callconv -> Bool) -> Eq Callconv
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Callconv -> Callconv -> Bool
    $c/= :: Callconv -> Callconv -> Bool
    == :: Callconv -> Callconv -> Bool
    $c== :: Callconv -> Callconv -> Bool
    Eq, Eq Callconv
    Eq Callconv
    -> (Callconv -> Callconv -> Ordering)
    -> (Callconv -> Callconv -> Bool)
    -> (Callconv -> Callconv -> Bool)
    -> (Callconv -> Callconv -> Bool)
    -> (Callconv -> Callconv -> Bool)
    -> (Callconv -> Callconv -> Callconv)
    -> (Callconv -> Callconv -> Callconv)
    -> Ord Callconv
    Callconv -> Callconv -> Bool
    Callconv -> Callconv -> Ordering
    Callconv -> Callconv -> Callconv
    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
    min :: Callconv -> Callconv -> Callconv
    $cmin :: Callconv -> Callconv -> Callconv
    max :: Callconv -> Callconv -> Callconv
    $cmax :: Callconv -> Callconv -> Callconv
    >= :: Callconv -> Callconv -> Bool
    $c>= :: Callconv -> Callconv -> Bool
    > :: Callconv -> Callconv -> Bool
    $c> :: Callconv -> Callconv -> Bool
    <= :: Callconv -> Callconv -> Bool
    $c<= :: Callconv -> Callconv -> Bool
    < :: Callconv -> Callconv -> Bool
    $c< :: Callconv -> Callconv -> Bool
    compare :: Callconv -> Callconv -> Ordering
    $ccompare :: Callconv -> Callconv -> Ordering
    Ord, Typeable Callconv
    Typeable Callconv
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Callconv -> c Callconv)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Callconv)
    -> (Callconv -> Constr)
    -> (Callconv -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Callconv))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv))
    -> ((forall b. Data b => b -> b) -> Callconv -> Callconv)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Callconv -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Callconv -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Callconv -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Callconv -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Callconv -> m Callconv)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Callconv -> m Callconv)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Callconv -> m Callconv)
    -> Data Callconv
    Callconv -> DataType
    Callconv -> Constr
    (forall b. Data b => b -> b) -> Callconv -> Callconv
    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) -> Callconv -> u
    forall u. (forall d. Data d => d -> u) -> Callconv -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Callconv -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Callconv -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Callconv -> m Callconv
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Callconv -> m Callconv
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Callconv
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Callconv -> c Callconv
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Callconv)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Callconv -> m Callconv
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Callconv -> m Callconv
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Callconv -> m Callconv
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Callconv -> m Callconv
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Callconv -> m Callconv
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Callconv -> m Callconv
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Callconv -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Callconv -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Callconv -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Callconv -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Callconv -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Callconv -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Callconv -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Callconv -> r
    gmapT :: (forall b. Data b => b -> b) -> Callconv -> Callconv
    $cgmapT :: (forall b. Data b => b -> b) -> Callconv -> Callconv
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Callconv)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Callconv)
    dataTypeOf :: Callconv -> DataType
    $cdataTypeOf :: Callconv -> DataType
    toConstr :: Callconv -> Constr
    $ctoConstr :: Callconv -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Callconv
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Callconv
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Callconv -> c Callconv
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Callconv -> c Callconv
    Data, (forall x. Callconv -> Rep Callconv x)
    -> (forall x. Rep Callconv x -> Callconv) -> Generic Callconv
    forall x. Rep Callconv x -> Callconv
    forall x. Callconv -> Rep Callconv x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Callconv x -> Callconv
    $cfrom :: forall x. Callconv -> Rep Callconv x
    Generic )

    data Safety = Unsafe | Safe | Interruptible
            deriving( Int -> Safety -> String -> String
    [Safety] -> String -> String
    Safety -> String
    (Int -> Safety -> String -> String)
    -> (Safety -> String)
    -> ([Safety] -> String -> String)
    -> Show Safety
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Safety] -> String -> String
    $cshowList :: [Safety] -> String -> String
    show :: Safety -> String
    $cshow :: Safety -> String
    showsPrec :: Int -> Safety -> String -> String
    $cshowsPrec :: Int -> Safety -> String -> String
    Show, Safety -> Safety -> Bool
    (Safety -> Safety -> Bool)
    -> (Safety -> Safety -> Bool) -> Eq Safety
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Safety -> Safety -> Bool
    $c/= :: Safety -> Safety -> Bool
    == :: Safety -> Safety -> Bool
    $c== :: Safety -> Safety -> Bool
    Eq, Eq Safety
    Eq Safety
    -> (Safety -> Safety -> Ordering)
    -> (Safety -> Safety -> Bool)
    -> (Safety -> Safety -> Bool)
    -> (Safety -> Safety -> Bool)
    -> (Safety -> Safety -> Bool)
    -> (Safety -> Safety -> Safety)
    -> (Safety -> Safety -> Safety)
    -> Ord Safety
    Safety -> Safety -> Bool
    Safety -> Safety -> Ordering
    Safety -> Safety -> Safety
    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
    min :: Safety -> Safety -> Safety
    $cmin :: Safety -> Safety -> Safety
    max :: Safety -> Safety -> Safety
    $cmax :: Safety -> Safety -> Safety
    >= :: Safety -> Safety -> Bool
    $c>= :: Safety -> Safety -> Bool
    > :: Safety -> Safety -> Bool
    $c> :: Safety -> Safety -> Bool
    <= :: Safety -> Safety -> Bool
    $c<= :: Safety -> Safety -> Bool
    < :: Safety -> Safety -> Bool
    $c< :: Safety -> Safety -> Bool
    compare :: Safety -> Safety -> Ordering
    $ccompare :: Safety -> Safety -> Ordering
    Ord, Typeable Safety
    Typeable Safety
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Safety -> c Safety)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Safety)
    -> (Safety -> Constr)
    -> (Safety -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Safety))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety))
    -> ((forall b. Data b => b -> b) -> Safety -> Safety)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Safety -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Safety -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Safety -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Safety -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Safety -> m Safety)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Safety -> m Safety)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Safety -> m Safety)
    -> Data Safety
    Safety -> DataType
    Safety -> Constr
    (forall b. Data b => b -> b) -> Safety -> Safety
    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) -> Safety -> u
    forall u. (forall d. Data d => d -> u) -> Safety -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Safety -> m Safety
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety -> m Safety
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Safety
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Safety -> c Safety
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Safety)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety -> m Safety
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety -> m Safety
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety -> m Safety
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety -> m Safety
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Safety -> m Safety
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Safety -> m Safety
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Safety -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Safety -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Safety -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Safety -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
    gmapT :: (forall b. Data b => b -> b) -> Safety -> Safety
    $cgmapT :: (forall b. Data b => b -> b) -> Safety -> Safety
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Safety)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Safety)
    dataTypeOf :: Safety -> DataType
    $cdataTypeOf :: Safety -> DataType
    toConstr :: Safety -> Constr
    $ctoConstr :: Safety -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Safety
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Safety
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Safety -> c Safety
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Safety -> c Safety
    Data, (forall x. Safety -> Rep Safety x)
    -> (forall x. Rep Safety x -> Safety) -> Generic Safety
    forall x. Rep Safety x -> Safety
    forall x. Safety -> Rep Safety x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Safety x -> Safety
    $cfrom :: forall x. Safety -> Rep Safety x
    Generic )

    data Pragma = InlineP         Name Inline RuleMatch Phases
                | SpecialiseP     Name Type (Maybe Inline) Phases
                | SpecialiseInstP Type
                | RuleP           String (Maybe [TyVarBndr ()]) [RuleBndr] Exp Exp Phases
                | AnnP            AnnTarget Exp
                | LineP           Int String
                | CompleteP       [Name] (Maybe Name)
                    -- ^ @{ {\-\# COMPLETE C_1, ..., C_i [ :: T ] \#-} }@
            deriving( Int -> Pragma -> String -> String
    [Pragma] -> String -> String
    Pragma -> String
    (Int -> Pragma -> String -> String)
    -> (Pragma -> String)
    -> ([Pragma] -> String -> String)
    -> Show Pragma
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Pragma] -> String -> String
    $cshowList :: [Pragma] -> String -> String
    show :: Pragma -> String
    $cshow :: Pragma -> String
    showsPrec :: Int -> Pragma -> String -> String
    $cshowsPrec :: Int -> Pragma -> String -> String
    Show, Pragma -> Pragma -> Bool
    (Pragma -> Pragma -> Bool)
    -> (Pragma -> Pragma -> Bool) -> Eq Pragma
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Pragma -> Pragma -> Bool
    $c/= :: Pragma -> Pragma -> Bool
    == :: Pragma -> Pragma -> Bool
    $c== :: Pragma -> Pragma -> Bool
    Eq, Eq Pragma
    Eq Pragma
    -> (Pragma -> Pragma -> Ordering)
    -> (Pragma -> Pragma -> Bool)
    -> (Pragma -> Pragma -> Bool)
    -> (Pragma -> Pragma -> Bool)
    -> (Pragma -> Pragma -> Bool)
    -> (Pragma -> Pragma -> Pragma)
    -> (Pragma -> Pragma -> Pragma)
    -> Ord Pragma
    Pragma -> Pragma -> Bool
    Pragma -> Pragma -> Ordering
    Pragma -> Pragma -> Pragma
    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
    min :: Pragma -> Pragma -> Pragma
    $cmin :: Pragma -> Pragma -> Pragma
    max :: Pragma -> Pragma -> Pragma
    $cmax :: Pragma -> Pragma -> Pragma
    >= :: Pragma -> Pragma -> Bool
    $c>= :: Pragma -> Pragma -> Bool
    > :: Pragma -> Pragma -> Bool
    $c> :: Pragma -> Pragma -> Bool
    <= :: Pragma -> Pragma -> Bool
    $c<= :: Pragma -> Pragma -> Bool
    < :: Pragma -> Pragma -> Bool
    $c< :: Pragma -> Pragma -> Bool
    compare :: Pragma -> Pragma -> Ordering
    $ccompare :: Pragma -> Pragma -> Ordering
    Ord, Typeable Pragma
    Typeable Pragma
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Pragma -> c Pragma)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Pragma)
    -> (Pragma -> Constr)
    -> (Pragma -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Pragma))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma))
    -> ((forall b. Data b => b -> b) -> Pragma -> Pragma)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Pragma -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Pragma -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Pragma -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Pragma -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Pragma -> m Pragma)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Pragma -> m Pragma)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Pragma -> m Pragma)
    -> Data Pragma
    Pragma -> DataType
    Pragma -> Constr
    (forall b. Data b => b -> b) -> Pragma -> Pragma
    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) -> Pragma -> u
    forall u. (forall d. Data d => d -> u) -> Pragma -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pragma -> m Pragma
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pragma -> m Pragma
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pragma
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pragma -> c Pragma
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pragma)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pragma -> m Pragma
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pragma -> m Pragma
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pragma -> m Pragma
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pragma -> m Pragma
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pragma -> m Pragma
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pragma -> m Pragma
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pragma -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pragma -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Pragma -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pragma -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
    gmapT :: (forall b. Data b => b -> b) -> Pragma -> Pragma
    $cgmapT :: (forall b. Data b => b -> b) -> Pragma -> Pragma
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pragma)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pragma)
    dataTypeOf :: Pragma -> DataType
    $cdataTypeOf :: Pragma -> DataType
    toConstr :: Pragma -> Constr
    $ctoConstr :: Pragma -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pragma
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pragma
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pragma -> c Pragma
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pragma -> c Pragma
    Data, (forall x. Pragma -> Rep Pragma x)
    -> (forall x. Rep Pragma x -> Pragma) -> Generic Pragma
    forall x. Rep Pragma x -> Pragma
    forall x. Pragma -> Rep Pragma x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Pragma x -> Pragma
    $cfrom :: forall x. Pragma -> Rep Pragma x
    Generic )

    data Inline = NoInline
                | Inline
                | Inlinable
                deriving (Int -> Inline -> String -> String
    [Inline] -> String -> String
    Inline -> String
    (Int -> Inline -> String -> String)
    -> (Inline -> String)
    -> ([Inline] -> String -> String)
    -> Show Inline
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Inline] -> String -> String
    $cshowList :: [Inline] -> String -> String
    show :: Inline -> String
    $cshow :: Inline -> String
    showsPrec :: Int -> Inline -> String -> String
    $cshowsPrec :: Int -> Inline -> String -> String
    Show, Inline -> Inline -> Bool
    (Inline -> Inline -> Bool)
    -> (Inline -> Inline -> Bool) -> Eq Inline
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Inline -> Inline -> Bool
    $c/= :: Inline -> Inline -> Bool
    == :: Inline -> Inline -> Bool
    $c== :: Inline -> Inline -> Bool
    Eq, Eq Inline
    Eq Inline
    -> (Inline -> Inline -> Ordering)
    -> (Inline -> Inline -> Bool)
    -> (Inline -> Inline -> Bool)
    -> (Inline -> Inline -> Bool)
    -> (Inline -> Inline -> Bool)
    -> (Inline -> Inline -> Inline)
    -> (Inline -> Inline -> Inline)
    -> Ord Inline
    Inline -> Inline -> Bool
    Inline -> Inline -> Ordering
    Inline -> Inline -> Inline
    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
    min :: Inline -> Inline -> Inline
    $cmin :: Inline -> Inline -> Inline
    max :: Inline -> Inline -> Inline
    $cmax :: Inline -> Inline -> Inline
    >= :: Inline -> Inline -> Bool
    $c>= :: Inline -> Inline -> Bool
    > :: Inline -> Inline -> Bool
    $c> :: Inline -> Inline -> Bool
    <= :: Inline -> Inline -> Bool
    $c<= :: Inline -> Inline -> Bool
    < :: Inline -> Inline -> Bool
    $c< :: Inline -> Inline -> Bool
    compare :: Inline -> Inline -> Ordering
    $ccompare :: Inline -> Inline -> Ordering
    Ord, Typeable Inline
    Typeable Inline
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Inline -> c Inline)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Inline)
    -> (Inline -> Constr)
    -> (Inline -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Inline))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline))
    -> ((forall b. Data b => b -> b) -> Inline -> Inline)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Inline -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Inline -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Inline -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Inline -> m Inline)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Inline -> m Inline)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Inline -> m Inline)
    -> Data Inline
    Inline -> DataType
    Inline -> Constr
    (forall b. Data b => b -> b) -> Inline -> Inline
    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) -> Inline -> u
    forall u. (forall d. Data d => d -> u) -> Inline -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inline
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Inline -> c Inline
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inline)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Inline -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Inline -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    gmapT :: (forall b. Data b => b -> b) -> Inline -> Inline
    $cgmapT :: (forall b. Data b => b -> b) -> Inline -> Inline
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inline)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inline)
    dataTypeOf :: Inline -> DataType
    $cdataTypeOf :: Inline -> DataType
    toConstr :: Inline -> Constr
    $ctoConstr :: Inline -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inline
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inline
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Inline -> c Inline
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Inline -> c Inline
    Data, (forall x. Inline -> Rep Inline x)
    -> (forall x. Rep Inline x -> Inline) -> Generic Inline
    forall x. Rep Inline x -> Inline
    forall x. Inline -> Rep Inline x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Inline x -> Inline
    $cfrom :: forall x. Inline -> Rep Inline x
    Generic)

    data RuleMatch = ConLike
                   | FunLike
                   deriving (Int -> RuleMatch -> String -> String
    [RuleMatch] -> String -> String
    RuleMatch -> String
    (Int -> RuleMatch -> String -> String)
    -> (RuleMatch -> String)
    -> ([RuleMatch] -> String -> String)
    -> Show RuleMatch
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [RuleMatch] -> String -> String
    $cshowList :: [RuleMatch] -> String -> String
    show :: RuleMatch -> String
    $cshow :: RuleMatch -> String
    showsPrec :: Int -> RuleMatch -> String -> String
    $cshowsPrec :: Int -> RuleMatch -> String -> String
    Show, RuleMatch -> RuleMatch -> Bool
    (RuleMatch -> RuleMatch -> Bool)
    -> (RuleMatch -> RuleMatch -> Bool) -> Eq RuleMatch
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: RuleMatch -> RuleMatch -> Bool
    $c/= :: RuleMatch -> RuleMatch -> Bool
    == :: RuleMatch -> RuleMatch -> Bool
    $c== :: RuleMatch -> RuleMatch -> Bool
    Eq, Eq RuleMatch
    Eq RuleMatch
    -> (RuleMatch -> RuleMatch -> Ordering)
    -> (RuleMatch -> RuleMatch -> Bool)
    -> (RuleMatch -> RuleMatch -> Bool)
    -> (RuleMatch -> RuleMatch -> Bool)
    -> (RuleMatch -> RuleMatch -> Bool)
    -> (RuleMatch -> RuleMatch -> RuleMatch)
    -> (RuleMatch -> RuleMatch -> RuleMatch)
    -> Ord RuleMatch
    RuleMatch -> RuleMatch -> Bool
    RuleMatch -> RuleMatch -> Ordering
    RuleMatch -> RuleMatch -> RuleMatch
    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
    min :: RuleMatch -> RuleMatch -> RuleMatch
    $cmin :: RuleMatch -> RuleMatch -> RuleMatch
    max :: RuleMatch -> RuleMatch -> RuleMatch
    $cmax :: RuleMatch -> RuleMatch -> RuleMatch
    >= :: RuleMatch -> RuleMatch -> Bool
    $c>= :: RuleMatch -> RuleMatch -> Bool
    > :: RuleMatch -> RuleMatch -> Bool
    $c> :: RuleMatch -> RuleMatch -> Bool
    <= :: RuleMatch -> RuleMatch -> Bool
    $c<= :: RuleMatch -> RuleMatch -> Bool
    < :: RuleMatch -> RuleMatch -> Bool
    $c< :: RuleMatch -> RuleMatch -> Bool
    compare :: RuleMatch -> RuleMatch -> Ordering
    $ccompare :: RuleMatch -> RuleMatch -> Ordering
    Ord, Typeable RuleMatch
    Typeable RuleMatch
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> RuleMatch -> c RuleMatch)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c RuleMatch)
    -> (RuleMatch -> Constr)
    -> (RuleMatch -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c RuleMatch))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch))
    -> ((forall b. Data b => b -> b) -> RuleMatch -> RuleMatch)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r)
    -> (forall u. (forall d. Data d => d -> u) -> RuleMatch -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> RuleMatch -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch)
    -> Data RuleMatch
    RuleMatch -> DataType
    RuleMatch -> Constr
    (forall b. Data b => b -> b) -> RuleMatch -> RuleMatch
    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) -> RuleMatch -> u
    forall u. (forall d. Data d => d -> u) -> RuleMatch -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RuleMatch
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RuleMatch -> c RuleMatch
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RuleMatch)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RuleMatch -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RuleMatch -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> RuleMatch -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> RuleMatch -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
    gmapT :: (forall b. Data b => b -> b) -> RuleMatch -> RuleMatch
    $cgmapT :: (forall b. Data b => b -> b) -> RuleMatch -> RuleMatch
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RuleMatch)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RuleMatch)
    dataTypeOf :: RuleMatch -> DataType
    $cdataTypeOf :: RuleMatch -> DataType
    toConstr :: RuleMatch -> Constr
    $ctoConstr :: RuleMatch -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RuleMatch
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RuleMatch
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RuleMatch -> c RuleMatch
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RuleMatch -> c RuleMatch
    Data, (forall x. RuleMatch -> Rep RuleMatch x)
    -> (forall x. Rep RuleMatch x -> RuleMatch) -> Generic RuleMatch
    forall x. Rep RuleMatch x -> RuleMatch
    forall x. RuleMatch -> Rep RuleMatch x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep RuleMatch x -> RuleMatch
    $cfrom :: forall x. RuleMatch -> Rep RuleMatch x
    Generic)

    data Phases = AllPhases
                | FromPhase Int
                | BeforePhase Int
                deriving (Int -> Phases -> String -> String
    [Phases] -> String -> String
    Phases -> String
    (Int -> Phases -> String -> String)
    -> (Phases -> String)
    -> ([Phases] -> String -> String)
    -> Show Phases
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Phases] -> String -> String
    $cshowList :: [Phases] -> String -> String
    show :: Phases -> String
    $cshow :: Phases -> String
    showsPrec :: Int -> Phases -> String -> String
    $cshowsPrec :: Int -> Phases -> String -> String
    Show, Phases -> Phases -> Bool
    (Phases -> Phases -> Bool)
    -> (Phases -> Phases -> Bool) -> Eq Phases
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Phases -> Phases -> Bool
    $c/= :: Phases -> Phases -> Bool
    == :: Phases -> Phases -> Bool
    $c== :: Phases -> Phases -> Bool
    Eq, Eq Phases
    Eq Phases
    -> (Phases -> Phases -> Ordering)
    -> (Phases -> Phases -> Bool)
    -> (Phases -> Phases -> Bool)
    -> (Phases -> Phases -> Bool)
    -> (Phases -> Phases -> Bool)
    -> (Phases -> Phases -> Phases)
    -> (Phases -> Phases -> Phases)
    -> Ord Phases
    Phases -> Phases -> Bool
    Phases -> Phases -> Ordering
    Phases -> Phases -> Phases
    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
    min :: Phases -> Phases -> Phases
    $cmin :: Phases -> Phases -> Phases
    max :: Phases -> Phases -> Phases
    $cmax :: Phases -> Phases -> Phases
    >= :: Phases -> Phases -> Bool
    $c>= :: Phases -> Phases -> Bool
    > :: Phases -> Phases -> Bool
    $c> :: Phases -> Phases -> Bool
    <= :: Phases -> Phases -> Bool
    $c<= :: Phases -> Phases -> Bool
    < :: Phases -> Phases -> Bool
    $c< :: Phases -> Phases -> Bool
    compare :: Phases -> Phases -> Ordering
    $ccompare :: Phases -> Phases -> Ordering
    Ord, Typeable Phases
    Typeable Phases
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Phases -> c Phases)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Phases)
    -> (Phases -> Constr)
    -> (Phases -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Phases))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases))
    -> ((forall b. Data b => b -> b) -> Phases -> Phases)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Phases -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Phases -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Phases -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Phases -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Phases -> m Phases)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Phases -> m Phases)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Phases -> m Phases)
    -> Data Phases
    Phases -> DataType
    Phases -> Constr
    (forall b. Data b => b -> b) -> Phases -> Phases
    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) -> Phases -> u
    forall u. (forall d. Data d => d -> u) -> Phases -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Phases -> m Phases
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Phases -> m Phases
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Phases
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Phases -> c Phases
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Phases)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Phases -> m Phases
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Phases -> m Phases
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Phases -> m Phases
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Phases -> m Phases
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Phases -> m Phases
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Phases -> m Phases
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Phases -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Phases -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Phases -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Phases -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
    gmapT :: (forall b. Data b => b -> b) -> Phases -> Phases
    $cgmapT :: (forall b. Data b => b -> b) -> Phases -> Phases
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Phases)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Phases)
    dataTypeOf :: Phases -> DataType
    $cdataTypeOf :: Phases -> DataType
    toConstr :: Phases -> Constr
    $ctoConstr :: Phases -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Phases
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Phases
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Phases -> c Phases
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Phases -> c Phases
    Data, (forall x. Phases -> Rep Phases x)
    -> (forall x. Rep Phases x -> Phases) -> Generic Phases
    forall x. Rep Phases x -> Phases
    forall x. Phases -> Rep Phases x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Phases x -> Phases
    $cfrom :: forall x. Phases -> Rep Phases x
    Generic)

    data RuleBndr = RuleVar Name
                  | TypedRuleVar Name Type
                  deriving (Int -> RuleBndr -> String -> String
    [RuleBndr] -> String -> String
    RuleBndr -> String
    (Int -> RuleBndr -> String -> String)
    -> (RuleBndr -> String)
    -> ([RuleBndr] -> String -> String)
    -> Show RuleBndr
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [RuleBndr] -> String -> String
    $cshowList :: [RuleBndr] -> String -> String
    show :: RuleBndr -> String
    $cshow :: RuleBndr -> String
    showsPrec :: Int -> RuleBndr -> String -> String
    $cshowsPrec :: Int -> RuleBndr -> String -> String
    Show, RuleBndr -> RuleBndr -> Bool
    (RuleBndr -> RuleBndr -> Bool)
    -> (RuleBndr -> RuleBndr -> Bool) -> Eq RuleBndr
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: RuleBndr -> RuleBndr -> Bool
    $c/= :: RuleBndr -> RuleBndr -> Bool
    == :: RuleBndr -> RuleBndr -> Bool
    $c== :: RuleBndr -> RuleBndr -> Bool
    Eq, Eq RuleBndr
    Eq RuleBndr
    -> (RuleBndr -> RuleBndr -> Ordering)
    -> (RuleBndr -> RuleBndr -> Bool)
    -> (RuleBndr -> RuleBndr -> Bool)
    -> (RuleBndr -> RuleBndr -> Bool)
    -> (RuleBndr -> RuleBndr -> Bool)
    -> (RuleBndr -> RuleBndr -> RuleBndr)
    -> (RuleBndr -> RuleBndr -> RuleBndr)
    -> Ord RuleBndr
    RuleBndr -> RuleBndr -> Bool
    RuleBndr -> RuleBndr -> Ordering
    RuleBndr -> RuleBndr -> RuleBndr
    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
    min :: RuleBndr -> RuleBndr -> RuleBndr
    $cmin :: RuleBndr -> RuleBndr -> RuleBndr
    max :: RuleBndr -> RuleBndr -> RuleBndr
    $cmax :: RuleBndr -> RuleBndr -> RuleBndr
    >= :: RuleBndr -> RuleBndr -> Bool
    $c>= :: RuleBndr -> RuleBndr -> Bool
    > :: RuleBndr -> RuleBndr -> Bool
    $c> :: RuleBndr -> RuleBndr -> Bool
    <= :: RuleBndr -> RuleBndr -> Bool
    $c<= :: RuleBndr -> RuleBndr -> Bool
    < :: RuleBndr -> RuleBndr -> Bool
    $c< :: RuleBndr -> RuleBndr -> Bool
    compare :: RuleBndr -> RuleBndr -> Ordering
    $ccompare :: RuleBndr -> RuleBndr -> Ordering
    Ord, Typeable RuleBndr
    Typeable RuleBndr
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> RuleBndr -> c RuleBndr)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c RuleBndr)
    -> (RuleBndr -> Constr)
    -> (RuleBndr -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c RuleBndr))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr))
    -> ((forall b. Data b => b -> b) -> RuleBndr -> RuleBndr)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r)
    -> (forall u. (forall d. Data d => d -> u) -> RuleBndr -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> RuleBndr -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr)
    -> Data RuleBndr
    RuleBndr -> DataType
    RuleBndr -> Constr
    (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr
    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) -> RuleBndr -> u
    forall u. (forall d. Data d => d -> u) -> RuleBndr -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RuleBndr
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RuleBndr -> c RuleBndr
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RuleBndr)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RuleBndr -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RuleBndr -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> RuleBndr -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> RuleBndr -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
    gmapT :: (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr
    $cgmapT :: (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RuleBndr)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RuleBndr)
    dataTypeOf :: RuleBndr -> DataType
    $cdataTypeOf :: RuleBndr -> DataType
    toConstr :: RuleBndr -> Constr
    $ctoConstr :: RuleBndr -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RuleBndr
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RuleBndr
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RuleBndr -> c RuleBndr
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RuleBndr -> c RuleBndr
    Data, (forall x. RuleBndr -> Rep RuleBndr x)
    -> (forall x. Rep RuleBndr x -> RuleBndr) -> Generic RuleBndr
    forall x. Rep RuleBndr x -> RuleBndr
    forall x. RuleBndr -> Rep RuleBndr x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep RuleBndr x -> RuleBndr
    $cfrom :: forall x. RuleBndr -> Rep RuleBndr x
    Generic)

    data AnnTarget = ModuleAnnotation
                   | TypeAnnotation Name
                   | ValueAnnotation Name
                  deriving (Int -> AnnTarget -> String -> String
    [AnnTarget] -> String -> String
    AnnTarget -> String
    (Int -> AnnTarget -> String -> String)
    -> (AnnTarget -> String)
    -> ([AnnTarget] -> String -> String)
    -> Show AnnTarget
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [AnnTarget] -> String -> String
    $cshowList :: [AnnTarget] -> String -> String
    show :: AnnTarget -> String
    $cshow :: AnnTarget -> String
    showsPrec :: Int -> AnnTarget -> String -> String
    $cshowsPrec :: Int -> AnnTarget -> String -> String
    Show, AnnTarget -> AnnTarget -> Bool
    (AnnTarget -> AnnTarget -> Bool)
    -> (AnnTarget -> AnnTarget -> Bool) -> Eq AnnTarget
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AnnTarget -> AnnTarget -> Bool
    $c/= :: AnnTarget -> AnnTarget -> Bool
    == :: AnnTarget -> AnnTarget -> Bool
    $c== :: AnnTarget -> AnnTarget -> Bool
    Eq, Eq AnnTarget
    Eq AnnTarget
    -> (AnnTarget -> AnnTarget -> Ordering)
    -> (AnnTarget -> AnnTarget -> Bool)
    -> (AnnTarget -> AnnTarget -> Bool)
    -> (AnnTarget -> AnnTarget -> Bool)
    -> (AnnTarget -> AnnTarget -> Bool)
    -> (AnnTarget -> AnnTarget -> AnnTarget)
    -> (AnnTarget -> AnnTarget -> AnnTarget)
    -> Ord AnnTarget
    AnnTarget -> AnnTarget -> Bool
    AnnTarget -> AnnTarget -> Ordering
    AnnTarget -> AnnTarget -> AnnTarget
    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
    min :: AnnTarget -> AnnTarget -> AnnTarget
    $cmin :: AnnTarget -> AnnTarget -> AnnTarget
    max :: AnnTarget -> AnnTarget -> AnnTarget
    $cmax :: AnnTarget -> AnnTarget -> AnnTarget
    >= :: AnnTarget -> AnnTarget -> Bool
    $c>= :: AnnTarget -> AnnTarget -> Bool
    > :: AnnTarget -> AnnTarget -> Bool
    $c> :: AnnTarget -> AnnTarget -> Bool
    <= :: AnnTarget -> AnnTarget -> Bool
    $c<= :: AnnTarget -> AnnTarget -> Bool
    < :: AnnTarget -> AnnTarget -> Bool
    $c< :: AnnTarget -> AnnTarget -> Bool
    compare :: AnnTarget -> AnnTarget -> Ordering
    $ccompare :: AnnTarget -> AnnTarget -> Ordering
    Ord, Typeable AnnTarget
    Typeable AnnTarget
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> AnnTarget -> c AnnTarget)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnTarget)
    -> (AnnTarget -> Constr)
    -> (AnnTarget -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnTarget))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget))
    -> ((forall b. Data b => b -> b) -> AnnTarget -> AnnTarget)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnTarget -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnTarget -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget)
    -> Data AnnTarget
    AnnTarget -> DataType
    AnnTarget -> Constr
    (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget
    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) -> AnnTarget -> u
    forall u. (forall d. Data d => d -> u) -> AnnTarget -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnTarget
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnTarget -> c AnnTarget
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnTarget)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnTarget -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnTarget -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnTarget -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnTarget -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
    gmapT :: (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget
    $cgmapT :: (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnTarget)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnTarget)
    dataTypeOf :: AnnTarget -> DataType
    $cdataTypeOf :: AnnTarget -> DataType
    toConstr :: AnnTarget -> Constr
    $ctoConstr :: AnnTarget -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnTarget
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnTarget
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnTarget -> c AnnTarget
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnTarget -> c AnnTarget
    Data, (forall x. AnnTarget -> Rep AnnTarget x)
    -> (forall x. Rep AnnTarget x -> AnnTarget) -> Generic AnnTarget
    forall x. Rep AnnTarget x -> AnnTarget
    forall x. AnnTarget -> Rep AnnTarget x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep AnnTarget x -> AnnTarget
    $cfrom :: forall x. AnnTarget -> Rep AnnTarget x
    Generic)

    type Cxt = [Pred]                 -- ^ @(Eq a, Ord b)@

    -- | Since the advent of @ConstraintKinds@, constraints are really just types.
    -- Equality constraints use the 'EqualityT' constructor. Constraints may also
    -- be tuples of other constraints.
    type Pred = Type

    data SourceUnpackedness
      = NoSourceUnpackedness -- ^ @C a@
      | SourceNoUnpack       -- ^ @C { {\-\# NOUNPACK \#-\} } a@
      | SourceUnpack         -- ^ @C { {\-\# UNPACK \#-\} } a@
            deriving (Int -> SourceUnpackedness -> String -> String
    [SourceUnpackedness] -> String -> String
    SourceUnpackedness -> String
    (Int -> SourceUnpackedness -> String -> String)
    -> (SourceUnpackedness -> String)
    -> ([SourceUnpackedness] -> String -> String)
    -> Show SourceUnpackedness
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [SourceUnpackedness] -> String -> String
    $cshowList :: [SourceUnpackedness] -> String -> String
    show :: SourceUnpackedness -> String
    $cshow :: SourceUnpackedness -> String
    showsPrec :: Int -> SourceUnpackedness -> String -> String
    $cshowsPrec :: Int -> SourceUnpackedness -> String -> String
    Show, SourceUnpackedness -> SourceUnpackedness -> Bool
    (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> Eq SourceUnpackedness
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    $c/= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    == :: SourceUnpackedness -> SourceUnpackedness -> Bool
    $c== :: SourceUnpackedness -> SourceUnpackedness -> Bool
    Eq, Eq SourceUnpackedness
    Eq SourceUnpackedness
    -> (SourceUnpackedness -> SourceUnpackedness -> Ordering)
    -> (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> (SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness)
    -> (SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness)
    -> Ord SourceUnpackedness
    SourceUnpackedness -> SourceUnpackedness -> Bool
    SourceUnpackedness -> SourceUnpackedness -> Ordering
    SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
    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
    min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
    $cmin :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
    max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
    $cmax :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
    >= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    $c>= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    > :: SourceUnpackedness -> SourceUnpackedness -> Bool
    $c> :: SourceUnpackedness -> SourceUnpackedness -> Bool
    <= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    $c<= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    < :: SourceUnpackedness -> SourceUnpackedness -> Bool
    $c< :: SourceUnpackedness -> SourceUnpackedness -> Bool
    compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering
    $ccompare :: SourceUnpackedness -> SourceUnpackedness -> Ordering
    Ord, Typeable SourceUnpackedness
    Typeable SourceUnpackedness
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g)
        -> SourceUnpackedness
        -> c SourceUnpackedness)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness)
    -> (SourceUnpackedness -> Constr)
    -> (SourceUnpackedness -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c SourceUnpackedness))
    -> ((forall b. Data b => b -> b)
        -> SourceUnpackedness -> SourceUnpackedness)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> SourceUnpackedness -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> SourceUnpackedness -> m SourceUnpackedness)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> SourceUnpackedness -> m SourceUnpackedness)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> SourceUnpackedness -> m SourceUnpackedness)
    -> Data SourceUnpackedness
    SourceUnpackedness -> DataType
    SourceUnpackedness -> Constr
    (forall b. Data b => b -> b)
    -> SourceUnpackedness -> SourceUnpackedness
    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) -> SourceUnpackedness -> u
    forall u. (forall d. Data d => d -> u) -> SourceUnpackedness -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SourceUnpackedness -> m SourceUnpackedness
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceUnpackedness -> m SourceUnpackedness
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> SourceUnpackedness
    -> c SourceUnpackedness
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SourceUnpackedness)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceUnpackedness -> m SourceUnpackedness
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceUnpackedness -> m SourceUnpackedness
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceUnpackedness -> m SourceUnpackedness
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceUnpackedness -> m SourceUnpackedness
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SourceUnpackedness -> m SourceUnpackedness
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SourceUnpackedness -> m SourceUnpackedness
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> SourceUnpackedness -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> SourceUnpackedness -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
    gmapT :: (forall b. Data b => b -> b)
    -> SourceUnpackedness -> SourceUnpackedness
    $cgmapT :: (forall b. Data b => b -> b)
    -> SourceUnpackedness -> SourceUnpackedness
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SourceUnpackedness)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SourceUnpackedness)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness)
    dataTypeOf :: SourceUnpackedness -> DataType
    $cdataTypeOf :: SourceUnpackedness -> DataType
    toConstr :: SourceUnpackedness -> Constr
    $ctoConstr :: SourceUnpackedness -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> SourceUnpackedness
    -> c SourceUnpackedness
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> SourceUnpackedness
    -> c SourceUnpackedness
    Data, (forall x. SourceUnpackedness -> Rep SourceUnpackedness x)
    -> (forall x. Rep SourceUnpackedness x -> SourceUnpackedness)
    -> Generic SourceUnpackedness
    forall x. Rep SourceUnpackedness x -> SourceUnpackedness
    forall x. SourceUnpackedness -> Rep SourceUnpackedness x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep SourceUnpackedness x -> SourceUnpackedness
    $cfrom :: forall x. SourceUnpackedness -> Rep SourceUnpackedness x
    Generic)

    data SourceStrictness = NoSourceStrictness    -- ^ @C a@
                          | SourceLazy            -- ^ @C {~}a@
                          | SourceStrict          -- ^ @C {!}a@
            deriving (Int -> SourceStrictness -> String -> String
    [SourceStrictness] -> String -> String
    SourceStrictness -> String
    (Int -> SourceStrictness -> String -> String)
    -> (SourceStrictness -> String)
    -> ([SourceStrictness] -> String -> String)
    -> Show SourceStrictness
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [SourceStrictness] -> String -> String
    $cshowList :: [SourceStrictness] -> String -> String
    show :: SourceStrictness -> String
    $cshow :: SourceStrictness -> String
    showsPrec :: Int -> SourceStrictness -> String -> String
    $cshowsPrec :: Int -> SourceStrictness -> String -> String
    Show, SourceStrictness -> SourceStrictness -> Bool
    (SourceStrictness -> SourceStrictness -> Bool)
    -> (SourceStrictness -> SourceStrictness -> Bool)
    -> Eq SourceStrictness
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: SourceStrictness -> SourceStrictness -> Bool
    $c/= :: SourceStrictness -> SourceStrictness -> Bool
    == :: SourceStrictness -> SourceStrictness -> Bool
    $c== :: SourceStrictness -> SourceStrictness -> Bool
    Eq, Eq SourceStrictness
    Eq SourceStrictness
    -> (SourceStrictness -> SourceStrictness -> Ordering)
    -> (SourceStrictness -> SourceStrictness -> Bool)
    -> (SourceStrictness -> SourceStrictness -> Bool)
    -> (SourceStrictness -> SourceStrictness -> Bool)
    -> (SourceStrictness -> SourceStrictness -> Bool)
    -> (SourceStrictness -> SourceStrictness -> SourceStrictness)
    -> (SourceStrictness -> SourceStrictness -> SourceStrictness)
    -> Ord SourceStrictness
    SourceStrictness -> SourceStrictness -> Bool
    SourceStrictness -> SourceStrictness -> Ordering
    SourceStrictness -> SourceStrictness -> SourceStrictness
    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
    min :: SourceStrictness -> SourceStrictness -> SourceStrictness
    $cmin :: SourceStrictness -> SourceStrictness -> SourceStrictness
    max :: SourceStrictness -> SourceStrictness -> SourceStrictness
    $cmax :: SourceStrictness -> SourceStrictness -> SourceStrictness
    >= :: SourceStrictness -> SourceStrictness -> Bool
    $c>= :: SourceStrictness -> SourceStrictness -> Bool
    > :: SourceStrictness -> SourceStrictness -> Bool
    $c> :: SourceStrictness -> SourceStrictness -> Bool
    <= :: SourceStrictness -> SourceStrictness -> Bool
    $c<= :: SourceStrictness -> SourceStrictness -> Bool
    < :: SourceStrictness -> SourceStrictness -> Bool
    $c< :: SourceStrictness -> SourceStrictness -> Bool
    compare :: SourceStrictness -> SourceStrictness -> Ordering
    $ccompare :: SourceStrictness -> SourceStrictness -> Ordering
    Ord, Typeable SourceStrictness
    Typeable SourceStrictness
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c SourceStrictness)
    -> (SourceStrictness -> Constr)
    -> (SourceStrictness -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c SourceStrictness))
    -> ((forall b. Data b => b -> b)
        -> SourceStrictness -> SourceStrictness)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> SourceStrictness -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> SourceStrictness -> m SourceStrictness)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> SourceStrictness -> m SourceStrictness)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> SourceStrictness -> m SourceStrictness)
    -> Data SourceStrictness
    SourceStrictness -> DataType
    SourceStrictness -> Constr
    (forall b. Data b => b -> b)
    -> SourceStrictness -> SourceStrictness
    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) -> SourceStrictness -> u
    forall u. (forall d. Data d => d -> u) -> SourceStrictness -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SourceStrictness -> m SourceStrictness
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceStrictness -> m SourceStrictness
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SourceStrictness
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SourceStrictness)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceStrictness -> m SourceStrictness
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceStrictness -> m SourceStrictness
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceStrictness -> m SourceStrictness
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceStrictness -> m SourceStrictness
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SourceStrictness -> m SourceStrictness
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SourceStrictness -> m SourceStrictness
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> SourceStrictness -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> SourceStrictness -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
    gmapT :: (forall b. Data b => b -> b)
    -> SourceStrictness -> SourceStrictness
    $cgmapT :: (forall b. Data b => b -> b)
    -> SourceStrictness -> SourceStrictness
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SourceStrictness)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SourceStrictness)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness)
    dataTypeOf :: SourceStrictness -> DataType
    $cdataTypeOf :: SourceStrictness -> DataType
    toConstr :: SourceStrictness -> Constr
    $ctoConstr :: SourceStrictness -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SourceStrictness
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SourceStrictness
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness
    Data, (forall x. SourceStrictness -> Rep SourceStrictness x)
    -> (forall x. Rep SourceStrictness x -> SourceStrictness)
    -> Generic SourceStrictness
    forall x. Rep SourceStrictness x -> SourceStrictness
    forall x. SourceStrictness -> Rep SourceStrictness x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep SourceStrictness x -> SourceStrictness
    $cfrom :: forall x. SourceStrictness -> Rep SourceStrictness x
    Generic)

    -- | Unlike 'SourceStrictness' and 'SourceUnpackedness', 'DecidedStrictness'
    -- refers to the strictness that the compiler chooses for a data constructor
    -- field, which may be different from what is written in source code. See
    -- 'reifyConStrictness' for more information.
    data DecidedStrictness = DecidedLazy
                           | DecidedStrict
                           | DecidedUnpack
            deriving (Int -> DecidedStrictness -> String -> String
    [DecidedStrictness] -> String -> String
    DecidedStrictness -> String
    (Int -> DecidedStrictness -> String -> String)
    -> (DecidedStrictness -> String)
    -> ([DecidedStrictness] -> String -> String)
    -> Show DecidedStrictness
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [DecidedStrictness] -> String -> String
    $cshowList :: [DecidedStrictness] -> String -> String
    show :: DecidedStrictness -> String
    $cshow :: DecidedStrictness -> String
    showsPrec :: Int -> DecidedStrictness -> String -> String
    $cshowsPrec :: Int -> DecidedStrictness -> String -> String
    Show, DecidedStrictness -> DecidedStrictness -> Bool
    (DecidedStrictness -> DecidedStrictness -> Bool)
    -> (DecidedStrictness -> DecidedStrictness -> Bool)
    -> Eq DecidedStrictness
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: DecidedStrictness -> DecidedStrictness -> Bool
    $c/= :: DecidedStrictness -> DecidedStrictness -> Bool
    == :: DecidedStrictness -> DecidedStrictness -> Bool
    $c== :: DecidedStrictness -> DecidedStrictness -> Bool
    Eq, Eq DecidedStrictness
    Eq DecidedStrictness
    -> (DecidedStrictness -> DecidedStrictness -> Ordering)
    -> (DecidedStrictness -> DecidedStrictness -> Bool)
    -> (DecidedStrictness -> DecidedStrictness -> Bool)
    -> (DecidedStrictness -> DecidedStrictness -> Bool)
    -> (DecidedStrictness -> DecidedStrictness -> Bool)
    -> (DecidedStrictness -> DecidedStrictness -> DecidedStrictness)
    -> (DecidedStrictness -> DecidedStrictness -> DecidedStrictness)
    -> Ord DecidedStrictness
    DecidedStrictness -> DecidedStrictness -> Bool
    DecidedStrictness -> DecidedStrictness -> Ordering
    DecidedStrictness -> DecidedStrictness -> DecidedStrictness
    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
    min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
    $cmin :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
    max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
    $cmax :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
    >= :: DecidedStrictness -> DecidedStrictness -> Bool
    $c>= :: DecidedStrictness -> DecidedStrictness -> Bool
    > :: DecidedStrictness -> DecidedStrictness -> Bool
    $c> :: DecidedStrictness -> DecidedStrictness -> Bool
    <= :: DecidedStrictness -> DecidedStrictness -> Bool
    $c<= :: DecidedStrictness -> DecidedStrictness -> Bool
    < :: DecidedStrictness -> DecidedStrictness -> Bool
    $c< :: DecidedStrictness -> DecidedStrictness -> Bool
    compare :: DecidedStrictness -> DecidedStrictness -> Ordering
    $ccompare :: DecidedStrictness -> DecidedStrictness -> Ordering
    Ord, Typeable DecidedStrictness
    Typeable DecidedStrictness
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g)
        -> DecidedStrictness
        -> c DecidedStrictness)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DecidedStrictness)
    -> (DecidedStrictness -> Constr)
    -> (DecidedStrictness -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DecidedStrictness))
    -> ((forall b. Data b => b -> b)
        -> DecidedStrictness -> DecidedStrictness)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> DecidedStrictness -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> DecidedStrictness -> m DecidedStrictness)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DecidedStrictness -> m DecidedStrictness)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DecidedStrictness -> m DecidedStrictness)
    -> Data DecidedStrictness
    DecidedStrictness -> DataType
    DecidedStrictness -> Constr
    (forall b. Data b => b -> b)
    -> DecidedStrictness -> DecidedStrictness
    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) -> DecidedStrictness -> u
    forall u. (forall d. Data d => d -> u) -> DecidedStrictness -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DecidedStrictness -> m DecidedStrictness
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DecidedStrictness -> m DecidedStrictness
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DecidedStrictness
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DecidedStrictness)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DecidedStrictness -> m DecidedStrictness
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DecidedStrictness -> m DecidedStrictness
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DecidedStrictness -> m DecidedStrictness
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DecidedStrictness -> m DecidedStrictness
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DecidedStrictness -> m DecidedStrictness
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DecidedStrictness -> m DecidedStrictness
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DecidedStrictness -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DecidedStrictness -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
    gmapT :: (forall b. Data b => b -> b)
    -> DecidedStrictness -> DecidedStrictness
    $cgmapT :: (forall b. Data b => b -> b)
    -> DecidedStrictness -> DecidedStrictness
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DecidedStrictness)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DecidedStrictness)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness)
    dataTypeOf :: DecidedStrictness -> DataType
    $cdataTypeOf :: DecidedStrictness -> DataType
    toConstr :: DecidedStrictness -> Constr
    $ctoConstr :: DecidedStrictness -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DecidedStrictness
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DecidedStrictness
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness
    Data, (forall x. DecidedStrictness -> Rep DecidedStrictness x)
    -> (forall x. Rep DecidedStrictness x -> DecidedStrictness)
    -> Generic DecidedStrictness
    forall x. Rep DecidedStrictness x -> DecidedStrictness
    forall x. DecidedStrictness -> Rep DecidedStrictness x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep DecidedStrictness x -> DecidedStrictness
    $cfrom :: forall x. DecidedStrictness -> Rep DecidedStrictness x
    Generic)

    -- | A single data constructor.
    --
    -- The constructors for 'Con' can roughly be divided up into two categories:
    -- those for constructors with \"vanilla\" syntax ('NormalC', 'RecC', and
    -- 'InfixC'), and those for constructors with GADT syntax ('GadtC' and
    -- 'RecGadtC'). The 'ForallC' constructor, which quantifies additional type
    -- variables and class contexts, can surround either variety of constructor.
    -- However, the type variables that it quantifies are different depending
    -- on what constructor syntax is used:
    --
    -- * If a 'ForallC' surrounds a constructor with vanilla syntax, then the
    --   'ForallC' will only quantify /existential/ type variables. For example:
    --
    --   @
    --   data Foo a = forall b. MkFoo a b
    --   @
    --
    --   In @MkFoo@, 'ForallC' will quantify @b@, but not @a@.
    --
    -- * If a 'ForallC' surrounds a constructor with GADT syntax, then the
    --   'ForallC' will quantify /all/ type variables used in the constructor.
    --   For example:
    --
    --   @
    --   data Bar a b where
    --     MkBar :: (a ~ b) => c -> MkBar a b
    --   @
    --
    --   In @MkBar@, 'ForallC' will quantify @a@, @b@, and @c@.
    data Con = NormalC Name [BangType]       -- ^ @C Int a@
             | RecC Name [VarBangType]       -- ^ @C { v :: Int, w :: a }@
             | InfixC BangType Name BangType -- ^ @Int :+ a@
             | ForallC [TyVarBndr Specificity] Cxt Con -- ^ @forall a. Eq a => C [a]@
             | GadtC [Name] [BangType]
                     Type                    -- See Note [GADT return type]
                                             -- ^ @C :: a -> b -> T b Int@
             | RecGadtC [Name] [VarBangType]
                        Type                 -- See Note [GADT return type]
                                             -- ^ @C :: { v :: Int } -> T b Int@
            deriving (Int -> Con -> String -> String
    [Con] -> String -> String
    Con -> String
    (Int -> Con -> String -> String)
    -> (Con -> String) -> ([Con] -> String -> String) -> Show Con
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Con] -> String -> String
    $cshowList :: [Con] -> String -> String
    show :: Con -> String
    $cshow :: Con -> String
    showsPrec :: Int -> Con -> String -> String
    $cshowsPrec :: Int -> Con -> String -> String
    Show, Con -> Con -> Bool
    (Con -> Con -> Bool) -> (Con -> Con -> Bool) -> Eq Con
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Con -> Con -> Bool
    $c/= :: Con -> Con -> Bool
    == :: Con -> Con -> Bool
    $c== :: Con -> Con -> Bool
    Eq, Eq Con
    Eq Con
    -> (Con -> Con -> Ordering)
    -> (Con -> Con -> Bool)
    -> (Con -> Con -> Bool)
    -> (Con -> Con -> Bool)
    -> (Con -> Con -> Bool)
    -> (Con -> Con -> Con)
    -> (Con -> Con -> Con)
    -> Ord Con
    Con -> Con -> Bool
    Con -> Con -> Ordering
    Con -> Con -> Con
    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
    min :: Con -> Con -> Con
    $cmin :: Con -> Con -> Con
    max :: Con -> Con -> Con
    $cmax :: Con -> Con -> Con
    >= :: Con -> Con -> Bool
    $c>= :: Con -> Con -> Bool
    > :: Con -> Con -> Bool
    $c> :: Con -> Con -> Bool
    <= :: Con -> Con -> Bool
    $c<= :: Con -> Con -> Bool
    < :: Con -> Con -> Bool
    $c< :: Con -> Con -> Bool
    compare :: Con -> Con -> Ordering
    $ccompare :: Con -> Con -> Ordering
    Ord, Typeable Con
    Typeable Con
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Con -> c Con)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Con)
    -> (Con -> Constr)
    -> (Con -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Con))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con))
    -> ((forall b. Data b => b -> b) -> Con -> Con)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Con -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Con -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Con -> m Con)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Con -> m Con)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Con -> m Con)
    -> Data Con
    Con -> DataType
    Con -> Constr
    (forall b. Data b => b -> b) -> Con -> Con
    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) -> Con -> u
    forall u. (forall d. Data d => d -> u) -> Con -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Con -> m Con
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Con -> m Con
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Con
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Con -> c Con
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Con)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Con -> m Con
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Con -> m Con
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Con -> m Con
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Con -> m Con
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Con -> m Con
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Con -> m Con
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Con -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Con -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Con -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Con -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
    gmapT :: (forall b. Data b => b -> b) -> Con -> Con
    $cgmapT :: (forall b. Data b => b -> b) -> Con -> Con
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Con)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Con)
    dataTypeOf :: Con -> DataType
    $cdataTypeOf :: Con -> DataType
    toConstr :: Con -> Constr
    $ctoConstr :: Con -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Con
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Con
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Con -> c Con
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Con -> c Con
    Data, (forall x. Con -> Rep Con x)
    -> (forall x. Rep Con x -> Con) -> Generic Con
    forall x. Rep Con x -> Con
    forall x. Con -> Rep Con x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Con x -> Con
    $cfrom :: forall x. Con -> Rep Con x
    Generic)

    -- Note [GADT return type]
    -- ~~~~~~~~~~~~~~~~~~~~~~~
    --
    -- The return type of a GADT constructor does not necessarily match the name of
    -- the data type:
    --
    -- type S = T
    --
    -- data T a where
    --     MkT :: S Int
    --
    --
    -- type S a = T
    --
    -- data T a where
    --     MkT :: S Char Int
    --
    --
    -- type Id a = a
    -- type S a = T
    --
    -- data T a where
    --     MkT :: Id (S Char Int)
    --
    --
    -- That is why we allow the return type stored by a constructor to be an
    -- arbitrary type. See also #11341

    data Bang = Bang SourceUnpackedness SourceStrictness
             -- ^ @C { {\-\# UNPACK \#-\} !}a@
            deriving (Int -> Bang -> String -> String
    [Bang] -> String -> String
    Bang -> String
    (Int -> Bang -> String -> String)
    -> (Bang -> String) -> ([Bang] -> String -> String) -> Show Bang
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Bang] -> String -> String
    $cshowList :: [Bang] -> String -> String
    show :: Bang -> String
    $cshow :: Bang -> String
    showsPrec :: Int -> Bang -> String -> String
    $cshowsPrec :: Int -> Bang -> String -> String
    Show, Bang -> Bang -> Bool
    (Bang -> Bang -> Bool) -> (Bang -> Bang -> Bool) -> Eq Bang
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Bang -> Bang -> Bool
    $c/= :: Bang -> Bang -> Bool
    == :: Bang -> Bang -> Bool
    $c== :: Bang -> Bang -> Bool
    Eq, Eq Bang
    Eq Bang
    -> (Bang -> Bang -> Ordering)
    -> (Bang -> Bang -> Bool)
    -> (Bang -> Bang -> Bool)
    -> (Bang -> Bang -> Bool)
    -> (Bang -> Bang -> Bool)
    -> (Bang -> Bang -> Bang)
    -> (Bang -> Bang -> Bang)
    -> Ord Bang
    Bang -> Bang -> Bool
    Bang -> Bang -> Ordering
    Bang -> Bang -> Bang
    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
    min :: Bang -> Bang -> Bang
    $cmin :: Bang -> Bang -> Bang
    max :: Bang -> Bang -> Bang
    $cmax :: Bang -> Bang -> Bang
    >= :: Bang -> Bang -> Bool
    $c>= :: Bang -> Bang -> Bool
    > :: Bang -> Bang -> Bool
    $c> :: Bang -> Bang -> Bool
    <= :: Bang -> Bang -> Bool
    $c<= :: Bang -> Bang -> Bool
    < :: Bang -> Bang -> Bool
    $c< :: Bang -> Bang -> Bool
    compare :: Bang -> Bang -> Ordering
    $ccompare :: Bang -> Bang -> Ordering
    Ord, Typeable Bang
    Typeable Bang
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Bang -> c Bang)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Bang)
    -> (Bang -> Constr)
    -> (Bang -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Bang))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang))
    -> ((forall b. Data b => b -> b) -> Bang -> Bang)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Bang -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Bang -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Bang -> m Bang)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Bang -> m Bang)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Bang -> m Bang)
    -> Data Bang
    Bang -> DataType
    Bang -> Constr
    (forall b. Data b => b -> b) -> Bang -> Bang
    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) -> Bang -> u
    forall u. (forall d. Data d => d -> u) -> Bang -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bang -> m Bang
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bang -> m Bang
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bang
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bang -> c Bang
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bang)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bang -> m Bang
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bang -> m Bang
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bang -> m Bang
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bang -> m Bang
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bang -> m Bang
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bang -> m Bang
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bang -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bang -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Bang -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Bang -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
    gmapT :: (forall b. Data b => b -> b) -> Bang -> Bang
    $cgmapT :: (forall b. Data b => b -> b) -> Bang -> Bang
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bang)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bang)
    dataTypeOf :: Bang -> DataType
    $cdataTypeOf :: Bang -> DataType
    toConstr :: Bang -> Constr
    $ctoConstr :: Bang -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bang
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bang
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bang -> c Bang
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bang -> c Bang
    Data, (forall x. Bang -> Rep Bang x)
    -> (forall x. Rep Bang x -> Bang) -> Generic Bang
    forall x. Rep Bang x -> Bang
    forall x. Bang -> Rep Bang x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Bang x -> Bang
    $cfrom :: forall x. Bang -> Rep Bang x
    Generic)

    type BangType    = (Bang, Type)
    type VarBangType = (Name, Bang, Type)

    -- | As of @template-haskell-2.11.0.0@, 'Strict' has been replaced by 'Bang'.
    type Strict      = Bang

    -- | As of @template-haskell-2.11.0.0@, 'StrictType' has been replaced by
    -- 'BangType'.
    type StrictType    = BangType

    -- | As of @template-haskell-2.11.0.0@, 'VarStrictType' has been replaced by
    -- 'VarBangType'.
    type VarStrictType = VarBangType

    -- | A pattern synonym's directionality.
    data PatSynDir
      = Unidir             -- ^ @pattern P x {<-} p@
      | ImplBidir          -- ^ @pattern P x {=} p@
      | ExplBidir [Clause] -- ^ @pattern P x {<-} p where P x = e@
      deriving( Int -> PatSynDir -> String -> String
    [PatSynDir] -> String -> String
    PatSynDir -> String
    (Int -> PatSynDir -> String -> String)
    -> (PatSynDir -> String)
    -> ([PatSynDir] -> String -> String)
    -> Show PatSynDir
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [PatSynDir] -> String -> String
    $cshowList :: [PatSynDir] -> String -> String
    show :: PatSynDir -> String
    $cshow :: PatSynDir -> String
    showsPrec :: Int -> PatSynDir -> String -> String
    $cshowsPrec :: Int -> PatSynDir -> String -> String
    Show, PatSynDir -> PatSynDir -> Bool
    (PatSynDir -> PatSynDir -> Bool)
    -> (PatSynDir -> PatSynDir -> Bool) -> Eq PatSynDir
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: PatSynDir -> PatSynDir -> Bool
    $c/= :: PatSynDir -> PatSynDir -> Bool
    == :: PatSynDir -> PatSynDir -> Bool
    $c== :: PatSynDir -> PatSynDir -> Bool
    Eq, Eq PatSynDir
    Eq PatSynDir
    -> (PatSynDir -> PatSynDir -> Ordering)
    -> (PatSynDir -> PatSynDir -> Bool)
    -> (PatSynDir -> PatSynDir -> Bool)
    -> (PatSynDir -> PatSynDir -> Bool)
    -> (PatSynDir -> PatSynDir -> Bool)
    -> (PatSynDir -> PatSynDir -> PatSynDir)
    -> (PatSynDir -> PatSynDir -> PatSynDir)
    -> Ord PatSynDir
    PatSynDir -> PatSynDir -> Bool
    PatSynDir -> PatSynDir -> Ordering
    PatSynDir -> PatSynDir -> PatSynDir
    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
    min :: PatSynDir -> PatSynDir -> PatSynDir
    $cmin :: PatSynDir -> PatSynDir -> PatSynDir
    max :: PatSynDir -> PatSynDir -> PatSynDir
    $cmax :: PatSynDir -> PatSynDir -> PatSynDir
    >= :: PatSynDir -> PatSynDir -> Bool
    $c>= :: PatSynDir -> PatSynDir -> Bool
    > :: PatSynDir -> PatSynDir -> Bool
    $c> :: PatSynDir -> PatSynDir -> Bool
    <= :: PatSynDir -> PatSynDir -> Bool
    $c<= :: PatSynDir -> PatSynDir -> Bool
    < :: PatSynDir -> PatSynDir -> Bool
    $c< :: PatSynDir -> PatSynDir -> Bool
    compare :: PatSynDir -> PatSynDir -> Ordering
    $ccompare :: PatSynDir -> PatSynDir -> Ordering
    Ord, Typeable PatSynDir
    Typeable PatSynDir
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> PatSynDir -> c PatSynDir)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c PatSynDir)
    -> (PatSynDir -> Constr)
    -> (PatSynDir -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c PatSynDir))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir))
    -> ((forall b. Data b => b -> b) -> PatSynDir -> PatSynDir)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r)
    -> (forall u. (forall d. Data d => d -> u) -> PatSynDir -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> PatSynDir -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir)
    -> Data PatSynDir
    PatSynDir -> DataType
    PatSynDir -> Constr
    (forall b. Data b => b -> b) -> PatSynDir -> PatSynDir
    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) -> PatSynDir -> u
    forall u. (forall d. Data d => d -> u) -> PatSynDir -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PatSynDir
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatSynDir -> c PatSynDir
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PatSynDir)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatSynDir -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatSynDir -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> PatSynDir -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> PatSynDir -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
    gmapT :: (forall b. Data b => b -> b) -> PatSynDir -> PatSynDir
    $cgmapT :: (forall b. Data b => b -> b) -> PatSynDir -> PatSynDir
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PatSynDir)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PatSynDir)
    dataTypeOf :: PatSynDir -> DataType
    $cdataTypeOf :: PatSynDir -> DataType
    toConstr :: PatSynDir -> Constr
    $ctoConstr :: PatSynDir -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PatSynDir
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PatSynDir
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatSynDir -> c PatSynDir
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatSynDir -> c PatSynDir
    Data, (forall x. PatSynDir -> Rep PatSynDir x)
    -> (forall x. Rep PatSynDir x -> PatSynDir) -> Generic PatSynDir
    forall x. Rep PatSynDir x -> PatSynDir
    forall x. PatSynDir -> Rep PatSynDir x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep PatSynDir x -> PatSynDir
    $cfrom :: forall x. PatSynDir -> Rep PatSynDir x
    Generic )

    -- | A pattern synonym's argument type.
    data PatSynArgs
      = PrefixPatSyn [Name]        -- ^ @pattern P {x y z} = p@
      | InfixPatSyn Name Name      -- ^ @pattern {x P y} = p@
      | RecordPatSyn [Name]        -- ^ @pattern P { {x,y,z} } = p@
      deriving( Int -> PatSynArgs -> String -> String
    [PatSynArgs] -> String -> String
    PatSynArgs -> String
    (Int -> PatSynArgs -> String -> String)
    -> (PatSynArgs -> String)
    -> ([PatSynArgs] -> String -> String)
    -> Show PatSynArgs
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [PatSynArgs] -> String -> String
    $cshowList :: [PatSynArgs] -> String -> String
    show :: PatSynArgs -> String
    $cshow :: PatSynArgs -> String
    showsPrec :: Int -> PatSynArgs -> String -> String
    $cshowsPrec :: Int -> PatSynArgs -> String -> String
    Show, PatSynArgs -> PatSynArgs -> Bool
    (PatSynArgs -> PatSynArgs -> Bool)
    -> (PatSynArgs -> PatSynArgs -> Bool) -> Eq PatSynArgs
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: PatSynArgs -> PatSynArgs -> Bool
    $c/= :: PatSynArgs -> PatSynArgs -> Bool
    == :: PatSynArgs -> PatSynArgs -> Bool
    $c== :: PatSynArgs -> PatSynArgs -> Bool
    Eq, Eq PatSynArgs
    Eq PatSynArgs
    -> (PatSynArgs -> PatSynArgs -> Ordering)
    -> (PatSynArgs -> PatSynArgs -> Bool)
    -> (PatSynArgs -> PatSynArgs -> Bool)
    -> (PatSynArgs -> PatSynArgs -> Bool)
    -> (PatSynArgs -> PatSynArgs -> Bool)
    -> (PatSynArgs -> PatSynArgs -> PatSynArgs)
    -> (PatSynArgs -> PatSynArgs -> PatSynArgs)
    -> Ord PatSynArgs
    PatSynArgs -> PatSynArgs -> Bool
    PatSynArgs -> PatSynArgs -> Ordering
    PatSynArgs -> PatSynArgs -> PatSynArgs
    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
    min :: PatSynArgs -> PatSynArgs -> PatSynArgs
    $cmin :: PatSynArgs -> PatSynArgs -> PatSynArgs
    max :: PatSynArgs -> PatSynArgs -> PatSynArgs
    $cmax :: PatSynArgs -> PatSynArgs -> PatSynArgs
    >= :: PatSynArgs -> PatSynArgs -> Bool
    $c>= :: PatSynArgs -> PatSynArgs -> Bool
    > :: PatSynArgs -> PatSynArgs -> Bool
    $c> :: PatSynArgs -> PatSynArgs -> Bool
    <= :: PatSynArgs -> PatSynArgs -> Bool
    $c<= :: PatSynArgs -> PatSynArgs -> Bool
    < :: PatSynArgs -> PatSynArgs -> Bool
    $c< :: PatSynArgs -> PatSynArgs -> Bool
    compare :: PatSynArgs -> PatSynArgs -> Ordering
    $ccompare :: PatSynArgs -> PatSynArgs -> Ordering
    Ord, Typeable PatSynArgs
    Typeable PatSynArgs
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c PatSynArgs)
    -> (PatSynArgs -> Constr)
    -> (PatSynArgs -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c PatSynArgs))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c PatSynArgs))
    -> ((forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r)
    -> (forall u. (forall d. Data d => d -> u) -> PatSynArgs -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> PatSynArgs -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs)
    -> Data PatSynArgs
    PatSynArgs -> DataType
    PatSynArgs -> Constr
    (forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs
    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) -> PatSynArgs -> u
    forall u. (forall d. Data d => d -> u) -> PatSynArgs -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PatSynArgs
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PatSynArgs)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynArgs)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatSynArgs -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatSynArgs -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> PatSynArgs -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> PatSynArgs -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
    gmapT :: (forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs
    $cgmapT :: (forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynArgs)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynArgs)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PatSynArgs)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PatSynArgs)
    dataTypeOf :: PatSynArgs -> DataType
    $cdataTypeOf :: PatSynArgs -> DataType
    toConstr :: PatSynArgs -> Constr
    $ctoConstr :: PatSynArgs -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PatSynArgs
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PatSynArgs
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs
    Data, (forall x. PatSynArgs -> Rep PatSynArgs x)
    -> (forall x. Rep PatSynArgs x -> PatSynArgs) -> Generic PatSynArgs
    forall x. Rep PatSynArgs x -> PatSynArgs
    forall x. PatSynArgs -> Rep PatSynArgs x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep PatSynArgs x -> PatSynArgs
    $cfrom :: forall x. PatSynArgs -> Rep PatSynArgs x
    Generic )

    data Type = ForallT [TyVarBndr Specificity] Cxt Type -- ^ @forall \<vars\>. \<ctxt\> => \<type\>@
              | ForallVisT [TyVarBndr ()] Type  -- ^ @forall \<vars\> -> \<type\>@
              | AppT Type Type                -- ^ @T a b@
              | AppKindT Type Kind            -- ^ @T \@k t@
              | SigT Type Kind                -- ^ @t :: k@
              | VarT Name                     -- ^ @a@
              | ConT Name                     -- ^ @T@
              | PromotedT Name                -- ^ @'T@
              | InfixT Type Name Type         -- ^ @T + T@
              | UInfixT Type Name Type        -- ^ @T + T@
                                              --
                                              -- See "Language.Haskell.TH.Syntax#infix"
              | ParensT Type                  -- ^ @(T)@

              -- See Note [Representing concrete syntax in types]
              | TupleT Int                    -- ^ @(,), (,,), etc.@
              | UnboxedTupleT Int             -- ^ @(\#,\#), (\#,,\#), etc.@
              | UnboxedSumT SumArity          -- ^ @(\#|\#), (\#||\#), etc.@
              | ArrowT                        -- ^ @->@
              | MulArrowT                     -- ^ @FUN@
              | EqualityT                     -- ^ @~@
              | ListT                         -- ^ @[]@
              | PromotedTupleT Int            -- ^ @'(), '(,), '(,,), etc.@
              | PromotedNilT                  -- ^ @'[]@
              | PromotedConsT                 -- ^ @(':)@
              | StarT                         -- ^ @*@
              | ConstraintT                   -- ^ @Constraint@
              | LitT TyLit                    -- ^ @0,1,2, etc.@
              | WildCardT                     -- ^ @_@
              | ImplicitParamT String Type    -- ^ @?x :: t@
          deriving( Int -> Type -> String -> String
    [Type] -> String -> String
    Type -> String
    (Int -> Type -> String -> String)
    -> (Type -> String) -> ([Type] -> String -> String) -> Show Type
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Type] -> String -> String
    $cshowList :: [Type] -> String -> String
    show :: Type -> String
    $cshow :: Type -> String
    showsPrec :: Int -> Type -> String -> String
    $cshowsPrec :: Int -> Type -> String -> String
    Show, Type -> Type -> Bool
    (Type -> Type -> Bool) -> (Type -> Type -> Bool) -> Eq Type
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Type -> Type -> Bool
    $c/= :: Type -> Type -> Bool
    == :: Type -> Type -> Bool
    $c== :: Type -> Type -> Bool
    Eq, Eq Type
    Eq Type
    -> (Type -> Type -> Ordering)
    -> (Type -> Type -> Bool)
    -> (Type -> Type -> Bool)
    -> (Type -> Type -> Bool)
    -> (Type -> Type -> Bool)
    -> (Type -> Type -> Type)
    -> (Type -> Type -> Type)
    -> Ord Type
    Type -> Type -> Bool
    Type -> Type -> Ordering
    Type -> Type -> Type
    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
    min :: Type -> Type -> Type
    $cmin :: Type -> Type -> Type
    max :: Type -> Type -> Type
    $cmax :: Type -> Type -> Type
    >= :: Type -> Type -> Bool
    $c>= :: Type -> Type -> Bool
    > :: Type -> Type -> Bool
    $c> :: Type -> Type -> Bool
    <= :: Type -> Type -> Bool
    $c<= :: Type -> Type -> Bool
    < :: Type -> Type -> Bool
    $c< :: Type -> Type -> Bool
    compare :: Type -> Type -> Ordering
    $ccompare :: Type -> Type -> Ordering
    Ord, Typeable Type
    Typeable Type
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Type -> c Type)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Type)
    -> (Type -> Constr)
    -> (Type -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Type))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type))
    -> ((forall b. Data b => b -> b) -> Type -> Type)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Type -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Type -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Type -> m Type)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Type -> m Type)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Type -> m Type)
    -> Data Type
    Type -> DataType
    Type -> Constr
    (forall b. Data b => b -> b) -> Type -> Type
    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) -> Type -> u
    forall u. (forall d. Data d => d -> u) -> Type -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Type -> m Type
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Type
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Type -> c Type
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Type)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Type -> m Type
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Type -> m Type
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Type -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Type -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
    gmapT :: (forall b. Data b => b -> b) -> Type -> Type
    $cgmapT :: (forall b. Data b => b -> b) -> Type -> Type
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Type)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Type)
    dataTypeOf :: Type -> DataType
    $cdataTypeOf :: Type -> DataType
    toConstr :: Type -> Constr
    $ctoConstr :: Type -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Type
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Type
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Type -> c Type
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Type -> c Type
    Data, (forall x. Type -> Rep Type x)
    -> (forall x. Rep Type x -> Type) -> Generic Type
    forall x. Rep Type x -> Type
    forall x. Type -> Rep Type x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Type x -> Type
    $cfrom :: forall x. Type -> Rep Type x
    Generic )

    data Specificity = SpecifiedSpec          -- ^ @a@
                     | InferredSpec           -- ^ @{a}@
          deriving( Int -> Specificity -> String -> String
    [Specificity] -> String -> String
    Specificity -> String
    (Int -> Specificity -> String -> String)
    -> (Specificity -> String)
    -> ([Specificity] -> String -> String)
    -> Show Specificity
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Specificity] -> String -> String
    $cshowList :: [Specificity] -> String -> String
    show :: Specificity -> String
    $cshow :: Specificity -> String
    showsPrec :: Int -> Specificity -> String -> String
    $cshowsPrec :: Int -> Specificity -> String -> String
    Show, Specificity -> Specificity -> Bool
    (Specificity -> Specificity -> Bool)
    -> (Specificity -> Specificity -> Bool) -> Eq Specificity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Specificity -> Specificity -> Bool
    $c/= :: Specificity -> Specificity -> Bool
    == :: Specificity -> Specificity -> Bool
    $c== :: Specificity -> Specificity -> Bool
    Eq, Eq Specificity
    Eq Specificity
    -> (Specificity -> Specificity -> Ordering)
    -> (Specificity -> Specificity -> Bool)
    -> (Specificity -> Specificity -> Bool)
    -> (Specificity -> Specificity -> Bool)
    -> (Specificity -> Specificity -> Bool)
    -> (Specificity -> Specificity -> Specificity)
    -> (Specificity -> Specificity -> Specificity)
    -> Ord Specificity
    Specificity -> Specificity -> Bool
    Specificity -> Specificity -> Ordering
    Specificity -> Specificity -> Specificity
    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
    min :: Specificity -> Specificity -> Specificity
    $cmin :: Specificity -> Specificity -> Specificity
    max :: Specificity -> Specificity -> Specificity
    $cmax :: Specificity -> Specificity -> Specificity
    >= :: Specificity -> Specificity -> Bool
    $c>= :: Specificity -> Specificity -> Bool
    > :: Specificity -> Specificity -> Bool
    $c> :: Specificity -> Specificity -> Bool
    <= :: Specificity -> Specificity -> Bool
    $c<= :: Specificity -> Specificity -> Bool
    < :: Specificity -> Specificity -> Bool
    $c< :: Specificity -> Specificity -> Bool
    compare :: Specificity -> Specificity -> Ordering
    $ccompare :: Specificity -> Specificity -> Ordering
    Ord, Typeable Specificity
    Typeable Specificity
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Specificity -> c Specificity)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Specificity)
    -> (Specificity -> Constr)
    -> (Specificity -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Specificity))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c Specificity))
    -> ((forall b. Data b => b -> b) -> Specificity -> Specificity)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Specificity -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Specificity -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Specificity -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Specificity -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Specificity -> m Specificity)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Specificity -> m Specificity)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Specificity -> m Specificity)
    -> Data Specificity
    Specificity -> DataType
    Specificity -> Constr
    (forall b. Data b => b -> b) -> Specificity -> Specificity
    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) -> Specificity -> u
    forall u. (forall d. Data d => d -> u) -> Specificity -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Specificity -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Specificity -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Specificity -> m Specificity
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Specificity -> m Specificity
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Specificity
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Specificity -> c Specificity
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Specificity)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Specificity)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Specificity -> m Specificity
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Specificity -> m Specificity
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Specificity -> m Specificity
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Specificity -> m Specificity
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Specificity -> m Specificity
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Specificity -> m Specificity
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Specificity -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Specificity -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Specificity -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Specificity -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Specificity -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Specificity -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Specificity -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Specificity -> r
    gmapT :: (forall b. Data b => b -> b) -> Specificity -> Specificity
    $cgmapT :: (forall b. Data b => b -> b) -> Specificity -> Specificity
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Specificity)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Specificity)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Specificity)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Specificity)
    dataTypeOf :: Specificity -> DataType
    $cdataTypeOf :: Specificity -> DataType
    toConstr :: Specificity -> Constr
    $ctoConstr :: Specificity -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Specificity
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Specificity
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Specificity -> c Specificity
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Specificity -> c Specificity
    Data, (forall x. Specificity -> Rep Specificity x)
    -> (forall x. Rep Specificity x -> Specificity)
    -> Generic Specificity
    forall x. Rep Specificity x -> Specificity
    forall x. Specificity -> Rep Specificity x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Specificity x -> Specificity
    $cfrom :: forall x. Specificity -> Rep Specificity x
    Generic )

    data TyVarBndr flag = PlainTV  Name flag      -- ^ @a@
                        | KindedTV Name flag Kind -- ^ @(a :: k)@
          deriving( Int -> TyVarBndr flag -> String -> String
    [TyVarBndr flag] -> String -> String
    TyVarBndr flag -> String
    (Int -> TyVarBndr flag -> String -> String)
    -> (TyVarBndr flag -> String)
    -> ([TyVarBndr flag] -> String -> String)
    -> Show (TyVarBndr flag)
    forall flag. Show flag => Int -> TyVarBndr flag -> String -> String
    forall flag. Show flag => [TyVarBndr flag] -> String -> String
    forall flag. Show flag => TyVarBndr flag -> String
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [TyVarBndr flag] -> String -> String
    $cshowList :: forall flag. Show flag => [TyVarBndr flag] -> String -> String
    show :: TyVarBndr flag -> String
    $cshow :: forall flag. Show flag => TyVarBndr flag -> String
    showsPrec :: Int -> TyVarBndr flag -> String -> String
    $cshowsPrec :: forall flag. Show flag => Int -> TyVarBndr flag -> String -> String
    Show, TyVarBndr flag -> TyVarBndr flag -> Bool
    (TyVarBndr flag -> TyVarBndr flag -> Bool)
    -> (TyVarBndr flag -> TyVarBndr flag -> Bool)
    -> Eq (TyVarBndr flag)
    forall flag. Eq flag => TyVarBndr flag -> TyVarBndr flag -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: TyVarBndr flag -> TyVarBndr flag -> Bool
    $c/= :: forall flag. Eq flag => TyVarBndr flag -> TyVarBndr flag -> Bool
    == :: TyVarBndr flag -> TyVarBndr flag -> Bool
    $c== :: forall flag. Eq flag => TyVarBndr flag -> TyVarBndr flag -> Bool
    Eq, Eq (TyVarBndr flag)
    Eq (TyVarBndr flag)
    -> (TyVarBndr flag -> TyVarBndr flag -> Ordering)
    -> (TyVarBndr flag -> TyVarBndr flag -> Bool)
    -> (TyVarBndr flag -> TyVarBndr flag -> Bool)
    -> (TyVarBndr flag -> TyVarBndr flag -> Bool)
    -> (TyVarBndr flag -> TyVarBndr flag -> Bool)
    -> (TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag)
    -> (TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag)
    -> Ord (TyVarBndr flag)
    TyVarBndr flag -> TyVarBndr flag -> Bool
    TyVarBndr flag -> TyVarBndr flag -> Ordering
    TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag
    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 {flag}. Ord flag => Eq (TyVarBndr flag)
    forall flag. Ord flag => TyVarBndr flag -> TyVarBndr flag -> Bool
    forall flag.
    Ord flag =>
    TyVarBndr flag -> TyVarBndr flag -> Ordering
    forall flag.
    Ord flag =>
    TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag
    min :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag
    $cmin :: forall flag.
    Ord flag =>
    TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag
    max :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag
    $cmax :: forall flag.
    Ord flag =>
    TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag
    >= :: TyVarBndr flag -> TyVarBndr flag -> Bool
    $c>= :: forall flag. Ord flag => TyVarBndr flag -> TyVarBndr flag -> Bool
    > :: TyVarBndr flag -> TyVarBndr flag -> Bool
    $c> :: forall flag. Ord flag => TyVarBndr flag -> TyVarBndr flag -> Bool
    <= :: TyVarBndr flag -> TyVarBndr flag -> Bool
    $c<= :: forall flag. Ord flag => TyVarBndr flag -> TyVarBndr flag -> Bool
    < :: TyVarBndr flag -> TyVarBndr flag -> Bool
    $c< :: forall flag. Ord flag => TyVarBndr flag -> TyVarBndr flag -> Bool
    compare :: TyVarBndr flag -> TyVarBndr flag -> Ordering
    $ccompare :: forall flag.
    Ord flag =>
    TyVarBndr flag -> TyVarBndr flag -> Ordering
    Ord, Typeable (TyVarBndr flag)
    Typeable (TyVarBndr flag)
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> TyVarBndr flag -> c (TyVarBndr flag))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (TyVarBndr flag))
    -> (TyVarBndr flag -> Constr)
    -> (TyVarBndr flag -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (TyVarBndr flag)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (TyVarBndr flag)))
    -> ((forall b. Data b => b -> b)
        -> TyVarBndr flag -> TyVarBndr flag)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> TyVarBndr flag -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TyVarBndr flag -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> TyVarBndr flag -> m (TyVarBndr flag))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> TyVarBndr flag -> m (TyVarBndr flag))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> TyVarBndr flag -> m (TyVarBndr flag))
    -> Data (TyVarBndr flag)
    TyVarBndr flag -> DataType
    TyVarBndr flag -> Constr
    (forall b. Data b => b -> b) -> TyVarBndr flag -> TyVarBndr flag
    forall {flag}. Data flag => Typeable (TyVarBndr flag)
    forall flag. Data flag => TyVarBndr flag -> DataType
    forall flag. Data flag => TyVarBndr flag -> Constr
    forall flag.
    Data flag =>
    (forall b. Data b => b -> b) -> TyVarBndr flag -> TyVarBndr flag
    forall flag u.
    Data flag =>
    Int -> (forall d. Data d => d -> u) -> TyVarBndr flag -> u
    forall flag u.
    Data flag =>
    (forall d. Data d => d -> u) -> TyVarBndr flag -> [u]
    forall flag r r'.
    Data flag =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r
    forall flag r r'.
    Data flag =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r
    forall flag (m :: * -> *).
    (Data flag, Monad m) =>
    (forall d. Data d => d -> m d)
    -> TyVarBndr flag -> m (TyVarBndr flag)
    forall flag (m :: * -> *).
    (Data flag, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> TyVarBndr flag -> m (TyVarBndr flag)
    forall flag (c :: * -> *).
    Data flag =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TyVarBndr flag)
    forall flag (c :: * -> *).
    Data flag =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyVarBndr flag -> c (TyVarBndr flag)
    forall flag (t :: * -> *) (c :: * -> *).
    (Data flag, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (TyVarBndr flag))
    forall flag (t :: * -> * -> *) (c :: * -> *).
    (Data flag, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TyVarBndr flag))
    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) -> TyVarBndr flag -> u
    forall u. (forall d. Data d => d -> u) -> TyVarBndr flag -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TyVarBndr flag -> m (TyVarBndr flag)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TyVarBndr flag -> m (TyVarBndr flag)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TyVarBndr flag)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyVarBndr flag -> c (TyVarBndr flag)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TyVarBndr flag))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TyVarBndr flag))
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TyVarBndr flag -> m (TyVarBndr flag)
    $cgmapMo :: forall flag (m :: * -> *).
    (Data flag, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> TyVarBndr flag -> m (TyVarBndr flag)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TyVarBndr flag -> m (TyVarBndr flag)
    $cgmapMp :: forall flag (m :: * -> *).
    (Data flag, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> TyVarBndr flag -> m (TyVarBndr flag)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TyVarBndr flag -> m (TyVarBndr flag)
    $cgmapM :: forall flag (m :: * -> *).
    (Data flag, Monad m) =>
    (forall d. Data d => d -> m d)
    -> TyVarBndr flag -> m (TyVarBndr flag)
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> TyVarBndr flag -> u
    $cgmapQi :: forall flag u.
    Data flag =>
    Int -> (forall d. Data d => d -> u) -> TyVarBndr flag -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TyVarBndr flag -> [u]
    $cgmapQ :: forall flag u.
    Data flag =>
    (forall d. Data d => d -> u) -> TyVarBndr flag -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r
    $cgmapQr :: forall flag r r'.
    Data flag =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r
    $cgmapQl :: forall flag r r'.
    Data flag =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r
    gmapT :: (forall b. Data b => b -> b) -> TyVarBndr flag -> TyVarBndr flag
    $cgmapT :: forall flag.
    Data flag =>
    (forall b. Data b => b -> b) -> TyVarBndr flag -> TyVarBndr flag
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TyVarBndr flag))
    $cdataCast2 :: forall flag (t :: * -> * -> *) (c :: * -> *).
    (Data flag, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TyVarBndr flag))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TyVarBndr flag))
    $cdataCast1 :: forall flag (t :: * -> *) (c :: * -> *).
    (Data flag, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (TyVarBndr flag))
    dataTypeOf :: TyVarBndr flag -> DataType
    $cdataTypeOf :: forall flag. Data flag => TyVarBndr flag -> DataType
    toConstr :: TyVarBndr flag -> Constr
    $ctoConstr :: forall flag. Data flag => TyVarBndr flag -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TyVarBndr flag)
    $cgunfold :: forall flag (c :: * -> *).
    Data flag =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TyVarBndr flag)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyVarBndr flag -> c (TyVarBndr flag)
    $cgfoldl :: forall flag (c :: * -> *).
    Data flag =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyVarBndr flag -> c (TyVarBndr flag)
    Data, (forall x. TyVarBndr flag -> Rep (TyVarBndr flag) x)
    -> (forall x. Rep (TyVarBndr flag) x -> TyVarBndr flag)
    -> Generic (TyVarBndr flag)
    forall x. Rep (TyVarBndr flag) x -> TyVarBndr flag
    forall x. TyVarBndr flag -> Rep (TyVarBndr flag) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall flag x. Rep (TyVarBndr flag) x -> TyVarBndr flag
    forall flag x. TyVarBndr flag -> Rep (TyVarBndr flag) x
    $cto :: forall flag x. Rep (TyVarBndr flag) x -> TyVarBndr flag
    $cfrom :: forall flag x. TyVarBndr flag -> Rep (TyVarBndr flag) x
    Generic, (forall a b. (a -> b) -> TyVarBndr a -> TyVarBndr b)
    -> (forall a b. a -> TyVarBndr b -> TyVarBndr a)
    -> Functor TyVarBndr
    forall a b. a -> TyVarBndr b -> TyVarBndr a
    forall a b. (a -> b) -> TyVarBndr a -> TyVarBndr b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> TyVarBndr b -> TyVarBndr a
    $c<$ :: forall a b. a -> TyVarBndr b -> TyVarBndr a
    fmap :: forall a b. (a -> b) -> TyVarBndr a -> TyVarBndr b
    $cfmap :: forall a b. (a -> b) -> TyVarBndr a -> TyVarBndr b
    Functor )

    -- | Type family result signature
    data FamilyResultSig = NoSig              -- ^ no signature
                         | KindSig  Kind      -- ^ @k@
                         | TyVarSig (TyVarBndr ()) -- ^ @= r, = (r :: k)@
          deriving( Int -> FamilyResultSig -> String -> String
    [FamilyResultSig] -> String -> String
    FamilyResultSig -> String
    (Int -> FamilyResultSig -> String -> String)
    -> (FamilyResultSig -> String)
    -> ([FamilyResultSig] -> String -> String)
    -> Show FamilyResultSig
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [FamilyResultSig] -> String -> String
    $cshowList :: [FamilyResultSig] -> String -> String
    show :: FamilyResultSig -> String
    $cshow :: FamilyResultSig -> String
    showsPrec :: Int -> FamilyResultSig -> String -> String
    $cshowsPrec :: Int -> FamilyResultSig -> String -> String
    Show, FamilyResultSig -> FamilyResultSig -> Bool
    (FamilyResultSig -> FamilyResultSig -> Bool)
    -> (FamilyResultSig -> FamilyResultSig -> Bool)
    -> Eq FamilyResultSig
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: FamilyResultSig -> FamilyResultSig -> Bool
    $c/= :: FamilyResultSig -> FamilyResultSig -> Bool
    == :: FamilyResultSig -> FamilyResultSig -> Bool
    $c== :: FamilyResultSig -> FamilyResultSig -> Bool
    Eq, Eq FamilyResultSig
    Eq FamilyResultSig
    -> (FamilyResultSig -> FamilyResultSig -> Ordering)
    -> (FamilyResultSig -> FamilyResultSig -> Bool)
    -> (FamilyResultSig -> FamilyResultSig -> Bool)
    -> (FamilyResultSig -> FamilyResultSig -> Bool)
    -> (FamilyResultSig -> FamilyResultSig -> Bool)
    -> (FamilyResultSig -> FamilyResultSig -> FamilyResultSig)
    -> (FamilyResultSig -> FamilyResultSig -> FamilyResultSig)
    -> Ord FamilyResultSig
    FamilyResultSig -> FamilyResultSig -> Bool
    FamilyResultSig -> FamilyResultSig -> Ordering
    FamilyResultSig -> FamilyResultSig -> FamilyResultSig
    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
    min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig
    $cmin :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig
    max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig
    $cmax :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig
    >= :: FamilyResultSig -> FamilyResultSig -> Bool
    $c>= :: FamilyResultSig -> FamilyResultSig -> Bool
    > :: FamilyResultSig -> FamilyResultSig -> Bool
    $c> :: FamilyResultSig -> FamilyResultSig -> Bool
    <= :: FamilyResultSig -> FamilyResultSig -> Bool
    $c<= :: FamilyResultSig -> FamilyResultSig -> Bool
    < :: FamilyResultSig -> FamilyResultSig -> Bool
    $c< :: FamilyResultSig -> FamilyResultSig -> Bool
    compare :: FamilyResultSig -> FamilyResultSig -> Ordering
    $ccompare :: FamilyResultSig -> FamilyResultSig -> Ordering
    Ord, Typeable FamilyResultSig
    Typeable FamilyResultSig
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c FamilyResultSig)
    -> (FamilyResultSig -> Constr)
    -> (FamilyResultSig -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c FamilyResultSig))
    -> ((forall b. Data b => b -> b)
        -> FamilyResultSig -> FamilyResultSig)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> FamilyResultSig -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> FamilyResultSig -> m FamilyResultSig)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FamilyResultSig -> m FamilyResultSig)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FamilyResultSig -> m FamilyResultSig)
    -> Data FamilyResultSig
    FamilyResultSig -> DataType
    FamilyResultSig -> Constr
    (forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig
    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) -> FamilyResultSig -> u
    forall u. (forall d. Data d => d -> u) -> FamilyResultSig -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FamilyResultSig -> m FamilyResultSig
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FamilyResultSig -> m FamilyResultSig
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FamilyResultSig
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FamilyResultSig)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FamilyResultSig -> m FamilyResultSig
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FamilyResultSig -> m FamilyResultSig
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FamilyResultSig -> m FamilyResultSig
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FamilyResultSig -> m FamilyResultSig
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FamilyResultSig -> m FamilyResultSig
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FamilyResultSig -> m FamilyResultSig
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> FamilyResultSig -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> FamilyResultSig -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
    gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig
    $cgmapT :: (forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FamilyResultSig)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FamilyResultSig)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig)
    dataTypeOf :: FamilyResultSig -> DataType
    $cdataTypeOf :: FamilyResultSig -> DataType
    toConstr :: FamilyResultSig -> Constr
    $ctoConstr :: FamilyResultSig -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FamilyResultSig
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FamilyResultSig
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig
    Data, (forall x. FamilyResultSig -> Rep FamilyResultSig x)
    -> (forall x. Rep FamilyResultSig x -> FamilyResultSig)
    -> Generic FamilyResultSig
    forall x. Rep FamilyResultSig x -> FamilyResultSig
    forall x. FamilyResultSig -> Rep FamilyResultSig x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep FamilyResultSig x -> FamilyResultSig
    $cfrom :: forall x. FamilyResultSig -> Rep FamilyResultSig x
    Generic )

    -- | Injectivity annotation
    data InjectivityAnn = InjectivityAnn Name [Name]
      deriving ( Int -> InjectivityAnn -> String -> String
    [InjectivityAnn] -> String -> String
    InjectivityAnn -> String
    (Int -> InjectivityAnn -> String -> String)
    -> (InjectivityAnn -> String)
    -> ([InjectivityAnn] -> String -> String)
    -> Show InjectivityAnn
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [InjectivityAnn] -> String -> String
    $cshowList :: [InjectivityAnn] -> String -> String
    show :: InjectivityAnn -> String
    $cshow :: InjectivityAnn -> String
    showsPrec :: Int -> InjectivityAnn -> String -> String
    $cshowsPrec :: Int -> InjectivityAnn -> String -> String
    Show, InjectivityAnn -> InjectivityAnn -> Bool
    (InjectivityAnn -> InjectivityAnn -> Bool)
    -> (InjectivityAnn -> InjectivityAnn -> Bool) -> Eq InjectivityAnn
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: InjectivityAnn -> InjectivityAnn -> Bool
    $c/= :: InjectivityAnn -> InjectivityAnn -> Bool
    == :: InjectivityAnn -> InjectivityAnn -> Bool
    $c== :: InjectivityAnn -> InjectivityAnn -> Bool
    Eq, Eq InjectivityAnn
    Eq InjectivityAnn
    -> (InjectivityAnn -> InjectivityAnn -> Ordering)
    -> (InjectivityAnn -> InjectivityAnn -> Bool)
    -> (InjectivityAnn -> InjectivityAnn -> Bool)
    -> (InjectivityAnn -> InjectivityAnn -> Bool)
    -> (InjectivityAnn -> InjectivityAnn -> Bool)
    -> (InjectivityAnn -> InjectivityAnn -> InjectivityAnn)
    -> (InjectivityAnn -> InjectivityAnn -> InjectivityAnn)
    -> Ord InjectivityAnn
    InjectivityAnn -> InjectivityAnn -> Bool
    InjectivityAnn -> InjectivityAnn -> Ordering
    InjectivityAnn -> InjectivityAnn -> InjectivityAnn
    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
    min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn
    $cmin :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn
    max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn
    $cmax :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn
    >= :: InjectivityAnn -> InjectivityAnn -> Bool
    $c>= :: InjectivityAnn -> InjectivityAnn -> Bool
    > :: InjectivityAnn -> InjectivityAnn -> Bool
    $c> :: InjectivityAnn -> InjectivityAnn -> Bool
    <= :: InjectivityAnn -> InjectivityAnn -> Bool
    $c<= :: InjectivityAnn -> InjectivityAnn -> Bool
    < :: InjectivityAnn -> InjectivityAnn -> Bool
    $c< :: InjectivityAnn -> InjectivityAnn -> Bool
    compare :: InjectivityAnn -> InjectivityAnn -> Ordering
    $ccompare :: InjectivityAnn -> InjectivityAnn -> Ordering
    Ord, Typeable InjectivityAnn
    Typeable InjectivityAnn
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c InjectivityAnn)
    -> (InjectivityAnn -> Constr)
    -> (InjectivityAnn -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c InjectivityAnn))
    -> ((forall b. Data b => b -> b)
        -> InjectivityAnn -> InjectivityAnn)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> InjectivityAnn -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> InjectivityAnn -> m InjectivityAnn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> InjectivityAnn -> m InjectivityAnn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> InjectivityAnn -> m InjectivityAnn)
    -> Data InjectivityAnn
    InjectivityAnn -> DataType
    InjectivityAnn -> Constr
    (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn
    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) -> InjectivityAnn -> u
    forall u. (forall d. Data d => d -> u) -> InjectivityAnn -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> InjectivityAnn -> m InjectivityAnn
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InjectivityAnn -> m InjectivityAnn
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InjectivityAnn
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c InjectivityAnn)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InjectivityAnn -> m InjectivityAnn
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InjectivityAnn -> m InjectivityAnn
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InjectivityAnn -> m InjectivityAnn
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InjectivityAnn -> m InjectivityAnn
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> InjectivityAnn -> m InjectivityAnn
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> InjectivityAnn -> m InjectivityAnn
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> InjectivityAnn -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> InjectivityAnn -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
    gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn
    $cgmapT :: (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c InjectivityAnn)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c InjectivityAnn)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn)
    dataTypeOf :: InjectivityAnn -> DataType
    $cdataTypeOf :: InjectivityAnn -> DataType
    toConstr :: InjectivityAnn -> Constr
    $ctoConstr :: InjectivityAnn -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InjectivityAnn
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InjectivityAnn
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn
    Data, (forall x. InjectivityAnn -> Rep InjectivityAnn x)
    -> (forall x. Rep InjectivityAnn x -> InjectivityAnn)
    -> Generic InjectivityAnn
    forall x. Rep InjectivityAnn x -> InjectivityAnn
    forall x. InjectivityAnn -> Rep InjectivityAnn x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep InjectivityAnn x -> InjectivityAnn
    $cfrom :: forall x. InjectivityAnn -> Rep InjectivityAnn x
    Generic )

    data TyLit = NumTyLit Integer             -- ^ @2@
               | StrTyLit String              -- ^ @\"Hello\"@
      deriving ( Int -> TyLit -> String -> String
    [TyLit] -> String -> String
    TyLit -> String
    (Int -> TyLit -> String -> String)
    -> (TyLit -> String) -> ([TyLit] -> String -> String) -> Show TyLit
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [TyLit] -> String -> String
    $cshowList :: [TyLit] -> String -> String
    show :: TyLit -> String
    $cshow :: TyLit -> String
    showsPrec :: Int -> TyLit -> String -> String
    $cshowsPrec :: Int -> TyLit -> String -> String
    Show, TyLit -> TyLit -> Bool
    (TyLit -> TyLit -> Bool) -> (TyLit -> TyLit -> Bool) -> Eq TyLit
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: TyLit -> TyLit -> Bool
    $c/= :: TyLit -> TyLit -> Bool
    == :: TyLit -> TyLit -> Bool
    $c== :: TyLit -> TyLit -> Bool
    Eq, Eq TyLit
    Eq TyLit
    -> (TyLit -> TyLit -> Ordering)
    -> (TyLit -> TyLit -> Bool)
    -> (TyLit -> TyLit -> Bool)
    -> (TyLit -> TyLit -> Bool)
    -> (TyLit -> TyLit -> Bool)
    -> (TyLit -> TyLit -> TyLit)
    -> (TyLit -> TyLit -> TyLit)
    -> Ord TyLit
    TyLit -> TyLit -> Bool
    TyLit -> TyLit -> Ordering
    TyLit -> TyLit -> TyLit
    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
    min :: TyLit -> TyLit -> TyLit
    $cmin :: TyLit -> TyLit -> TyLit
    max :: TyLit -> TyLit -> TyLit
    $cmax :: TyLit -> TyLit -> TyLit
    >= :: TyLit -> TyLit -> Bool
    $c>= :: TyLit -> TyLit -> Bool
    > :: TyLit -> TyLit -> Bool
    $c> :: TyLit -> TyLit -> Bool
    <= :: TyLit -> TyLit -> Bool
    $c<= :: TyLit -> TyLit -> Bool
    < :: TyLit -> TyLit -> Bool
    $c< :: TyLit -> TyLit -> Bool
    compare :: TyLit -> TyLit -> Ordering
    $ccompare :: TyLit -> TyLit -> Ordering
    Ord, Typeable TyLit
    Typeable TyLit
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> TyLit -> c TyLit)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TyLit)
    -> (TyLit -> Constr)
    -> (TyLit -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TyLit))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit))
    -> ((forall b. Data b => b -> b) -> TyLit -> TyLit)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TyLit -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> TyLit -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TyLit -> m TyLit)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TyLit -> m TyLit)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TyLit -> m TyLit)
    -> Data TyLit
    TyLit -> DataType
    TyLit -> Constr
    (forall b. Data b => b -> b) -> TyLit -> TyLit
    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) -> TyLit -> u
    forall u. (forall d. Data d => d -> u) -> TyLit -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyLit -> m TyLit
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyLit -> m TyLit
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TyLit
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyLit -> c TyLit
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TyLit)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyLit -> m TyLit
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyLit -> m TyLit
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyLit -> m TyLit
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyLit -> m TyLit
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyLit -> m TyLit
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyLit -> m TyLit
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyLit -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyLit -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TyLit -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TyLit -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
    gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit
    $cgmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TyLit)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TyLit)
    dataTypeOf :: TyLit -> DataType
    $cdataTypeOf :: TyLit -> DataType
    toConstr :: TyLit -> Constr
    $ctoConstr :: TyLit -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TyLit
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TyLit
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyLit -> c TyLit
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyLit -> c TyLit
    Data, (forall x. TyLit -> Rep TyLit x)
    -> (forall x. Rep TyLit x -> TyLit) -> Generic TyLit
    forall x. Rep TyLit x -> TyLit
    forall x. TyLit -> Rep TyLit x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TyLit x -> TyLit
    $cfrom :: forall x. TyLit -> Rep TyLit x
    Generic )

    -- | Role annotations
    data Role = NominalR            -- ^ @nominal@
              | RepresentationalR   -- ^ @representational@
              | PhantomR            -- ^ @phantom@
              | InferR              -- ^ @_@
      deriving( Int -> Role -> String -> String
    [Role] -> String -> String
    Role -> String
    (Int -> Role -> String -> String)
    -> (Role -> String) -> ([Role] -> String -> String) -> Show Role
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Role] -> String -> String
    $cshowList :: [Role] -> String -> String
    show :: Role -> String
    $cshow :: Role -> String
    showsPrec :: Int -> Role -> String -> String
    $cshowsPrec :: Int -> Role -> String -> String
    Show, Role -> Role -> Bool
    (Role -> Role -> Bool) -> (Role -> Role -> Bool) -> Eq Role
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Role -> Role -> Bool
    $c/= :: Role -> Role -> Bool
    == :: Role -> Role -> Bool
    $c== :: Role -> Role -> Bool
    Eq, Eq Role
    Eq Role
    -> (Role -> Role -> Ordering)
    -> (Role -> Role -> Bool)
    -> (Role -> Role -> Bool)
    -> (Role -> Role -> Bool)
    -> (Role -> Role -> Bool)
    -> (Role -> Role -> Role)
    -> (Role -> Role -> Role)
    -> Ord Role
    Role -> Role -> Bool
    Role -> Role -> Ordering
    Role -> Role -> Role
    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
    min :: Role -> Role -> Role
    $cmin :: Role -> Role -> Role
    max :: Role -> Role -> Role
    $cmax :: Role -> Role -> Role
    >= :: Role -> Role -> Bool
    $c>= :: Role -> Role -> Bool
    > :: Role -> Role -> Bool
    $c> :: Role -> Role -> Bool
    <= :: Role -> Role -> Bool
    $c<= :: Role -> Role -> Bool
    < :: Role -> Role -> Bool
    $c< :: Role -> Role -> Bool
    compare :: Role -> Role -> Ordering
    $ccompare :: Role -> Role -> Ordering
    Ord, Typeable Role
    Typeable Role
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Role -> c Role)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Role)
    -> (Role -> Constr)
    -> (Role -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Role))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role))
    -> ((forall b. Data b => b -> b) -> Role -> Role)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Role -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Role -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Role -> m Role)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Role -> m Role)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Role -> m Role)
    -> Data Role
    Role -> DataType
    Role -> Constr
    (forall b. Data b => b -> b) -> Role -> Role
    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) -> Role -> u
    forall u. (forall d. Data d => d -> u) -> Role -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Role -> m Role
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role -> m Role
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Role
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Role -> c Role
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Role)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role -> m Role
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role -> m Role
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role -> m Role
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role -> m Role
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Role -> m Role
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Role -> m Role
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Role -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Role -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Role -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Role -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
    gmapT :: (forall b. Data b => b -> b) -> Role -> Role
    $cgmapT :: (forall b. Data b => b -> b) -> Role -> Role
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Role)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Role)
    dataTypeOf :: Role -> DataType
    $cdataTypeOf :: Role -> DataType
    toConstr :: Role -> Constr
    $ctoConstr :: Role -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Role
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Role
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Role -> c Role
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Role -> c Role
    Data, (forall x. Role -> Rep Role x)
    -> (forall x. Rep Role x -> Role) -> Generic Role
    forall x. Rep Role x -> Role
    forall x. Role -> Rep Role x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Role x -> Role
    $cfrom :: forall x. Role -> Rep Role x
    Generic )

    -- | Annotation target for reifyAnnotations
    data AnnLookup = AnnLookupModule Module
                   | AnnLookupName Name
                   deriving( Int -> AnnLookup -> String -> String
    [AnnLookup] -> String -> String
    AnnLookup -> String
    (Int -> AnnLookup -> String -> String)
    -> (AnnLookup -> String)
    -> ([AnnLookup] -> String -> String)
    -> Show AnnLookup
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [AnnLookup] -> String -> String
    $cshowList :: [AnnLookup] -> String -> String
    show :: AnnLookup -> String
    $cshow :: AnnLookup -> String
    showsPrec :: Int -> AnnLookup -> String -> String
    $cshowsPrec :: Int -> AnnLookup -> String -> String
    Show, AnnLookup -> AnnLookup -> Bool
    (AnnLookup -> AnnLookup -> Bool)
    -> (AnnLookup -> AnnLookup -> Bool) -> Eq AnnLookup
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AnnLookup -> AnnLookup -> Bool
    $c/= :: AnnLookup -> AnnLookup -> Bool
    == :: AnnLookup -> AnnLookup -> Bool
    $c== :: AnnLookup -> AnnLookup -> Bool
    Eq, Eq AnnLookup
    Eq AnnLookup
    -> (AnnLookup -> AnnLookup -> Ordering)
    -> (AnnLookup -> AnnLookup -> Bool)
    -> (AnnLookup -> AnnLookup -> Bool)
    -> (AnnLookup -> AnnLookup -> Bool)
    -> (AnnLookup -> AnnLookup -> Bool)
    -> (AnnLookup -> AnnLookup -> AnnLookup)
    -> (AnnLookup -> AnnLookup -> AnnLookup)
    -> Ord AnnLookup
    AnnLookup -> AnnLookup -> Bool
    AnnLookup -> AnnLookup -> Ordering
    AnnLookup -> AnnLookup -> AnnLookup
    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
    min :: AnnLookup -> AnnLookup -> AnnLookup
    $cmin :: AnnLookup -> AnnLookup -> AnnLookup
    max :: AnnLookup -> AnnLookup -> AnnLookup
    $cmax :: AnnLookup -> AnnLookup -> AnnLookup
    >= :: AnnLookup -> AnnLookup -> Bool
    $c>= :: AnnLookup -> AnnLookup -> Bool
    > :: AnnLookup -> AnnLookup -> Bool
    $c> :: AnnLookup -> AnnLookup -> Bool
    <= :: AnnLookup -> AnnLookup -> Bool
    $c<= :: AnnLookup -> AnnLookup -> Bool
    < :: AnnLookup -> AnnLookup -> Bool
    $c< :: AnnLookup -> AnnLookup -> Bool
    compare :: AnnLookup -> AnnLookup -> Ordering
    $ccompare :: AnnLookup -> AnnLookup -> Ordering
    Ord, Typeable AnnLookup
    Typeable AnnLookup
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> AnnLookup -> c AnnLookup)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnLookup)
    -> (AnnLookup -> Constr)
    -> (AnnLookup -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnLookup))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup))
    -> ((forall b. Data b => b -> b) -> AnnLookup -> AnnLookup)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnLookup -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnLookup -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup)
    -> Data AnnLookup
    AnnLookup -> DataType
    AnnLookup -> Constr
    (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup
    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) -> AnnLookup -> u
    forall u. (forall d. Data d => d -> u) -> AnnLookup -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnLookup
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnLookup -> c AnnLookup
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnLookup)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnLookup -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnLookup -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnLookup -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnLookup -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
    gmapT :: (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup
    $cgmapT :: (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnLookup)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnLookup)
    dataTypeOf :: AnnLookup -> DataType
    $cdataTypeOf :: AnnLookup -> DataType
    toConstr :: AnnLookup -> Constr
    $ctoConstr :: AnnLookup -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnLookup
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnLookup
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnLookup -> c AnnLookup
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnLookup -> c AnnLookup
    Data, (forall x. AnnLookup -> Rep AnnLookup x)
    -> (forall x. Rep AnnLookup x -> AnnLookup) -> Generic AnnLookup
    forall x. Rep AnnLookup x -> AnnLookup
    forall x. AnnLookup -> Rep AnnLookup x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep AnnLookup x -> AnnLookup
    $cfrom :: forall x. AnnLookup -> Rep AnnLookup x
    Generic )

    -- | To avoid duplication between kinds and types, they
    -- are defined to be the same. Naturally, you would never
    -- have a type be 'StarT' and you would never have a kind
    -- be 'SigT', but many of the other constructors are shared.
    -- Note that the kind @Bool@ is denoted with 'ConT', not
    -- 'PromotedT'. Similarly, tuple kinds are made with 'TupleT',
    -- not 'PromotedTupleT'.

    type Kind = Type

    {- Note [Representing concrete syntax in types]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Haskell has a rich concrete syntax for types, including
      t1 -> t2, (t1,t2), [t], and so on
    In TH we represent all of this using AppT, with a distinguished
    type constructor at the head.  So,
      Type              TH representation
      -----------------------------------------------
      t1 -> t2          ArrowT `AppT` t2 `AppT` t2
      [t]               ListT `AppT` t
      (t1,t2)           TupleT 2 `AppT` t1 `AppT` t2
      '(t1,t2)          PromotedTupleT 2 `AppT` t1 `AppT` t2

    But if the original HsSyn used prefix application, we won't use
    these special TH constructors.  For example
      [] t              ConT "[]" `AppT` t
      (->) t            ConT "->" `AppT` t
    In this way we can faithfully represent in TH whether the original
    HsType used concrete syntax or not.

    The one case that doesn't fit this pattern is that of promoted lists
      '[ Maybe, IO ]    PromotedListT 2 `AppT` t1 `AppT` t2
    but it's very smelly because there really is no type constructor
    corresponding to PromotedListT. So we encode HsExplicitListTy with
    PromotedConsT and PromotedNilT (which *do* have underlying type
    constructors):
      '[ Maybe, IO ]    PromotedConsT `AppT` Maybe `AppT`
                        (PromotedConsT  `AppT` IO `AppT` PromotedNilT)
    -}

    -----------------------------------------------------
    --              Internal helper functions
    -----------------------------------------------------

    cmpEq :: Ordering -> Bool
    cmpEq :: Ordering -> Bool
    cmpEq Ordering
    EQ = Bool
    True
    cmpEq Ordering
    _  = Bool
    False

    thenCmp :: Ordering -> Ordering -> Ordering
    thenCmp :: Ordering -> Ordering -> Ordering
    thenCmp Ordering
    EQ Ordering
    o2 = Ordering
    o2
    thenCmp Ordering
    o1 Ordering
    _  = Ordering
    o1