    {- Language/Haskell/TH/Desugar/AST.hs

    (c) Ryan Scott 2018

    Defines the desugared Template Haskell AST. The desugared types and
    constructors are prefixed with a D.
    -}

    {-# LANGUAGE CPP, DeriveDataTypeable, DeriveFunctor, DeriveGeneric, DeriveLift #-}

    module Language.Haskell.TH.Desugar.AST where

    import Data.Data hiding (Fixity)
    import GHC.Generics hiding (Fixity)
    import Language.Haskell.TH
    import Language.Haskell.TH.Instances ()
    import Language.Haskell.TH.Syntax (Lift)
    #if __GLASGOW_HASKELL__ < 900
    import Language.Haskell.TH.Datatype.TyVarBndr (Specificity(..))
    #endif

    import Language.Haskell.TH.Desugar.Util (DataFlavor)

    -- | Corresponds to TH's @Exp@ type. Note that @DLamE@ takes names, not patterns.

    data DExp = DVarE Name
              | DConE Name
              | DLitE Lit
              | DAppE DExp DExp
              | DAppTypeE DExp DType
              | DLamE [Name] DExp
              | DCaseE DExp [DMatch]
              | DLetE [DLetDec] DExp
              | DSigE DExp DType
              | DStaticE DExp
              deriving (DExp -> DExp -> Bool
    (DExp -> DExp -> Bool) -> (DExp -> DExp -> Bool) -> Eq DExp
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DExp -> DExp -> Bool
    == :: DExp -> DExp -> Bool
    $c/= :: DExp -> DExp -> Bool
    /= :: DExp -> DExp -> Bool
    Eq, Int -> DExp -> ShowS
    [DExp] -> ShowS
    DExp -> String
    (Int -> DExp -> ShowS)
    -> (DExp -> String) -> ([DExp] -> ShowS) -> Show DExp
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DExp -> ShowS
    showsPrec :: Int -> DExp -> ShowS
    $cshow :: DExp -> String
    show :: DExp -> String
    $cshowList :: [DExp] -> ShowS
    showList :: [DExp] -> ShowS
    Show, Typeable DExp
    Typeable DExp =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DExp -> c DExp)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DExp)
    -> (DExp -> Constr)
    -> (DExp -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DExp))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DExp))
    -> ((forall b. Data b => b -> b) -> DExp -> DExp)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DExp -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DExp -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DExp -> m DExp)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DExp -> m DExp)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DExp -> m DExp)
    -> Data DExp
    DExp -> Constr
    DExp -> DataType
    (forall b. Data b => b -> b) -> DExp -> DExp
    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) -> DExp -> u
    forall u. (forall d. Data d => d -> u) -> DExp -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DExp -> m DExp
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DExp -> m DExp
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DExp
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DExp -> c DExp
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DExp)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DExp)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DExp -> c DExp
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DExp -> c DExp
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DExp
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DExp
    $ctoConstr :: DExp -> Constr
    toConstr :: DExp -> Constr
    $cdataTypeOf :: DExp -> DataType
    dataTypeOf :: DExp -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DExp)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DExp)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DExp)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DExp)
    $cgmapT :: (forall b. Data b => b -> b) -> DExp -> DExp
    gmapT :: (forall b. Data b => b -> b) -> DExp -> DExp
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DExp -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DExp -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DExp -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DExp -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DExp -> m DExp
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DExp -> m DExp
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DExp -> m DExp
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DExp -> m DExp
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DExp -> m DExp
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DExp -> m DExp
    Data, (forall x. DExp -> Rep DExp x)
    -> (forall x. Rep DExp x -> DExp) -> Generic DExp
    forall x. Rep DExp x -> DExp
    forall x. DExp -> Rep DExp x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DExp -> Rep DExp x
    from :: forall x. DExp -> Rep DExp x
    $cto :: forall x. Rep DExp x -> DExp
    to :: forall x. Rep DExp x -> DExp
    Generic, (forall (m :: * -> *). Quote m => DExp -> m Exp)
    -> (forall (m :: * -> *). Quote m => DExp -> Code m DExp)
    -> Lift DExp
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DExp -> m Exp
    forall (m :: * -> *). Quote m => DExp -> Code m DExp
    $clift :: forall (m :: * -> *). Quote m => DExp -> m Exp
    lift :: forall (m :: * -> *). Quote m => DExp -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DExp -> Code m DExp
    liftTyped :: forall (m :: * -> *). Quote m => DExp -> Code m DExp
    Lift)

    -- | Corresponds to TH's @Pat@ type.

    data DPat = DLitP Lit
              | DVarP Name
              | DConP Name [DType] [DPat]
              | DTildeP DPat
              | DBangP DPat
              | DSigP DPat DType
              | DWildP
              deriving (DPat -> DPat -> Bool
    (DPat -> DPat -> Bool) -> (DPat -> DPat -> Bool) -> Eq DPat
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DPat -> DPat -> Bool
    == :: DPat -> DPat -> Bool
    $c/= :: DPat -> DPat -> Bool
    /= :: DPat -> DPat -> Bool
    Eq, Int -> DPat -> ShowS
    [DPat] -> ShowS
    DPat -> String
    (Int -> DPat -> ShowS)
    -> (DPat -> String) -> ([DPat] -> ShowS) -> Show DPat
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DPat -> ShowS
    showsPrec :: Int -> DPat -> ShowS
    $cshow :: DPat -> String
    show :: DPat -> String
    $cshowList :: [DPat] -> ShowS
    showList :: [DPat] -> ShowS
    Show, Typeable DPat
    Typeable DPat =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DPat -> c DPat)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DPat)
    -> (DPat -> Constr)
    -> (DPat -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DPat))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPat))
    -> ((forall b. Data b => b -> b) -> DPat -> DPat)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DPat -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DPat -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DPat -> m DPat)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DPat -> m DPat)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DPat -> m DPat)
    -> Data DPat
    DPat -> Constr
    DPat -> DataType
    (forall b. Data b => b -> b) -> DPat -> DPat
    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) -> DPat -> u
    forall u. (forall d. Data d => d -> u) -> DPat -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPat -> m DPat
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPat -> m DPat
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPat
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPat -> c DPat
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPat)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPat)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPat -> c DPat
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPat -> c DPat
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPat
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPat
    $ctoConstr :: DPat -> Constr
    toConstr :: DPat -> Constr
    $cdataTypeOf :: DPat -> DataType
    dataTypeOf :: DPat -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPat)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPat)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPat)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPat)
    $cgmapT :: (forall b. Data b => b -> b) -> DPat -> DPat
    gmapT :: (forall b. Data b => b -> b) -> DPat -> DPat
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DPat -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DPat -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPat -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPat -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPat -> m DPat
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPat -> m DPat
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPat -> m DPat
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPat -> m DPat
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPat -> m DPat
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPat -> m DPat
    Data, (forall x. DPat -> Rep DPat x)
    -> (forall x. Rep DPat x -> DPat) -> Generic DPat
    forall x. Rep DPat x -> DPat
    forall x. DPat -> Rep DPat x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DPat -> Rep DPat x
    from :: forall x. DPat -> Rep DPat x
    $cto :: forall x. Rep DPat x -> DPat
    to :: forall x. Rep DPat x -> DPat
    Generic, (forall (m :: * -> *). Quote m => DPat -> m Exp)
    -> (forall (m :: * -> *). Quote m => DPat -> Code m DPat)
    -> Lift DPat
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DPat -> m Exp
    forall (m :: * -> *). Quote m => DPat -> Code m DPat
    $clift :: forall (m :: * -> *). Quote m => DPat -> m Exp
    lift :: forall (m :: * -> *). Quote m => DPat -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DPat -> Code m DPat
    liftTyped :: forall (m :: * -> *). Quote m => DPat -> Code m DPat
    Lift)

    -- | Corresponds to TH's @Type@ type, used to represent

    -- types and kinds.

    data DType = DForallT DForallTelescope DType
               | DConstrainedT DCxt DType
               | DAppT DType DType
               | DAppKindT DType DKind
               | DSigT DType DKind
               | DVarT Name
               | DConT Name
               | DArrowT
               | DLitT TyLit
               | DWildCardT
               deriving (DType -> DType -> Bool
    (DType -> DType -> Bool) -> (DType -> DType -> Bool) -> Eq DType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DType -> DType -> Bool
    == :: DType -> DType -> Bool
    $c/= :: DType -> DType -> Bool
    /= :: DType -> DType -> Bool
    Eq, Int -> DType -> ShowS
    [DType] -> ShowS
    DType -> String
    (Int -> DType -> ShowS)
    -> (DType -> String) -> ([DType] -> ShowS) -> Show DType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DType -> ShowS
    showsPrec :: Int -> DType -> ShowS
    $cshow :: DType -> String
    show :: DType -> String
    $cshowList :: [DType] -> ShowS
    showList :: [DType] -> ShowS
    Show, Typeable DType
    Typeable DType =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DType -> c DType)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DType)
    -> (DType -> Constr)
    -> (DType -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DType))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DType))
    -> ((forall b. Data b => b -> b) -> DType -> DType)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DType -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DType -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DType -> m DType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DType -> m DType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DType -> m DType)
    -> Data DType
    DType -> Constr
    DType -> DataType
    (forall b. Data b => b -> b) -> DType -> DType
    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) -> DType -> u
    forall u. (forall d. Data d => d -> u) -> DType -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DType -> m DType
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DType -> m DType
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DType
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DType -> c DType
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DType)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DType)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DType -> c DType
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DType -> c DType
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DType
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DType
    $ctoConstr :: DType -> Constr
    toConstr :: DType -> Constr
    $cdataTypeOf :: DType -> DataType
    dataTypeOf :: DType -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DType)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DType)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DType)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DType)
    $cgmapT :: (forall b. Data b => b -> b) -> DType -> DType
    gmapT :: (forall b. Data b => b -> b) -> DType -> DType
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DType -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DType -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DType -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DType -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DType -> m DType
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DType -> m DType
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DType -> m DType
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DType -> m DType
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DType -> m DType
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DType -> m DType
    Data, (forall x. DType -> Rep DType x)
    -> (forall x. Rep DType x -> DType) -> Generic DType
    forall x. Rep DType x -> DType
    forall x. DType -> Rep DType x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DType -> Rep DType x
    from :: forall x. DType -> Rep DType x
    $cto :: forall x. Rep DType x -> DType
    to :: forall x. Rep DType x -> DType
    Generic, (forall (m :: * -> *). Quote m => DType -> m Exp)
    -> (forall (m :: * -> *). Quote m => DType -> Code m DType)
    -> Lift DType
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DType -> m Exp
    forall (m :: * -> *). Quote m => DType -> Code m DType
    $clift :: forall (m :: * -> *). Quote m => DType -> m Exp
    lift :: forall (m :: * -> *). Quote m => DType -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DType -> Code m DType
    liftTyped :: forall (m :: * -> *). Quote m => DType -> Code m DType
    Lift)

    -- | The type variable binders in a @forall@.

    data DForallTelescope
      = DForallVis   [DTyVarBndrUnit]
        -- ^ A visible @forall@ (e.g., @forall a -> {...}@).

        --   These do not have any notion of specificity, so we use

        --   '()' as a placeholder value in the 'DTyVarBndr's.

      | DForallInvis [DTyVarBndrSpec]
        -- ^ An invisible @forall@ (e.g., @forall a {b} c -> {...}@),

        --   where each binder has a 'Specificity'.

      deriving (DForallTelescope -> DForallTelescope -> Bool
    (DForallTelescope -> DForallTelescope -> Bool)
    -> (DForallTelescope -> DForallTelescope -> Bool)
    -> Eq DForallTelescope
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DForallTelescope -> DForallTelescope -> Bool
    == :: DForallTelescope -> DForallTelescope -> Bool
    $c/= :: DForallTelescope -> DForallTelescope -> Bool
    /= :: DForallTelescope -> DForallTelescope -> Bool
    Eq, Int -> DForallTelescope -> ShowS
    [DForallTelescope] -> ShowS
    DForallTelescope -> String
    (Int -> DForallTelescope -> ShowS)
    -> (DForallTelescope -> String)
    -> ([DForallTelescope] -> ShowS)
    -> Show DForallTelescope
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DForallTelescope -> ShowS
    showsPrec :: Int -> DForallTelescope -> ShowS
    $cshow :: DForallTelescope -> String
    show :: DForallTelescope -> String
    $cshowList :: [DForallTelescope] -> ShowS
    showList :: [DForallTelescope] -> ShowS
    Show, Typeable DForallTelescope
    Typeable DForallTelescope =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DForallTelescope -> c DForallTelescope)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DForallTelescope)
    -> (DForallTelescope -> Constr)
    -> (DForallTelescope -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DForallTelescope))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DForallTelescope))
    -> ((forall b. Data b => b -> b)
        -> DForallTelescope -> DForallTelescope)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> DForallTelescope -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DForallTelescope -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> DForallTelescope -> m DForallTelescope)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DForallTelescope -> m DForallTelescope)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DForallTelescope -> m DForallTelescope)
    -> Data DForallTelescope
    DForallTelescope -> Constr
    DForallTelescope -> DataType
    (forall b. Data b => b -> b)
    -> DForallTelescope -> DForallTelescope
    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) -> DForallTelescope -> u
    forall u. (forall d. Data d => d -> u) -> DForallTelescope -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DForallTelescope -> m DForallTelescope
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DForallTelescope -> m DForallTelescope
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DForallTelescope
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DForallTelescope -> c DForallTelescope
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DForallTelescope)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DForallTelescope)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DForallTelescope -> c DForallTelescope
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DForallTelescope -> c DForallTelescope
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DForallTelescope
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DForallTelescope
    $ctoConstr :: DForallTelescope -> Constr
    toConstr :: DForallTelescope -> Constr
    $cdataTypeOf :: DForallTelescope -> DataType
    dataTypeOf :: DForallTelescope -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DForallTelescope)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DForallTelescope)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DForallTelescope)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DForallTelescope)
    $cgmapT :: (forall b. Data b => b -> b)
    -> DForallTelescope -> DForallTelescope
    gmapT :: (forall b. Data b => b -> b)
    -> DForallTelescope -> DForallTelescope
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DForallTelescope -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DForallTelescope -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DForallTelescope -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DForallTelescope -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DForallTelescope -> m DForallTelescope
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DForallTelescope -> m DForallTelescope
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DForallTelescope -> m DForallTelescope
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DForallTelescope -> m DForallTelescope
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DForallTelescope -> m DForallTelescope
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DForallTelescope -> m DForallTelescope
    Data, (forall x. DForallTelescope -> Rep DForallTelescope x)
    -> (forall x. Rep DForallTelescope x -> DForallTelescope)
    -> Generic DForallTelescope
    forall x. Rep DForallTelescope x -> DForallTelescope
    forall x. DForallTelescope -> Rep DForallTelescope x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DForallTelescope -> Rep DForallTelescope x
    from :: forall x. DForallTelescope -> Rep DForallTelescope x
    $cto :: forall x. Rep DForallTelescope x -> DForallTelescope
    to :: forall x. Rep DForallTelescope x -> DForallTelescope
    Generic, (forall (m :: * -> *). Quote m => DForallTelescope -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        DForallTelescope -> Code m DForallTelescope)
    -> Lift DForallTelescope
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DForallTelescope -> m Exp
    forall (m :: * -> *).
    Quote m =>
    DForallTelescope -> Code m DForallTelescope
    $clift :: forall (m :: * -> *). Quote m => DForallTelescope -> m Exp
    lift :: forall (m :: * -> *). Quote m => DForallTelescope -> m Exp
    $cliftTyped :: forall (m :: * -> *).
    Quote m =>
    DForallTelescope -> Code m DForallTelescope
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    DForallTelescope -> Code m DForallTelescope
    Lift)

    -- | Kinds are types. Corresponds to TH's @Kind@

    type DKind = DType

    -- | Predicates are types. Corresponds to TH's @Pred@

    type DPred = DType

    -- | Corresponds to TH's @Cxt@

    type DCxt = [DPred]

    -- | Corresponds to TH's @TyVarBndr@

    data DTyVarBndr flag
      = DPlainTV Name flag
      | DKindedTV Name flag DKind
      deriving (DTyVarBndr flag -> DTyVarBndr flag -> Bool
    (DTyVarBndr flag -> DTyVarBndr flag -> Bool)
    -> (DTyVarBndr flag -> DTyVarBndr flag -> Bool)
    -> Eq (DTyVarBndr flag)
    forall flag. Eq flag => DTyVarBndr flag -> DTyVarBndr flag -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall flag. Eq flag => DTyVarBndr flag -> DTyVarBndr flag -> Bool
    == :: DTyVarBndr flag -> DTyVarBndr flag -> Bool
    $c/= :: forall flag. Eq flag => DTyVarBndr flag -> DTyVarBndr flag -> Bool
    /= :: DTyVarBndr flag -> DTyVarBndr flag -> Bool
    Eq, Int -> DTyVarBndr flag -> ShowS
    [DTyVarBndr flag] -> ShowS
    DTyVarBndr flag -> String
    (Int -> DTyVarBndr flag -> ShowS)
    -> (DTyVarBndr flag -> String)
    -> ([DTyVarBndr flag] -> ShowS)
    -> Show (DTyVarBndr flag)
    forall flag. Show flag => Int -> DTyVarBndr flag -> ShowS
    forall flag. Show flag => [DTyVarBndr flag] -> ShowS
    forall flag. Show flag => DTyVarBndr flag -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall flag. Show flag => Int -> DTyVarBndr flag -> ShowS
    showsPrec :: Int -> DTyVarBndr flag -> ShowS
    $cshow :: forall flag. Show flag => DTyVarBndr flag -> String
    show :: DTyVarBndr flag -> String
    $cshowList :: forall flag. Show flag => [DTyVarBndr flag] -> ShowS
    showList :: [DTyVarBndr flag] -> ShowS
    Show, Typeable (DTyVarBndr flag)
    Typeable (DTyVarBndr flag) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DTyVarBndr flag -> c (DTyVarBndr flag))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (DTyVarBndr flag))
    -> (DTyVarBndr flag -> Constr)
    -> (DTyVarBndr flag -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (DTyVarBndr flag)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (DTyVarBndr flag)))
    -> ((forall b. Data b => b -> b)
        -> DTyVarBndr flag -> DTyVarBndr flag)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> DTyVarBndr flag -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DTyVarBndr flag -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> DTyVarBndr flag -> m (DTyVarBndr flag))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DTyVarBndr flag -> m (DTyVarBndr flag))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DTyVarBndr flag -> m (DTyVarBndr flag))
    -> Data (DTyVarBndr flag)
    DTyVarBndr flag -> Constr
    DTyVarBndr flag -> DataType
    (forall b. Data b => b -> b) -> DTyVarBndr flag -> DTyVarBndr flag
    forall flag. Data flag => Typeable (DTyVarBndr flag)
    forall flag. Data flag => DTyVarBndr flag -> Constr
    forall flag. Data flag => DTyVarBndr flag -> DataType
    forall flag.
    Data flag =>
    (forall b. Data b => b -> b) -> DTyVarBndr flag -> DTyVarBndr flag
    forall flag u.
    Data flag =>
    Int -> (forall d. Data d => d -> u) -> DTyVarBndr flag -> u
    forall flag u.
    Data flag =>
    (forall d. Data d => d -> u) -> DTyVarBndr flag -> [u]
    forall flag r r'.
    Data flag =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
    forall flag r r'.
    Data flag =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
    forall flag (m :: * -> *).
    (Data flag, Monad m) =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag)
    forall flag (m :: * -> *).
    (Data flag, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag)
    forall flag (c :: * -> *).
    Data flag =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DTyVarBndr flag)
    forall flag (c :: * -> *).
    Data flag =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTyVarBndr flag -> c (DTyVarBndr flag)
    forall flag (t :: * -> *) (c :: * -> *).
    (Data flag, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (DTyVarBndr flag))
    forall flag (t :: * -> * -> *) (c :: * -> *).
    (Data flag, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DTyVarBndr 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) -> DTyVarBndr flag -> u
    forall u. (forall d. Data d => d -> u) -> DTyVarBndr flag -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DTyVarBndr flag)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTyVarBndr flag -> c (DTyVarBndr flag)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DTyVarBndr flag))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DTyVarBndr flag))
    $cgfoldl :: forall flag (c :: * -> *).
    Data flag =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTyVarBndr flag -> c (DTyVarBndr flag)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTyVarBndr flag -> c (DTyVarBndr flag)
    $cgunfold :: forall flag (c :: * -> *).
    Data flag =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DTyVarBndr flag)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DTyVarBndr flag)
    $ctoConstr :: forall flag. Data flag => DTyVarBndr flag -> Constr
    toConstr :: DTyVarBndr flag -> Constr
    $cdataTypeOf :: forall flag. Data flag => DTyVarBndr flag -> DataType
    dataTypeOf :: DTyVarBndr flag -> DataType
    $cdataCast1 :: forall flag (t :: * -> *) (c :: * -> *).
    (Data flag, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (DTyVarBndr flag))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DTyVarBndr flag))
    $cdataCast2 :: forall flag (t :: * -> * -> *) (c :: * -> *).
    (Data flag, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DTyVarBndr flag))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DTyVarBndr flag))
    $cgmapT :: forall flag.
    Data flag =>
    (forall b. Data b => b -> b) -> DTyVarBndr flag -> DTyVarBndr flag
    gmapT :: (forall b. Data b => b -> b) -> DTyVarBndr flag -> DTyVarBndr flag
    $cgmapQl :: forall flag r r'.
    Data flag =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
    $cgmapQr :: forall flag r r'.
    Data flag =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
    $cgmapQ :: forall flag u.
    Data flag =>
    (forall d. Data d => d -> u) -> DTyVarBndr flag -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DTyVarBndr flag -> [u]
    $cgmapQi :: forall flag u.
    Data flag =>
    Int -> (forall d. Data d => d -> u) -> DTyVarBndr flag -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DTyVarBndr flag -> u
    $cgmapM :: forall flag (m :: * -> *).
    (Data flag, Monad m) =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag)
    $cgmapMp :: forall flag (m :: * -> *).
    (Data flag, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag)
    $cgmapMo :: forall flag (m :: * -> *).
    (Data flag, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag)
    Data, (forall x. DTyVarBndr flag -> Rep (DTyVarBndr flag) x)
    -> (forall x. Rep (DTyVarBndr flag) x -> DTyVarBndr flag)
    -> Generic (DTyVarBndr flag)
    forall x. Rep (DTyVarBndr flag) x -> DTyVarBndr flag
    forall x. DTyVarBndr flag -> Rep (DTyVarBndr flag) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall flag x. Rep (DTyVarBndr flag) x -> DTyVarBndr flag
    forall flag x. DTyVarBndr flag -> Rep (DTyVarBndr flag) x
    $cfrom :: forall flag x. DTyVarBndr flag -> Rep (DTyVarBndr flag) x
    from :: forall x. DTyVarBndr flag -> Rep (DTyVarBndr flag) x
    $cto :: forall flag x. Rep (DTyVarBndr flag) x -> DTyVarBndr flag
    to :: forall x. Rep (DTyVarBndr flag) x -> DTyVarBndr flag
    Generic, (forall a b. (a -> b) -> DTyVarBndr a -> DTyVarBndr b)
    -> (forall a b. a -> DTyVarBndr b -> DTyVarBndr a)
    -> Functor DTyVarBndr
    forall a b. a -> DTyVarBndr b -> DTyVarBndr a
    forall a b. (a -> b) -> DTyVarBndr a -> DTyVarBndr b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> DTyVarBndr a -> DTyVarBndr b
    fmap :: forall a b. (a -> b) -> DTyVarBndr a -> DTyVarBndr b
    $c<$ :: forall a b. a -> DTyVarBndr b -> DTyVarBndr a
    <$ :: forall a b. a -> DTyVarBndr b -> DTyVarBndr a
    Functor, (forall (m :: * -> *). Quote m => DTyVarBndr flag -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        DTyVarBndr flag -> Code m (DTyVarBndr flag))
    -> Lift (DTyVarBndr flag)
    forall flag (m :: * -> *).
    (Lift flag, Quote m) =>
    DTyVarBndr flag -> m Exp
    forall flag (m :: * -> *).
    (Lift flag, Quote m) =>
    DTyVarBndr flag -> Code m (DTyVarBndr flag)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DTyVarBndr flag -> m Exp
    forall (m :: * -> *).
    Quote m =>
    DTyVarBndr flag -> Code m (DTyVarBndr flag)
    $clift :: forall flag (m :: * -> *).
    (Lift flag, Quote m) =>
    DTyVarBndr flag -> m Exp
    lift :: forall (m :: * -> *). Quote m => DTyVarBndr flag -> m Exp
    $cliftTyped :: forall flag (m :: * -> *).
    (Lift flag, Quote m) =>
    DTyVarBndr flag -> Code m (DTyVarBndr flag)
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    DTyVarBndr flag -> Code m (DTyVarBndr flag)
    Lift)

    -- | Corresponds to TH's @TyVarBndrSpec@

    type DTyVarBndrSpec = DTyVarBndr Specificity

    -- | Corresponds to TH's @TyVarBndrUnit@

    type DTyVarBndrUnit = DTyVarBndr ()

    -- | Corresponds to TH's @Match@ type.

    data DMatch = DMatch DPat DExp
      deriving (DMatch -> DMatch -> Bool
    (DMatch -> DMatch -> Bool)
    -> (DMatch -> DMatch -> Bool) -> Eq DMatch
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DMatch -> DMatch -> Bool
    == :: DMatch -> DMatch -> Bool
    $c/= :: DMatch -> DMatch -> Bool
    /= :: DMatch -> DMatch -> Bool
    Eq, Int -> DMatch -> ShowS
    [DMatch] -> ShowS
    DMatch -> String
    (Int -> DMatch -> ShowS)
    -> (DMatch -> String) -> ([DMatch] -> ShowS) -> Show DMatch
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DMatch -> ShowS
    showsPrec :: Int -> DMatch -> ShowS
    $cshow :: DMatch -> String
    show :: DMatch -> String
    $cshowList :: [DMatch] -> ShowS
    showList :: [DMatch] -> ShowS
    Show, Typeable DMatch
    Typeable DMatch =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DMatch -> c DMatch)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DMatch)
    -> (DMatch -> Constr)
    -> (DMatch -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DMatch))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DMatch))
    -> ((forall b. Data b => b -> b) -> DMatch -> DMatch)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DMatch -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DMatch -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DMatch -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DMatch -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DMatch -> m DMatch)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DMatch -> m DMatch)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DMatch -> m DMatch)
    -> Data DMatch
    DMatch -> Constr
    DMatch -> DataType
    (forall b. Data b => b -> b) -> DMatch -> DMatch
    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) -> DMatch -> u
    forall u. (forall d. Data d => d -> u) -> DMatch -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DMatch -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DMatch -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DMatch -> m DMatch
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DMatch -> m DMatch
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DMatch
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DMatch -> c DMatch
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DMatch)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DMatch)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DMatch -> c DMatch
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DMatch -> c DMatch
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DMatch
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DMatch
    $ctoConstr :: DMatch -> Constr
    toConstr :: DMatch -> Constr
    $cdataTypeOf :: DMatch -> DataType
    dataTypeOf :: DMatch -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DMatch)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DMatch)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DMatch)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DMatch)
    $cgmapT :: (forall b. Data b => b -> b) -> DMatch -> DMatch
    gmapT :: (forall b. Data b => b -> b) -> DMatch -> DMatch
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DMatch -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DMatch -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DMatch -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DMatch -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DMatch -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DMatch -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DMatch -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DMatch -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DMatch -> m DMatch
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DMatch -> m DMatch
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DMatch -> m DMatch
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DMatch -> m DMatch
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DMatch -> m DMatch
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DMatch -> m DMatch
    Data, (forall x. DMatch -> Rep DMatch x)
    -> (forall x. Rep DMatch x -> DMatch) -> Generic DMatch
    forall x. Rep DMatch x -> DMatch
    forall x. DMatch -> Rep DMatch x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DMatch -> Rep DMatch x
    from :: forall x. DMatch -> Rep DMatch x
    $cto :: forall x. Rep DMatch x -> DMatch
    to :: forall x. Rep DMatch x -> DMatch
    Generic, (forall (m :: * -> *). Quote m => DMatch -> m Exp)
    -> (forall (m :: * -> *). Quote m => DMatch -> Code m DMatch)
    -> Lift DMatch
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DMatch -> m Exp
    forall (m :: * -> *). Quote m => DMatch -> Code m DMatch
    $clift :: forall (m :: * -> *). Quote m => DMatch -> m Exp
    lift :: forall (m :: * -> *). Quote m => DMatch -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DMatch -> Code m DMatch
    liftTyped :: forall (m :: * -> *). Quote m => DMatch -> Code m DMatch
    Lift)

    -- | Corresponds to TH's @Clause@ type.

    data DClause = DClause [DPat] DExp
      deriving (DClause -> DClause -> Bool
    (DClause -> DClause -> Bool)
    -> (DClause -> DClause -> Bool) -> Eq DClause
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DClause -> DClause -> Bool
    == :: DClause -> DClause -> Bool
    $c/= :: DClause -> DClause -> Bool
    /= :: DClause -> DClause -> Bool
    Eq, Int -> DClause -> ShowS
    [DClause] -> ShowS
    DClause -> String
    (Int -> DClause -> ShowS)
    -> (DClause -> String) -> ([DClause] -> ShowS) -> Show DClause
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DClause -> ShowS
    showsPrec :: Int -> DClause -> ShowS
    $cshow :: DClause -> String
    show :: DClause -> String
    $cshowList :: [DClause] -> ShowS
    showList :: [DClause] -> ShowS
    Show, Typeable DClause
    Typeable DClause =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DClause -> c DClause)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DClause)
    -> (DClause -> Constr)
    -> (DClause -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DClause))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DClause))
    -> ((forall b. Data b => b -> b) -> DClause -> DClause)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DClause -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DClause -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DClause -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DClause -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DClause -> m DClause)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DClause -> m DClause)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DClause -> m DClause)
    -> Data DClause
    DClause -> Constr
    DClause -> DataType
    (forall b. Data b => b -> b) -> DClause -> DClause
    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) -> DClause -> u
    forall u. (forall d. Data d => d -> u) -> DClause -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DClause -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DClause -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DClause -> m DClause
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DClause -> m DClause
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DClause
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DClause -> c DClause
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DClause)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DClause)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DClause -> c DClause
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DClause -> c DClause
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DClause
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DClause
    $ctoConstr :: DClause -> Constr
    toConstr :: DClause -> Constr
    $cdataTypeOf :: DClause -> DataType
    dataTypeOf :: DClause -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DClause)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DClause)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DClause)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DClause)
    $cgmapT :: (forall b. Data b => b -> b) -> DClause -> DClause
    gmapT :: (forall b. Data b => b -> b) -> DClause -> DClause
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DClause -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DClause -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DClause -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DClause -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DClause -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DClause -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DClause -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DClause -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DClause -> m DClause
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DClause -> m DClause
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DClause -> m DClause
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DClause -> m DClause
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DClause -> m DClause
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DClause -> m DClause
    Data, (forall x. DClause -> Rep DClause x)
    -> (forall x. Rep DClause x -> DClause) -> Generic DClause
    forall x. Rep DClause x -> DClause
    forall x. DClause -> Rep DClause x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DClause -> Rep DClause x
    from :: forall x. DClause -> Rep DClause x
    $cto :: forall x. Rep DClause x -> DClause
    to :: forall x. Rep DClause x -> DClause
    Generic, (forall (m :: * -> *). Quote m => DClause -> m Exp)
    -> (forall (m :: * -> *). Quote m => DClause -> Code m DClause)
    -> Lift DClause
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DClause -> m Exp
    forall (m :: * -> *). Quote m => DClause -> Code m DClause
    $clift :: forall (m :: * -> *). Quote m => DClause -> m Exp
    lift :: forall (m :: * -> *). Quote m => DClause -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DClause -> Code m DClause
    liftTyped :: forall (m :: * -> *). Quote m => DClause -> Code m DClause
    Lift)

    -- | Declarations as used in a @let@ statement.

    data DLetDec = DFunD Name [DClause]
                 | DValD DPat DExp
                 | DSigD Name DType
                 | DInfixD Fixity Name
                 | DPragmaD DPragma
                 deriving (DLetDec -> DLetDec -> Bool
    (DLetDec -> DLetDec -> Bool)
    -> (DLetDec -> DLetDec -> Bool) -> Eq DLetDec
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DLetDec -> DLetDec -> Bool
    == :: DLetDec -> DLetDec -> Bool
    $c/= :: DLetDec -> DLetDec -> Bool
    /= :: DLetDec -> DLetDec -> Bool
    Eq, Int -> DLetDec -> ShowS
    [DLetDec] -> ShowS
    DLetDec -> String
    (Int -> DLetDec -> ShowS)
    -> (DLetDec -> String) -> ([DLetDec] -> ShowS) -> Show DLetDec
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DLetDec -> ShowS
    showsPrec :: Int -> DLetDec -> ShowS
    $cshow :: DLetDec -> String
    show :: DLetDec -> String
    $cshowList :: [DLetDec] -> ShowS
    showList :: [DLetDec] -> ShowS
    Show, Typeable DLetDec
    Typeable DLetDec =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DLetDec -> c DLetDec)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DLetDec)
    -> (DLetDec -> Constr)
    -> (DLetDec -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DLetDec))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DLetDec))
    -> ((forall b. Data b => b -> b) -> DLetDec -> DLetDec)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DLetDec -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DLetDec -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DLetDec -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DLetDec -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec)
    -> Data DLetDec
    DLetDec -> Constr
    DLetDec -> DataType
    (forall b. Data b => b -> b) -> DLetDec -> DLetDec
    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) -> DLetDec -> u
    forall u. (forall d. Data d => d -> u) -> DLetDec -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DLetDec -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DLetDec -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DLetDec
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DLetDec -> c DLetDec
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DLetDec)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DLetDec)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DLetDec -> c DLetDec
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DLetDec -> c DLetDec
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DLetDec
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DLetDec
    $ctoConstr :: DLetDec -> Constr
    toConstr :: DLetDec -> Constr
    $cdataTypeOf :: DLetDec -> DataType
    dataTypeOf :: DLetDec -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DLetDec)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DLetDec)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DLetDec)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DLetDec)
    $cgmapT :: (forall b. Data b => b -> b) -> DLetDec -> DLetDec
    gmapT :: (forall b. Data b => b -> b) -> DLetDec -> DLetDec
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DLetDec -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DLetDec -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DLetDec -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DLetDec -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DLetDec -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DLetDec -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DLetDec -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DLetDec -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec
    Data, (forall x. DLetDec -> Rep DLetDec x)
    -> (forall x. Rep DLetDec x -> DLetDec) -> Generic DLetDec
    forall x. Rep DLetDec x -> DLetDec
    forall x. DLetDec -> Rep DLetDec x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DLetDec -> Rep DLetDec x
    from :: forall x. DLetDec -> Rep DLetDec x
    $cto :: forall x. Rep DLetDec x -> DLetDec
    to :: forall x. Rep DLetDec x -> DLetDec
    Generic, (forall (m :: * -> *). Quote m => DLetDec -> m Exp)
    -> (forall (m :: * -> *). Quote m => DLetDec -> Code m DLetDec)
    -> Lift DLetDec
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DLetDec -> m Exp
    forall (m :: * -> *). Quote m => DLetDec -> Code m DLetDec
    $clift :: forall (m :: * -> *). Quote m => DLetDec -> m Exp
    lift :: forall (m :: * -> *). Quote m => DLetDec -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DLetDec -> Code m DLetDec
    liftTyped :: forall (m :: * -> *). Quote m => DLetDec -> Code m DLetDec
    Lift)

    -- | Corresponds to TH's @Dec@ type.

    data DDec = DLetDec DLetDec
                -- | An ordinary (i.e., non-data family) data type declaration. Note

                -- that desugaring upholds the following properties regarding the

                -- 'DataFlavor' field:

                --

                -- * If the 'DataFlavor' is 'NewType', then there will be exactly

                --   one 'DCon'.

                --

                -- * If the 'DataFlavor' is 'TypeData', then there will be no

                --   'DDerivClause's, the 'DCxt' will be empty, and the 'DConFields'

                --   in each 'DCon' will be a 'NormalC' where each 'Bang' is equal

                --   to @Bang 'NoSourceUnpackedness' 'NoSourceStrictness'@.

              | DDataD DataFlavor DCxt Name [DTyVarBndrUnit] (Maybe DKind) [DCon] [DDerivClause]
              | DTySynD Name [DTyVarBndrUnit] DType
              | DClassD DCxt Name [DTyVarBndrUnit] [FunDep] [DDec]
                -- | Note that the @Maybe [DTyVarBndrUnit]@ field is dropped

                -- entirely when sweetened, so it is only useful for functions

                -- that directly consume @DDec@s.

              | DInstanceD (Maybe Overlap) (Maybe [DTyVarBndrUnit]) DCxt DType [DDec]
              | DForeignD DForeign
              | DOpenTypeFamilyD DTypeFamilyHead
              | DClosedTypeFamilyD DTypeFamilyHead [DTySynEqn]
              | DDataFamilyD Name [DTyVarBndrUnit] (Maybe DKind)
                -- | A data family instance declaration. Note that desugaring

                -- upholds the following properties regarding the 'DataFlavor'

                -- field:

                --

                -- * If the 'DataFlavor' is 'NewType', then there will be exactly

                --   one 'DCon'.

                --

                -- * The 'DataFlavor' will never be 'TypeData', as GHC does not

                --   permit combining data families with @type data@.

              | DDataInstD DataFlavor DCxt (Maybe [DTyVarBndrUnit]) DType (Maybe DKind)
                           [DCon] [DDerivClause]
              | DTySynInstD DTySynEqn
              | DRoleAnnotD Name [Role]
                -- | Note that the @Maybe [DTyVarBndrUnit]@ field is dropped

                -- entirely when sweetened, so it is only useful for functions

                -- that directly consume @DDec@s.

              | DStandaloneDerivD (Maybe DDerivStrategy) (Maybe [DTyVarBndrUnit]) DCxt DType
              | DDefaultSigD Name DType
              | DPatSynD Name PatSynArgs DPatSynDir DPat
              | DPatSynSigD Name DPatSynType
              | DKiSigD Name DKind
                  -- DKiSigD is part of DDec, not DLetDec, because standalone kind

                  -- signatures can only appear on the top level.

              | DDefaultD [DType]
              deriving (DDec -> DDec -> Bool
    (DDec -> DDec -> Bool) -> (DDec -> DDec -> Bool) -> Eq DDec
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DDec -> DDec -> Bool
    == :: DDec -> DDec -> Bool
    $c/= :: DDec -> DDec -> Bool
    /= :: DDec -> DDec -> Bool
    Eq, Int -> DDec -> ShowS
    [DDec] -> ShowS
    DDec -> String
    (Int -> DDec -> ShowS)
    -> (DDec -> String) -> ([DDec] -> ShowS) -> Show DDec
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DDec -> ShowS
    showsPrec :: Int -> DDec -> ShowS
    $cshow :: DDec -> String
    show :: DDec -> String
    $cshowList :: [DDec] -> ShowS
    showList :: [DDec] -> ShowS
    Show, Typeable DDec
    Typeable DDec =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DDec -> c DDec)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DDec)
    -> (DDec -> Constr)
    -> (DDec -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DDec))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DDec))
    -> ((forall b. Data b => b -> b) -> DDec -> DDec)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DDec -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DDec -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DDec -> m DDec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DDec -> m DDec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DDec -> m DDec)
    -> Data DDec
    DDec -> Constr
    DDec -> DataType
    (forall b. Data b => b -> b) -> DDec -> DDec
    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) -> DDec -> u
    forall u. (forall d. Data d => d -> u) -> DDec -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DDec -> m DDec
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDec -> m DDec
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDec
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDec -> c DDec
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDec)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DDec)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDec -> c DDec
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDec -> c DDec
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDec
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDec
    $ctoConstr :: DDec -> Constr
    toConstr :: DDec -> Constr
    $cdataTypeOf :: DDec -> DataType
    dataTypeOf :: DDec -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDec)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDec)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DDec)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DDec)
    $cgmapT :: (forall b. Data b => b -> b) -> DDec -> DDec
    gmapT :: (forall b. Data b => b -> b) -> DDec -> DDec
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DDec -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DDec -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DDec -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DDec -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DDec -> m DDec
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DDec -> m DDec
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDec -> m DDec
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDec -> m DDec
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDec -> m DDec
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDec -> m DDec
    Data, (forall x. DDec -> Rep DDec x)
    -> (forall x. Rep DDec x -> DDec) -> Generic DDec
    forall x. Rep DDec x -> DDec
    forall x. DDec -> Rep DDec x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DDec -> Rep DDec x
    from :: forall x. DDec -> Rep DDec x
    $cto :: forall x. Rep DDec x -> DDec
    to :: forall x. Rep DDec x -> DDec
    Generic, (forall (m :: * -> *). Quote m => DDec -> m Exp)
    -> (forall (m :: * -> *). Quote m => DDec -> Code m DDec)
    -> Lift DDec
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DDec -> m Exp
    forall (m :: * -> *). Quote m => DDec -> Code m DDec
    $clift :: forall (m :: * -> *). Quote m => DDec -> m Exp
    lift :: forall (m :: * -> *). Quote m => DDec -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DDec -> Code m DDec
    liftTyped :: forall (m :: * -> *). Quote m => DDec -> Code m DDec
    Lift)

    -- | Corresponds to TH's 'PatSynDir' type

    data DPatSynDir = DUnidir              -- ^ @pattern P x {<-} p@

                    | DImplBidir           -- ^ @pattern P x {=} p@

                    | DExplBidir [DClause] -- ^ @pattern P x {<-} p where P x = e@

                    deriving (DPatSynDir -> DPatSynDir -> Bool
    (DPatSynDir -> DPatSynDir -> Bool)
    -> (DPatSynDir -> DPatSynDir -> Bool) -> Eq DPatSynDir
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DPatSynDir -> DPatSynDir -> Bool
    == :: DPatSynDir -> DPatSynDir -> Bool
    $c/= :: DPatSynDir -> DPatSynDir -> Bool
    /= :: DPatSynDir -> DPatSynDir -> Bool
    Eq, Int -> DPatSynDir -> ShowS
    [DPatSynDir] -> ShowS
    DPatSynDir -> String
    (Int -> DPatSynDir -> ShowS)
    -> (DPatSynDir -> String)
    -> ([DPatSynDir] -> ShowS)
    -> Show DPatSynDir
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DPatSynDir -> ShowS
    showsPrec :: Int -> DPatSynDir -> ShowS
    $cshow :: DPatSynDir -> String
    show :: DPatSynDir -> String
    $cshowList :: [DPatSynDir] -> ShowS
    showList :: [DPatSynDir] -> ShowS
    Show, Typeable DPatSynDir
    Typeable DPatSynDir =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DPatSynDir -> c DPatSynDir)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DPatSynDir)
    -> (DPatSynDir -> Constr)
    -> (DPatSynDir -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DPatSynDir))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DPatSynDir))
    -> ((forall b. Data b => b -> b) -> DPatSynDir -> DPatSynDir)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DPatSynDir -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DPatSynDir -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir)
    -> Data DPatSynDir
    DPatSynDir -> Constr
    DPatSynDir -> DataType
    (forall b. Data b => b -> b) -> DPatSynDir -> DPatSynDir
    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) -> DPatSynDir -> u
    forall u. (forall d. Data d => d -> u) -> DPatSynDir -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPatSynDir
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPatSynDir -> c DPatSynDir
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPatSynDir)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPatSynDir)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPatSynDir -> c DPatSynDir
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPatSynDir -> c DPatSynDir
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPatSynDir
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPatSynDir
    $ctoConstr :: DPatSynDir -> Constr
    toConstr :: DPatSynDir -> Constr
    $cdataTypeOf :: DPatSynDir -> DataType
    dataTypeOf :: DPatSynDir -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPatSynDir)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPatSynDir)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPatSynDir)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPatSynDir)
    $cgmapT :: (forall b. Data b => b -> b) -> DPatSynDir -> DPatSynDir
    gmapT :: (forall b. Data b => b -> b) -> DPatSynDir -> DPatSynDir
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DPatSynDir -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DPatSynDir -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPatSynDir -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPatSynDir -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir
    Data, (forall x. DPatSynDir -> Rep DPatSynDir x)
    -> (forall x. Rep DPatSynDir x -> DPatSynDir) -> Generic DPatSynDir
    forall x. Rep DPatSynDir x -> DPatSynDir
    forall x. DPatSynDir -> Rep DPatSynDir x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DPatSynDir -> Rep DPatSynDir x
    from :: forall x. DPatSynDir -> Rep DPatSynDir x
    $cto :: forall x. Rep DPatSynDir x -> DPatSynDir
    to :: forall x. Rep DPatSynDir x -> DPatSynDir
    Generic, (forall (m :: * -> *). Quote m => DPatSynDir -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        DPatSynDir -> Code m DPatSynDir)
    -> Lift DPatSynDir
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DPatSynDir -> m Exp
    forall (m :: * -> *). Quote m => DPatSynDir -> Code m DPatSynDir
    $clift :: forall (m :: * -> *). Quote m => DPatSynDir -> m Exp
    lift :: forall (m :: * -> *). Quote m => DPatSynDir -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DPatSynDir -> Code m DPatSynDir
    liftTyped :: forall (m :: * -> *). Quote m => DPatSynDir -> Code m DPatSynDir
    Lift)

    -- | Corresponds to TH's 'PatSynType' type

    type DPatSynType = DType

    #if __GLASGOW_HASKELL__ < 801
    -- | Same as @PatSynArgs@ from TH; defined here for backwards compatibility.

    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 (Eq, Show, Data, Generic, Lift)
    #endif

    -- | Corresponds to TH's 'TypeFamilyHead' type

    data DTypeFamilyHead = DTypeFamilyHead Name [DTyVarBndrUnit] DFamilyResultSig
                                           (Maybe InjectivityAnn)
                         deriving (DTypeFamilyHead -> DTypeFamilyHead -> Bool
    (DTypeFamilyHead -> DTypeFamilyHead -> Bool)
    -> (DTypeFamilyHead -> DTypeFamilyHead -> Bool)
    -> Eq DTypeFamilyHead
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
    == :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
    $c/= :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
    /= :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
    Eq, Int -> DTypeFamilyHead -> ShowS
    [DTypeFamilyHead] -> ShowS
    DTypeFamilyHead -> String
    (Int -> DTypeFamilyHead -> ShowS)
    -> (DTypeFamilyHead -> String)
    -> ([DTypeFamilyHead] -> ShowS)
    -> Show DTypeFamilyHead
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DTypeFamilyHead -> ShowS
    showsPrec :: Int -> DTypeFamilyHead -> ShowS
    $cshow :: DTypeFamilyHead -> String
    show :: DTypeFamilyHead -> String
    $cshowList :: [DTypeFamilyHead] -> ShowS
    showList :: [DTypeFamilyHead] -> ShowS
    Show, Typeable DTypeFamilyHead
    Typeable DTypeFamilyHead =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DTypeFamilyHead -> c DTypeFamilyHead)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DTypeFamilyHead)
    -> (DTypeFamilyHead -> Constr)
    -> (DTypeFamilyHead -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DTypeFamilyHead))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DTypeFamilyHead))
    -> ((forall b. Data b => b -> b)
        -> DTypeFamilyHead -> DTypeFamilyHead)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> DTypeFamilyHead -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DTypeFamilyHead -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> DTypeFamilyHead -> m DTypeFamilyHead)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DTypeFamilyHead -> m DTypeFamilyHead)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DTypeFamilyHead -> m DTypeFamilyHead)
    -> Data DTypeFamilyHead
    DTypeFamilyHead -> Constr
    DTypeFamilyHead -> DataType
    (forall b. Data b => b -> b) -> DTypeFamilyHead -> DTypeFamilyHead
    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) -> DTypeFamilyHead -> u
    forall u. (forall d. Data d => d -> u) -> DTypeFamilyHead -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DTypeFamilyHead -> m DTypeFamilyHead
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTypeFamilyHead -> m DTypeFamilyHead
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DTypeFamilyHead
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTypeFamilyHead -> c DTypeFamilyHead
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DTypeFamilyHead)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DTypeFamilyHead)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTypeFamilyHead -> c DTypeFamilyHead
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTypeFamilyHead -> c DTypeFamilyHead
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DTypeFamilyHead
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DTypeFamilyHead
    $ctoConstr :: DTypeFamilyHead -> Constr
    toConstr :: DTypeFamilyHead -> Constr
    $cdataTypeOf :: DTypeFamilyHead -> DataType
    dataTypeOf :: DTypeFamilyHead -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DTypeFamilyHead)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DTypeFamilyHead)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DTypeFamilyHead)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DTypeFamilyHead)
    $cgmapT :: (forall b. Data b => b -> b) -> DTypeFamilyHead -> DTypeFamilyHead
    gmapT :: (forall b. Data b => b -> b) -> DTypeFamilyHead -> DTypeFamilyHead
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DTypeFamilyHead -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DTypeFamilyHead -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DTypeFamilyHead -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DTypeFamilyHead -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DTypeFamilyHead -> m DTypeFamilyHead
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DTypeFamilyHead -> m DTypeFamilyHead
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTypeFamilyHead -> m DTypeFamilyHead
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTypeFamilyHead -> m DTypeFamilyHead
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTypeFamilyHead -> m DTypeFamilyHead
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTypeFamilyHead -> m DTypeFamilyHead
    Data, (forall x. DTypeFamilyHead -> Rep DTypeFamilyHead x)
    -> (forall x. Rep DTypeFamilyHead x -> DTypeFamilyHead)
    -> Generic DTypeFamilyHead
    forall x. Rep DTypeFamilyHead x -> DTypeFamilyHead
    forall x. DTypeFamilyHead -> Rep DTypeFamilyHead x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DTypeFamilyHead -> Rep DTypeFamilyHead x
    from :: forall x. DTypeFamilyHead -> Rep DTypeFamilyHead x
    $cto :: forall x. Rep DTypeFamilyHead x -> DTypeFamilyHead
    to :: forall x. Rep DTypeFamilyHead x -> DTypeFamilyHead
    Generic, (forall (m :: * -> *). Quote m => DTypeFamilyHead -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        DTypeFamilyHead -> Code m DTypeFamilyHead)
    -> Lift DTypeFamilyHead
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DTypeFamilyHead -> m Exp
    forall (m :: * -> *).
    Quote m =>
    DTypeFamilyHead -> Code m DTypeFamilyHead
    $clift :: forall (m :: * -> *). Quote m => DTypeFamilyHead -> m Exp
    lift :: forall (m :: * -> *). Quote m => DTypeFamilyHead -> m Exp
    $cliftTyped :: forall (m :: * -> *).
    Quote m =>
    DTypeFamilyHead -> Code m DTypeFamilyHead
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    DTypeFamilyHead -> Code m DTypeFamilyHead
    Lift)

    -- | Corresponds to TH's 'FamilyResultSig' type

    data DFamilyResultSig = DNoSig
                          | DKindSig DKind
                          | DTyVarSig DTyVarBndrUnit
                          deriving (DFamilyResultSig -> DFamilyResultSig -> Bool
    (DFamilyResultSig -> DFamilyResultSig -> Bool)
    -> (DFamilyResultSig -> DFamilyResultSig -> Bool)
    -> Eq DFamilyResultSig
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DFamilyResultSig -> DFamilyResultSig -> Bool
    == :: DFamilyResultSig -> DFamilyResultSig -> Bool
    $c/= :: DFamilyResultSig -> DFamilyResultSig -> Bool
    /= :: DFamilyResultSig -> DFamilyResultSig -> Bool
    Eq, Int -> DFamilyResultSig -> ShowS
    [DFamilyResultSig] -> ShowS
    DFamilyResultSig -> String
    (Int -> DFamilyResultSig -> ShowS)
    -> (DFamilyResultSig -> String)
    -> ([DFamilyResultSig] -> ShowS)
    -> Show DFamilyResultSig
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DFamilyResultSig -> ShowS
    showsPrec :: Int -> DFamilyResultSig -> ShowS
    $cshow :: DFamilyResultSig -> String
    show :: DFamilyResultSig -> String
    $cshowList :: [DFamilyResultSig] -> ShowS
    showList :: [DFamilyResultSig] -> ShowS
    Show, Typeable DFamilyResultSig
    Typeable DFamilyResultSig =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DFamilyResultSig -> c DFamilyResultSig)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DFamilyResultSig)
    -> (DFamilyResultSig -> Constr)
    -> (DFamilyResultSig -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DFamilyResultSig))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DFamilyResultSig))
    -> ((forall b. Data b => b -> b)
        -> DFamilyResultSig -> DFamilyResultSig)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DFamilyResultSig -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DFamilyResultSig -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> DFamilyResultSig -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DFamilyResultSig -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> DFamilyResultSig -> m DFamilyResultSig)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DFamilyResultSig -> m DFamilyResultSig)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DFamilyResultSig -> m DFamilyResultSig)
    -> Data DFamilyResultSig
    DFamilyResultSig -> Constr
    DFamilyResultSig -> DataType
    (forall b. Data b => b -> b)
    -> DFamilyResultSig -> DFamilyResultSig
    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) -> DFamilyResultSig -> u
    forall u. (forall d. Data d => d -> u) -> DFamilyResultSig -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DFamilyResultSig -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DFamilyResultSig -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DFamilyResultSig -> m DFamilyResultSig
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DFamilyResultSig -> m DFamilyResultSig
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DFamilyResultSig
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DFamilyResultSig -> c DFamilyResultSig
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DFamilyResultSig)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DFamilyResultSig)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DFamilyResultSig -> c DFamilyResultSig
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DFamilyResultSig -> c DFamilyResultSig
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DFamilyResultSig
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DFamilyResultSig
    $ctoConstr :: DFamilyResultSig -> Constr
    toConstr :: DFamilyResultSig -> Constr
    $cdataTypeOf :: DFamilyResultSig -> DataType
    dataTypeOf :: DFamilyResultSig -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DFamilyResultSig)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DFamilyResultSig)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DFamilyResultSig)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DFamilyResultSig)
    $cgmapT :: (forall b. Data b => b -> b)
    -> DFamilyResultSig -> DFamilyResultSig
    gmapT :: (forall b. Data b => b -> b)
    -> DFamilyResultSig -> DFamilyResultSig
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DFamilyResultSig -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DFamilyResultSig -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DFamilyResultSig -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DFamilyResultSig -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DFamilyResultSig -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DFamilyResultSig -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DFamilyResultSig -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DFamilyResultSig -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DFamilyResultSig -> m DFamilyResultSig
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DFamilyResultSig -> m DFamilyResultSig
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DFamilyResultSig -> m DFamilyResultSig
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DFamilyResultSig -> m DFamilyResultSig
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DFamilyResultSig -> m DFamilyResultSig
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DFamilyResultSig -> m DFamilyResultSig
    Data, (forall x. DFamilyResultSig -> Rep DFamilyResultSig x)
    -> (forall x. Rep DFamilyResultSig x -> DFamilyResultSig)
    -> Generic DFamilyResultSig
    forall x. Rep DFamilyResultSig x -> DFamilyResultSig
    forall x. DFamilyResultSig -> Rep DFamilyResultSig x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DFamilyResultSig -> Rep DFamilyResultSig x
    from :: forall x. DFamilyResultSig -> Rep DFamilyResultSig x
    $cto :: forall x. Rep DFamilyResultSig x -> DFamilyResultSig
    to :: forall x. Rep DFamilyResultSig x -> DFamilyResultSig
    Generic, (forall (m :: * -> *). Quote m => DFamilyResultSig -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        DFamilyResultSig -> Code m DFamilyResultSig)
    -> Lift DFamilyResultSig
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DFamilyResultSig -> m Exp
    forall (m :: * -> *).
    Quote m =>
    DFamilyResultSig -> Code m DFamilyResultSig
    $clift :: forall (m :: * -> *). Quote m => DFamilyResultSig -> m Exp
    lift :: forall (m :: * -> *). Quote m => DFamilyResultSig -> m Exp
    $cliftTyped :: forall (m :: * -> *).
    Quote m =>
    DFamilyResultSig -> Code m DFamilyResultSig
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    DFamilyResultSig -> Code m DFamilyResultSig
    Lift)

    -- | Corresponds to TH's 'Con' type. Unlike 'Con', all 'DCon's reflect GADT

    -- syntax. This is beneficial for @th-desugar@'s since it means

    -- that all data type declarations can support explicit return kinds, so

    -- one does not need to represent them with something like @'Maybe' 'DKind'@,

    -- since Haskell98-style data declaration syntax isn't used. Accordingly,

    -- there are some differences between 'DCon' and 'Con' to keep in mind:

    --

    -- * Unlike 'ForallC', where the meaning of the 'TyVarBndr's changes depending

    --   on whether it's followed by 'GadtC'/'RecGadtC' or not, the meaning of the

    --   'DTyVarBndr's in a 'DCon' is always the same: it is the list of

    --   universally /and/ existentially quantified type variables. Note that it is

    --   not guaranteed that one set of type variables will appear before the

    --   other.

    --

    -- * A 'DCon' always has an explicit return type.

    data DCon = DCon [DTyVarBndrSpec] DCxt Name DConFields
                     DType  -- ^ The GADT result type

              deriving (DCon -> DCon -> Bool
    (DCon -> DCon -> Bool) -> (DCon -> DCon -> Bool) -> Eq DCon
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DCon -> DCon -> Bool
    == :: DCon -> DCon -> Bool
    $c/= :: DCon -> DCon -> Bool
    /= :: DCon -> DCon -> Bool
    Eq, Int -> DCon -> ShowS
    [DCon] -> ShowS
    DCon -> String
    (Int -> DCon -> ShowS)
    -> (DCon -> String) -> ([DCon] -> ShowS) -> Show DCon
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DCon -> ShowS
    showsPrec :: Int -> DCon -> ShowS
    $cshow :: DCon -> String
    show :: DCon -> String
    $cshowList :: [DCon] -> ShowS
    showList :: [DCon] -> ShowS
    Show, Typeable DCon
    Typeable DCon =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DCon -> c DCon)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DCon)
    -> (DCon -> Constr)
    -> (DCon -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DCon))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DCon))
    -> ((forall b. Data b => b -> b) -> DCon -> DCon)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DCon -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DCon -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DCon -> m DCon)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DCon -> m DCon)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DCon -> m DCon)
    -> Data DCon
    DCon -> Constr
    DCon -> DataType
    (forall b. Data b => b -> b) -> DCon -> DCon
    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) -> DCon -> u
    forall u. (forall d. Data d => d -> u) -> DCon -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DCon -> m DCon
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DCon -> m DCon
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DCon
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DCon -> c DCon
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DCon)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DCon)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DCon -> c DCon
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DCon -> c DCon
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DCon
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DCon
    $ctoConstr :: DCon -> Constr
    toConstr :: DCon -> Constr
    $cdataTypeOf :: DCon -> DataType
    dataTypeOf :: DCon -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DCon)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DCon)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DCon)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DCon)
    $cgmapT :: (forall b. Data b => b -> b) -> DCon -> DCon
    gmapT :: (forall b. Data b => b -> b) -> DCon -> DCon
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DCon -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DCon -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DCon -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DCon -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DCon -> m DCon
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DCon -> m DCon
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DCon -> m DCon
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DCon -> m DCon
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DCon -> m DCon
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DCon -> m DCon
    Data, (forall x. DCon -> Rep DCon x)
    -> (forall x. Rep DCon x -> DCon) -> Generic DCon
    forall x. Rep DCon x -> DCon
    forall x. DCon -> Rep DCon x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DCon -> Rep DCon x
    from :: forall x. DCon -> Rep DCon x
    $cto :: forall x. Rep DCon x -> DCon
    to :: forall x. Rep DCon x -> DCon
    Generic, (forall (m :: * -> *). Quote m => DCon -> m Exp)
    -> (forall (m :: * -> *). Quote m => DCon -> Code m DCon)
    -> Lift DCon
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DCon -> m Exp
    forall (m :: * -> *). Quote m => DCon -> Code m DCon
    $clift :: forall (m :: * -> *). Quote m => DCon -> m Exp
    lift :: forall (m :: * -> *). Quote m => DCon -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DCon -> Code m DCon
    liftTyped :: forall (m :: * -> *). Quote m => DCon -> Code m DCon
    Lift)

    -- | A list of fields either for a standard data constructor or a record

    -- data constructor.

    data DConFields = DNormalC DDeclaredInfix [DBangType]
                    | DRecC [DVarBangType]
                    deriving (DConFields -> DConFields -> Bool
    (DConFields -> DConFields -> Bool)
    -> (DConFields -> DConFields -> Bool) -> Eq DConFields
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DConFields -> DConFields -> Bool
    == :: DConFields -> DConFields -> Bool
    $c/= :: DConFields -> DConFields -> Bool
    /= :: DConFields -> DConFields -> Bool
    Eq, Int -> DConFields -> ShowS
    [DConFields] -> ShowS
    DConFields -> String
    (Int -> DConFields -> ShowS)
    -> (DConFields -> String)
    -> ([DConFields] -> ShowS)
    -> Show DConFields
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DConFields -> ShowS
    showsPrec :: Int -> DConFields -> ShowS
    $cshow :: DConFields -> String
    show :: DConFields -> String
    $cshowList :: [DConFields] -> ShowS
    showList :: [DConFields] -> ShowS
    Show, Typeable DConFields
    Typeable DConFields =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DConFields -> c DConFields)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DConFields)
    -> (DConFields -> Constr)
    -> (DConFields -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DConFields))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DConFields))
    -> ((forall b. Data b => b -> b) -> DConFields -> DConFields)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DConFields -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DConFields -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DConFields -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DConFields -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DConFields -> m DConFields)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DConFields -> m DConFields)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DConFields -> m DConFields)
    -> Data DConFields
    DConFields -> Constr
    DConFields -> DataType
    (forall b. Data b => b -> b) -> DConFields -> DConFields
    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) -> DConFields -> u
    forall u. (forall d. Data d => d -> u) -> DConFields -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DConFields -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DConFields -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DConFields -> m DConFields
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DConFields -> m DConFields
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DConFields
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DConFields -> c DConFields
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DConFields)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DConFields)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DConFields -> c DConFields
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DConFields -> c DConFields
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DConFields
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DConFields
    $ctoConstr :: DConFields -> Constr
    toConstr :: DConFields -> Constr
    $cdataTypeOf :: DConFields -> DataType
    dataTypeOf :: DConFields -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DConFields)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DConFields)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DConFields)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DConFields)
    $cgmapT :: (forall b. Data b => b -> b) -> DConFields -> DConFields
    gmapT :: (forall b. Data b => b -> b) -> DConFields -> DConFields
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DConFields -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DConFields -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DConFields -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DConFields -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DConFields -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DConFields -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DConFields -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DConFields -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DConFields -> m DConFields
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DConFields -> m DConFields
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DConFields -> m DConFields
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DConFields -> m DConFields
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DConFields -> m DConFields
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DConFields -> m DConFields
    Data, (forall x. DConFields -> Rep DConFields x)
    -> (forall x. Rep DConFields x -> DConFields) -> Generic DConFields
    forall x. Rep DConFields x -> DConFields
    forall x. DConFields -> Rep DConFields x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DConFields -> Rep DConFields x
    from :: forall x. DConFields -> Rep DConFields x
    $cto :: forall x. Rep DConFields x -> DConFields
    to :: forall x. Rep DConFields x -> DConFields
    Generic, (forall (m :: * -> *). Quote m => DConFields -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        DConFields -> Code m DConFields)
    -> Lift DConFields
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DConFields -> m Exp
    forall (m :: * -> *). Quote m => DConFields -> Code m DConFields
    $clift :: forall (m :: * -> *). Quote m => DConFields -> m Exp
    lift :: forall (m :: * -> *). Quote m => DConFields -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DConFields -> Code m DConFields
    liftTyped :: forall (m :: * -> *). Quote m => DConFields -> Code m DConFields
    Lift)

    -- | 'True' if a constructor is declared infix. For normal ADTs, this means

    -- that is was written in infix style. For example, both of the constructors

    -- below are declared infix.

    --

    -- @

    -- data Infix = Int `Infix` Int | Int :*: Int

    -- @

    --

    -- Whereas neither of these constructors are declared infix:

    --

    -- @

    -- data Prefix = Prefix Int Int | (:+:) Int Int

    -- @

    --

    -- For GADTs, detecting whether a constructor is declared infix is a bit

    -- trickier, as one cannot write a GADT constructor "infix-style" like one

    -- can for normal ADT constructors. GHC considers a GADT constructor to be

    -- declared infix if it meets the following three criteria:

    --

    -- 1. Its name uses operator syntax (e.g., @(:*:)@).

    -- 2. It has exactly two fields (without record syntax).

    -- 3. It has a programmer-specified fixity declaration.

    --

    -- For example, in the following GADT:

    --

    -- @

    -- infixl 5 :**:, :&&:, :^^:, `ActuallyPrefix`

    -- data InfixGADT a where

    --   (:**:) :: Int -> b -> InfixGADT (Maybe b) -- Only this one is infix

    --   ActuallyPrefix :: Char -> Bool -> InfixGADT Double

    --   (:&&:) :: { infixGADT1 :: b, infixGADT2 :: Int } -> InfixGADT [b]

    --   (:^^:) :: Int -> Int -> Int -> InfixGADT Int

    --   (:!!:) :: Char -> Char -> InfixGADT Char

    -- @

    --

    -- Only the @(:**:)@ constructor is declared infix. The other constructors

    -- are not declared infix, because:

    --

    -- * @ActuallyPrefix@ does not use operator syntax (criterion 1).

    -- * @(:&&:)@ uses record syntax (criterion 2).

    -- * @(:^^:)@ does not have exactly two fields (criterion 2).

    -- * @(:!!:)@ does not have a programmer-specified fixity declaration (criterion 3).

    type DDeclaredInfix = Bool

    -- | Corresponds to TH's @BangType@ type.

    type DBangType = (Bang, DType)

    -- | Corresponds to TH's @VarBangType@ type.

    type DVarBangType = (Name, Bang, DType)

    -- | Corresponds to TH's @Foreign@ type.

    data DForeign = DImportF Callconv Safety String Name DType
                  | DExportF Callconv String Name DType
                  deriving (DForeign -> DForeign -> Bool
    (DForeign -> DForeign -> Bool)
    -> (DForeign -> DForeign -> Bool) -> Eq DForeign
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DForeign -> DForeign -> Bool
    == :: DForeign -> DForeign -> Bool
    $c/= :: DForeign -> DForeign -> Bool
    /= :: DForeign -> DForeign -> Bool
    Eq, Int -> DForeign -> ShowS
    [DForeign] -> ShowS
    DForeign -> String
    (Int -> DForeign -> ShowS)
    -> (DForeign -> String) -> ([DForeign] -> ShowS) -> Show DForeign
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DForeign -> ShowS
    showsPrec :: Int -> DForeign -> ShowS
    $cshow :: DForeign -> String
    show :: DForeign -> String
    $cshowList :: [DForeign] -> ShowS
    showList :: [DForeign] -> ShowS
    Show, Typeable DForeign
    Typeable DForeign =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DForeign -> c DForeign)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DForeign)
    -> (DForeign -> Constr)
    -> (DForeign -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DForeign))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DForeign))
    -> ((forall b. Data b => b -> b) -> DForeign -> DForeign)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DForeign -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DForeign -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DForeign -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DForeign -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DForeign -> m DForeign)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DForeign -> m DForeign)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DForeign -> m DForeign)
    -> Data DForeign
    DForeign -> Constr
    DForeign -> DataType
    (forall b. Data b => b -> b) -> DForeign -> DForeign
    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) -> DForeign -> u
    forall u. (forall d. Data d => d -> u) -> DForeign -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DForeign -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DForeign -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DForeign -> m DForeign
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DForeign -> m DForeign
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DForeign
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DForeign -> c DForeign
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DForeign)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DForeign)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DForeign -> c DForeign
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DForeign -> c DForeign
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DForeign
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DForeign
    $ctoConstr :: DForeign -> Constr
    toConstr :: DForeign -> Constr
    $cdataTypeOf :: DForeign -> DataType
    dataTypeOf :: DForeign -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DForeign)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DForeign)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DForeign)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DForeign)
    $cgmapT :: (forall b. Data b => b -> b) -> DForeign -> DForeign
    gmapT :: (forall b. Data b => b -> b) -> DForeign -> DForeign
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DForeign -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DForeign -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DForeign -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DForeign -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DForeign -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DForeign -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DForeign -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DForeign -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DForeign -> m DForeign
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DForeign -> m DForeign
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DForeign -> m DForeign
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DForeign -> m DForeign
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DForeign -> m DForeign
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DForeign -> m DForeign
    Data, (forall x. DForeign -> Rep DForeign x)
    -> (forall x. Rep DForeign x -> DForeign) -> Generic DForeign
    forall x. Rep DForeign x -> DForeign
    forall x. DForeign -> Rep DForeign x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DForeign -> Rep DForeign x
    from :: forall x. DForeign -> Rep DForeign x
    $cto :: forall x. Rep DForeign x -> DForeign
    to :: forall x. Rep DForeign x -> DForeign
    Generic, (forall (m :: * -> *). Quote m => DForeign -> m Exp)
    -> (forall (m :: * -> *). Quote m => DForeign -> Code m DForeign)
    -> Lift DForeign
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DForeign -> m Exp
    forall (m :: * -> *). Quote m => DForeign -> Code m DForeign
    $clift :: forall (m :: * -> *). Quote m => DForeign -> m Exp
    lift :: forall (m :: * -> *). Quote m => DForeign -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DForeign -> Code m DForeign
    liftTyped :: forall (m :: * -> *). Quote m => DForeign -> Code m DForeign
    Lift)

    -- | Corresponds to TH's @Pragma@ type.

    data DPragma = DInlineP Name Inline RuleMatch Phases
                 | DSpecialiseP Name DType (Maybe Inline) Phases
                 | DSpecialiseInstP DType
                 | DRuleP String (Maybe [DTyVarBndrUnit]) [DRuleBndr] DExp DExp Phases
                 | DAnnP AnnTarget DExp
                 | DLineP Int String
                 | DCompleteP [Name] (Maybe Name)
                 | DOpaqueP Name
                 deriving (DPragma -> DPragma -> Bool
    (DPragma -> DPragma -> Bool)
    -> (DPragma -> DPragma -> Bool) -> Eq DPragma
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DPragma -> DPragma -> Bool
    == :: DPragma -> DPragma -> Bool
    $c/= :: DPragma -> DPragma -> Bool
    /= :: DPragma -> DPragma -> Bool
    Eq, Int -> DPragma -> ShowS
    [DPragma] -> ShowS
    DPragma -> String
    (Int -> DPragma -> ShowS)
    -> (DPragma -> String) -> ([DPragma] -> ShowS) -> Show DPragma
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DPragma -> ShowS
    showsPrec :: Int -> DPragma -> ShowS
    $cshow :: DPragma -> String
    show :: DPragma -> String
    $cshowList :: [DPragma] -> ShowS
    showList :: [DPragma] -> ShowS
    Show, Typeable DPragma
    Typeable DPragma =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DPragma -> c DPragma)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DPragma)
    -> (DPragma -> Constr)
    -> (DPragma -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DPragma))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPragma))
    -> ((forall b. Data b => b -> b) -> DPragma -> DPragma)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DPragma -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DPragma -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DPragma -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DPragma -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DPragma -> m DPragma)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DPragma -> m DPragma)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DPragma -> m DPragma)
    -> Data DPragma
    DPragma -> Constr
    DPragma -> DataType
    (forall b. Data b => b -> b) -> DPragma -> DPragma
    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) -> DPragma -> u
    forall u. (forall d. Data d => d -> u) -> DPragma -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DPragma -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DPragma -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPragma -> m DPragma
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPragma -> m DPragma
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPragma
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPragma -> c DPragma
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPragma)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPragma)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPragma -> c DPragma
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPragma -> c DPragma
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPragma
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPragma
    $ctoConstr :: DPragma -> Constr
    toConstr :: DPragma -> Constr
    $cdataTypeOf :: DPragma -> DataType
    dataTypeOf :: DPragma -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPragma)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPragma)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPragma)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPragma)
    $cgmapT :: (forall b. Data b => b -> b) -> DPragma -> DPragma
    gmapT :: (forall b. Data b => b -> b) -> DPragma -> DPragma
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DPragma -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DPragma -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DPragma -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DPragma -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DPragma -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DPragma -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPragma -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPragma -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPragma -> m DPragma
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPragma -> m DPragma
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPragma -> m DPragma
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPragma -> m DPragma
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPragma -> m DPragma
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPragma -> m DPragma
    Data, (forall x. DPragma -> Rep DPragma x)
    -> (forall x. Rep DPragma x -> DPragma) -> Generic DPragma
    forall x. Rep DPragma x -> DPragma
    forall x. DPragma -> Rep DPragma x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DPragma -> Rep DPragma x
    from :: forall x. DPragma -> Rep DPragma x
    $cto :: forall x. Rep DPragma x -> DPragma
    to :: forall x. Rep DPragma x -> DPragma
    Generic, (forall (m :: * -> *). Quote m => DPragma -> m Exp)
    -> (forall (m :: * -> *). Quote m => DPragma -> Code m DPragma)
    -> Lift DPragma
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DPragma -> m Exp
    forall (m :: * -> *). Quote m => DPragma -> Code m DPragma
    $clift :: forall (m :: * -> *). Quote m => DPragma -> m Exp
    lift :: forall (m :: * -> *). Quote m => DPragma -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DPragma -> Code m DPragma
    liftTyped :: forall (m :: * -> *). Quote m => DPragma -> Code m DPragma
    Lift)

    -- | Corresponds to TH's @RuleBndr@ type.

    data DRuleBndr = DRuleVar Name
                   | DTypedRuleVar Name DType
                   deriving (DRuleBndr -> DRuleBndr -> Bool
    (DRuleBndr -> DRuleBndr -> Bool)
    -> (DRuleBndr -> DRuleBndr -> Bool) -> Eq DRuleBndr
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DRuleBndr -> DRuleBndr -> Bool
    == :: DRuleBndr -> DRuleBndr -> Bool
    $c/= :: DRuleBndr -> DRuleBndr -> Bool
    /= :: DRuleBndr -> DRuleBndr -> Bool
    Eq, Int -> DRuleBndr -> ShowS
    [DRuleBndr] -> ShowS
    DRuleBndr -> String
    (Int -> DRuleBndr -> ShowS)
    -> (DRuleBndr -> String)
    -> ([DRuleBndr] -> ShowS)
    -> Show DRuleBndr
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DRuleBndr -> ShowS
    showsPrec :: Int -> DRuleBndr -> ShowS
    $cshow :: DRuleBndr -> String
    show :: DRuleBndr -> String
    $cshowList :: [DRuleBndr] -> ShowS
    showList :: [DRuleBndr] -> ShowS
    Show, Typeable DRuleBndr
    Typeable DRuleBndr =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DRuleBndr -> c DRuleBndr)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DRuleBndr)
    -> (DRuleBndr -> Constr)
    -> (DRuleBndr -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DRuleBndr))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DRuleBndr))
    -> ((forall b. Data b => b -> b) -> DRuleBndr -> DRuleBndr)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DRuleBndr -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DRuleBndr -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr)
    -> Data DRuleBndr
    DRuleBndr -> Constr
    DRuleBndr -> DataType
    (forall b. Data b => b -> b) -> DRuleBndr -> DRuleBndr
    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) -> DRuleBndr -> u
    forall u. (forall d. Data d => d -> u) -> DRuleBndr -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DRuleBndr
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DRuleBndr -> c DRuleBndr
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DRuleBndr)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DRuleBndr)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DRuleBndr -> c DRuleBndr
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DRuleBndr -> c DRuleBndr
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DRuleBndr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DRuleBndr
    $ctoConstr :: DRuleBndr -> Constr
    toConstr :: DRuleBndr -> Constr
    $cdataTypeOf :: DRuleBndr -> DataType
    dataTypeOf :: DRuleBndr -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DRuleBndr)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DRuleBndr)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DRuleBndr)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DRuleBndr)
    $cgmapT :: (forall b. Data b => b -> b) -> DRuleBndr -> DRuleBndr
    gmapT :: (forall b. Data b => b -> b) -> DRuleBndr -> DRuleBndr
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DRuleBndr -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DRuleBndr -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DRuleBndr -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DRuleBndr -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr
    Data, (forall x. DRuleBndr -> Rep DRuleBndr x)
    -> (forall x. Rep DRuleBndr x -> DRuleBndr) -> Generic DRuleBndr
    forall x. Rep DRuleBndr x -> DRuleBndr
    forall x. DRuleBndr -> Rep DRuleBndr x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DRuleBndr -> Rep DRuleBndr x
    from :: forall x. DRuleBndr -> Rep DRuleBndr x
    $cto :: forall x. Rep DRuleBndr x -> DRuleBndr
    to :: forall x. Rep DRuleBndr x -> DRuleBndr
    Generic, (forall (m :: * -> *). Quote m => DRuleBndr -> m Exp)
    -> (forall (m :: * -> *). Quote m => DRuleBndr -> Code m DRuleBndr)
    -> Lift DRuleBndr
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DRuleBndr -> m Exp
    forall (m :: * -> *). Quote m => DRuleBndr -> Code m DRuleBndr
    $clift :: forall (m :: * -> *). Quote m => DRuleBndr -> m Exp
    lift :: forall (m :: * -> *). Quote m => DRuleBndr -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DRuleBndr -> Code m DRuleBndr
    liftTyped :: forall (m :: * -> *). Quote m => DRuleBndr -> Code m DRuleBndr
    Lift)

    -- | Corresponds to TH's @TySynEqn@ type (to store type family equations).

    data DTySynEqn = DTySynEqn (Maybe [DTyVarBndrUnit]) DType DType
                   deriving (DTySynEqn -> DTySynEqn -> Bool
    (DTySynEqn -> DTySynEqn -> Bool)
    -> (DTySynEqn -> DTySynEqn -> Bool) -> Eq DTySynEqn
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DTySynEqn -> DTySynEqn -> Bool
    == :: DTySynEqn -> DTySynEqn -> Bool
    $c/= :: DTySynEqn -> DTySynEqn -> Bool
    /= :: DTySynEqn -> DTySynEqn -> Bool
    Eq, Int -> DTySynEqn -> ShowS
    [DTySynEqn] -> ShowS
    DTySynEqn -> String
    (Int -> DTySynEqn -> ShowS)
    -> (DTySynEqn -> String)
    -> ([DTySynEqn] -> ShowS)
    -> Show DTySynEqn
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DTySynEqn -> ShowS
    showsPrec :: Int -> DTySynEqn -> ShowS
    $cshow :: DTySynEqn -> String
    show :: DTySynEqn -> String
    $cshowList :: [DTySynEqn] -> ShowS
    showList :: [DTySynEqn] -> ShowS
    Show, Typeable DTySynEqn
    Typeable DTySynEqn =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DTySynEqn -> c DTySynEqn)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DTySynEqn)
    -> (DTySynEqn -> Constr)
    -> (DTySynEqn -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DTySynEqn))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DTySynEqn))
    -> ((forall b. Data b => b -> b) -> DTySynEqn -> DTySynEqn)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DTySynEqn -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DTySynEqn -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn)
    -> Data DTySynEqn
    DTySynEqn -> Constr
    DTySynEqn -> DataType
    (forall b. Data b => b -> b) -> DTySynEqn -> DTySynEqn
    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) -> DTySynEqn -> u
    forall u. (forall d. Data d => d -> u) -> DTySynEqn -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DTySynEqn
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTySynEqn -> c DTySynEqn
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DTySynEqn)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DTySynEqn)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTySynEqn -> c DTySynEqn
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTySynEqn -> c DTySynEqn
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DTySynEqn
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DTySynEqn
    $ctoConstr :: DTySynEqn -> Constr
    toConstr :: DTySynEqn -> Constr
    $cdataTypeOf :: DTySynEqn -> DataType
    dataTypeOf :: DTySynEqn -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DTySynEqn)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DTySynEqn)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DTySynEqn)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DTySynEqn)
    $cgmapT :: (forall b. Data b => b -> b) -> DTySynEqn -> DTySynEqn
    gmapT :: (forall b. Data b => b -> b) -> DTySynEqn -> DTySynEqn
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DTySynEqn -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DTySynEqn -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DTySynEqn -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DTySynEqn -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn
    Data, (forall x. DTySynEqn -> Rep DTySynEqn x)
    -> (forall x. Rep DTySynEqn x -> DTySynEqn) -> Generic DTySynEqn
    forall x. Rep DTySynEqn x -> DTySynEqn
    forall x. DTySynEqn -> Rep DTySynEqn x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DTySynEqn -> Rep DTySynEqn x
    from :: forall x. DTySynEqn -> Rep DTySynEqn x
    $cto :: forall x. Rep DTySynEqn x -> DTySynEqn
    to :: forall x. Rep DTySynEqn x -> DTySynEqn
    Generic, (forall (m :: * -> *). Quote m => DTySynEqn -> m Exp)
    -> (forall (m :: * -> *). Quote m => DTySynEqn -> Code m DTySynEqn)
    -> Lift DTySynEqn
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DTySynEqn -> m Exp
    forall (m :: * -> *). Quote m => DTySynEqn -> Code m DTySynEqn
    $clift :: forall (m :: * -> *). Quote m => DTySynEqn -> m Exp
    lift :: forall (m :: * -> *). Quote m => DTySynEqn -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DTySynEqn -> Code m DTySynEqn
    liftTyped :: forall (m :: * -> *). Quote m => DTySynEqn -> Code m DTySynEqn
    Lift)

    -- | Corresponds to TH's @Info@ type.

    data DInfo = DTyConI DDec (Maybe [DInstanceDec])
               | DVarI Name DType (Maybe Name)
                   -- ^ The @Maybe Name@ stores the name of the enclosing definition

                   -- (datatype, for a data constructor; class, for a method),

                   -- if any

               | DTyVarI Name DKind
               | DPrimTyConI Name Int Bool
                   -- ^ The @Int@ is the arity; the @Bool@ is whether this tycon

                   -- is unlifted.

               | DPatSynI Name DPatSynType
               deriving (DInfo -> DInfo -> Bool
    (DInfo -> DInfo -> Bool) -> (DInfo -> DInfo -> Bool) -> Eq DInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DInfo -> DInfo -> Bool
    == :: DInfo -> DInfo -> Bool
    $c/= :: DInfo -> DInfo -> Bool
    /= :: DInfo -> DInfo -> Bool
    Eq, Int -> DInfo -> ShowS
    [DInfo] -> ShowS
    DInfo -> String
    (Int -> DInfo -> ShowS)
    -> (DInfo -> String) -> ([DInfo] -> ShowS) -> Show DInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DInfo -> ShowS
    showsPrec :: Int -> DInfo -> ShowS
    $cshow :: DInfo -> String
    show :: DInfo -> String
    $cshowList :: [DInfo] -> ShowS
    showList :: [DInfo] -> ShowS
    Show, Typeable DInfo
    Typeable DInfo =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DInfo -> c DInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DInfo)
    -> (DInfo -> Constr)
    -> (DInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DInfo))
    -> ((forall b. Data b => b -> b) -> DInfo -> DInfo)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DInfo -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DInfo -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DInfo -> m DInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DInfo -> m DInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DInfo -> m DInfo)
    -> Data DInfo
    DInfo -> Constr
    DInfo -> DataType
    (forall b. Data b => b -> b) -> DInfo -> DInfo
    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) -> DInfo -> u
    forall u. (forall d. Data d => d -> u) -> DInfo -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DInfo -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DInfo -> m DInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DInfo -> m DInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DInfo -> c DInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DInfo)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DInfo -> c DInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DInfo -> c DInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DInfo
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DInfo
    $ctoConstr :: DInfo -> Constr
    toConstr :: DInfo -> Constr
    $cdataTypeOf :: DInfo -> DataType
    dataTypeOf :: DInfo -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DInfo)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DInfo)
    $cgmapT :: (forall b. Data b => b -> b) -> DInfo -> DInfo
    gmapT :: (forall b. Data b => b -> b) -> DInfo -> DInfo
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DInfo -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DInfo -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DInfo -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DInfo -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DInfo -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DInfo -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DInfo -> m DInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DInfo -> m DInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DInfo -> m DInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DInfo -> m DInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DInfo -> m DInfo
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DInfo -> m DInfo
    Data, (forall x. DInfo -> Rep DInfo x)
    -> (forall x. Rep DInfo x -> DInfo) -> Generic DInfo
    forall x. Rep DInfo x -> DInfo
    forall x. DInfo -> Rep DInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DInfo -> Rep DInfo x
    from :: forall x. DInfo -> Rep DInfo x
    $cto :: forall x. Rep DInfo x -> DInfo
    to :: forall x. Rep DInfo x -> DInfo
    Generic, (forall (m :: * -> *). Quote m => DInfo -> m Exp)
    -> (forall (m :: * -> *). Quote m => DInfo -> Code m DInfo)
    -> Lift DInfo
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DInfo -> m Exp
    forall (m :: * -> *). Quote m => DInfo -> Code m DInfo
    $clift :: forall (m :: * -> *). Quote m => DInfo -> m Exp
    lift :: forall (m :: * -> *). Quote m => DInfo -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => DInfo -> Code m DInfo
    liftTyped :: forall (m :: * -> *). Quote m => DInfo -> Code m DInfo
    Lift)

    type DInstanceDec = DDec -- ^ Guaranteed to be an instance declaration

    -- | Corresponds to TH's @DerivClause@ type.

    data DDerivClause = DDerivClause (Maybe DDerivStrategy) DCxt
                      deriving (DDerivClause -> DDerivClause -> Bool
    (DDerivClause -> DDerivClause -> Bool)
    -> (DDerivClause -> DDerivClause -> Bool) -> Eq DDerivClause
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DDerivClause -> DDerivClause -> Bool
    == :: DDerivClause -> DDerivClause -> Bool
    $c/= :: DDerivClause -> DDerivClause -> Bool
    /= :: DDerivClause -> DDerivClause -> Bool
    Eq, Int -> DDerivClause -> ShowS
    [DDerivClause] -> ShowS
    DDerivClause -> String
    (Int -> DDerivClause -> ShowS)
    -> (DDerivClause -> String)
    -> ([DDerivClause] -> ShowS)
    -> Show DDerivClause
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DDerivClause -> ShowS
    showsPrec :: Int -> DDerivClause -> ShowS
    $cshow :: DDerivClause -> String
    show :: DDerivClause -> String
    $cshowList :: [DDerivClause] -> ShowS
    showList :: [DDerivClause] -> ShowS
    Show, Typeable DDerivClause
    Typeable DDerivClause =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DDerivClause -> c DDerivClause)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DDerivClause)
    -> (DDerivClause -> Constr)
    -> (DDerivClause -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DDerivClause))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DDerivClause))
    -> ((forall b. Data b => b -> b) -> DDerivClause -> DDerivClause)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DDerivClause -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DDerivClause -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DDerivClause -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DDerivClause -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause)
    -> Data DDerivClause
    DDerivClause -> Constr
    DDerivClause -> DataType
    (forall b. Data b => b -> b) -> DDerivClause -> DDerivClause
    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) -> DDerivClause -> u
    forall u. (forall d. Data d => d -> u) -> DDerivClause -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivClause -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivClause -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDerivClause
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDerivClause -> c DDerivClause
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDerivClause)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DDerivClause)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDerivClause -> c DDerivClause
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDerivClause -> c DDerivClause
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDerivClause
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDerivClause
    $ctoConstr :: DDerivClause -> Constr
    toConstr :: DDerivClause -> Constr
    $cdataTypeOf :: DDerivClause -> DataType
    dataTypeOf :: DDerivClause -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDerivClause)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDerivClause)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DDerivClause)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DDerivClause)
    $cgmapT :: (forall b. Data b => b -> b) -> DDerivClause -> DDerivClause
    gmapT :: (forall b. Data b => b -> b) -> DDerivClause -> DDerivClause
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivClause -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivClause -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivClause -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivClause -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DDerivClause -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DDerivClause -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DDerivClause -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DDerivClause -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause
    Data, (forall x. DDerivClause -> Rep DDerivClause x)
    -> (forall x. Rep DDerivClause x -> DDerivClause)
    -> Generic DDerivClause
    forall x. Rep DDerivClause x -> DDerivClause
    forall x. DDerivClause -> Rep DDerivClause x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DDerivClause -> Rep DDerivClause x
    from :: forall x. DDerivClause -> Rep DDerivClause x
    $cto :: forall x. Rep DDerivClause x -> DDerivClause
    to :: forall x. Rep DDerivClause x -> DDerivClause
    Generic, (forall (m :: * -> *). Quote m => DDerivClause -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        DDerivClause -> Code m DDerivClause)
    -> Lift DDerivClause
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DDerivClause -> m Exp
    forall (m :: * -> *).
    Quote m =>
    DDerivClause -> Code m DDerivClause
    $clift :: forall (m :: * -> *). Quote m => DDerivClause -> m Exp
    lift :: forall (m :: * -> *). Quote m => DDerivClause -> m Exp
    $cliftTyped :: forall (m :: * -> *).
    Quote m =>
    DDerivClause -> Code m DDerivClause
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    DDerivClause -> Code m DDerivClause
    Lift)

    -- | Corresponds to TH's @DerivStrategy@ type.

    data DDerivStrategy = DStockStrategy     -- ^ A \"standard\" derived instance

                        | DAnyclassStrategy  -- ^ @-XDeriveAnyClass@

                        | DNewtypeStrategy   -- ^ @-XGeneralizedNewtypeDeriving@

                        | DViaStrategy DType -- ^ @-XDerivingVia@

                        deriving (DDerivStrategy -> DDerivStrategy -> Bool
    (DDerivStrategy -> DDerivStrategy -> Bool)
    -> (DDerivStrategy -> DDerivStrategy -> Bool) -> Eq DDerivStrategy
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DDerivStrategy -> DDerivStrategy -> Bool
    == :: DDerivStrategy -> DDerivStrategy -> Bool
    $c/= :: DDerivStrategy -> DDerivStrategy -> Bool
    /= :: DDerivStrategy -> DDerivStrategy -> Bool
    Eq, Int -> DDerivStrategy -> ShowS
    [DDerivStrategy] -> ShowS
    DDerivStrategy -> String
    (Int -> DDerivStrategy -> ShowS)
    -> (DDerivStrategy -> String)
    -> ([DDerivStrategy] -> ShowS)
    -> Show DDerivStrategy
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DDerivStrategy -> ShowS
    showsPrec :: Int -> DDerivStrategy -> ShowS
    $cshow :: DDerivStrategy -> String
    show :: DDerivStrategy -> String
    $cshowList :: [DDerivStrategy] -> ShowS
    showList :: [DDerivStrategy] -> ShowS
    Show, Typeable DDerivStrategy
    Typeable DDerivStrategy =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DDerivStrategy -> c DDerivStrategy)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DDerivStrategy)
    -> (DDerivStrategy -> Constr)
    -> (DDerivStrategy -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DDerivStrategy))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DDerivStrategy))
    -> ((forall b. Data b => b -> b)
        -> DDerivStrategy -> DDerivStrategy)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DDerivStrategy -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DDerivStrategy -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> DDerivStrategy -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DDerivStrategy -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> DDerivStrategy -> m DDerivStrategy)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DDerivStrategy -> m DDerivStrategy)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DDerivStrategy -> m DDerivStrategy)
    -> Data DDerivStrategy
    DDerivStrategy -> Constr
    DDerivStrategy -> DataType
    (forall b. Data b => b -> b) -> DDerivStrategy -> DDerivStrategy
    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) -> DDerivStrategy -> u
    forall u. (forall d. Data d => d -> u) -> DDerivStrategy -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivStrategy -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivStrategy -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DDerivStrategy -> m DDerivStrategy
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DDerivStrategy -> m DDerivStrategy
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDerivStrategy
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDerivStrategy -> c DDerivStrategy
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDerivStrategy)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DDerivStrategy)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDerivStrategy -> c DDerivStrategy
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDerivStrategy -> c DDerivStrategy
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDerivStrategy
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDerivStrategy
    $ctoConstr :: DDerivStrategy -> Constr
    toConstr :: DDerivStrategy -> Constr
    $cdataTypeOf :: DDerivStrategy -> DataType
    dataTypeOf :: DDerivStrategy -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDerivStrategy)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDerivStrategy)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DDerivStrategy)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DDerivStrategy)
    $cgmapT :: (forall b. Data b => b -> b) -> DDerivStrategy -> DDerivStrategy
    gmapT :: (forall b. Data b => b -> b) -> DDerivStrategy -> DDerivStrategy
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivStrategy -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivStrategy -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivStrategy -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivStrategy -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DDerivStrategy -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DDerivStrategy -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DDerivStrategy -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DDerivStrategy -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DDerivStrategy -> m DDerivStrategy
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DDerivStrategy -> m DDerivStrategy
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DDerivStrategy -> m DDerivStrategy
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DDerivStrategy -> m DDerivStrategy
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DDerivStrategy -> m DDerivStrategy
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DDerivStrategy -> m DDerivStrategy
    Data, (forall x. DDerivStrategy -> Rep DDerivStrategy x)
    -> (forall x. Rep DDerivStrategy x -> DDerivStrategy)
    -> Generic DDerivStrategy
    forall x. Rep DDerivStrategy x -> DDerivStrategy
    forall x. DDerivStrategy -> Rep DDerivStrategy x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DDerivStrategy -> Rep DDerivStrategy x
    from :: forall x. DDerivStrategy -> Rep DDerivStrategy x
    $cto :: forall x. Rep DDerivStrategy x -> DDerivStrategy
    to :: forall x. Rep DDerivStrategy x -> DDerivStrategy
    Generic, (forall (m :: * -> *). Quote m => DDerivStrategy -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        DDerivStrategy -> Code m DDerivStrategy)
    -> Lift DDerivStrategy
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => DDerivStrategy -> m Exp
    forall (m :: * -> *).
    Quote m =>
    DDerivStrategy -> Code m DDerivStrategy
    $clift :: forall (m :: * -> *). Quote m => DDerivStrategy -> m Exp
    lift :: forall (m :: * -> *). Quote m => DDerivStrategy -> m Exp
    $cliftTyped :: forall (m :: * -> *).
    Quote m =>
    DDerivStrategy -> Code m DDerivStrategy
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    DDerivStrategy -> Code m DDerivStrategy
    Lift)