Safe Haskell	Safe
Language	Haskell2010

Language.Haskell.TH.Lib.Internal

Description

Language.Haskell.TH.Lib.Internal exposes some additional functionality that is used internally in GHC's integration with Template Haskell. This is not a part of the public API, and as such, there are no API guarantees for this module from version to version.

Synopsis

type InfoQ = Q Info
type PatQ = Q Pat
type FieldPatQ = Q FieldPat
type ExpQ = Q Exp
type TExpQ a = Q (TExp a)
type DecQ = Q Dec
type DecsQ = Q [Dec]
type ConQ = Q Con
type TypeQ = Q Type
type KindQ = Q Kind
type TyVarBndrQ = Q TyVarBndr
type TyLitQ = Q TyLit
type CxtQ = Q Cxt
type PredQ = Q Pred
type DerivClauseQ = Q DerivClause
type MatchQ = Q Match
type ClauseQ = Q Clause
type BodyQ = Q Body
type GuardQ = Q Guard
type StmtQ = Q Stmt
type RangeQ = Q Range
type SourceStrictnessQ = Q SourceStrictness
type SourceUnpackednessQ = Q SourceUnpackedness
type BangQ = Q Bang
type BangTypeQ = Q BangType
type VarBangTypeQ = Q VarBangType
type StrictTypeQ = Q StrictType
type VarStrictTypeQ = Q VarStrictType
type FieldExpQ = Q FieldExp
type RuleBndrQ = Q RuleBndr
type TySynEqnQ = Q TySynEqn
type PatSynDirQ = Q PatSynDir
type PatSynArgsQ = Q PatSynArgs
type FamilyResultSigQ = Q FamilyResultSig
type Role = Role
type InjectivityAnn = InjectivityAnn
intPrimL :: Integer -> Lit
intPrimL :: Integer -> Lit
wordPrimL :: Integer -> Lit
wordPrimL :: Integer -> Lit
floatPrimL :: Rational -> Lit
floatPrimL :: Rational -> Lit
doublePrimL :: Rational -> Lit
doublePrimL :: Rational -> Lit
integerL :: Integer -> Lit
integerL :: Integer -> Lit
charL :: Char -> Lit
charL :: Char -> Lit
charPrimL :: Char -> Lit
charPrimL :: Char -> Lit
stringL :: String -> Lit
stringL :: String -> Lit
stringPrimL :: [Word8] -> Lit
stringPrimL :: [Word8] -> Lit
rationalL :: Rational -> Lit
rationalL :: Rational -> Lit
litP :: Lit -> PatQ
litP :: Lit -> PatQ
varP :: Name -> PatQ
varP :: Name -> PatQ
tupP :: [PatQ] -> PatQ
tupP :: [PatQ] -> PatQ
unboxedTupP :: [PatQ] -> PatQ
unboxedTupP :: [PatQ] -> PatQ
unboxedSumP :: PatQ -> SumAlt -> SumArity -> PatQ
unboxedSumP :: PatQ -> SumAlt -> SumArity -> PatQ
conP :: Name -> [PatQ] -> PatQ
conP :: Name -> [PatQ] -> PatQ
infixP :: PatQ -> Name -> PatQ -> PatQ
infixP :: PatQ -> Name -> PatQ -> PatQ
uInfixP :: PatQ -> Name -> PatQ -> PatQ
uInfixP :: PatQ -> Name -> PatQ -> PatQ
parensP :: PatQ -> PatQ
parensP :: PatQ -> PatQ
tildeP :: PatQ -> PatQ
tildeP :: PatQ -> PatQ
bangP :: PatQ -> PatQ
bangP :: PatQ -> PatQ
asP :: Name -> PatQ -> PatQ
asP :: Name -> PatQ -> PatQ
wildP :: PatQ
wildP :: PatQ
recP :: Name -> [FieldPatQ] -> PatQ
recP :: Name -> [FieldPatQ] -> PatQ
listP :: [PatQ] -> PatQ
listP :: [PatQ] -> PatQ
sigP :: PatQ -> TypeQ -> PatQ
sigP :: PatQ -> TypeQ -> PatQ
viewP :: ExpQ -> PatQ -> PatQ
viewP :: ExpQ -> PatQ -> PatQ
fieldPat :: Name -> PatQ -> FieldPatQ
fieldPat :: Name -> PatQ -> FieldPatQ
bindS :: PatQ -> ExpQ -> StmtQ
bindS :: PatQ -> ExpQ -> StmtQ
letS :: [DecQ] -> StmtQ
letS :: [DecQ] -> StmtQ
noBindS :: ExpQ -> StmtQ
noBindS :: ExpQ -> StmtQ
parS :: [[StmtQ]] -> StmtQ
parS :: [[StmtQ]] -> StmtQ
fromR :: ExpQ -> RangeQ
fromR :: ExpQ -> RangeQ
fromThenR :: ExpQ -> ExpQ -> RangeQ
fromThenR :: ExpQ -> ExpQ -> RangeQ
fromToR :: ExpQ -> ExpQ -> RangeQ
fromToR :: ExpQ -> ExpQ -> RangeQ
fromThenToR :: ExpQ -> ExpQ -> ExpQ -> RangeQ
fromThenToR :: ExpQ -> ExpQ -> ExpQ -> RangeQ
normalB :: ExpQ -> BodyQ
normalB :: ExpQ -> BodyQ
guardedB :: [Q (Guard, Exp)] -> BodyQ
guardedB :: [Q (Guard, Exp)] -> BodyQ
normalG :: ExpQ -> GuardQ
normalG :: ExpQ -> GuardQ
normalGE :: ExpQ -> ExpQ -> Q (Guard, Exp)
normalGE :: ExpQ -> ExpQ -> Q (Guard, Exp)
patG :: [StmtQ] -> GuardQ
patG :: [StmtQ] -> GuardQ
patGE :: [StmtQ] -> ExpQ -> Q (Guard, Exp)
patGE :: [StmtQ] -> ExpQ -> Q (Guard, Exp)
match :: PatQ -> BodyQ -> [DecQ] -> MatchQ
match :: PatQ -> BodyQ -> [DecQ] -> MatchQ
clause :: [PatQ] -> BodyQ -> [DecQ] -> ClauseQ
clause :: [PatQ] -> BodyQ -> [DecQ] -> ClauseQ
dyn :: String -> ExpQ
dyn :: String -> ExpQ
varE :: Name -> ExpQ
varE :: Name -> ExpQ
conE :: Name -> ExpQ
conE :: Name -> ExpQ
litE :: Lit -> ExpQ
litE :: Lit -> ExpQ
appE :: ExpQ -> ExpQ -> ExpQ
appE :: ExpQ -> ExpQ -> ExpQ
appTypeE :: ExpQ -> TypeQ -> ExpQ
appTypeE :: ExpQ -> TypeQ -> ExpQ
parensE :: ExpQ -> ExpQ
parensE :: ExpQ -> ExpQ
uInfixE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
uInfixE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
infixE :: Maybe ExpQ -> ExpQ -> Maybe ExpQ -> ExpQ
infixE :: Maybe ExpQ -> ExpQ -> Maybe ExpQ -> ExpQ
infixApp :: ExpQ -> ExpQ -> ExpQ -> ExpQ
infixApp :: ExpQ -> ExpQ -> ExpQ -> ExpQ
sectionL :: ExpQ -> ExpQ -> ExpQ
sectionL :: ExpQ -> ExpQ -> ExpQ
sectionR :: ExpQ -> ExpQ -> ExpQ
sectionR :: ExpQ -> ExpQ -> ExpQ
lamE :: [PatQ] -> ExpQ -> ExpQ
lamE :: [PatQ] -> ExpQ -> ExpQ
lam1E :: PatQ -> ExpQ -> ExpQ
lam1E :: PatQ -> ExpQ -> ExpQ
lamCaseE :: [MatchQ] -> ExpQ
lamCaseE :: [MatchQ] -> ExpQ
tupE :: [ExpQ] -> ExpQ
tupE :: [ExpQ] -> ExpQ
unboxedTupE :: [ExpQ] -> ExpQ
unboxedTupE :: [ExpQ] -> ExpQ
unboxedSumE :: ExpQ -> SumAlt -> SumArity -> ExpQ
unboxedSumE :: ExpQ -> SumAlt -> SumArity -> ExpQ
condE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
condE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
multiIfE :: [Q (Guard, Exp)] -> ExpQ
multiIfE :: [Q (Guard, Exp)] -> ExpQ
letE :: [DecQ] -> ExpQ -> ExpQ
letE :: [DecQ] -> ExpQ -> ExpQ
caseE :: ExpQ -> [MatchQ] -> ExpQ
caseE :: ExpQ -> [MatchQ] -> ExpQ
doE :: [StmtQ] -> ExpQ
doE :: [StmtQ] -> ExpQ
compE :: [StmtQ] -> ExpQ
compE :: [StmtQ] -> ExpQ
arithSeqE :: RangeQ -> ExpQ
arithSeqE :: RangeQ -> ExpQ
listE :: [ExpQ] -> ExpQ
listE :: [ExpQ] -> ExpQ
sigE :: ExpQ -> TypeQ -> ExpQ
sigE :: ExpQ -> TypeQ -> ExpQ
recConE :: Name -> [Q (Name, Exp)] -> ExpQ
recConE :: Name -> [Q (Name, Exp)] -> ExpQ
recUpdE :: ExpQ -> [Q (Name, Exp)] -> ExpQ
recUpdE :: ExpQ -> [Q (Name, Exp)] -> ExpQ
stringE :: String -> ExpQ
stringE :: String -> ExpQ
fieldExp :: Name -> ExpQ -> Q (Name, Exp)
fieldExp :: Name -> ExpQ -> Q (Name, Exp)
staticE :: ExpQ -> ExpQ
staticE :: ExpQ -> ExpQ
unboundVarE :: Name -> ExpQ
unboundVarE :: Name -> ExpQ
labelE :: String -> ExpQ
labelE :: String -> ExpQ
fromE :: ExpQ -> ExpQ
fromE :: ExpQ -> ExpQ
fromThenE :: ExpQ -> ExpQ -> ExpQ
fromThenE :: ExpQ -> ExpQ -> ExpQ
fromToE :: ExpQ -> ExpQ -> ExpQ
fromToE :: ExpQ -> ExpQ -> ExpQ
fromThenToE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
fromThenToE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
valD :: PatQ -> BodyQ -> [DecQ] -> DecQ
valD :: PatQ -> BodyQ -> [DecQ] -> DecQ
funD :: Name -> [ClauseQ] -> DecQ
funD :: Name -> [ClauseQ] -> DecQ
tySynD :: Name -> [TyVarBndrQ] -> TypeQ -> DecQ
tySynD :: Name -> [TyVarBndrQ] -> TypeQ -> DecQ
dataD :: CxtQ -> Name -> [TyVarBndrQ] -> Maybe KindQ -> [ConQ] -> [DerivClauseQ] -> DecQ
dataD :: CxtQ -> Name -> [TyVarBndrQ] -> Maybe KindQ -> [ConQ] -> [DerivClauseQ] -> DecQ
newtypeD :: CxtQ -> Name -> [TyVarBndrQ] -> Maybe KindQ -> ConQ -> [DerivClauseQ] -> DecQ
newtypeD :: CxtQ -> Name -> [TyVarBndrQ] -> Maybe KindQ -> ConQ -> [DerivClauseQ] -> DecQ
classD :: CxtQ -> Name -> [TyVarBndrQ] -> [FunDep] -> [DecQ] -> DecQ
classD :: CxtQ -> Name -> [TyVarBndrQ] -> [FunDep] -> [DecQ] -> DecQ
instanceD :: CxtQ -> TypeQ -> [DecQ] -> DecQ
instanceD :: CxtQ -> TypeQ -> [DecQ] -> DecQ
instanceWithOverlapD :: Maybe Overlap -> CxtQ -> TypeQ -> [DecQ] -> DecQ
instanceWithOverlapD :: Maybe Overlap -> CxtQ -> TypeQ -> [DecQ] -> DecQ
sigD :: Name -> TypeQ -> DecQ
sigD :: Name -> TypeQ -> DecQ
forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ
forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ
infixLD :: Int -> Name -> DecQ
infixLD :: Int -> Name -> DecQ
infixRD :: Int -> Name -> DecQ
infixRD :: Int -> Name -> DecQ
infixND :: Int -> Name -> DecQ
infixND :: Int -> Name -> DecQ
pragInlD :: Name -> Inline -> RuleMatch -> Phases -> DecQ
pragInlD :: Name -> Inline -> RuleMatch -> Phases -> DecQ
pragSpecD :: Name -> TypeQ -> Phases -> DecQ
pragSpecD :: Name -> TypeQ -> Phases -> DecQ
pragSpecInlD :: Name -> TypeQ -> Inline -> Phases -> DecQ
pragSpecInlD :: Name -> TypeQ -> Inline -> Phases -> DecQ
pragSpecInstD :: TypeQ -> DecQ
pragSpecInstD :: TypeQ -> DecQ
pragRuleD :: String -> [RuleBndrQ] -> ExpQ -> ExpQ -> Phases -> DecQ
pragRuleD :: String -> [RuleBndrQ] -> ExpQ -> ExpQ -> Phases -> DecQ
pragAnnD :: AnnTarget -> ExpQ -> DecQ
pragAnnD :: AnnTarget -> ExpQ -> DecQ
pragLineD :: Int -> String -> DecQ
pragLineD :: Int -> String -> DecQ
pragCompleteD :: [Name] -> Maybe Name -> DecQ
pragCompleteD :: [Name] -> Maybe Name -> DecQ
dataInstD :: CxtQ -> Name -> [TypeQ] -> Maybe KindQ -> [ConQ] -> [DerivClauseQ] -> DecQ
dataInstD :: CxtQ -> Name -> [TypeQ] -> Maybe KindQ -> [ConQ] -> [DerivClauseQ] -> DecQ
newtypeInstD :: CxtQ -> Name -> [TypeQ] -> Maybe KindQ -> ConQ -> [DerivClauseQ] -> DecQ
newtypeInstD :: CxtQ -> Name -> [TypeQ] -> Maybe KindQ -> ConQ -> [DerivClauseQ] -> DecQ
tySynInstD :: Name -> TySynEqnQ -> DecQ
tySynInstD :: Name -> TySynEqnQ -> DecQ
dataFamilyD :: Name -> [TyVarBndrQ] -> Maybe KindQ -> DecQ
dataFamilyD :: Name -> [TyVarBndrQ] -> Maybe KindQ -> DecQ
openTypeFamilyD :: Name -> [TyVarBndrQ] -> FamilyResultSigQ -> Maybe InjectivityAnn -> DecQ
openTypeFamilyD :: Name -> [TyVarBndrQ] -> FamilyResultSigQ -> Maybe InjectivityAnn -> DecQ
closedTypeFamilyD :: Name -> [TyVarBndrQ] -> FamilyResultSigQ -> Maybe InjectivityAnn -> [TySynEqnQ] -> DecQ
closedTypeFamilyD :: Name -> [TyVarBndrQ] -> FamilyResultSigQ -> Maybe InjectivityAnn -> [TySynEqnQ] -> DecQ
roleAnnotD :: Name -> [Role] -> DecQ
roleAnnotD :: Name -> [Role] -> DecQ
standaloneDerivD :: CxtQ -> TypeQ -> DecQ
standaloneDerivD :: CxtQ -> TypeQ -> DecQ
standaloneDerivWithStrategyD :: Maybe DerivStrategy -> CxtQ -> TypeQ -> DecQ
standaloneDerivWithStrategyD :: Maybe DerivStrategy -> CxtQ -> TypeQ -> DecQ
defaultSigD :: Name -> TypeQ -> DecQ
defaultSigD :: Name -> TypeQ -> DecQ
patSynD :: Name -> PatSynArgsQ -> PatSynDirQ -> PatQ -> DecQ
patSynD :: Name -> PatSynArgsQ -> PatSynDirQ -> PatQ -> DecQ
patSynSigD :: Name -> TypeQ -> DecQ
patSynSigD :: Name -> TypeQ -> DecQ
tySynEqn :: [TypeQ] -> TypeQ -> TySynEqnQ
tySynEqn :: [TypeQ] -> TypeQ -> TySynEqnQ
cxt :: [PredQ] -> CxtQ
cxt :: [PredQ] -> CxtQ
derivClause :: Maybe DerivStrategy -> [PredQ] -> DerivClauseQ
derivClause :: Maybe DerivStrategy -> [PredQ] -> DerivClauseQ
normalC :: Name -> [BangTypeQ] -> ConQ
normalC :: Name -> [BangTypeQ] -> ConQ
recC :: Name -> [VarBangTypeQ] -> ConQ
recC :: Name -> [VarBangTypeQ] -> ConQ
infixC :: Q (Bang, Type) -> Name -> Q (Bang, Type) -> ConQ
infixC :: Q (Bang, Type) -> Name -> Q (Bang, Type) -> ConQ
forallC :: [TyVarBndrQ] -> CxtQ -> ConQ -> ConQ
forallC :: [TyVarBndrQ] -> CxtQ -> ConQ -> ConQ
gadtC :: [Name] -> [StrictTypeQ] -> TypeQ -> ConQ
gadtC :: [Name] -> [StrictTypeQ] -> TypeQ -> ConQ
recGadtC :: [Name] -> [VarStrictTypeQ] -> TypeQ -> ConQ
recGadtC :: [Name] -> [VarStrictTypeQ] -> TypeQ -> ConQ
forallT :: [TyVarBndrQ] -> CxtQ -> TypeQ -> TypeQ
forallT :: [TyVarBndrQ] -> CxtQ -> TypeQ -> TypeQ
varT :: Name -> TypeQ
varT :: Name -> TypeQ
conT :: Name -> TypeQ
conT :: Name -> TypeQ
infixT :: TypeQ -> Name -> TypeQ -> TypeQ
infixT :: TypeQ -> Name -> TypeQ -> TypeQ
uInfixT :: TypeQ -> Name -> TypeQ -> TypeQ
uInfixT :: TypeQ -> Name -> TypeQ -> TypeQ
parensT :: TypeQ -> TypeQ
parensT :: TypeQ -> TypeQ
appT :: TypeQ -> TypeQ -> TypeQ
appT :: TypeQ -> TypeQ -> TypeQ
arrowT :: TypeQ
arrowT :: TypeQ
listT :: TypeQ
listT :: TypeQ
litT :: TyLitQ -> TypeQ
litT :: TyLitQ -> TypeQ
tupleT :: Int -> TypeQ
tupleT :: Int -> TypeQ
unboxedTupleT :: Int -> TypeQ
unboxedTupleT :: Int -> TypeQ
unboxedSumT :: SumArity -> TypeQ
unboxedSumT :: SumArity -> TypeQ
sigT :: TypeQ -> KindQ -> TypeQ
sigT :: TypeQ -> KindQ -> TypeQ
equalityT :: TypeQ
equalityT :: TypeQ
wildCardT :: TypeQ
wildCardT :: TypeQ
classP :: Name -> [Q Type] -> Q Pred
classP :: Name -> [Q Type] -> Q Pred
equalP :: TypeQ -> TypeQ -> PredQ
equalP :: TypeQ -> TypeQ -> PredQ
promotedT :: Name -> TypeQ
promotedT :: Name -> TypeQ
promotedTupleT :: Int -> TypeQ
promotedTupleT :: Int -> TypeQ
promotedNilT :: TypeQ
promotedNilT :: TypeQ
promotedConsT :: TypeQ
promotedConsT :: TypeQ
noSourceUnpackedness :: SourceUnpackednessQ
sourceNoUnpack :: SourceUnpackednessQ
sourceUnpack :: SourceUnpackednessQ
noSourceUnpackedness :: SourceUnpackednessQ
sourceNoUnpack :: SourceUnpackednessQ
sourceUnpack :: SourceUnpackednessQ
noSourceStrictness :: SourceStrictnessQ
sourceLazy :: SourceStrictnessQ
sourceStrict :: SourceStrictnessQ
noSourceStrictness :: SourceStrictnessQ
sourceLazy :: SourceStrictnessQ
sourceStrict :: SourceStrictnessQ
isStrict :: Q Strict
notStrict :: Q Strict
unpacked :: Q Strict
isStrict :: Q Strict
notStrict :: Q Strict
unpacked :: Q Strict
bang :: SourceUnpackednessQ -> SourceStrictnessQ -> BangQ
bang :: SourceUnpackednessQ -> SourceStrictnessQ -> BangQ
bangType :: BangQ -> TypeQ -> BangTypeQ
bangType :: BangQ -> TypeQ -> BangTypeQ
varBangType :: Name -> BangTypeQ -> VarBangTypeQ
varBangType :: Name -> BangTypeQ -> VarBangTypeQ
strictType :: Q Strict -> TypeQ -> StrictTypeQ
strictType :: Q Strict -> TypeQ -> StrictTypeQ
varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ
varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ
numTyLit :: Integer -> TyLitQ
numTyLit :: Integer -> TyLitQ
strTyLit :: String -> TyLitQ
strTyLit :: String -> TyLitQ
plainTV :: Name -> TyVarBndrQ
plainTV :: Name -> TyVarBndrQ
kindedTV :: Name -> KindQ -> TyVarBndrQ
kindedTV :: Name -> KindQ -> TyVarBndrQ
varK :: Name -> Kind
varK :: Name -> Kind
conK :: Name -> Kind
conK :: Name -> Kind
tupleK :: Int -> Kind
tupleK :: Int -> Kind
arrowK :: Kind
arrowK :: Kind
listK :: Kind
listK :: Kind
appK :: Kind -> Kind -> Kind
appK :: Kind -> Kind -> Kind
starK :: KindQ
starK :: KindQ
constraintK :: KindQ
constraintK :: KindQ
noSig :: FamilyResultSigQ
noSig :: FamilyResultSigQ
kindSig :: KindQ -> FamilyResultSigQ
kindSig :: KindQ -> FamilyResultSigQ
tyVarSig :: TyVarBndrQ -> FamilyResultSigQ
tyVarSig :: TyVarBndrQ -> FamilyResultSigQ
injectivityAnn :: Name -> [Name] -> InjectivityAnn
injectivityAnn :: Name -> [Name] -> InjectivityAnn
nominalR :: Role
representationalR :: Role
phantomR :: Role
inferR :: Role
nominalR :: Role
representationalR :: Role
phantomR :: Role
inferR :: Role
cCall :: Callconv
stdCall :: Callconv
cApi :: Callconv
prim :: Callconv
javaScript :: Callconv
cCall :: Callconv
stdCall :: Callconv
cApi :: Callconv
prim :: Callconv
javaScript :: Callconv
unsafe :: Safety
safe :: Safety
interruptible :: Safety
unsafe :: Safety
safe :: Safety
interruptible :: Safety
funDep :: [Name] -> [Name] -> FunDep
funDep :: [Name] -> [Name] -> FunDep
ruleVar :: Name -> RuleBndrQ
ruleVar :: Name -> RuleBndrQ
typedRuleVar :: Name -> TypeQ -> RuleBndrQ
typedRuleVar :: Name -> TypeQ -> RuleBndrQ
valueAnnotation :: Name -> AnnTarget
valueAnnotation :: Name -> AnnTarget
typeAnnotation :: Name -> AnnTarget
typeAnnotation :: Name -> AnnTarget
moduleAnnotation :: AnnTarget
moduleAnnotation :: AnnTarget
unidir :: PatSynDirQ
implBidir :: PatSynDirQ
unidir :: PatSynDirQ
implBidir :: PatSynDirQ
explBidir :: [ClauseQ] -> PatSynDirQ
explBidir :: [ClauseQ] -> PatSynDirQ
prefixPatSyn :: [Name] -> PatSynArgsQ
prefixPatSyn :: [Name] -> PatSynArgsQ
recordPatSyn :: [Name] -> PatSynArgsQ
recordPatSyn :: [Name] -> PatSynArgsQ
infixPatSyn :: Name -> Name -> PatSynArgsQ
infixPatSyn :: Name -> Name -> PatSynArgsQ
appsE :: [ExpQ] -> ExpQ
appsE :: [ExpQ] -> ExpQ
thisModule :: Q Module
thisModule :: Q Module

Documentation

type InfoQ = Q Info Source #

type PatQ = Q Pat Source #

type FieldPatQ = Q FieldPat Source #

type ExpQ = Q Exp Source #

type TExpQ a = Q (TExp a) Source #

type DecQ = Q Dec Source #

type DecsQ = Q [Dec] Source #

type ConQ = Q Con Source #

type TypeQ = Q Type Source #

type KindQ = Q Kind Source #

type TyVarBndrQ = Q TyVarBndr Source #

type TyLitQ = Q TyLit Source #

type CxtQ = Q Cxt Source #

type PredQ = Q Pred Source #

type DerivClauseQ = Q DerivClause Source #

type MatchQ = Q Match Source #

type ClauseQ = Q Clause Source #

type BodyQ = Q Body Source #

type GuardQ = Q Guard Source #

type StmtQ = Q Stmt Source #

type RangeQ = Q Range Source #

type SourceStrictnessQ = Q SourceStrictness Source #

type SourceUnpackednessQ = Q SourceUnpackedness Source #

type BangQ = Q Bang Source #

type BangTypeQ = Q BangType Source #

type VarBangTypeQ = Q VarBangType Source #

type StrictTypeQ = Q StrictType Source #

type VarStrictTypeQ = Q VarStrictType Source #

type FieldExpQ = Q FieldExp Source #

type RuleBndrQ = Q RuleBndr Source #

type TySynEqnQ = Q TySynEqn Source #

type PatSynDirQ = Q PatSynDir Source #

type PatSynArgsQ = Q PatSynArgs Source #

type FamilyResultSigQ = Q FamilyResultSig Source #

type Role = Role Source #

type InjectivityAnn = InjectivityAnn Source #

intPrimL :: Integer -> Lit Source #

wordPrimL :: Integer -> Lit Source #

floatPrimL :: Rational -> Lit Source #

doublePrimL :: Rational -> Lit Source #

integerL :: Integer -> Lit Source #

charL :: Char -> Lit Source #

charPrimL :: Char -> Lit Source #

stringL :: String -> Lit Source #

stringPrimL :: [Word8] -> Lit Source #

rationalL :: Rational -> Lit Source #

litP :: Lit -> PatQ Source #

varP :: Name -> PatQ Source #

tupP :: [PatQ] -> PatQ Source #

unboxedTupP :: [PatQ] -> PatQ Source #

unboxedSumP :: PatQ -> SumAlt -> SumArity -> PatQ Source #

conP :: Name -> [PatQ] -> PatQ Source #

infixP :: PatQ -> Name -> PatQ -> PatQ Source #

uInfixP :: PatQ -> Name -> PatQ -> PatQ Source #

parensP :: PatQ -> PatQ Source #

tildeP :: PatQ -> PatQ Source #

bangP :: PatQ -> PatQ Source #

asP :: Name -> PatQ -> PatQ Source #

wildP :: PatQ Source #

recP :: Name -> [FieldPatQ] -> PatQ Source #

listP :: [PatQ] -> PatQ Source #

sigP :: PatQ -> TypeQ -> PatQ Source #

viewP :: ExpQ -> PatQ -> PatQ Source #

fieldPat :: Name -> PatQ -> FieldPatQ Source #

bindS :: PatQ -> ExpQ -> StmtQ Source #

letS :: [DecQ] -> StmtQ Source #

noBindS :: ExpQ -> StmtQ Source #

parS :: [[StmtQ]] -> StmtQ Source #

fromR :: ExpQ -> RangeQ Source #

fromThenR :: ExpQ -> ExpQ -> RangeQ Source #

fromToR :: ExpQ -> ExpQ -> RangeQ Source #

fromThenToR :: ExpQ -> ExpQ -> ExpQ -> RangeQ Source #

normalB :: ExpQ -> BodyQ Source #

guardedB :: [Q (Guard, Exp)] -> BodyQ Source #

normalG :: ExpQ -> GuardQ Source #

normalGE :: ExpQ -> ExpQ -> Q (Guard, Exp) Source #

patG :: [StmtQ] -> GuardQ Source #

patGE :: [StmtQ] -> ExpQ -> Q (Guard, Exp) Source #

match :: PatQ -> BodyQ -> [DecQ] -> MatchQ Source #

Use with caseE

match :: PatQ -> BodyQ -> [DecQ] -> MatchQ Source #

Use with caseE

clause :: [PatQ] -> BodyQ -> [DecQ] -> ClauseQ Source #

Use with funD

clause :: [PatQ] -> BodyQ -> [DecQ] -> ClauseQ Source #

Use with funD

dyn :: String -> ExpQ Source #

Dynamically binding a variable (unhygenic)

dyn :: String -> ExpQ Source #

Dynamically binding a variable (unhygenic)

varE :: Name -> ExpQ Source #

conE :: Name -> ExpQ Source #

litE :: Lit -> ExpQ Source #

appE :: ExpQ -> ExpQ -> ExpQ Source #

appTypeE :: ExpQ -> TypeQ -> ExpQ Source #

parensE :: ExpQ -> ExpQ Source #

uInfixE :: ExpQ -> ExpQ -> ExpQ -> ExpQ Source #

infixE :: Maybe ExpQ -> ExpQ -> Maybe ExpQ -> ExpQ Source #

infixApp :: ExpQ -> ExpQ -> ExpQ -> ExpQ Source #

sectionL :: ExpQ -> ExpQ -> ExpQ Source #

sectionR :: ExpQ -> ExpQ -> ExpQ Source #

lamE :: [PatQ] -> ExpQ -> ExpQ Source #

lam1E :: PatQ -> ExpQ -> ExpQ Source #

Single-arg lambda

lam1E :: PatQ -> ExpQ -> ExpQ Source #

Single-arg lambda

lamCaseE :: [MatchQ] -> ExpQ Source #

tupE :: [ExpQ] -> ExpQ Source #

unboxedTupE :: [ExpQ] -> ExpQ Source #

unboxedSumE :: ExpQ -> SumAlt -> SumArity -> ExpQ Source #

condE :: ExpQ -> ExpQ -> ExpQ -> ExpQ Source #

multiIfE :: [Q (Guard, Exp)] -> ExpQ Source #

letE :: [DecQ] -> ExpQ -> ExpQ Source #

caseE :: ExpQ -> [MatchQ] -> ExpQ Source #

doE :: [StmtQ] -> ExpQ Source #

compE :: [StmtQ] -> ExpQ Source #

arithSeqE :: RangeQ -> ExpQ Source #

listE :: [ExpQ] -> ExpQ Source #

sigE :: ExpQ -> TypeQ -> ExpQ Source #

recConE :: Name -> [Q (Name, Exp)] -> ExpQ Source #

recUpdE :: ExpQ -> [Q (Name, Exp)] -> ExpQ Source #

stringE :: String -> ExpQ Source #

fieldExp :: Name -> ExpQ -> Q (Name, Exp) Source #

staticE :: ExpQ -> ExpQ Source #

staticE x = [| static x |]

staticE :: ExpQ -> ExpQ Source #

staticE x = [| static x |]

unboundVarE :: Name -> ExpQ Source #

labelE :: String -> ExpQ Source #

fromE :: ExpQ -> ExpQ Source #

fromThenE :: ExpQ -> ExpQ -> ExpQ Source #

fromToE :: ExpQ -> ExpQ -> ExpQ Source #

fromThenToE :: ExpQ -> ExpQ -> ExpQ -> ExpQ Source #

valD :: PatQ -> BodyQ -> [DecQ] -> DecQ Source #

funD :: Name -> [ClauseQ] -> DecQ Source #

tySynD :: Name -> [TyVarBndrQ] -> TypeQ -> DecQ Source #

dataD :: CxtQ -> Name -> [TyVarBndrQ] -> Maybe KindQ -> [ConQ] -> [DerivClauseQ] -> DecQ Source #

newtypeD :: CxtQ -> Name -> [TyVarBndrQ] -> Maybe KindQ -> ConQ -> [DerivClauseQ] -> DecQ Source #

classD :: CxtQ -> Name -> [TyVarBndrQ] -> [FunDep] -> [DecQ] -> DecQ Source #

instanceD :: CxtQ -> TypeQ -> [DecQ] -> DecQ Source #

instanceWithOverlapD :: Maybe Overlap -> CxtQ -> TypeQ -> [DecQ] -> DecQ Source #

sigD :: Name -> TypeQ -> DecQ Source #

forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ Source #

infixLD :: Int -> Name -> DecQ Source #

infixRD :: Int -> Name -> DecQ Source #

infixND :: Int -> Name -> DecQ Source #

pragInlD :: Name -> Inline -> RuleMatch -> Phases -> DecQ Source #

pragSpecD :: Name -> TypeQ -> Phases -> DecQ Source #

pragSpecInlD :: Name -> TypeQ -> Inline -> Phases -> DecQ Source #

pragSpecInstD :: TypeQ -> DecQ Source #

pragRuleD :: String -> [RuleBndrQ] -> ExpQ -> ExpQ -> Phases -> DecQ Source #

pragAnnD :: AnnTarget -> ExpQ -> DecQ Source #

pragLineD :: Int -> String -> DecQ Source #

pragCompleteD :: [Name] -> Maybe Name -> DecQ Source #

dataInstD :: CxtQ -> Name -> [TypeQ] -> Maybe KindQ -> [ConQ] -> [DerivClauseQ] -> DecQ Source #

newtypeInstD :: CxtQ -> Name -> [TypeQ] -> Maybe KindQ -> ConQ -> [DerivClauseQ] -> DecQ Source #

tySynInstD :: Name -> TySynEqnQ -> DecQ Source #

dataFamilyD :: Name -> [TyVarBndrQ] -> Maybe KindQ -> DecQ Source #

openTypeFamilyD :: Name -> [TyVarBndrQ] -> FamilyResultSigQ -> Maybe InjectivityAnn -> DecQ Source #

closedTypeFamilyD :: Name -> [TyVarBndrQ] -> FamilyResultSigQ -> Maybe InjectivityAnn -> [TySynEqnQ] -> DecQ Source #

roleAnnotD :: Name -> [Role] -> DecQ Source #

standaloneDerivD :: CxtQ -> TypeQ -> DecQ Source #

standaloneDerivWithStrategyD :: Maybe DerivStrategy -> CxtQ -> TypeQ -> DecQ Source #

defaultSigD :: Name -> TypeQ -> DecQ Source #

patSynD :: Name -> PatSynArgsQ -> PatSynDirQ -> PatQ -> DecQ Source #

Pattern synonym declaration

patSynD :: Name -> PatSynArgsQ -> PatSynDirQ -> PatQ -> DecQ Source #

Pattern synonym declaration

patSynSigD :: Name -> TypeQ -> DecQ Source #

Pattern synonym type signature

patSynSigD :: Name -> TypeQ -> DecQ Source #

Pattern synonym type signature

tySynEqn :: [TypeQ] -> TypeQ -> TySynEqnQ Source #

cxt :: [PredQ] -> CxtQ Source #

derivClause :: Maybe DerivStrategy -> [PredQ] -> DerivClauseQ Source #

normalC :: Name -> [BangTypeQ] -> ConQ Source #

recC :: Name -> [VarBangTypeQ] -> ConQ Source #

infixC :: Q (Bang, Type) -> Name -> Q (Bang, Type) -> ConQ Source #

forallC :: [TyVarBndrQ] -> CxtQ -> ConQ -> ConQ Source #

gadtC :: [Name] -> [StrictTypeQ] -> TypeQ -> ConQ Source #

recGadtC :: [Name] -> [VarStrictTypeQ] -> TypeQ -> ConQ Source #

forallT :: [TyVarBndrQ] -> CxtQ -> TypeQ -> TypeQ Source #

varT :: Name -> TypeQ Source #

conT :: Name -> TypeQ Source #

infixT :: TypeQ -> Name -> TypeQ -> TypeQ Source #

uInfixT :: TypeQ -> Name -> TypeQ -> TypeQ Source #

parensT :: TypeQ -> TypeQ Source #

appT :: TypeQ -> TypeQ -> TypeQ Source #

arrowT :: TypeQ Source #

listT :: TypeQ Source #

litT :: TyLitQ -> TypeQ Source #

tupleT :: Int -> TypeQ Source #

unboxedTupleT :: Int -> TypeQ Source #

unboxedSumT :: SumArity -> TypeQ Source #

sigT :: TypeQ -> KindQ -> TypeQ Source #

equalityT :: TypeQ Source #

wildCardT :: TypeQ Source #

classP :: Name -> [Q Type] -> Q Pred Source #

Deprecated: As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please use conT and appT.

classP :: Name -> [Q Type] -> Q Pred Source #

Deprecated: As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please use conT and appT.

equalP :: TypeQ -> TypeQ -> PredQ Source #

Deprecated: As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please see equalityT.

equalP :: TypeQ -> TypeQ -> PredQ Source #

Deprecated: As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please see equalityT.

promotedT :: Name -> TypeQ Source #

promotedTupleT :: Int -> TypeQ Source #

promotedNilT :: TypeQ Source #

promotedConsT :: TypeQ Source #

noSourceUnpackedness :: SourceUnpackednessQ Source #

sourceNoUnpack :: SourceUnpackednessQ Source #

sourceUnpack :: SourceUnpackednessQ Source #

noSourceUnpackedness :: SourceUnpackednessQ Source #