{- 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 #-}

module Language.Haskell.TH.Desugar.AST where

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

-- | Corresponds to TH's @Exp@ type. Note that @DLamE@ takes names, not patterns.
data DExp = DVarE Name
          | DConE Name
          | DLitE Lit
          | DAppE DExp DExp
          | DAppTypeE DExp DType
          | DLamE [Name] DExp
          | DCaseE DExp [DMatch]
          | DLetE [DLetDec] DExp
          | DSigE DExp DType
          | DStaticE DExp
          deriving (DExp -> DExp -> Bool
(DExp -> DExp -> Bool) -> (DExp -> DExp -> Bool) -> Eq DExp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DExp -> DExp -> Bool
$c/= :: DExp -> DExp -> Bool
== :: DExp -> DExp -> Bool
$c== :: DExp -> DExp -> Bool
Eq, Int -> DExp -> ShowS
[DExp] -> ShowS
DExp -> String
(Int -> DExp -> ShowS)
-> (DExp -> String) -> ([DExp] -> ShowS) -> Show DExp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DExp] -> ShowS
$cshowList :: [DExp] -> ShowS
show :: DExp -> String
$cshow :: DExp -> String
showsPrec :: Int -> DExp -> ShowS
$cshowsPrec :: Int -> DExp -> ShowS
Show, Typeable, Typeable DExp
DataType
Constr
Typeable DExp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DExp -> c DExp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DExp)
-> (DExp -> Constr)
-> (DExp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DExp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DExp))
-> ((forall b. Data b => b -> b) -> DExp -> DExp)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DExp -> r)
-> (forall u. (forall d. Data d => d -> u) -> DExp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DExp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DExp -> m DExp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DExp -> m DExp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DExp -> m DExp)
-> Data DExp
DExp -> DataType
DExp -> Constr
(forall b. Data b => b -> b) -> DExp -> DExp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DExp -> c DExp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDStaticE :: Constr
$cDSigE :: Constr
$cDLetE :: Constr
$cDCaseE :: Constr
$cDLamE :: Constr
$cDAppTypeE :: Constr
$cDAppE :: Constr
$cDLitE :: Constr
$cDConE :: Constr
$cDVarE :: Constr
$tDExp :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DExp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DExp -> u
gmapQ :: (forall d. Data d => d -> u) -> DExp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DExp -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DExp
Data, (forall x. DExp -> Rep DExp x)
-> (forall x. Rep DExp x -> DExp) -> Generic DExp
forall x. Rep DExp x -> DExp
forall x. DExp -> Rep DExp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DExp x -> DExp
$cfrom :: forall x. DExp -> Rep DExp x
Generic)


-- | Corresponds to TH's @Pat@ type.
data DPat = DLitP Lit
          | DVarP Name
          | DConP Name [DType] [DPat]
          | DTildeP DPat
          | DBangP DPat
          | DSigP DPat DType
          | DWildP
          deriving (DPat -> DPat -> Bool
(DPat -> DPat -> Bool) -> (DPat -> DPat -> Bool) -> Eq DPat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DPat -> DPat -> Bool
$c/= :: DPat -> DPat -> Bool
== :: DPat -> DPat -> Bool
$c== :: DPat -> DPat -> Bool
Eq, Int -> DPat -> ShowS
[DPat] -> ShowS
DPat -> String
(Int -> DPat -> ShowS)
-> (DPat -> String) -> ([DPat] -> ShowS) -> Show DPat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DPat] -> ShowS
$cshowList :: [DPat] -> ShowS
show :: DPat -> String
$cshow :: DPat -> String
showsPrec :: Int -> DPat -> ShowS
$cshowsPrec :: Int -> DPat -> ShowS
Show, Typeable, Typeable DPat
DataType
Constr
Typeable DPat
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPat -> c DPat)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPat)
-> (DPat -> Constr)
-> (DPat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPat))
-> ((forall b. Data b => b -> b) -> DPat -> DPat)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DPat -> r)
-> (forall u. (forall d. Data d => d -> u) -> DPat -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DPat -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPat -> m DPat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPat -> m DPat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPat -> m DPat)
-> Data DPat
DPat -> DataType
DPat -> Constr
(forall b. Data b => b -> b) -> DPat -> DPat
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DPat -> c DPat
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDWildP :: Constr
$cDSigP :: Constr
$cDBangP :: Constr
$cDTildeP :: Constr
$cDConP :: Constr
$cDVarP :: Constr
$cDLitP :: Constr
$tDPat :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DPat -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPat -> u
gmapQ :: (forall d. Data d => d -> u) -> DPat -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DPat -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DPat
Data, (forall x. DPat -> Rep DPat x)
-> (forall x. Rep DPat x -> DPat) -> Generic DPat
forall x. Rep DPat x -> DPat
forall x. DPat -> Rep DPat x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DPat x -> DPat
$cfrom :: forall x. DPat -> Rep DPat x
Generic)

-- | Corresponds to TH's @Type@ type, used to represent
-- types and kinds.
data DType = DForallT DForallTelescope DType
           | DConstrainedT DCxt DType
           | DAppT DType DType
           | DAppKindT DType DKind
           | DSigT DType DKind
           | DVarT Name
           | DConT Name
           | DArrowT
           | DLitT TyLit
           | DWildCardT
           deriving (DType -> DType -> Bool
(DType -> DType -> Bool) -> (DType -> DType -> Bool) -> Eq DType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DType -> DType -> Bool
$c/= :: DType -> DType -> Bool
== :: DType -> DType -> Bool
$c== :: DType -> DType -> Bool
Eq, Int -> DType -> ShowS
[DType] -> ShowS
DType -> String
(Int -> DType -> ShowS)
-> (DType -> String) -> ([DType] -> ShowS) -> Show DType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DType] -> ShowS
$cshowList :: [DType] -> ShowS
show :: DType -> String
$cshow :: DType -> String
showsPrec :: Int -> DType -> ShowS
$cshowsPrec :: Int -> DType -> ShowS
Show, Typeable, Typeable DType
DataType
Constr
Typeable DType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DType -> c DType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DType)
-> (DType -> Constr)
-> (DType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DType))
-> ((forall b. Data b => b -> b) -> DType -> DType)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DType -> m DType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DType -> m DType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DType -> m DType)
-> Data DType
DType -> DataType
DType -> Constr
(forall b. Data b => b -> b) -> DType -> DType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DType -> c DType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDWildCardT :: Constr
$cDLitT :: Constr
$cDArrowT :: Constr
$cDConT :: Constr
$cDVarT :: Constr
$cDSigT :: Constr
$cDAppKindT :: Constr
$cDAppT :: Constr
$cDConstrainedT :: Constr
$cDForallT :: Constr
$tDType :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DType -> u
gmapQ :: (forall d. Data d => d -> u) -> DType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DType -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DType
Data, (forall x. DType -> Rep DType x)
-> (forall x. Rep DType x -> DType) -> Generic DType
forall x. Rep DType x -> DType
forall x. DType -> Rep DType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DType x -> DType
$cfrom :: forall x. DType -> Rep DType x
Generic)

-- | The type variable binders in a @forall@.
data DForallTelescope
  = DForallVis   [DTyVarBndrUnit]
    -- ^ A visible @forall@ (e.g., @forall a -> {...}@).
    --   These do not have any notion of specificity, so we use
    --   '()' as a placeholder value in the 'DTyVarBndr's.
  | DForallInvis [DTyVarBndrSpec]
    -- ^ An invisible @forall@ (e.g., @forall a {b} c -> {...}@),
    --   where each binder has a 'Specificity'.
  deriving (DForallTelescope -> DForallTelescope -> Bool
(DForallTelescope -> DForallTelescope -> Bool)
-> (DForallTelescope -> DForallTelescope -> Bool)
-> Eq DForallTelescope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DForallTelescope -> DForallTelescope -> Bool
$c/= :: DForallTelescope -> DForallTelescope -> Bool
== :: DForallTelescope -> DForallTelescope -> Bool
$c== :: DForallTelescope -> DForallTelescope -> Bool
Eq, Int -> DForallTelescope -> ShowS
[DForallTelescope] -> ShowS
DForallTelescope -> String
(Int -> DForallTelescope -> ShowS)
-> (DForallTelescope -> String)
-> ([DForallTelescope] -> ShowS)
-> Show DForallTelescope
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DForallTelescope] -> ShowS
$cshowList :: [DForallTelescope] -> ShowS
show :: DForallTelescope -> String
$cshow :: DForallTelescope -> String
showsPrec :: Int -> DForallTelescope -> ShowS
$cshowsPrec :: Int -> DForallTelescope -> ShowS
Show, Typeable, Typeable DForallTelescope
DataType
Constr
Typeable DForallTelescope
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DForallTelescope -> c DForallTelescope)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DForallTelescope)
-> (DForallTelescope -> Constr)
-> (DForallTelescope -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DForallTelescope))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DForallTelescope))
-> ((forall b. Data b => b -> b)
    -> DForallTelescope -> DForallTelescope)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DForallTelescope -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DForallTelescope -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DForallTelescope -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DForallTelescope -> m DForallTelescope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DForallTelescope -> m DForallTelescope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DForallTelescope -> m DForallTelescope)
-> Data DForallTelescope
DForallTelescope -> DataType
DForallTelescope -> Constr
(forall b. Data b => b -> b)
-> DForallTelescope -> DForallTelescope
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DForallTelescope -> c DForallTelescope
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDForallInvis :: Constr
$cDForallVis :: Constr
$tDForallTelescope :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DForallTelescope -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DForallTelescope -> u
gmapQ :: (forall d. Data d => d -> u) -> DForallTelescope -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DForallTelescope -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DForallTelescope
Data, (forall x. DForallTelescope -> Rep DForallTelescope x)
-> (forall x. Rep DForallTelescope x -> DForallTelescope)
-> Generic DForallTelescope
forall x. Rep DForallTelescope x -> DForallTelescope
forall x. DForallTelescope -> Rep DForallTelescope x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DForallTelescope x -> DForallTelescope
$cfrom :: forall x. DForallTelescope -> Rep DForallTelescope x
Generic)

-- | Kinds are types. Corresponds to TH's @Kind@
type DKind = DType

-- | Predicates are types. Corresponds to TH's @Pred@
type DPred = DType

-- | Corresponds to TH's @Cxt@
type DCxt = [DPred]

-- | Corresponds to TH's @TyVarBndr@
data DTyVarBndr flag
  = DPlainTV Name flag
  | DKindedTV Name flag DKind
  deriving (DTyVarBndr flag -> DTyVarBndr flag -> Bool
(DTyVarBndr flag -> DTyVarBndr flag -> Bool)
-> (DTyVarBndr flag -> DTyVarBndr flag -> Bool)
-> Eq (DTyVarBndr flag)
forall flag. Eq flag => DTyVarBndr flag -> DTyVarBndr flag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: 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
[DTyVarBndr flag] -> ShowS
DTyVarBndr flag -> String
(Int -> DTyVarBndr flag -> ShowS)
-> (DTyVarBndr flag -> String)
-> ([DTyVarBndr flag] -> ShowS)
-> Show (DTyVarBndr flag)
forall flag. Show flag => Int -> DTyVarBndr flag -> ShowS
forall flag. Show flag => [DTyVarBndr flag] -> ShowS
forall flag. Show flag => DTyVarBndr flag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
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, Typeable, Typeable (DTyVarBndr flag)
DataType
Constr
Typeable (DTyVarBndr flag)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTyVarBndr flag -> c (DTyVarBndr flag))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DTyVarBndr flag))
-> (DTyVarBndr flag -> Constr)
-> (DTyVarBndr flag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DTyVarBndr flag)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DTyVarBndr flag)))
-> ((forall b. Data b => b -> b)
    -> DTyVarBndr flag -> DTyVarBndr flag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DTyVarBndr flag -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DTyVarBndr flag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTyVarBndr flag -> m (DTyVarBndr flag))
-> Data (DTyVarBndr flag)
DTyVarBndr flag -> DataType
DTyVarBndr flag -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (DTyVarBndr flag))
(forall b. Data b => b -> b) -> DTyVarBndr flag -> DTyVarBndr flag
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DTyVarBndr flag -> c (DTyVarBndr flag)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DTyVarBndr flag)
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 u.
Int -> (forall d. Data d => d -> u) -> DTyVarBndr flag -> u
forall u. (forall d. Data d => d -> u) -> DTyVarBndr flag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DTyVarBndr flag -> m (DTyVarBndr flag)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DTyVarBndr flag -> m (DTyVarBndr flag)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DTyVarBndr flag)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DTyVarBndr flag -> c (DTyVarBndr flag)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DTyVarBndr flag))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DTyVarBndr flag))
$cDKindedTV :: Constr
$cDPlainTV :: Constr
$tDTyVarBndr :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> DTyVarBndr flag -> [u]
$cgmapQ :: forall flag u.
Data flag =>
(forall d. Data d => d -> u) -> DTyVarBndr flag -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall flag. Data flag => Typeable (DTyVarBndr flag)
Data, (forall x. DTyVarBndr flag -> Rep (DTyVarBndr flag) x)
-> (forall x. Rep (DTyVarBndr flag) x -> DTyVarBndr flag)
-> Generic (DTyVarBndr flag)
forall x. Rep (DTyVarBndr flag) x -> DTyVarBndr flag
forall x. DTyVarBndr flag -> Rep (DTyVarBndr flag) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall flag x. Rep (DTyVarBndr flag) x -> DTyVarBndr flag
forall flag x. DTyVarBndr flag -> Rep (DTyVarBndr flag) x
$cto :: forall flag x. Rep (DTyVarBndr flag) x -> DTyVarBndr flag
$cfrom :: forall flag x. DTyVarBndr flag -> Rep (DTyVarBndr flag) x
Generic, a -> DTyVarBndr b -> DTyVarBndr a
(a -> b) -> DTyVarBndr a -> DTyVarBndr b
(forall a b. (a -> b) -> DTyVarBndr a -> DTyVarBndr b)
-> (forall a b. a -> DTyVarBndr b -> DTyVarBndr a)
-> Functor DTyVarBndr
forall a b. a -> DTyVarBndr b -> DTyVarBndr a
forall a b. (a -> b) -> DTyVarBndr a -> DTyVarBndr b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> DTyVarBndr b -> DTyVarBndr a
$c<$ :: forall a b. a -> DTyVarBndr b -> DTyVarBndr a
fmap :: (a -> b) -> DTyVarBndr a -> DTyVarBndr b
$cfmap :: forall a b. (a -> b) -> DTyVarBndr a -> DTyVarBndr b
Functor)

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

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

-- | Corresponds to TH's @Match@ type.
data DMatch = DMatch DPat DExp
  deriving (DMatch -> DMatch -> Bool
(DMatch -> DMatch -> Bool)
-> (DMatch -> DMatch -> Bool) -> Eq DMatch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DMatch -> DMatch -> Bool
$c/= :: DMatch -> DMatch -> Bool
== :: DMatch -> DMatch -> Bool
$c== :: DMatch -> DMatch -> Bool
Eq, Int -> DMatch -> ShowS
[DMatch] -> ShowS
DMatch -> String
(Int -> DMatch -> ShowS)
-> (DMatch -> String) -> ([DMatch] -> ShowS) -> Show DMatch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DMatch] -> ShowS
$cshowList :: [DMatch] -> ShowS
show :: DMatch -> String
$cshow :: DMatch -> String
showsPrec :: Int -> DMatch -> ShowS
$cshowsPrec :: Int -> DMatch -> ShowS
Show, Typeable, Typeable DMatch
DataType
Constr
Typeable DMatch
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DMatch -> c DMatch)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DMatch)
-> (DMatch -> Constr)
-> (DMatch -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DMatch))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DMatch))
-> ((forall b. Data b => b -> b) -> DMatch -> DMatch)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DMatch -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DMatch -> r)
-> (forall u. (forall d. Data d => d -> u) -> DMatch -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DMatch -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DMatch -> m DMatch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DMatch -> m DMatch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DMatch -> m DMatch)
-> Data DMatch
DMatch -> DataType
DMatch -> Constr
(forall b. Data b => b -> b) -> DMatch -> DMatch
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DMatch -> c DMatch
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDMatch :: Constr
$tDMatch :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DMatch -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DMatch -> u
gmapQ :: (forall d. Data d => d -> u) -> DMatch -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DMatch -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DMatch
Data, (forall x. DMatch -> Rep DMatch x)
-> (forall x. Rep DMatch x -> DMatch) -> Generic DMatch
forall x. Rep DMatch x -> DMatch
forall x. DMatch -> Rep DMatch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DMatch x -> DMatch
$cfrom :: forall x. DMatch -> Rep DMatch x
Generic)

-- | Corresponds to TH's @Clause@ type.
data DClause = DClause [DPat] DExp
  deriving (DClause -> DClause -> Bool
(DClause -> DClause -> Bool)
-> (DClause -> DClause -> Bool) -> Eq DClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DClause -> DClause -> Bool
$c/= :: DClause -> DClause -> Bool
== :: DClause -> DClause -> Bool
$c== :: DClause -> DClause -> Bool
Eq, Int -> DClause -> ShowS
[DClause] -> ShowS
DClause -> String
(Int -> DClause -> ShowS)
-> (DClause -> String) -> ([DClause] -> ShowS) -> Show DClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DClause] -> ShowS
$cshowList :: [DClause] -> ShowS
show :: DClause -> String
$cshow :: DClause -> String
showsPrec :: Int -> DClause -> ShowS
$cshowsPrec :: Int -> DClause -> ShowS
Show, Typeable, Typeable DClause
DataType
Constr
Typeable DClause
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DClause -> c DClause)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DClause)
-> (DClause -> Constr)
-> (DClause -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DClause))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DClause))
-> ((forall b. Data b => b -> b) -> DClause -> DClause)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DClause -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DClause -> r)
-> (forall u. (forall d. Data d => d -> u) -> DClause -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DClause -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DClause -> m DClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DClause -> m DClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DClause -> m DClause)
-> Data DClause
DClause -> DataType
DClause -> Constr
(forall b. Data b => b -> b) -> DClause -> DClause
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DClause -> c DClause
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDClause :: Constr
$tDClause :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DClause -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DClause -> u
gmapQ :: (forall d. Data d => d -> u) -> DClause -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DClause -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DClause
Data, (forall x. DClause -> Rep DClause x)
-> (forall x. Rep DClause x -> DClause) -> Generic DClause
forall x. Rep DClause x -> DClause
forall x. DClause -> Rep DClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DClause x -> DClause
$cfrom :: forall x. DClause -> Rep DClause x
Generic)

-- | Declarations as used in a @let@ statement.
data DLetDec = DFunD Name [DClause]
             | DValD DPat DExp
             | DSigD Name DType
             | DInfixD Fixity Name
             | DPragmaD DPragma
             deriving (DLetDec -> DLetDec -> Bool
(DLetDec -> DLetDec -> Bool)
-> (DLetDec -> DLetDec -> Bool) -> Eq DLetDec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DLetDec -> DLetDec -> Bool
$c/= :: DLetDec -> DLetDec -> Bool
== :: DLetDec -> DLetDec -> Bool
$c== :: DLetDec -> DLetDec -> Bool
Eq, Int -> DLetDec -> ShowS
[DLetDec] -> ShowS
DLetDec -> String
(Int -> DLetDec -> ShowS)
-> (DLetDec -> String) -> ([DLetDec] -> ShowS) -> Show DLetDec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DLetDec] -> ShowS
$cshowList :: [DLetDec] -> ShowS
show :: DLetDec -> String
$cshow :: DLetDec -> String
showsPrec :: Int -> DLetDec -> ShowS
$cshowsPrec :: Int -> DLetDec -> ShowS
Show, Typeable, Typeable DLetDec
DataType
Constr
Typeable DLetDec
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DLetDec -> c DLetDec)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DLetDec)
-> (DLetDec -> Constr)
-> (DLetDec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DLetDec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DLetDec))
-> ((forall b. Data b => b -> b) -> DLetDec -> DLetDec)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DLetDec -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DLetDec -> r)
-> (forall u. (forall d. Data d => d -> u) -> DLetDec -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DLetDec -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DLetDec -> m DLetDec)
-> Data DLetDec
DLetDec -> DataType
DLetDec -> Constr
(forall b. Data b => b -> b) -> DLetDec -> DLetDec
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DLetDec -> c DLetDec
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDPragmaD :: Constr
$cDInfixD :: Constr
$cDSigD :: Constr
$cDValD :: Constr
$cDFunD :: Constr
$tDLetDec :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DLetDec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DLetDec -> u
gmapQ :: (forall d. Data d => d -> u) -> DLetDec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DLetDec -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DLetDec
Data, (forall x. DLetDec -> Rep DLetDec x)
-> (forall x. Rep DLetDec x -> DLetDec) -> Generic DLetDec
forall x. Rep DLetDec x -> DLetDec
forall x. DLetDec -> Rep DLetDec x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DLetDec x -> DLetDec
$cfrom :: forall x. DLetDec -> Rep DLetDec x
Generic)

-- | Is it a @newtype@ or a @data@ type?
data NewOrData = Newtype
               | Data
               deriving (NewOrData -> NewOrData -> Bool
(NewOrData -> NewOrData -> Bool)
-> (NewOrData -> NewOrData -> Bool) -> Eq NewOrData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NewOrData -> NewOrData -> Bool
$c/= :: NewOrData -> NewOrData -> Bool
== :: NewOrData -> NewOrData -> Bool
$c== :: NewOrData -> NewOrData -> Bool
Eq, Int -> NewOrData -> ShowS
[NewOrData] -> ShowS
NewOrData -> String
(Int -> NewOrData -> ShowS)
-> (NewOrData -> String)
-> ([NewOrData] -> ShowS)
-> Show NewOrData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NewOrData] -> ShowS
$cshowList :: [NewOrData] -> ShowS
show :: NewOrData -> String
$cshow :: NewOrData -> String
showsPrec :: Int -> NewOrData -> ShowS
$cshowsPrec :: Int -> NewOrData -> ShowS
Show, Typeable, Typeable NewOrData
DataType
Constr
Typeable NewOrData
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NewOrData -> c NewOrData)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NewOrData)
-> (NewOrData -> Constr)
-> (NewOrData -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NewOrData))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewOrData))
-> ((forall b. Data b => b -> b) -> NewOrData -> NewOrData)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NewOrData -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NewOrData -> r)
-> (forall u. (forall d. Data d => d -> u) -> NewOrData -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NewOrData -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData)
-> Data NewOrData
NewOrData -> DataType
NewOrData -> Constr
(forall b. Data b => b -> b) -> NewOrData -> NewOrData
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewOrData -> c NewOrData
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewOrData
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) -> NewOrData -> u
forall u. (forall d. Data d => d -> u) -> NewOrData -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewOrData -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewOrData -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NewOrData -> m NewOrData
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewOrData -> m NewOrData
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewOrData
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewOrData -> c NewOrData
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewOrData)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewOrData)
$cData :: Constr
$cNewtype :: Constr
$tNewOrData :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewOrData -> m NewOrData
gmapMp :: (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewOrData -> m NewOrData
gmapM :: (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NewOrData -> m NewOrData
gmapQi :: Int -> (forall d. Data d => d -> u) -> NewOrData -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NewOrData -> u
gmapQ :: (forall d. Data d => d -> u) -> NewOrData -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NewOrData -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewOrData -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewOrData -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewOrData -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewOrData -> r
gmapT :: (forall b. Data b => b -> b) -> NewOrData -> NewOrData
$cgmapT :: (forall b. Data b => b -> b) -> NewOrData -> NewOrData
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewOrData)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewOrData)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c NewOrData)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewOrData)
dataTypeOf :: NewOrData -> DataType
$cdataTypeOf :: NewOrData -> DataType
toConstr :: NewOrData -> Constr
$ctoConstr :: NewOrData -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewOrData
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewOrData
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewOrData -> c NewOrData
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewOrData -> c NewOrData
$cp1Data :: Typeable NewOrData
Data, (forall x. NewOrData -> Rep NewOrData x)
-> (forall x. Rep NewOrData x -> NewOrData) -> Generic NewOrData
forall x. Rep NewOrData x -> NewOrData
forall x. NewOrData -> Rep NewOrData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NewOrData x -> NewOrData
$cfrom :: forall x. NewOrData -> Rep NewOrData x
Generic)

-- | Corresponds to TH's @Dec@ type.
data DDec = DLetDec DLetDec
          | DDataD NewOrData DCxt Name [DTyVarBndrUnit] (Maybe DKind) [DCon] [DDerivClause]
          | DTySynD Name [DTyVarBndrUnit] DType
          | DClassD DCxt Name [DTyVarBndrUnit] [FunDep] [DDec]
            -- | Note that the @Maybe [DTyVarBndrUnit]@ field is dropped
            -- entirely when sweetened, so it is only useful for functions
            -- that directly consume @DDec@s.
          | DInstanceD (Maybe Overlap) (Maybe [DTyVarBndrUnit]) DCxt DType [DDec]
          | DForeignD DForeign
          | DOpenTypeFamilyD DTypeFamilyHead
          | DClosedTypeFamilyD DTypeFamilyHead [DTySynEqn]
          | DDataFamilyD Name [DTyVarBndrUnit] (Maybe DKind)
          | DDataInstD NewOrData 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.
          deriving (DDec -> DDec -> Bool
(DDec -> DDec -> Bool) -> (DDec -> DDec -> Bool) -> Eq DDec
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
(Int -> DDec -> ShowS)
-> (DDec -> String) -> ([DDec] -> ShowS) -> Show DDec
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, Typeable DDec
DataType
Constr
Typeable DDec
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDec -> c DDec)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDec)
-> (DDec -> Constr)
-> (DDec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DDec))
-> ((forall b. Data b => b -> b) -> DDec -> DDec)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DDec -> r)
-> (forall u. (forall d. Data d => d -> u) -> DDec -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DDec -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DDec -> m DDec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDec -> m DDec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDec -> m DDec)
-> Data DDec
DDec -> DataType
DDec -> Constr
(forall b. Data b => b -> b) -> DDec -> DDec
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DDec -> c DDec
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDKiSigD :: Constr
$cDPatSynSigD :: Constr
$cDPatSynD :: Constr
$cDDefaultSigD :: Constr
$cDStandaloneDerivD :: Constr
$cDRoleAnnotD :: Constr
$cDTySynInstD :: Constr
$cDDataInstD :: Constr
$cDDataFamilyD :: Constr
$cDClosedTypeFamilyD :: Constr
$cDOpenTypeFamilyD :: Constr
$cDForeignD :: Constr
$cDInstanceD :: Constr
$cDClassD :: Constr
$cDTySynD :: Constr
$cDDataD :: Constr
$cDLetDec :: Constr
$tDDec :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DDec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DDec -> u
gmapQ :: (forall d. Data d => d -> u) -> DDec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DDec -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DDec
Data, (forall x. DDec -> Rep DDec x)
-> (forall x. Rep DDec x -> DDec) -> Generic DDec
forall x. Rep DDec x -> DDec
forall x. DDec -> Rep DDec x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DDec x -> DDec
$cfrom :: forall x. DDec -> Rep DDec x
Generic)

#if __GLASGOW_HASKELL__ < 711
data Overlap = Overlappable | Overlapping | Overlaps | Incoherent
  deriving (Eq, Ord, Show, Typeable, Data, Generic)
#endif

-- | Corresponds to TH's 'PatSynDir' type
data DPatSynDir = DUnidir              -- ^ @pattern P x {<-} p@
                | DImplBidir           -- ^ @pattern P x {=} p@
                | DExplBidir [DClause] -- ^ @pattern P x {<-} p where P x = e@
                deriving (DPatSynDir -> DPatSynDir -> Bool
(DPatSynDir -> DPatSynDir -> Bool)
-> (DPatSynDir -> DPatSynDir -> Bool) -> Eq DPatSynDir
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DPatSynDir -> DPatSynDir -> Bool
$c/= :: DPatSynDir -> DPatSynDir -> Bool
== :: DPatSynDir -> DPatSynDir -> Bool
$c== :: DPatSynDir -> DPatSynDir -> Bool
Eq, Int -> DPatSynDir -> ShowS
[DPatSynDir] -> ShowS
DPatSynDir -> String
(Int -> DPatSynDir -> ShowS)
-> (DPatSynDir -> String)
-> ([DPatSynDir] -> ShowS)
-> Show DPatSynDir
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DPatSynDir] -> ShowS
$cshowList :: [DPatSynDir] -> ShowS
show :: DPatSynDir -> String
$cshow :: DPatSynDir -> String
showsPrec :: Int -> DPatSynDir -> ShowS
$cshowsPrec :: Int -> DPatSynDir -> ShowS
Show, Typeable, Typeable DPatSynDir
DataType
Constr
Typeable DPatSynDir
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPatSynDir -> c DPatSynDir)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPatSynDir)
-> (DPatSynDir -> Constr)
-> (DPatSynDir -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPatSynDir))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DPatSynDir))
-> ((forall b. Data b => b -> b) -> DPatSynDir -> DPatSynDir)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r)
-> (forall u. (forall d. Data d => d -> u) -> DPatSynDir -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DPatSynDir -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir)
-> Data DPatSynDir
DPatSynDir -> DataType
DPatSynDir -> Constr
(forall b. Data b => b -> b) -> DPatSynDir -> DPatSynDir
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DPatSynDir -> c DPatSynDir
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDExplBidir :: Constr
$cDImplBidir :: Constr
$cDUnidir :: Constr
$tDPatSynDir :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DPatSynDir -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPatSynDir -> u
gmapQ :: (forall d. Data d => d -> u) -> DPatSynDir -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DPatSynDir -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DPatSynDir
Data, (forall x. DPatSynDir -> Rep DPatSynDir x)
-> (forall x. Rep DPatSynDir x -> DPatSynDir) -> Generic DPatSynDir
forall x. Rep DPatSynDir x -> DPatSynDir
forall x. DPatSynDir -> Rep DPatSynDir x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DPatSynDir x -> DPatSynDir
$cfrom :: forall x. DPatSynDir -> Rep DPatSynDir x
Generic)

-- | 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, Typeable, Data, Generic)
#endif

-- | Corresponds to TH's 'TypeFamilyHead' type
data DTypeFamilyHead = DTypeFamilyHead Name [DTyVarBndrUnit] DFamilyResultSig
                                       (Maybe InjectivityAnn)
                     deriving (DTypeFamilyHead -> DTypeFamilyHead -> Bool
(DTypeFamilyHead -> DTypeFamilyHead -> Bool)
-> (DTypeFamilyHead -> DTypeFamilyHead -> Bool)
-> Eq DTypeFamilyHead
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
$c/= :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
== :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
$c== :: DTypeFamilyHead -> DTypeFamilyHead -> Bool
Eq, Int -> DTypeFamilyHead -> ShowS
[DTypeFamilyHead] -> ShowS
DTypeFamilyHead -> String
(Int -> DTypeFamilyHead -> ShowS)
-> (DTypeFamilyHead -> String)
-> ([DTypeFamilyHead] -> ShowS)
-> Show DTypeFamilyHead
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DTypeFamilyHead] -> ShowS
$cshowList :: [DTypeFamilyHead] -> ShowS
show :: DTypeFamilyHead -> String
$cshow :: DTypeFamilyHead -> String
showsPrec :: Int -> DTypeFamilyHead -> ShowS
$cshowsPrec :: Int -> DTypeFamilyHead -> ShowS
Show, Typeable, Typeable DTypeFamilyHead
DataType
Constr
Typeable DTypeFamilyHead
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTypeFamilyHead -> c DTypeFamilyHead)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DTypeFamilyHead)
-> (DTypeFamilyHead -> Constr)
-> (DTypeFamilyHead -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DTypeFamilyHead))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DTypeFamilyHead))
-> ((forall b. Data b => b -> b)
    -> DTypeFamilyHead -> DTypeFamilyHead)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTypeFamilyHead -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DTypeFamilyHead -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DTypeFamilyHead -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DTypeFamilyHead -> m DTypeFamilyHead)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTypeFamilyHead -> m DTypeFamilyHead)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DTypeFamilyHead -> m DTypeFamilyHead)
-> Data DTypeFamilyHead
DTypeFamilyHead -> DataType
DTypeFamilyHead -> Constr
(forall b. Data b => b -> b) -> DTypeFamilyHead -> DTypeFamilyHead
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DTypeFamilyHead -> c DTypeFamilyHead
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDTypeFamilyHead :: Constr
$tDTypeFamilyHead :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DTypeFamilyHead -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DTypeFamilyHead -> u
gmapQ :: (forall d. Data d => d -> u) -> DTypeFamilyHead -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DTypeFamilyHead -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DTypeFamilyHead
Data, (forall x. DTypeFamilyHead -> Rep DTypeFamilyHead x)
-> (forall x. Rep DTypeFamilyHead x -> DTypeFamilyHead)
-> Generic DTypeFamilyHead
forall x. Rep DTypeFamilyHead x -> DTypeFamilyHead
forall x. DTypeFamilyHead -> Rep DTypeFamilyHead x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DTypeFamilyHead x -> DTypeFamilyHead
$cfrom :: forall x. DTypeFamilyHead -> Rep DTypeFamilyHead x
Generic)

-- | Corresponds to TH's 'FamilyResultSig' type
data DFamilyResultSig = DNoSig
                      | DKindSig DKind
                      | DTyVarSig DTyVarBndrUnit
                      deriving (DFamilyResultSig -> DFamilyResultSig -> Bool
(DFamilyResultSig -> DFamilyResultSig -> Bool)
-> (DFamilyResultSig -> DFamilyResultSig -> Bool)
-> Eq DFamilyResultSig
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DFamilyResultSig -> DFamilyResultSig -> Bool
$c/= :: DFamilyResultSig -> DFamilyResultSig -> Bool
== :: DFamilyResultSig -> DFamilyResultSig -> Bool
$c== :: DFamilyResultSig -> DFamilyResultSig -> Bool
Eq, Int -> DFamilyResultSig -> ShowS
[DFamilyResultSig] -> ShowS
DFamilyResultSig -> String
(Int -> DFamilyResultSig -> ShowS)
-> (DFamilyResultSig -> String)
-> ([DFamilyResultSig] -> ShowS)
-> Show DFamilyResultSig
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DFamilyResultSig] -> ShowS
$cshowList :: [DFamilyResultSig] -> ShowS
show :: DFamilyResultSig -> String
$cshow :: DFamilyResultSig -> String
showsPrec :: Int -> DFamilyResultSig -> ShowS
$cshowsPrec :: Int -> DFamilyResultSig -> ShowS
Show, Typeable, Typeable DFamilyResultSig
DataType
Constr
Typeable DFamilyResultSig
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DFamilyResultSig -> c DFamilyResultSig)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DFamilyResultSig)
-> (DFamilyResultSig -> Constr)
-> (DFamilyResultSig -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DFamilyResultSig))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DFamilyResultSig))
-> ((forall b. Data b => b -> b)
    -> DFamilyResultSig -> DFamilyResultSig)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DFamilyResultSig -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DFamilyResultSig -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DFamilyResultSig -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DFamilyResultSig -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DFamilyResultSig -> m DFamilyResultSig)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DFamilyResultSig -> m DFamilyResultSig)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DFamilyResultSig -> m DFamilyResultSig)
-> Data DFamilyResultSig
DFamilyResultSig -> DataType
DFamilyResultSig -> Constr
(forall b. Data b => b -> b)
-> DFamilyResultSig -> DFamilyResultSig
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DFamilyResultSig -> c DFamilyResultSig
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDTyVarSig :: Constr
$cDKindSig :: Constr
$cDNoSig :: Constr
$tDFamilyResultSig :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DFamilyResultSig -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DFamilyResultSig -> u
gmapQ :: (forall d. Data d => d -> u) -> DFamilyResultSig -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DFamilyResultSig -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DFamilyResultSig
Data, (forall x. DFamilyResultSig -> Rep DFamilyResultSig x)
-> (forall x. Rep DFamilyResultSig x -> DFamilyResultSig)
-> Generic DFamilyResultSig
forall x. Rep DFamilyResultSig x -> DFamilyResultSig
forall x. DFamilyResultSig -> Rep DFamilyResultSig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DFamilyResultSig x -> DFamilyResultSig
$cfrom :: forall x. DFamilyResultSig -> Rep DFamilyResultSig x
Generic)

#if __GLASGOW_HASKELL__ <= 710
data InjectivityAnn = InjectivityAnn Name [Name]
  deriving (Eq, Ord, Show, Typeable, Data, Generic)
#endif

-- | Corresponds to TH's 'Con' type. Unlike 'Con', all 'DCon's reflect GADT
-- syntax. This is beneficial for @th-desugar@'s since it means
-- that all data type declarations can support explicit return kinds, so
-- one does not need to represent them with something like @'Maybe' 'DKind'@,
-- since Haskell98-style data declaration syntax isn't used. Accordingly,
-- there are some differences between 'DCon' and 'Con' to keep in mind:
--
-- * Unlike 'ForallC', where the meaning of the 'TyVarBndr's changes depending
--   on whether it's followed by 'GadtC'/'RecGadtC' or not, the meaning of the
--   'DTyVarBndr's in a 'DCon' is always the same: it is the list of
--   universally /and/ existentially quantified type variables. Note that it is
--   not guaranteed that one set of type variables will appear before the
--   other.
--
-- * A 'DCon' always has an explicit return type.
data DCon = DCon [DTyVarBndrSpec] DCxt Name DConFields
                 DType  -- ^ The GADT result type
          deriving (DCon -> DCon -> Bool
(DCon -> DCon -> Bool) -> (DCon -> DCon -> Bool) -> Eq DCon
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DCon -> DCon -> Bool
$c/= :: DCon -> DCon -> Bool
== :: DCon -> DCon -> Bool
$c== :: DCon -> DCon -> Bool
Eq, Int -> DCon -> ShowS
[DCon] -> ShowS
DCon -> String
(Int -> DCon -> ShowS)
-> (DCon -> String) -> ([DCon] -> ShowS) -> Show DCon
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DCon] -> ShowS
$cshowList :: [DCon] -> ShowS
show :: DCon -> String
$cshow :: DCon -> String
showsPrec :: Int -> DCon -> ShowS
$cshowsPrec :: Int -> DCon -> ShowS
Show, Typeable, Typeable DCon
DataType
Constr
Typeable DCon
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DCon -> c DCon)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DCon)
-> (DCon -> Constr)
-> (DCon -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DCon))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DCon))
-> ((forall b. Data b => b -> b) -> DCon -> DCon)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r)
-> (forall u. (forall d. Data d => d -> u) -> DCon -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DCon -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DCon -> m DCon)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DCon -> m DCon)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DCon -> m DCon)
-> Data DCon
DCon -> DataType
DCon -> Constr
(forall b. Data b => b -> b) -> DCon -> DCon
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DCon -> c DCon
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDCon :: Constr
$tDCon :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DCon -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DCon -> u
gmapQ :: (forall d. Data d => d -> u) -> DCon -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DCon -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DCon
Data, (forall x. DCon -> Rep DCon x)
-> (forall x. Rep DCon x -> DCon) -> Generic DCon
forall x. Rep DCon x -> DCon
forall x. DCon -> Rep DCon x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DCon x -> DCon
$cfrom :: forall x. DCon -> Rep DCon x
Generic)

-- | A list of fields either for a standard data constructor or a record
-- data constructor.
data DConFields = DNormalC DDeclaredInfix [DBangType]
                | DRecC [DVarBangType]
                deriving (DConFields -> DConFields -> Bool
(DConFields -> DConFields -> Bool)
-> (DConFields -> DConFields -> Bool) -> Eq DConFields
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DConFields -> DConFields -> Bool
$c/= :: DConFields -> DConFields -> Bool
== :: DConFields -> DConFields -> Bool
$c== :: DConFields -> DConFields -> Bool
Eq, Int -> DConFields -> ShowS
[DConFields] -> ShowS
DConFields -> String
(Int -> DConFields -> ShowS)
-> (DConFields -> String)
-> ([DConFields] -> ShowS)
-> Show DConFields
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DConFields] -> ShowS
$cshowList :: [DConFields] -> ShowS
show :: DConFields -> String
$cshow :: DConFields -> String
showsPrec :: Int -> DConFields -> ShowS
$cshowsPrec :: Int -> DConFields -> ShowS
Show, Typeable, Typeable DConFields
DataType
Constr
Typeable DConFields
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DConFields -> c DConFields)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DConFields)
-> (DConFields -> Constr)
-> (DConFields -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DConFields))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DConFields))
-> ((forall b. Data b => b -> b) -> DConFields -> DConFields)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DConFields -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DConFields -> r)
-> (forall u. (forall d. Data d => d -> u) -> DConFields -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DConFields -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DConFields -> m DConFields)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DConFields -> m DConFields)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DConFields -> m DConFields)
-> Data DConFields
DConFields -> DataType
DConFields -> Constr
(forall b. Data b => b -> b) -> DConFields -> DConFields
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DConFields -> c DConFields
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDRecC :: Constr
$cDNormalC :: Constr
$tDConFields :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DConFields -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DConFields -> u
gmapQ :: (forall d. Data d => d -> u) -> DConFields -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DConFields -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DConFields
Data, (forall x. DConFields -> Rep DConFields x)
-> (forall x. Rep DConFields x -> DConFields) -> Generic DConFields
forall x. Rep DConFields x -> DConFields
forall x. DConFields -> Rep DConFields x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DConFields x -> DConFields
$cfrom :: forall x. DConFields -> Rep DConFields x
Generic)

-- | '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)

#if __GLASGOW_HASKELL__ <= 710
-- | Corresponds to TH's definition
data SourceUnpackedness = NoSourceUnpackedness
                        | SourceNoUnpack
                        | SourceUnpack
  deriving (Eq, Ord, Show, Typeable, Data, Generic)

-- | Corresponds to TH's definition
data SourceStrictness = NoSourceStrictness
                      | SourceLazy
                      | SourceStrict
  deriving (Eq, Ord, Show, Typeable, Data, Generic)

-- | Corresponds to TH's definition
data Bang = Bang SourceUnpackedness SourceStrictness
  deriving (Eq, Ord, Show, Typeable, Data, Generic)
#endif

-- | Corresponds to TH's @Foreign@ type.
data DForeign = DImportF Callconv Safety String Name DType
              | DExportF Callconv String Name DType
              deriving (DForeign -> DForeign -> Bool
(DForeign -> DForeign -> Bool)
-> (DForeign -> DForeign -> Bool) -> Eq DForeign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DForeign -> DForeign -> Bool
$c/= :: DForeign -> DForeign -> Bool
== :: DForeign -> DForeign -> Bool
$c== :: DForeign -> DForeign -> Bool
Eq, Int -> DForeign -> ShowS
[DForeign] -> ShowS
DForeign -> String
(Int -> DForeign -> ShowS)
-> (DForeign -> String) -> ([DForeign] -> ShowS) -> Show DForeign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DForeign] -> ShowS
$cshowList :: [DForeign] -> ShowS
show :: DForeign -> String
$cshow :: DForeign -> String
showsPrec :: Int -> DForeign -> ShowS
$cshowsPrec :: Int -> DForeign -> ShowS
Show, Typeable, Typeable DForeign
DataType
Constr
Typeable DForeign
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DForeign -> c DForeign)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DForeign)
-> (DForeign -> Constr)
-> (DForeign -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DForeign))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DForeign))
-> ((forall b. Data b => b -> b) -> DForeign -> DForeign)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DForeign -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DForeign -> r)
-> (forall u. (forall d. Data d => d -> u) -> DForeign -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DForeign -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DForeign -> m DForeign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DForeign -> m DForeign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DForeign -> m DForeign)
-> Data DForeign
DForeign -> DataType
DForeign -> Constr
(forall b. Data b => b -> b) -> DForeign -> DForeign
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DForeign -> c DForeign
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDExportF :: Constr
$cDImportF :: Constr
$tDForeign :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DForeign -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DForeign -> u
gmapQ :: (forall d. Data d => d -> u) -> DForeign -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DForeign -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DForeign
Data, (forall x. DForeign -> Rep DForeign x)
-> (forall x. Rep DForeign x -> DForeign) -> Generic DForeign
forall x. Rep DForeign x -> DForeign
forall x. DForeign -> Rep DForeign x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DForeign x -> DForeign
$cfrom :: forall x. DForeign -> Rep DForeign x
Generic)

-- | 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)
             deriving (DPragma -> DPragma -> Bool
(DPragma -> DPragma -> Bool)
-> (DPragma -> DPragma -> Bool) -> Eq DPragma
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
(Int -> DPragma -> ShowS)
-> (DPragma -> String) -> ([DPragma] -> ShowS) -> Show DPragma
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, Typeable DPragma
DataType
Constr
Typeable DPragma
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DPragma -> c DPragma)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DPragma)
-> (DPragma -> Constr)
-> (DPragma -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DPragma))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPragma))
-> ((forall b. Data b => b -> b) -> DPragma -> DPragma)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DPragma -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DPragma -> r)
-> (forall u. (forall d. Data d => d -> u) -> DPragma -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DPragma -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DPragma -> m DPragma)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPragma -> m DPragma)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DPragma -> m DPragma)
-> Data DPragma
DPragma -> DataType
DPragma -> Constr
(forall b. Data b => b -> b) -> DPragma -> DPragma
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DPragma -> c DPragma
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDCompleteP :: Constr
$cDLineP :: Constr
$cDAnnP :: Constr
$cDRuleP :: Constr
$cDSpecialiseInstP :: Constr
$cDSpecialiseP :: Constr
$cDInlineP :: Constr
$tDPragma :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DPragma -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DPragma -> u
gmapQ :: (forall d. Data d => d -> u) -> DPragma -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DPragma -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DPragma
Data, (forall x. DPragma -> Rep DPragma x)
-> (forall x. Rep DPragma x -> DPragma) -> Generic DPragma
forall x. Rep DPragma x -> DPragma
forall x. DPragma -> Rep DPragma x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DPragma x -> DPragma
$cfrom :: forall x. DPragma -> Rep DPragma x
Generic)

-- | Corresponds to TH's @RuleBndr@ type.
data DRuleBndr = DRuleVar Name
               | DTypedRuleVar Name DType
               deriving (DRuleBndr -> DRuleBndr -> Bool
(DRuleBndr -> DRuleBndr -> Bool)
-> (DRuleBndr -> DRuleBndr -> Bool) -> Eq DRuleBndr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DRuleBndr -> DRuleBndr -> Bool
$c/= :: DRuleBndr -> DRuleBndr -> Bool
== :: DRuleBndr -> DRuleBndr -> Bool
$c== :: DRuleBndr -> DRuleBndr -> Bool
Eq, Int -> DRuleBndr -> ShowS
[DRuleBndr] -> ShowS
DRuleBndr -> String
(Int -> DRuleBndr -> ShowS)
-> (DRuleBndr -> String)
-> ([DRuleBndr] -> ShowS)
-> Show DRuleBndr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DRuleBndr] -> ShowS
$cshowList :: [DRuleBndr] -> ShowS
show :: DRuleBndr -> String
$cshow :: DRuleBndr -> String
showsPrec :: Int -> DRuleBndr -> ShowS
$cshowsPrec :: Int -> DRuleBndr -> ShowS
Show, Typeable, Typeable DRuleBndr
DataType
Constr
Typeable DRuleBndr
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DRuleBndr -> c DRuleBndr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DRuleBndr)
-> (DRuleBndr -> Constr)
-> (DRuleBndr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DRuleBndr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DRuleBndr))
-> ((forall b. Data b => b -> b) -> DRuleBndr -> DRuleBndr)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r)
-> (forall u. (forall d. Data d => d -> u) -> DRuleBndr -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DRuleBndr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr)
-> Data DRuleBndr
DRuleBndr -> DataType
DRuleBndr -> Constr
(forall b. Data b => b -> b) -> DRuleBndr -> DRuleBndr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DRuleBndr -> c DRuleBndr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDTypedRuleVar :: Constr
$cDRuleVar :: Constr
$tDRuleBndr :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DRuleBndr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DRuleBndr -> u
gmapQ :: (forall d. Data d => d -> u) -> DRuleBndr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DRuleBndr -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DRuleBndr
Data, (forall x. DRuleBndr -> Rep DRuleBndr x)
-> (forall x. Rep DRuleBndr x -> DRuleBndr) -> Generic DRuleBndr
forall x. Rep DRuleBndr x -> DRuleBndr
forall x. DRuleBndr -> Rep DRuleBndr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DRuleBndr x -> DRuleBndr
$cfrom :: forall x. DRuleBndr -> Rep DRuleBndr x
Generic)

-- | Corresponds to TH's @TySynEqn@ type (to store type family equations).
data DTySynEqn = DTySynEqn (Maybe [DTyVarBndrUnit]) DType DType
               deriving (DTySynEqn -> DTySynEqn -> Bool
(DTySynEqn -> DTySynEqn -> Bool)
-> (DTySynEqn -> DTySynEqn -> Bool) -> Eq DTySynEqn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DTySynEqn -> DTySynEqn -> Bool
$c/= :: DTySynEqn -> DTySynEqn -> Bool
== :: DTySynEqn -> DTySynEqn -> Bool
$c== :: DTySynEqn -> DTySynEqn -> Bool
Eq, Int -> DTySynEqn -> ShowS
[DTySynEqn] -> ShowS
DTySynEqn -> String
(Int -> DTySynEqn -> ShowS)
-> (DTySynEqn -> String)
-> ([DTySynEqn] -> ShowS)
-> Show DTySynEqn
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DTySynEqn] -> ShowS
$cshowList :: [DTySynEqn] -> ShowS
show :: DTySynEqn -> String
$cshow :: DTySynEqn -> String
showsPrec :: Int -> DTySynEqn -> ShowS
$cshowsPrec :: Int -> DTySynEqn -> ShowS
Show, Typeable, Typeable DTySynEqn
DataType
Constr
Typeable DTySynEqn
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DTySynEqn -> c DTySynEqn)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DTySynEqn)
-> (DTySynEqn -> Constr)
-> (DTySynEqn -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DTySynEqn))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DTySynEqn))
-> ((forall b. Data b => b -> b) -> DTySynEqn -> DTySynEqn)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r)
-> (forall u. (forall d. Data d => d -> u) -> DTySynEqn -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DTySynEqn -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn)
-> Data DTySynEqn
DTySynEqn -> DataType
DTySynEqn -> Constr
(forall b. Data b => b -> b) -> DTySynEqn -> DTySynEqn
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DTySynEqn -> c DTySynEqn
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDTySynEqn :: Constr
$tDTySynEqn :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DTySynEqn -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DTySynEqn -> u
gmapQ :: (forall d. Data d => d -> u) -> DTySynEqn -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DTySynEqn -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DTySynEqn
Data, (forall x. DTySynEqn -> Rep DTySynEqn x)
-> (forall x. Rep DTySynEqn x -> DTySynEqn) -> Generic DTySynEqn
forall x. Rep DTySynEqn x -> DTySynEqn
forall x. DTySynEqn -> Rep DTySynEqn x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DTySynEqn x -> DTySynEqn
$cfrom :: forall x. DTySynEqn -> Rep DTySynEqn x
Generic)

-- | Corresponds to TH's @Info@ type.
data DInfo = DTyConI DDec (Maybe [DInstanceDec])
           | DVarI Name DType (Maybe Name)
               -- ^ The @Maybe Name@ stores the name of the enclosing definition
               -- (datatype, for a data constructor; class, for a method),
               -- if any
           | DTyVarI Name DKind
           | DPrimTyConI Name Int Bool
               -- ^ The @Int@ is the arity; the @Bool@ is whether this tycon
               -- is unlifted.
           | DPatSynI Name DPatSynType
           deriving (DInfo -> DInfo -> Bool
(DInfo -> DInfo -> Bool) -> (DInfo -> DInfo -> Bool) -> Eq DInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DInfo -> DInfo -> Bool
$c/= :: DInfo -> DInfo -> Bool
== :: DInfo -> DInfo -> Bool
$c== :: DInfo -> DInfo -> Bool
Eq, Int -> DInfo -> ShowS
[DInfo] -> ShowS
DInfo -> String
(Int -> DInfo -> ShowS)
-> (DInfo -> String) -> ([DInfo] -> ShowS) -> Show DInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DInfo] -> ShowS
$cshowList :: [DInfo] -> ShowS
show :: DInfo -> String
$cshow :: DInfo -> String
showsPrec :: Int -> DInfo -> ShowS
$cshowsPrec :: Int -> DInfo -> ShowS
Show, Typeable, Typeable DInfo
DataType
Constr
Typeable DInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DInfo -> c DInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DInfo)
-> (DInfo -> Constr)
-> (DInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DInfo))
-> ((forall b. Data b => b -> b) -> DInfo -> DInfo)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DInfo -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> DInfo -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DInfo -> m DInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DInfo -> m DInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DInfo -> m DInfo)
-> Data DInfo
DInfo -> DataType
DInfo -> Constr
(forall b. Data b => b -> b) -> DInfo -> DInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DInfo -> c DInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDPatSynI :: Constr
$cDPrimTyConI :: Constr
$cDTyVarI :: Constr
$cDVarI :: Constr
$cDTyConI :: Constr
$tDInfo :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> DInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DInfo -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DInfo
Data, (forall x. DInfo -> Rep DInfo x)
-> (forall x. Rep DInfo x -> DInfo) -> Generic DInfo
forall x. Rep DInfo x -> DInfo
forall x. DInfo -> Rep DInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DInfo x -> DInfo
$cfrom :: forall x. DInfo -> Rep DInfo x
Generic)

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

-- | Corresponds to TH's @DerivClause@ type.
data DDerivClause = DDerivClause (Maybe DDerivStrategy) DCxt
                  deriving (DDerivClause -> DDerivClause -> Bool
(DDerivClause -> DDerivClause -> Bool)
-> (DDerivClause -> DDerivClause -> Bool) -> Eq DDerivClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DDerivClause -> DDerivClause -> Bool
$c/= :: DDerivClause -> DDerivClause -> Bool
== :: DDerivClause -> DDerivClause -> Bool
$c== :: DDerivClause -> DDerivClause -> Bool
Eq, Int -> DDerivClause -> ShowS
[DDerivClause] -> ShowS
DDerivClause -> String
(Int -> DDerivClause -> ShowS)
-> (DDerivClause -> String)
-> ([DDerivClause] -> ShowS)
-> Show DDerivClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DDerivClause] -> ShowS
$cshowList :: [DDerivClause] -> ShowS
show :: DDerivClause -> String
$cshow :: DDerivClause -> String
showsPrec :: Int -> DDerivClause -> ShowS
$cshowsPrec :: Int -> DDerivClause -> ShowS
Show, Typeable, Typeable DDerivClause
DataType
Constr
Typeable DDerivClause
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDerivClause -> c DDerivClause)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDerivClause)
-> (DDerivClause -> Constr)
-> (DDerivClause -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDerivClause))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DDerivClause))
-> ((forall b. Data b => b -> b) -> DDerivClause -> DDerivClause)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivClause -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivClause -> r)
-> (forall u. (forall d. Data d => d -> u) -> DDerivClause -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DDerivClause -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DDerivClause -> m DDerivClause)
-> Data DDerivClause
DDerivClause -> DataType
DDerivClause -> Constr
(forall b. Data b => b -> b) -> DDerivClause -> DDerivClause
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DDerivClause -> c DDerivClause
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDDerivClause :: Constr
$tDDerivClause :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DDerivClause -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DDerivClause -> u
gmapQ :: (forall d. Data d => d -> u) -> DDerivClause -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DDerivClause -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DDerivClause
Data, (forall x. DDerivClause -> Rep DDerivClause x)
-> (forall x. Rep DDerivClause x -> DDerivClause)
-> Generic DDerivClause
forall x. Rep DDerivClause x -> DDerivClause
forall x. DDerivClause -> Rep DDerivClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DDerivClause x -> DDerivClause
$cfrom :: forall x. DDerivClause -> Rep DDerivClause x
Generic)

-- | Corresponds to TH's @DerivStrategy@ type.
data DDerivStrategy = DStockStrategy     -- ^ A \"standard\" derived instance
                    | DAnyclassStrategy  -- ^ @-XDeriveAnyClass@
                    | DNewtypeStrategy   -- ^ @-XGeneralizedNewtypeDeriving@
                    | DViaStrategy DType -- ^ @-XDerivingVia@
                    deriving (DDerivStrategy -> DDerivStrategy -> Bool
(DDerivStrategy -> DDerivStrategy -> Bool)
-> (DDerivStrategy -> DDerivStrategy -> Bool) -> Eq DDerivStrategy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DDerivStrategy -> DDerivStrategy -> Bool
$c/= :: DDerivStrategy -> DDerivStrategy -> Bool
== :: DDerivStrategy -> DDerivStrategy -> Bool
$c== :: DDerivStrategy -> DDerivStrategy -> Bool
Eq, Int -> DDerivStrategy -> ShowS
[DDerivStrategy] -> ShowS
DDerivStrategy -> String
(Int -> DDerivStrategy -> ShowS)
-> (DDerivStrategy -> String)
-> ([DDerivStrategy] -> ShowS)
-> Show DDerivStrategy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DDerivStrategy] -> ShowS
$cshowList :: [DDerivStrategy] -> ShowS
show :: DDerivStrategy -> String
$cshow :: DDerivStrategy -> String
showsPrec :: Int -> DDerivStrategy -> ShowS
$cshowsPrec :: Int -> DDerivStrategy -> ShowS
Show, Typeable, Typeable DDerivStrategy
DataType
Constr
Typeable DDerivStrategy
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DDerivStrategy -> c DDerivStrategy)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DDerivStrategy)
-> (DDerivStrategy -> Constr)
-> (DDerivStrategy -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DDerivStrategy))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DDerivStrategy))
-> ((forall b. Data b => b -> b)
    -> DDerivStrategy -> DDerivStrategy)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivStrategy -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DDerivStrategy -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DDerivStrategy -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DDerivStrategy -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DDerivStrategy -> m DDerivStrategy)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DDerivStrategy -> m DDerivStrategy)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DDerivStrategy -> m DDerivStrategy)
-> Data DDerivStrategy
DDerivStrategy -> DataType
DDerivStrategy -> Constr
(forall b. Data b => b -> b) -> DDerivStrategy -> DDerivStrategy
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DDerivStrategy -> c DDerivStrategy
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDViaStrategy :: Constr
$cDNewtypeStrategy :: Constr
$cDAnyclassStrategy :: Constr
$cDStockStrategy :: Constr
$tDDerivStrategy :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> DDerivStrategy -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DDerivStrategy -> u
gmapQ :: (forall d. Data d => d -> u) -> DDerivStrategy -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DDerivStrategy -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable DDerivStrategy
Data, (forall x. DDerivStrategy -> Rep DDerivStrategy x)
-> (forall x. Rep DDerivStrategy x -> DDerivStrategy)
-> Generic DDerivStrategy
forall x. Rep DDerivStrategy x -> DDerivStrategy
forall x. DDerivStrategy -> Rep DDerivStrategy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DDerivStrategy x -> DDerivStrategy
$cfrom :: forall x. DDerivStrategy -> Rep DDerivStrategy x
Generic)