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

(c) Ryan Scott 2018

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

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

module Language.Haskell.TH.Desugar.AST where

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

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

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

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


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

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

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

-- types and kinds.

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

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

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

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

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

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

    --   where each binder has a 'Specificity'.

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

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

type DKind = DType

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

type DPred = DType

-- | Corresponds to TH's @Cxt@

type DCxt = [DPred]

-- | Corresponds to TH's @TyVarBndr@

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

-- | Corresponds to TH's @TyVarBndrSpec@

type DTyVarBndrSpec = DTyVarBndr Specificity

-- | Corresponds to TH's @TyVarBndrUnit@

type DTyVarBndrUnit = DTyVarBndr ()

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

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

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

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

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

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

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

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

            -- that desugaring upholds the following properties regarding the

            -- 'DataFlavor' field:

            --

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

            --   one 'DCon'.

            --

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

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

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

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

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

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

            -- that directly consume @DDec@s.

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

            -- upholds the following properties regarding the 'DataFlavor'

            -- field:

            --

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

            --   one 'DCon'.

            --

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

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

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

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

            -- that directly consume @DDec@s.

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

              -- signatures can only appear on the top level.

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

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

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

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

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

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

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

type DPatSynType = DType

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

data PatSynArgs
  = PrefixPatSyn [Name]        -- ^ @pattern P {x y z} = p@

  | InfixPatSyn Name Name      -- ^ @pattern {x P y} = p@

  | RecordPatSyn [Name]        -- ^ @pattern P { {x,y,z} } = p@

  deriving (Eq, Show, Data, Generic, Lift)
#endif

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

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

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

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

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

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

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

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

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

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

--

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

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

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

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

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

--   other.

--

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

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

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

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

-- data constructor.

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

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

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

-- below are declared infix.

--

-- @

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

-- @

--

-- Whereas neither of these constructors are declared infix:

--

-- @

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

-- @

--

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

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

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

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

--

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

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

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

--

-- For example, in the following GADT:

--

-- @

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

-- data InfixGADT a where

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

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

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

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

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

-- @

--

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

-- are not declared infix, because:

--

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

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

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

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

type DDeclaredInfix = Bool

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

type DBangType = (Bang, DType)

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

type DVarBangType = (Name, Bang, DType)

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

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

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

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

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

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

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

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

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

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

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

               -- if any

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

               -- is unlifted.

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

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


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

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

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

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

                    | DAnyclassStrategy  -- ^ @-XDeriveAnyClass@

                    | DNewtypeStrategy   -- ^ @-XGeneralizedNewtypeDeriving@

                    | DViaStrategy DType -- ^ @-XDerivingVia@

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