Language.Haskell.TH.Lib

Language.Haskell.TH.Lib contains lots of useful helper functions for generating and manipulating Template Haskell terms

Library functions

Abbreviations

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 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 PatQ = Q Pat

type FieldPatQ = Q FieldPat

type RuleBndrQ = Q RuleBndr

type TySynEqnQ = Q TySynEqn

type PatSynDirQ = Q PatSynDir

type PatSynArgsQ = Q PatSynArgs

type FamilyResultSigQ = Q FamilyResultSig

type DerivStrategyQ = Q DerivStrategy

Constructors lifted to Q

Literals

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

bytesPrimL :: Bytes -> Lit

mkBytes

Arguments

:: ForeignPtr Word8

Pointer to the data

-> Word

Offset from the pointer

-> Word

Number of bytes

-> Bytes

Create a Bytes datatype representing raw bytes to be embedded into the program/library binary.

Since: 2.16.0.0

Patterns

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

Pattern Guards

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

Use with caseE

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

Use with funD

Expressions

dyn :: String -> ExpQ

Dynamically binding a variable (unhygenic)

varE :: Name -> ExpQ

unboundVarE :: Name -> ExpQ

labelE :: String -> ExpQ

implicitParamVarE :: String -> ExpQ

conE :: Name -> ExpQ

litE :: Lit -> ExpQ

staticE :: ExpQ -> ExpQ

staticE x = [| static x |]

appE :: ExpQ -> ExpQ -> ExpQ

appTypeE :: ExpQ -> TypeQ -> ExpQ

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

parensE :: 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

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)

Ranges

fromE :: ExpQ -> ExpQ

fromThenE :: ExpQ -> ExpQ -> ExpQ

fromToE :: ExpQ -> ExpQ -> ExpQ

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

Ranges with more indirection

arithSeqE :: RangeQ -> ExpQ

fromR :: ExpQ -> RangeQ

fromThenR :: ExpQ -> ExpQ -> RangeQ

fromToR :: ExpQ -> ExpQ -> RangeQ

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

Statements

doE :: [StmtQ] -> ExpQ

mdoE :: [StmtQ] -> ExpQ

compE :: [StmtQ] -> ExpQ

bindS :: PatQ -> ExpQ -> StmtQ

letS :: [DecQ] -> StmtQ

noBindS :: ExpQ -> StmtQ

parS :: [[StmtQ]] -> StmtQ

recS :: [StmtQ] -> StmtQ

Types

forallT :: [TyVarBndr] -> CxtQ -> TypeQ -> TypeQ

forallVisT :: [TyVarBndrQ] -> TypeQ -> TypeQ

varT :: Name -> TypeQ

conT :: Name -> TypeQ

appT :: TypeQ -> TypeQ -> TypeQ

appKindT :: TypeQ -> KindQ -> 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

implicitParamT :: String -> TypeQ -> TypeQ

Type literals

numTyLit :: Integer -> TyLitQ

strTyLit :: String -> TyLitQ

Strictness

noSourceUnpackedness :: SourceUnpackednessQ

sourceNoUnpack :: SourceUnpackednessQ

sourceUnpack :: SourceUnpackednessQ

noSourceStrictness :: SourceStrictnessQ

sourceLazy :: SourceStrictnessQ

sourceStrict :: SourceStrictnessQ

isStrict :: Q Strict

Deprecated: Use bang. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. Example usage: 'bang noSourceUnpackedness sourceStrict'

notStrict :: Q Strict

Deprecated: Use bang. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. Example usage: 'bang noSourceUnpackedness noSourceStrictness'

unpacked :: Q Strict

Deprecated: Use bang. See https://gitlab.haskell.org/ghc/ghc/wikis/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.

Class Contexts

cxt :: [PredQ] -> CxtQ

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.

Constructors

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

Kinds

varK :: Name -> Kind

conK :: Name -> Kind

tupleK :: Int -> Kind

arrowK :: Kind

listK :: Kind

appK :: Kind -> Kind -> Kind

starK :: Kind

constraintK :: Kind

Type variable binders

plainTV :: Name -> TyVarBndr

kindedTV :: Name -> Kind -> TyVarBndr

Roles

nominalR :: Role

representationalR :: Role

phantomR :: Role

inferR :: Role

Top Level Declarations

Data

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

A single deriving clause at the end of a datatype.

Constructors

DerivClause (Maybe DerivStrategy) Cxt

{ deriving stock (Eq, Ord) }

Instances

Eq DerivClause

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: DerivClause -> DerivClause -> Bool

(/=) :: DerivClause -> DerivClause -> Bool

Data DerivClause

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivClause -> c DerivClause

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivClause

toConstr :: DerivClause -> Constr

dataTypeOf :: DerivClause -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivClause)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivClause)

gmapT :: (forall b. Data b => b -> b) -> DerivClause -> DerivClause

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivClause -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivClause -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivClause -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClause -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause

Ord DerivClause

Defined in Language.Haskell.TH.Syntax

Methods

compare :: DerivClause -> DerivClause -> Ordering

(<) :: DerivClause -> DerivClause -> Bool

(<=) :: DerivClause -> DerivClause -> Bool

(>) :: DerivClause -> DerivClause -> Bool

(>=) :: DerivClause -> DerivClause -> Bool

max :: DerivClause -> DerivClause -> DerivClause

min :: DerivClause -> DerivClause -> DerivClause

Show DerivClause

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> DerivClause -> ShowS

show :: DerivClause -> String

showList :: [DerivClause] -> ShowS

Generic DerivClause

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivClause :: Type -> Type

Methods

from :: DerivClause -> Rep DerivClause x

to :: Rep DerivClause x -> DerivClause

type Rep DerivClause

Defined in Language.Haskell.TH.Syntax

type Rep DerivClause = D1 ('MetaData "DerivClause" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "DerivClause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe DerivStrategy)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt)))

stockStrategy :: DerivStrategyQ

anyclassStrategy :: DerivStrategyQ

newtypeStrategy :: DerivStrategyQ

viaStrategy :: TypeQ -> DerivStrategyQ

data DerivStrategy

What the user explicitly requests when deriving an instance.

Constructors

StockStrategy

A "standard" derived instance

AnyclassStrategy

-XDeriveAnyClass

NewtypeStrategy

-XGeneralizedNewtypeDeriving

ViaStrategy Type

-XDerivingVia

Instances

Eq DerivStrategy

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: DerivStrategy -> DerivStrategy -> Bool

(/=) :: DerivStrategy -> DerivStrategy -> Bool

Data DerivStrategy

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivStrategy

toConstr :: DerivStrategy -> Constr

dataTypeOf :: DerivStrategy -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivStrategy)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivStrategy)

gmapT :: (forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy

Ord DerivStrategy

Defined in Language.Haskell.TH.Syntax

Methods

compare :: DerivStrategy -> DerivStrategy -> Ordering

(<) :: DerivStrategy -> DerivStrategy -> Bool

(<=) :: DerivStrategy -> DerivStrategy -> Bool

(>) :: DerivStrategy -> DerivStrategy -> Bool

(>=) :: DerivStrategy -> DerivStrategy -> Bool

max :: DerivStrategy -> DerivStrategy -> DerivStrategy

min :: DerivStrategy -> DerivStrategy -> DerivStrategy

Show DerivStrategy

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> DerivStrategy -> ShowS

show :: DerivStrategy -> String

showList :: [DerivStrategy] -> ShowS

Generic DerivStrategy

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivStrategy :: Type -> Type

Methods

from :: DerivStrategy -> Rep DerivStrategy x

to :: Rep DerivStrategy x -> DerivStrategy

type Rep DerivStrategy

Defined in Language.Haskell.TH.Syntax

type Rep DerivStrategy = D1 ('MetaData "DerivStrategy" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "StockStrategy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AnyclassStrategy" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "NewtypeStrategy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ViaStrategy" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))

Class

classD :: CxtQ -> Name -> [TyVarBndr] -> [FunDep] -> [DecQ] -> DecQ

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

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

data Overlap

Varieties of allowed instance overlap.

Constructors

Overlappable

May be overlapped by more specific instances

Overlapping

May overlap a more general instance

Overlaps

Both Overlapping and Overlappable

Incoherent

Both Overlappable and Overlappable, and pick an arbitrary one if multiple choices are available.

Instances

Eq Overlap

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Overlap -> Overlap -> Bool

(/=) :: Overlap -> Overlap -> Bool

Data Overlap

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overlap -> c Overlap

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Overlap

toConstr :: Overlap -> Constr

dataTypeOf :: Overlap -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Overlap)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap)

gmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r

gmapQ :: (forall d. Data d => d -> u) -> Overlap -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap

Ord Overlap

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Overlap -> Overlap -> Ordering

(<) :: Overlap -> Overlap -> Bool

(<=) :: Overlap -> Overlap -> Bool

(>) :: Overlap -> Overlap -> Bool

(>=) :: Overlap -> Overlap -> Bool

max :: Overlap -> Overlap -> Overlap

min :: Overlap -> Overlap -> Overlap

Show Overlap

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Overlap -> ShowS

show :: Overlap -> String

showList :: [Overlap] -> ShowS

Generic Overlap

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Overlap :: Type -> Type

Methods

from :: Overlap -> Rep Overlap x

to :: Rep Overlap x -> Overlap

type Rep Overlap

Defined in Language.Haskell.TH.Syntax

type Rep Overlap = D1 ('MetaData "Overlap" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "Overlappable" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Overlapping" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Overlaps" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Incoherent" 'PrefixI 'False) (U1 :: Type -> Type)))

sigD :: Name -> TypeQ -> DecQ

kiSigD :: Name -> KindQ -> DecQ

standaloneDerivD :: CxtQ -> TypeQ -> DecQ

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

defaultSigD :: Name -> TypeQ -> DecQ

Role annotations

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

Type Family / Data Family

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

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

tySynInstD :: TySynEqnQ -> DecQ

tySynEqn :: Maybe [TyVarBndr] -> TypeQ -> TypeQ -> TySynEqnQ

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

noSig :: FamilyResultSig

kindSig :: Kind -> FamilyResultSig

tyVarSig :: TyVarBndr -> FamilyResultSig

Fixity

infixLD :: Int -> Name -> DecQ

infixRD :: Int -> Name -> DecQ

infixND :: Int -> Name -> DecQ

Foreign Function Interface (FFI)

cCall :: Callconv

stdCall :: Callconv

cApi :: Callconv

prim :: Callconv

javaScript :: Callconv

unsafe :: Safety

safe :: Safety

interruptible :: Safety

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

Functional dependencies

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

Pragmas

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

Pattern Synonyms

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

Pattern synonym declaration

patSynSigD :: Name -> TypeQ -> DecQ

Pattern synonym type signature

unidir :: PatSynDirQ

implBidir :: PatSynDirQ

explBidir :: [ClauseQ] -> PatSynDirQ

prefixPatSyn :: [Name] -> PatSynArgsQ

infixPatSyn :: Name -> Name -> PatSynArgsQ

recordPatSyn :: [Name] -> PatSynArgsQ

Implicit Parameters

implicitParamBindD :: String -> ExpQ -> DecQ

Implicit parameter binding declaration. Can only be used in let and where clauses which consist entirely of implicit bindings.

Reify

thisModule :: Q Module

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