Language.Haskell.TH.Lib.Internal

template-haskell-2.14.0.0: Support library for Template Haskell

Safe Haskell | Safe
Language | Haskell2010

Language.Haskell.TH.Lib.Internal

Contents

- Type synonyms
- Lowercase pattern syntax functions
- Stmt
- Range
- Body
- Guard
- Match and Clause
- Exp
  - `arithSeqE` Shortcuts
- Dec
- Type
- Type Literals
- Kind
- Type family result
- Injectivity annotation
- Role
- Callconv
- Safety
- FunDep
- RuleBndr
- AnnTarget
- Pattern Synonyms (sub constructs)
- Useful helper function

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

# Type synonyms

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 DerivStrategyQ = Q DerivStrategy #

type Role = Role #

type InjectivityAnn = InjectivityAnn #

# Lowercase pattern syntax functions

intPrimL :: Integer -> Lit #

wordPrimL :: Integer -> Lit #

floatPrimL :: Rational -> Lit #

doublePrimL :: Rational -> Lit #

integerL :: Integer -> Lit #

charL :: Char -> Lit #

charPrimL :: Char -> Lit #

stringL :: String -> Lit #

stringPrimL :: [Word8] -> Lit #

rationalL :: Rational -> Lit #

litP :: Lit -> PatQ #

varP :: Name -> PatQ #

tupP :: [PatQ] -> PatQ #

unboxedTupP :: [PatQ] -> PatQ #

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

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

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

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

parensP :: PatQ -> PatQ #

tildeP :: PatQ -> PatQ #

bangP :: PatQ -> PatQ #

asP :: Name -> PatQ -> PatQ #

wildP :: PatQ #

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

listP :: [PatQ] -> PatQ #

sigP :: PatQ -> TypeQ -> PatQ #

viewP :: ExpQ -> PatQ -> PatQ #

fieldPat :: Name -> PatQ -> FieldPatQ #

# Stmt

bindS :: PatQ -> ExpQ -> StmtQ #

letS :: [DecQ] -> StmtQ #

noBindS :: ExpQ -> StmtQ #

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

# Range

fromR :: ExpQ -> RangeQ #

fromThenR :: ExpQ -> ExpQ -> RangeQ #

fromToR :: ExpQ -> ExpQ -> RangeQ #

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

# Body

normalB :: ExpQ -> BodyQ #

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

# Guard

normalG :: ExpQ -> GuardQ #

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

patG :: [StmtQ] -> GuardQ #

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

# Match and Clause

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

Use with `caseE`

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

Use with `funD`

# Exp

dyn :: String -> ExpQ #

Dynamically binding a variable (unhygenic)

varE :: Name -> ExpQ #

conE :: Name -> ExpQ #

litE :: Lit -> ExpQ #

appE :: ExpQ -> ExpQ -> ExpQ #

appTypeE :: ExpQ -> TypeQ -> ExpQ #

parensE :: ExpQ -> ExpQ #

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

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

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

sectionL :: ExpQ -> ExpQ -> ExpQ #

sectionR :: ExpQ -> ExpQ -> ExpQ #

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

lam1E :: PatQ -> ExpQ -> ExpQ #

Single-arg lambda

lamCaseE :: [MatchQ] -> ExpQ #

tupE :: [ExpQ] -> ExpQ #

unboxedTupE :: [ExpQ] -> ExpQ #

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

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

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

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

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

doE :: [StmtQ] -> ExpQ #

compE :: [StmtQ] -> ExpQ #

arithSeqE :: RangeQ -> ExpQ #

listE :: [ExpQ] -> ExpQ #

sigE :: ExpQ -> TypeQ -> ExpQ #

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

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

stringE :: String -> ExpQ #

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

staticE :: ExpQ -> ExpQ #

    staticE x = [| static x |]

unboundVarE :: Name -> ExpQ #

labelE :: String -> ExpQ #

## `arithSeqE` Shortcuts

fromE :: ExpQ -> ExpQ #

fromThenE :: ExpQ -> ExpQ -> ExpQ #

fromToE :: ExpQ -> ExpQ -> ExpQ #

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

# Dec

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

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

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

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

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

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

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

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

sigD :: Name -> TypeQ -> DecQ #

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

infixLD :: Int -> Name -> DecQ #

infixRD :: Int -> Name -> DecQ #

infixND :: Int -> Name -> DecQ #

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

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

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

pragSpecInstD :: TypeQ -> DecQ #

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

pragAnnD :: AnnTarget -> ExpQ -> DecQ #

pragLineD :: Int -> String -> DecQ #

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

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

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

tySynInstD :: Name -> TySynEqnQ -> DecQ #

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

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

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

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

standaloneDerivD :: CxtQ -> TypeQ -> DecQ #

standaloneDerivWithStrategyD :: Maybe DerivStrategyQ -> CxtQ -> TypeQ -> DecQ #

defaultSigD :: Name -> TypeQ -> DecQ #

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

Pattern synonym declaration

patSynSigD :: Name -> TypeQ -> DecQ #

Pattern synonym type signature

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

cxt :: [PredQ] -> CxtQ #

derivClause :: Maybe DerivStrategyQ -> [PredQ] -> DerivClauseQ #

stockStrategy :: DerivStrategyQ #

anyclassStrategy :: DerivStrategyQ #

newtypeStrategy :: DerivStrategyQ #

viaStrategy :: TypeQ -> DerivStrategyQ #

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

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

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

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

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

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

# Type

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

varT :: Name -> TypeQ #

conT :: Name -> TypeQ #

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

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

parensT :: TypeQ -> TypeQ #

appT :: TypeQ -> TypeQ -> TypeQ #

arrowT :: TypeQ #

listT :: TypeQ #

litT :: TyLitQ -> TypeQ #

tupleT :: Int -> TypeQ #

unboxedTupleT :: Int -> TypeQ #

unboxedSumT :: SumArity -> TypeQ #

sigT :: TypeQ -> KindQ -> TypeQ #

equalityT :: TypeQ #

wildCardT :: TypeQ #

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

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 #

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

promotedT :: Name -> TypeQ #

promotedTupleT :: Int -> TypeQ #

promotedNilT :: TypeQ #

promotedConsT :: TypeQ #

noSourceUnpackedness :: SourceUnpackednessQ #

sourceNoUnpack :: SourceUnpackednessQ #

sourceUnpack :: SourceUnpackednessQ #

noSourceStrictness :: SourceStrictnessQ #

sourceLazy :: SourceStrictnessQ #

sourceStrict :: SourceStrictnessQ #

isStrict :: Q Strict #

Deprecated: Use `bang`. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. Example usage: 'bang noSourceUnpackedness sourceStrict'

notStrict :: Q Strict #

Deprecated: Use `bang`. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. Example usage: 'bang noSourceUnpackedness noSourceStrictness'

unpacked :: Q Strict #

Deprecated: Use `bang`. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. Example usage: 'bang sourceUnpack sourceStrict'

bang :: SourceUnpackednessQ -> SourceStrictnessQ -> BangQ #

bangType :: BangQ -> TypeQ -> BangTypeQ #

varBangType :: Name -> BangTypeQ -> VarBangTypeQ #

strictType :: Q Strict -> TypeQ -> StrictTypeQ #

Deprecated: As of `template-haskell-2.11.0.0`, `StrictType` has been replaced by `BangType`. Please use `bangType` instead.

varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ #

Deprecated: As of `template-haskell-2.11.0.0`, `VarStrictType` has been replaced by `VarBangType`. Please use `varBangType` instead.

# Type Literals

numTyLit :: Integer -> TyLitQ #

strTyLit :: String -> TyLitQ #

# Kind

plainTV :: Name -> TyVarBndrQ #

kindedTV :: Name -> KindQ -> TyVarBndrQ #

varK :: Name -> Kind #

conK :: Name -> Kind #

tupleK :: Int -> Kind #

arrowK :: Kind #

listK :: Kind #

appK :: Kind -> Kind -> Kind #

starK :: KindQ #

constraintK :: KindQ #

# Type family result

noSig :: FamilyResultSigQ #

kindSig :: KindQ -> FamilyResultSigQ #

tyVarSig :: TyVarBndrQ -> FamilyResultSigQ #

# Injectivity annotation

injectivityAnn :: Name -> [Name] -> InjectivityAnn #

# Role

nominalR :: Role #

representationalR :: Role #

phantomR :: Role #

inferR :: Role #

# Callconv

cCall :: Callconv #

stdCall :: Callconv #

cApi :: Callconv #

prim :: Callconv #

javaScript :: Callconv #

# Safety

unsafe :: Safety #

safe :: Safety #

interruptible :: Safety #

# FunDep

funDep :: [Name] -> [Name] -> FunDep #

# RuleBndr

ruleVar :: Name -> RuleBndrQ #

typedRuleVar :: Name -> TypeQ -> RuleBndrQ #

# AnnTarget

valueAnnotation :: Name -> AnnTarget #

typeAnnotation :: Name -> AnnTarget #

moduleAnnotation :: AnnTarget #

# Pattern Synonyms (sub constructs)

unidir :: PatSynDirQ #

implBidir :: PatSynDirQ #

explBidir :: [ClauseQ] -> PatSynDirQ #

prefixPatSyn :: [Name] -> PatSynArgsQ #

recordPatSyn :: [Name] -> PatSynArgsQ #

infixPatSyn :: Name -> Name -> PatSynArgsQ #

# Useful helper function

appsE :: [ExpQ] -> ExpQ #

thisModule :: Q Module #

Return the Module at the place of splicing. Can be used as an input for `reifyModule`.