{- 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
#if __GLASGOW_HASKELL__ < 907
import Language.Haskell.TH.Datatype.TyVarBndr (BndrVis)
#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
          | DTypedBracketE DExp
          | DTypedSpliceE DExp
          deriving (DExp -> DExp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DExp -> DExp -> Bool
$c/= :: DExp -> DExp -> Bool
== :: DExp -> DExp -> Bool
$c== :: DExp -> DExp -> Bool
Eq, Int -> DExp -> ShowS
[DExp] -> ShowS
DExp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DExp] -> ShowS
$cshowList :: [DExp] -> ShowS
show :: DExp -> String
$cshow :: DExp -> String
showsPrec :: Int -> DExp -> ShowS
$cshowsPrec :: Int -> DExp -> ShowS
Show, Typeable DExp
DExp -> DataType
DExp -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DExp -> m DExp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DExp -> m DExp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DExp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DExp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DExp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DExp -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r
gmapT :: (forall b. Data b => b -> b) -> DExp -> DExp
$cgmapT :: (forall b. Data b => b -> b) -> DExp -> DExp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DExp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DExp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DExp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DExp)
dataTypeOf :: DExp -> DataType
$cdataTypeOf :: DExp -> DataType
toConstr :: DExp -> Constr
$ctoConstr :: DExp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DExp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DExp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DExp -> c DExp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DExp -> c DExp
Data, 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
$cto :: forall x. Rep DExp x -> DExp
$cfrom :: forall x. DExp -> Rep DExp x
Generic, 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
liftTyped :: forall (m :: * -> *). Quote m => DExp -> Code m DExp
$cliftTyped :: forall (m :: * -> *). Quote m => DExp -> Code m DExp
lift :: forall (m :: * -> *). Quote m => DExp -> m Exp
$clift :: forall (m :: * -> *). Quote m => DExp -> m Exp
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
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DPat -> DPat -> Bool
$c/= :: DPat -> DPat -> Bool
== :: DPat -> DPat -> Bool
$c== :: DPat -> DPat -> Bool
Eq, Int -> DPat -> ShowS
[DPat] -> ShowS
DPat -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DPat] -> ShowS
$cshowList :: [DPat] -> ShowS
show :: DPat -> String
$cshow :: DPat -> String
showsPrec :: Int -> DPat -> ShowS
$cshowsPrec :: Int -> DPat -> ShowS
Show, Typeable DPat
DPat -> DataType
DPat -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DPat -> m DPat
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DPat -> m DPat
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPat -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPat -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DPat -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DPat -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r
gmapT :: (forall b. Data b => b -> b) -> DPat -> DPat
$cgmapT :: (forall b. Data b => b -> b) -> DPat -> DPat
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPat)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DPat)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DPat)
dataTypeOf :: DPat -> DataType
$cdataTypeOf :: DPat -> DataType
toConstr :: DPat -> Constr
$ctoConstr :: DPat -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DPat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DPat
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DPat -> c DPat
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DPat -> c DPat
Data, 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
$cto :: forall x. Rep DPat x -> DPat
$cfrom :: forall x. DPat -> Rep DPat x
Generic, 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
liftTyped :: forall (m :: * -> *). Quote m => DPat -> Code m DPat
$cliftTyped :: forall (m :: * -> *). Quote m => DPat -> Code m DPat
lift :: forall (m :: * -> *). Quote m => DPat -> m Exp
$clift :: forall (m :: * -> *). Quote m => DPat -> m Exp
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
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DType -> DType -> Bool
$c/= :: DType -> DType -> Bool
== :: DType -> DType -> Bool
$c== :: DType -> DType -> Bool
Eq, Int -> DType -> ShowS
[DType] -> ShowS
DType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DType] -> ShowS
$cshowList :: [DType] -> ShowS
show :: DType -> String
$cshow :: DType -> String
showsPrec :: Int -> DType -> ShowS
$cshowsPrec :: Int -> DType -> ShowS
Show, Typeable DType
DType -> DataType
DType -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DType -> m DType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DType -> m DType
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DType -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r
gmapT :: (forall b. Data b => b -> b) -> DType -> DType
$cgmapT :: (forall b. Data b => b -> b) -> DType -> DType
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DType)
dataTypeOf :: DType -> DataType
$cdataTypeOf :: DType -> DataType
toConstr :: DType -> Constr
$ctoConstr :: DType -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DType -> c DType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DType -> c DType
Data, 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
$cto :: forall x. Rep DType x -> DType
$cfrom :: forall x. DType -> Rep DType x
Generic, 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
liftTyped :: forall (m :: * -> *). Quote m => DType -> Code m DType
$cliftTyped :: forall (m :: * -> *). Quote m => DType -> Code m DType
lift :: forall (m :: * -> *). Quote m => DType -> m Exp
$clift :: forall (m :: * -> *). Quote m => DType -> m Exp
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
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DForallTelescope -> DForallTelescope -> Bool
$c/= :: DForallTelescope -> DForallTelescope -> Bool
== :: DForallTelescope -> DForallTelescope -> Bool
$c== :: DForallTelescope -> DForallTelescope -> Bool
Eq, Int -> DForallTelescope -> ShowS
[DForallTelescope] -> ShowS
DForallTelescope -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DForallTelescope] -> ShowS
$cshowList :: [DForallTelescope] -> ShowS
show :: DForallTelescope -> String
$cshow :: DForallTelescope -> String
showsPrec :: Int -> DForallTelescope -> ShowS
$cshowsPrec :: Int -> DForallTelescope -> ShowS
Show, Typeable DForallTelescope
DForallTelescope -> DataType
DForallTelescope -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DForallTelescope -> m DForallTelescope
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DForallTelescope -> m DForallTelescope
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DForallTelescope -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DForallTelescope -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DForallTelescope -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DForallTelescope -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r
gmapT :: (forall b. Data b => b -> b)
-> DForallTelescope -> DForallTelescope
$cgmapT :: (forall b. Data b => b -> b)
-> DForallTelescope -> DForallTelescope
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DForallTelescope)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DForallTelescope)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DForallTelescope)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DForallTelescope)
dataTypeOf :: DForallTelescope -> DataType
$cdataTypeOf :: DForallTelescope -> DataType
toConstr :: DForallTelescope -> Constr
$ctoConstr :: DForallTelescope -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DForallTelescope
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DForallTelescope
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DForallTelescope -> c DForallTelescope
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DForallTelescope -> c DForallTelescope
Data, 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
$cto :: forall x. Rep DForallTelescope x -> DForallTelescope
$cfrom :: forall x. DForallTelescope -> Rep DForallTelescope x
Generic, 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
liftTyped :: forall (m :: * -> *).
Quote m =>
DForallTelescope -> Code m DForallTelescope
$cliftTyped :: forall (m :: * -> *).
Quote m =>
DForallTelescope -> Code m DForallTelescope
lift :: forall (m :: * -> *). Quote m => DForallTelescope -> m Exp
$clift :: forall (m :: * -> *). Quote m => DForallTelescope -> m Exp
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
forall flag. Eq flag => DTyVarBndr flag -> DTyVarBndr flag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DTyVarBndr flag -> DTyVarBndr flag -> Bool
$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
Eq, Int -> DTyVarBndr flag -> ShowS
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
showList :: [DTyVarBndr flag] -> ShowS
$cshowList :: forall flag. Show flag => [DTyVarBndr flag] -> ShowS
show :: DTyVarBndr flag -> String
$cshow :: forall flag. Show flag => DTyVarBndr flag -> String
showsPrec :: Int -> DTyVarBndr flag -> ShowS
$cshowsPrec :: forall flag. Show flag => Int -> DTyVarBndr flag -> ShowS
Show, DTyVarBndr flag -> DataType
DTyVarBndr flag -> Constr
forall {flag}. Data flag => Typeable (DTyVarBndr flag)
forall flag. Data flag => DTyVarBndr flag -> DataType
forall flag. Data flag => DTyVarBndr flag -> Constr
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 (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))
gmapMo :: 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)
gmapMp :: forall (m :: * -> *).
MonadPlus 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)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DTyVarBndr flag -> m (DTyVarBndr flag)
$cgmapM :: forall flag (m :: * -> *).
(Data flag, Monad m) =>
(forall d. Data d => d -> m d)
-> DTyVarBndr flag -> m (DTyVarBndr flag)
gmapQi :: forall u.
Int -> (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
gmapQ :: forall u. (forall d. Data d => d -> u) -> DTyVarBndr flag -> [u]
$cgmapQ :: forall flag u.
Data flag =>
(forall d. Data d => d -> u) -> DTyVarBndr flag -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
$cgmapQl :: forall flag r r'.
Data flag =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
gmapT :: (forall b. Data b => b -> b) -> DTyVarBndr flag -> DTyVarBndr flag
$cgmapT :: forall flag.
Data flag =>
(forall b. Data b => b -> b) -> DTyVarBndr flag -> DTyVarBndr flag
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> 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))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DTyVarBndr flag))
$cdataCast1 :: forall flag (t :: * -> *) (c :: * -> *).
(Data flag, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DTyVarBndr flag))
dataTypeOf :: DTyVarBndr flag -> DataType
$cdataTypeOf :: forall flag. Data flag => DTyVarBndr flag -> DataType
toConstr :: DTyVarBndr flag -> Constr
$ctoConstr :: forall flag. Data flag => DTyVarBndr flag -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> 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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DTyVarBndr flag -> 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)
Data, 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
$cto :: forall flag x. Rep (DTyVarBndr flag) x -> DTyVarBndr flag
$cfrom :: forall flag x. DTyVarBndr flag -> Rep (DTyVarBndr flag) x
Generic, 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
<$ :: forall a b. a -> DTyVarBndr b -> DTyVarBndr a
$c<$ :: forall a b. a -> DTyVarBndr b -> DTyVarBndr a
fmap :: forall a b. (a -> b) -> DTyVarBndr a -> DTyVarBndr b
$cfmap :: forall a b. (a -> b) -> DTyVarBndr a -> DTyVarBndr b
Functor, 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)
liftTyped :: forall (m :: * -> *).
Quote m =>
DTyVarBndr flag -> Code m (DTyVarBndr flag)
$cliftTyped :: forall flag (m :: * -> *).
(Lift flag, Quote m) =>
DTyVarBndr flag -> Code m (DTyVarBndr flag)
lift :: forall (m :: * -> *). Quote m => DTyVarBndr flag -> m Exp
$clift :: forall flag (m :: * -> *).
(Lift flag, Quote m) =>
DTyVarBndr flag -> m Exp
Lift)

-- | Corresponds to TH's @TyVarBndrSpec@
type DTyVarBndrSpec = DTyVarBndr Specificity

-- | Corresponds to TH's @TyVarBndrUnit@
type DTyVarBndrUnit = DTyVarBndr ()

-- | Corresponds to TH's @TyVarBndrVis@
type DTyVarBndrVis = DTyVarBndr BndrVis

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

-- | Corresponds to TH's @Clause@ type.
data DClause = DClause [DPat] DExp
  deriving (DClause -> DClause -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DClause -> DClause -> Bool
$c/= :: DClause -> DClause -> Bool
== :: DClause -> DClause -> Bool
$c== :: DClause -> DClause -> Bool
Eq, Int -> DClause -> ShowS
[DClause] -> ShowS
DClause -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DClause] -> ShowS
$cshowList :: [DClause] -> ShowS
show :: DClause -> String
$cshow :: DClause -> String
showsPrec :: Int -> DClause -> ShowS
$cshowsPrec :: Int -> DClause -> ShowS
Show, Typeable DClause
DClause -> DataType
DClause -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DClause -> m DClause
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DClause -> m DClause
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DClause -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DClause -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DClause -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DClause -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DClause -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DClause -> r
gmapT :: (forall b. Data b => b -> b) -> DClause -> DClause
$cgmapT :: (forall b. Data b => b -> b) -> DClause -> DClause
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DClause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DClause)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DClause)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DClause)
dataTypeOf :: DClause -> DataType
$cdataTypeOf :: DClause -> DataType
toConstr :: DClause -> Constr
$ctoConstr :: DClause -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DClause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DClause
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DClause -> c DClause
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DClause -> c DClause
Data, 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
$cto :: forall x. Rep DClause x -> DClause
$cfrom :: forall x. DClause -> Rep DClause x
Generic, 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
liftTyped :: forall (m :: * -> *). Quote m => DClause -> Code m DClause
$cliftTyped :: forall (m :: * -> *). Quote m => DClause -> Code m DClause
lift :: forall (m :: * -> *). Quote m => DClause -> m Exp
$clift :: forall (m :: * -> *). Quote m => DClause -> m Exp
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
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DLetDec -> DLetDec -> Bool
$c/= :: DLetDec -> DLetDec -> Bool
== :: DLetDec -> DLetDec -> Bool
$c== :: DLetDec -> DLetDec -> Bool
Eq, Int -> DLetDec -> ShowS
[DLetDec] -> ShowS
DLetDec -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DLetDec] -> ShowS
$cshowList :: [DLetDec] -> ShowS
show :: DLetDec -> String
$cshow :: DLetDec -> String
showsPrec :: Int -> DLetDec -> ShowS
$cshowsPrec :: Int -> DLetDec -> ShowS
Show, Typeable DLetDec
DLetDec -> DataType
DLetDec -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DLetDec -> m DLetDec
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DLetDec -> m DLetDec
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DLetDec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DLetDec -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DLetDec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DLetDec -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DLetDec -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DLetDec -> r
gmapT :: (forall b. Data b => b -> b) -> DLetDec -> DLetDec
$cgmapT :: (forall b. Data b => b -> b) -> DLetDec -> DLetDec
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DLetDec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DLetDec)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DLetDec)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DLetDec)
dataTypeOf :: DLetDec -> DataType
$cdataTypeOf :: DLetDec -> DataType
toConstr :: DLetDec -> Constr
$ctoConstr :: DLetDec -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DLetDec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DLetDec
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DLetDec -> c DLetDec
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DLetDec -> c DLetDec
Data, 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
$cto :: forall x. Rep DLetDec x -> DLetDec
$cfrom :: forall x. DLetDec -> Rep DLetDec x
Generic, 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
liftTyped :: forall (m :: * -> *). Quote m => DLetDec -> Code m DLetDec
$cliftTyped :: forall (m :: * -> *). Quote m => DLetDec -> Code m DLetDec
lift :: forall (m :: * -> *). Quote m => DLetDec -> m Exp
$clift :: forall (m :: * -> *). Quote m => DLetDec -> m Exp
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 [DTyVarBndrVis] (Maybe DKind) [DCon] [DDerivClause]
          | DTySynD Name [DTyVarBndrVis] DType
          | DClassD DCxt Name [DTyVarBndrVis] [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 [DTyVarBndrVis] (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
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DDec -> DDec -> Bool
$c/= :: DDec -> DDec -> Bool
== :: DDec -> DDec -> Bool
$c== :: DDec -> DDec -> Bool
Eq, Int -> DDec -> ShowS
[DDec] -> ShowS
DDec -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DDec] -> ShowS
$cshowList :: [DDec] -> ShowS
show :: DDec -> String
$cshow :: DDec -> String
showsPrec :: Int -> DDec -> ShowS
$cshowsPrec :: Int -> DDec -> ShowS
Show, Typeable DDec
DDec -> DataType
DDec -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DDec -> m DDec
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DDec -> m DDec
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DDec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DDec -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DDec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DDec -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r
gmapT :: (forall b. Data b => b -> b) -> DDec -> DDec
$cgmapT :: (forall b. Data b => b -> b) -> DDec -> DDec
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DDec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DDec)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DDec)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DDec)
dataTypeOf :: DDec -> DataType
$cdataTypeOf :: DDec -> DataType
toConstr :: DDec -> Constr
$ctoConstr :: DDec -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DDec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DDec
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DDec -> c DDec
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DDec -> c DDec
Data, 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
$cto :: forall x. Rep DDec x -> DDec
$cfrom :: forall x. DDec -> Rep DDec x
Generic, 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
liftTyped :: forall (m :: * -> *). Quote m => DDec -> Code m DDec
$cliftTyped :: forall (m :: * -> *). Quote m => DDec -> Code m DDec
lift :: forall (m :: * -> *). Quote m => DDec -> m Exp
$clift :: forall (m :: * -> *). Quote m => DDec -> m Exp
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
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DPatSynDir -> DPatSynDir -> Bool
$c/= :: DPatSynDir -> DPatSynDir -> Bool
== :: DPatSynDir -> DPatSynDir -> Bool
$c== :: DPatSynDir -> DPatSynDir -> Bool
Eq, Int -> DPatSynDir -> ShowS
[DPatSynDir] -> ShowS
DPatSynDir -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DPatSynDir] -> ShowS
$cshowList :: [DPatSynDir] -> ShowS
show :: DPatSynDir -> String
$cshow :: DPatSynDir -> String
showsPrec :: Int -> DPatSynDir -> ShowS
$cshowsPrec :: Int -> DPatSynDir -> ShowS
Show, Typeable DPatSynDir
DPatSynDir -> DataType
DPatSynDir -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPatSynDir -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPatSynDir -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DPatSynDir -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DPatSynDir -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r
gmapT :: (forall b. Data b => b -> b) -> DPatSynDir -> DPatSynDir
$cgmapT :: (forall b. Data b => b -> b) -> DPatSynDir -> DPatSynDir
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPatSynDir)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPatSynDir)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DPatSynDir)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DPatSynDir)
dataTypeOf :: DPatSynDir -> DataType
$cdataTypeOf :: DPatSynDir -> DataType
toConstr :: DPatSynDir -> Constr
$ctoConstr :: DPatSynDir -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DPatSynDir
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DPatSynDir
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DPatSynDir -> c DPatSynDir
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DPatSynDir -> c DPatSynDir
Data, 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
$cto :: forall x. Rep DPatSynDir x -> DPatSynDir
$cfrom :: forall x. DPatSynDir -> Rep DPatSynDir x
Generic, 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
liftTyped :: forall (m :: * -> *). Quote m => DPatSynDir -> Code m DPatSynDir
$cliftTyped :: forall (m :: * -> *). Quote m => DPatSynDir -> Code m DPatSynDir
lift :: forall (m :: * -> *). Quote m => DPatSynDir -> m Exp
$clift :: forall (m :: * -> *). Quote m => DPatSynDir -> m Exp
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 [DTyVarBndrVis] DFamilyResultSig
                                       (Maybe InjectivityAnn)
                     deriving (DTypeFamilyHead -> DTypeFamilyHead -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
$c/= :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
== :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
$c== :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
Eq, Int -> DTypeFamilyHead -> ShowS
[DTypeFamilyHead] -> ShowS
DTypeFamilyHead -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DTypeFamilyHead] -> ShowS
$cshowList :: [DTypeFamilyHead] -> ShowS
show :: DTypeFamilyHead -> String
$cshow :: DTypeFamilyHead -> String
showsPrec :: Int -> DTypeFamilyHead -> ShowS
$cshowsPrec :: Int -> DTypeFamilyHead -> ShowS
Show, Typeable DTypeFamilyHead
DTypeFamilyHead -> DataType
DTypeFamilyHead -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DTypeFamilyHead -> m DTypeFamilyHead
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DTypeFamilyHead -> m DTypeFamilyHead
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DTypeFamilyHead -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DTypeFamilyHead -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DTypeFamilyHead -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DTypeFamilyHead -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r
gmapT :: (forall b. Data b => b -> b) -> DTypeFamilyHead -> DTypeFamilyHead
$cgmapT :: (forall b. Data b => b -> b) -> DTypeFamilyHead -> DTypeFamilyHead
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DTypeFamilyHead)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DTypeFamilyHead)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DTypeFamilyHead)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DTypeFamilyHead)
dataTypeOf :: DTypeFamilyHead -> DataType
$cdataTypeOf :: DTypeFamilyHead -> DataType
toConstr :: DTypeFamilyHead -> Constr
$ctoConstr :: DTypeFamilyHead -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DTypeFamilyHead
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DTypeFamilyHead
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DTypeFamilyHead -> c DTypeFamilyHead
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DTypeFamilyHead -> c DTypeFamilyHead
Data, 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
$cto :: forall x. Rep DTypeFamilyHead x -> DTypeFamilyHead
$cfrom :: forall x. DTypeFamilyHead -> Rep DTypeFamilyHead x
Generic, 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
liftTyped :: forall (m :: * -> *).
Quote m =>
DTypeFamilyHead -> Code m DTypeFamilyHead
$cliftTyped :: forall (m :: * -> *).
Quote m =>
DTypeFamilyHead -> Code m DTypeFamilyHead
lift :: forall (m :: * -> *). Quote m => DTypeFamilyHead -> m Exp
$clift :: forall (m :: * -> *). Quote m => DTypeFamilyHead -> m Exp
Lift)

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

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

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