Language.Haskell.TH.Lib

Contents

• Library functions
  • Abbreviations
  • Constructors lifted to Q
    • Literals
    • Patterns
    • Pattern Guards
    • Expressions
      • Ranges
        • Ranges with more indirection
      • Statements
    • Types
      • Type literals
      • Strictness
      • Class Contexts
      • Constructors
    • Kinds
    • Type variable binders
    • Roles
    • Top Level Declarations
      • Data
      • Class
      • Role annotations
      • Type Family / Data Family
      • Fixity
      • Foreign Function Interface (FFI)
      • Functional dependencies
      • Pragmas
      • Pattern Synonyms
  • Reify

Description

Synopsis

• type InfoQ = Q Info
• 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 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 PatQ = Q Pat
• type FieldPatQ = Q FieldPat
• type RuleBndrQ = Q RuleBndr
• type TySynEqnQ = Q TySynEqn
• type PatSynDirQ = Q PatSynDir
• type PatSynArgsQ = Q PatSynArgs
• intPrimL :: Integer -> Lit
• wordPrimL :: Integer -> Lit
• floatPrimL :: Rational -> Lit
• doublePrimL :: Rational -> Lit
• integerL :: Integer -> Lit
• rationalL :: Rational -> Lit
• charL :: Char -> Lit
• stringL :: String -> Lit
• stringPrimL :: [Word8] -> Lit
• charPrimL :: Char -> Lit
• litP :: Lit -> PatQ
• varP :: Name -> PatQ
• tupP :: [PatQ] -> PatQ
• unboxedTupP :: [PatQ] -> PatQ
• unboxedSumP :: PatQ -> SumAlt -> SumArity -> PatQ
• conP :: Name -> [PatQ] -> PatQ
• uInfixP :: PatQ -> Name -> PatQ -> PatQ
• parensP :: PatQ -> PatQ
• infixP :: PatQ -> Name -> 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
• 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
• unboundVarE :: Name -> ExpQ
• conE :: Name -> ExpQ
• litE :: Lit -> ExpQ
• appE :: ExpQ -> ExpQ -> ExpQ
• appTypeE :: ExpQ -> TypeQ -> ExpQ
• uInfixE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
• parensE :: ExpQ -> ExpQ
• staticE :: 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
• appsE :: [ExpQ] -> 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)
• fromE :: ExpQ -> ExpQ
• fromThenE :: ExpQ -> ExpQ -> ExpQ
• fromToE :: ExpQ -> ExpQ -> ExpQ
• fromThenToE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
• arithSeqE :: RangeQ -> ExpQ
• fromR :: ExpQ -> RangeQ
• fromThenR :: ExpQ -> ExpQ -> RangeQ
• fromToR :: ExpQ -> ExpQ -> RangeQ
• fromThenToR :: ExpQ -> ExpQ -> ExpQ -> RangeQ
• doE :: [StmtQ] -> ExpQ
• compE :: [StmtQ] -> ExpQ
• bindS :: PatQ -> ExpQ -> StmtQ
• letS :: [DecQ] -> StmtQ
• noBindS :: ExpQ -> StmtQ
• parS :: [[StmtQ]] -> StmtQ
• forallT :: [TyVarBndr] -> CxtQ -> TypeQ -> TypeQ
• varT :: Name -> TypeQ
• conT :: Name -> TypeQ
• appT :: TypeQ -> TypeQ -> TypeQ
• arrowT :: TypeQ
• infixT :: TypeQ -> Name -> TypeQ -> TypeQ
• uInfixT :: TypeQ -> Name -> TypeQ -> TypeQ
• parensT :: TypeQ -> TypeQ
• equalityT :: TypeQ
• listT :: TypeQ
• tupleT :: Int -> TypeQ
• unboxedTupleT :: Int -> TypeQ
• unboxedSumT :: SumArity -> TypeQ
• sigT :: TypeQ -> Kind -> TypeQ
• litT :: TyLitQ -> TypeQ
• wildCardT :: TypeQ
• promotedT :: Name -> TypeQ
• promotedTupleT :: Int -> TypeQ
• promotedNilT :: TypeQ
• promotedConsT :: TypeQ
• numTyLit :: Integer -> TyLitQ
• strTyLit :: String -> TyLitQ
• 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
• cxt :: [PredQ] -> CxtQ
• classP :: Name -> [Q Type] -> Q Pred
• equalP :: TypeQ -> TypeQ -> PredQ
• normalC :: Name -> [BangTypeQ] -> ConQ
• recC :: Name -> [VarBangTypeQ] -> ConQ
• infixC :: Q (Bang, Type) -> Name -> Q (Bang, Type) -> ConQ
• forallC :: [TyVarBndr] -> CxtQ -> ConQ -> ConQ
• gadtC :: [Name] -> [StrictTypeQ] -> TypeQ -> ConQ
• recGadtC :: [Name] -> [VarStrictTypeQ] -> TypeQ -> ConQ
• varK :: Name -> Kind
• conK :: Name -> Kind
• tupleK :: Int -> Kind
• arrowK :: Kind
• listK :: Kind
• appK :: Kind -> Kind -> Kind
• starK :: Kind
• constraintK :: Kind
• plainTV :: Name -> TyVarBndr
• kindedTV :: Name -> Kind -> TyVarBndr
• nominalR :: Role
• representationalR :: Role
• phantomR :: Role
• inferR :: Role
• valD :: PatQ -> BodyQ -> [DecQ] -> DecQ
• funD :: Name -> [ClauseQ] -> DecQ
• tySynD :: Name -> [TyVarBndr] -> TypeQ -> DecQ
• dataD :: CxtQ -> Name -> [TyVarBndr] -> Maybe Kind -> [ConQ] -> [DerivClauseQ] -> DecQ
• newtypeD :: CxtQ -> Name -> [TyVarBndr] -> Maybe Kind -> ConQ -> [DerivClauseQ] -> DecQ
• derivClause :: Maybe DerivStrategy -> [PredQ] -> DerivClauseQ
• data DerivClause = DerivClause (Maybe DerivStrategy) Cxt
• data DerivStrategy
  • = StockStrategy
  • | AnyclassStrategy
  • | NewtypeStrategy
• classD :: CxtQ -> Name -> [TyVarBndr] -> [FunDep] -> [DecQ] -> DecQ
• instanceD :: CxtQ -> TypeQ -> [DecQ] -> DecQ
• instanceWithOverlapD :: Maybe Overlap -> CxtQ -> TypeQ -> [DecQ] -> DecQ
• data Overlap
  • = Overlappable
  • | Overlapping
  • | Overlaps
  • | Incoherent
• sigD :: Name -> TypeQ -> DecQ
• standaloneDerivD :: CxtQ -> TypeQ -> DecQ
• standaloneDerivWithStrategyD :: Maybe DerivStrategy -> CxtQ -> TypeQ -> DecQ
• defaultSigD :: Name -> TypeQ -> DecQ
• roleAnnotD :: Name -> [Role] -> DecQ
• dataFamilyD :: Name -> [TyVarBndr] -> Maybe Kind -> DecQ
• openTypeFamilyD :: Name -> [TyVarBndr] -> FamilyResultSig -> Maybe InjectivityAnn -> DecQ
• closedTypeFamilyD :: Name -> [TyVarBndr] -> FamilyResultSig -> Maybe InjectivityAnn -> [TySynEqnQ] -> DecQ
• dataInstD :: CxtQ -> Name -> [TypeQ] -> Maybe Kind -> [ConQ] -> [DerivClauseQ] -> DecQ
• familyNoKindD :: FamFlavour -> Name -> [TyVarBndr] -> DecQ
• familyKindD :: FamFlavour -> Name -> [TyVarBndr] -> Kind -> DecQ
• closedTypeFamilyNoKindD :: Name -> [TyVarBndr] -> [TySynEqnQ] -> DecQ
• closedTypeFamilyKindD :: Name -> [TyVarBndr] -> Kind -> [TySynEqnQ] -> DecQ
• newtypeInstD :: CxtQ -> Name -> [TypeQ] -> Maybe Kind -> ConQ -> [DerivClauseQ] -> DecQ
• tySynInstD :: Name -> TySynEqnQ -> DecQ
• typeFam :: FamFlavour
• dataFam :: FamFlavour
• tySynEqn :: [TypeQ] -> TypeQ -> TySynEqnQ
• injectivityAnn :: Name -> [Name] -> InjectivityAnn
• noSig :: FamilyResultSig
• kindSig :: Kind -> FamilyResultSig
• tyVarSig :: TyVarBndr -> FamilyResultSig
• infixLD :: Int -> Name -> DecQ
• infixRD :: Int -> Name -> DecQ
• infixND :: Int -> Name -> DecQ
• cCall :: Callconv
• stdCall :: Callconv
• cApi :: Callconv
• prim :: Callconv
• javaScript :: Callconv
• unsafe :: Safety
• safe :: Safety
• interruptible :: Safety
• forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ
• funDep :: [Name] -> [Name] -> FunDep
• ruleVar :: Name -> RuleBndrQ
• typedRuleVar :: Name -> TypeQ -> RuleBndrQ
• valueAnnotation :: Name -> AnnTarget
• typeAnnotation :: Name -> AnnTarget
• moduleAnnotation :: AnnTarget
• 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
• patSynD :: Name -> PatSynArgsQ -> PatSynDirQ -> PatQ -> DecQ
• patSynSigD :: Name -> TypeQ -> DecQ
• unidir :: PatSynDirQ
• implBidir :: PatSynDirQ
• explBidir :: [ClauseQ] -> PatSynDirQ
• prefixPatSyn :: [Name] -> PatSynArgsQ
• infixPatSyn :: Name -> Name -> PatSynArgsQ
• recordPatSyn :: [Name] -> PatSynArgsQ
• thisModule :: Q Module

Library functions

Abbreviations

Constructors lifted to Q

Literals

Patterns

Pattern Guards

Expressions

staticE x = [| static x |]

Ranges

Ranges with more indirection

Statements

Types

Type literals

Strictness

Class Contexts

Constructors

Kinds

Type variable binders

Roles

Top Level Declarations

Data

{ deriving stock (Eq, Ord) }

-XDeriveAnyClass

-XGeneralizedNewtypeDeriving

Class

Role annotations

Type Family / Data Family

Fixity

Foreign Function Interface (FFI)

Functional dependencies

Pragmas

Pattern Synonyms

Reify