Language.Haskell.TH

Synopsis

Documentation

Instances

Monad Q
Functor Q
Quasi Q

runQ :: Quasi m => Q a -> m aSource

report :: Bool -> String -> Q ()Source

recover :: Q a -> Q a -> Q aSource

reify :: Name -> Q Info Source

reify looks up information about the Name

location :: Q Loc Source

location gives you the Location at which this computation is spliced.

runIO :: IO a -> Q aSource

The runIO function lets you run an I/O computation in the Q monad. Take care: you are guaranteed the ordering of calls to runIO within a single Q computation, but not about the order in which splices are run.

Note: for various murky reasons, stdout and stderr handles are not necesarily flushed when the compiler finishes running, so you should flush them yourself.

data Name Source

Instances

Eq Name
Data Name
Ord Name
Show Name
Typeable Name
Ppr Name

mkName :: String -> Name Source

newName :: String -> Q Name Source

nameBase :: Name -> String Source

nameModule :: Name -> Maybe String Source

tupleTypeName :: Int -> Name Source

tupleDataName :: Int -> Name Source

data Dec Source

Constructors

FunD Name [Clause]
ValD Pat Body [Dec]
DataD Cxt Name [TyVarBndr] [Con] [Name]
NewtypeD Cxt Name [TyVarBndr] Con [Name]
TySynD Name [TyVarBndr] Type
ClassD Cxt Name [TyVarBndr] [FunDep] [Dec]
InstanceD Cxt Type [Dec]
SigD Name Type
ForeignD Foreign
PragmaD Pragma
FamilyD FamFlavour Name [TyVarBndr] (Maybe Kind)
DataInstD Cxt Name [Type] [Con] [Name]
NewtypeInstD Cxt Name [Type] Con [Name]
TySynInstD Name [Type] Type

Instances

Eq Dec
Data Dec
Show Dec
Typeable Dec
Ppr Dec

data Exp Source

The CompE constructor represents a list comprehension, and takes a [Stmt]. The result expression of the comprehension is the *last* of these, and should be a NoBindS. E.g. [ f x | x <- xs ] is represented by CompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))]

Constructors

VarE Name
ConE Name
LitE Lit
AppE Exp Exp
InfixE (Maybe Exp) Exp (Maybe Exp)
LamE [Pat] Exp
TupE [Exp]
CondE Exp Exp Exp
LetE [Dec] Exp
CaseE Exp [Match]
DoE [Stmt]
CompE [Stmt]
ArithSeqE Range
ListE [Exp]
SigE Exp Type
RecConE Name [FieldExp]
RecUpdE Exp [FieldExp]

Instances

Eq Exp
Data Exp
Show Exp
Typeable Exp
Ppr Exp

data Con Source

Constructors

NormalC Name [StrictType]
RecC Name [VarStrictType]
InfixC StrictType Name StrictType
ForallC [TyVarBndr] Cxt Con

Instances

Eq Con
Data Con
Show Con
Typeable Con
Ppr Con

data Type Source

Constructors

ForallT [TyVarBndr] Cxt Type
VarT Name
ConT Name
TupleT Int
ArrowT
ListT
AppT Type Type
SigT Type Kind

Instances

Eq Type
Data Type
Show Type
Typeable Type
Ppr Type

data TyVarBndr Source

Constructors

PlainTV Name
KindedTV Name Kind

Instances

Eq TyVarBndr
Data TyVarBndr
Show TyVarBndr
Typeable TyVarBndr
Ppr TyVarBndr

data Kind Source

Constructors

StarK
ArrowK Kind Kind

Instances

Eq Kind
Data Kind
Show Kind
Typeable Kind
Ppr Kind

type Cxt = [Pred]Source

data Pred Source

Constructors

ClassP Name [Type]
EqualP Type Type

Instances

Eq Pred
Data Pred
Show Pred
Typeable Pred
Ppr Pred

data Match Source

Constructors

Match Pat Body [Dec]

Instances

Eq Match
Data Match
Show Match
Typeable Match
Ppr Match

data Clause Source

Constructors

Clause [Pat] Body [Dec]

Instances

Eq Clause
Data Clause
Show Clause
Typeable Clause
Ppr Clause

data Body Source

Constructors

GuardedB [(Guard, Exp)]
NormalB Exp

Instances

Eq Body
Data Body
Show Body
Typeable Body

data Guard Source

Constructors

NormalG Exp
PatG [Stmt]

Instances

Eq Guard
Data Guard
Show Guard
Typeable Guard

data Stmt Source

Constructors

BindS Pat Exp
LetS [Dec]
NoBindS Exp
ParS [[Stmt]]

Instances

Eq Stmt
Data Stmt
Show Stmt
Typeable Stmt
Ppr Stmt

data Range Source

Constructors

FromR Exp
FromThenR Exp Exp
FromToR Exp Exp
FromThenToR Exp Exp Exp

Instances

Eq Range
Data Range
Show Range
Typeable Range
Ppr Range

data Lit Source

Constructors

CharL Char
StringL String
IntegerL Integer
RationalL Rational
IntPrimL Integer
WordPrimL Integer
FloatPrimL Rational
DoublePrimL Rational

Instances

Eq Lit
Data Lit
Show Lit
Typeable Lit

data Pat Source

Constructors

LitP Lit
VarP Name
TupP [Pat]
ConP Name [Pat]
InfixP Pat Name Pat
TildeP Pat
BangP Pat
AsP Name Pat
WildP
RecP Name [FieldPat]
ListP [Pat]
SigP Pat Type

Instances

Eq Pat
Data Pat
Show Pat
Typeable Pat
Ppr Pat

type FieldExp = (Name, Exp)Source

type FieldPat = (Name, Pat)Source

data Strict Source

Constructors

IsStrict
NotStrict

Instances

Eq Strict
Data Strict
Show Strict
Typeable Strict

data Foreign Source

Constructors

ImportF Callconv Safety String Name Type
ExportF Callconv String Name Type

Instances

Eq Foreign
Data Foreign
Show Foreign
Typeable Foreign
Ppr Foreign

data Callconv Source

Constructors

CCall
StdCall

Instances

Eq Callconv
Data Callconv
Show Callconv
Typeable Callconv

data Safety Source

Constructors

Unsafe
Safe
Threadsafe

Instances

Eq Safety
Data Safety
Show Safety
Typeable Safety

data Pragma Source

Constructors

InlineP Name InlineSpec
SpecialiseP Name Type (Maybe InlineSpec)

Instances

Eq Pragma
Data Pragma
Show Pragma
Typeable Pragma
Ppr Pragma

data InlineSpec Source

Constructors

InlineSpec Bool Bool (Maybe (Bool, Int))

Instances

Eq InlineSpec
Data InlineSpec
Show InlineSpec
Typeable InlineSpec

data FunDep Source

Constructors

FunDep [Name] [Name]

Instances

Eq FunDep
Data FunDep
Show FunDep
Typeable FunDep
Ppr FunDep

data FamFlavour Source

Constructors

TypeFam
DataFam

Instances

Eq FamFlavour
Data FamFlavour
Show FamFlavour
Typeable FamFlavour
Ppr FamFlavour

data Info Source

Constructors

ClassI Dec
ClassOpI Name Type Name Fixity
TyConI Dec
PrimTyConI Name Int Bool
DataConI Name Type Name Fixity
VarI Name Type (Maybe Dec) Fixity
TyVarI Name Type

Instances

Data Info
Show Info
Typeable Info
Ppr Info

data Loc Source

Constructors

Loc
Fields loc_filename :: String loc_package :: String loc_module :: String loc_start :: CharPos loc_end :: CharPos

data Fixity Source

Constructors

Fixity Int FixityDirection

Instances

Eq Fixity
Data Fixity
Show Fixity
Typeable Fixity

data FixityDirection Source

Constructors

InfixL
InfixR
InfixN

Instances

Eq FixityDirection
Data FixityDirection
Show FixityDirection
Typeable FixityDirection

defaultFixity :: Fixity Source

maxPrecedence :: Int Source

type InfoQ = Q Info Source

type ExpQ = Q Exp Source

type DecQ = Q Dec Source

type ConQ = Q Con Source

type TypeQ = Q Type Source

type CxtQ = Q Cxt Source

type PredQ = Q Pred 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 StrictTypeQ = Q StrictType Source

type VarStrictTypeQ = Q VarStrictType Source

type PatQ = Q Pat Source

type FieldPatQ = Q FieldPat Source

type InlineSpecQ = Q InlineSpec Source

intPrimL :: Integer -> Lit Source

wordPrimL :: Integer -> Lit Source

floatPrimL :: Rational -> Lit Source

doublePrimL :: Rational -> Lit Source

integerL :: Integer -> Lit Source

rationalL :: Rational -> Lit Source

charL :: Char -> Lit Source

stringL :: String -> Lit Source

litP :: Lit -> PatQ Source

varP :: Name -> PatQ Source

tupP :: [PatQ] -> PatQ Source

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

infixP :: PatQ -> Name -> 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

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

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

dyn :: String -> Q Exp Source

global :: Name -> ExpQ Source

varE :: Name -> ExpQ Source

conE :: Name -> ExpQ Source

litE :: Lit -> ExpQ Source

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

tupE :: [ExpQ] -> ExpQ Source

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

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

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

doE :: [StmtQ] -> ExpQ Source

compE :: [StmtQ] -> ExpQ Source

arithSeqE :: RangeQ -> ExpQ Source

appsE :: [ExpQ] -> ExpQ Source

fromE :: ExpQ -> ExpQ Source

fromThenE :: ExpQ -> ExpQ -> ExpQ Source

fromToE :: ExpQ -> ExpQ -> ExpQ Source

fromThenToE :: ExpQ -> ExpQ -> ExpQ -> 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

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

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

tySynD :: Name -> [TyVarBndr] -> TypeQ -> DecQ Source

dataD :: CxtQ -> Name -> [TyVarBndr] -> [ConQ] -> [Name] -> DecQ Source

newtypeD :: CxtQ -> Name -> [TyVarBndr] -> ConQ -> [Name] -> DecQ Source

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

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

sigD :: Name -> TypeQ -> DecQ Source

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

pragInlD :: Name -> InlineSpecQ -> DecQ Source

pragSpecD :: Name -> TypeQ -> DecQ Source

familyNoKindD :: FamFlavour -> Name -> [TyVarBndr] -> DecQ Source

familyKindD :: FamFlavour -> Name -> [TyVarBndr] -> Kind -> DecQ Source

dataInstD :: CxtQ -> Name -> [TypeQ] -> [ConQ] -> [Name] -> DecQ Source

newtypeInstD :: CxtQ -> Name -> [TypeQ] -> ConQ -> [Name] -> DecQ Source

tySynInstD :: Name -> [TypeQ] -> TypeQ -> DecQ Source

cxt :: [PredQ] -> CxtQ Source

classP :: Name -> [TypeQ] -> PredQ Source

equalP :: TypeQ -> TypeQ -> PredQ Source

normalC :: Name -> [StrictTypeQ] -> ConQ Source

recC :: Name -> [VarStrictTypeQ] -> ConQ Source

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

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

varT :: Name -> TypeQ Source

conT :: Name -> TypeQ Source

appT :: TypeQ -> TypeQ -> TypeQ Source

arrowT :: TypeQ Source

listT :: TypeQ Source

tupleT :: Int -> TypeQ Source

sigT :: TypeQ -> Kind -> TypeQ Source

isStrict :: Q Strict Source

notStrict :: Q Strict Source

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

varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ Source

cCall :: Callconv Source

stdCall :: Callconv Source

unsafe :: Safety Source

safe :: Safety Source

threadsafe :: Safety Source

inlineSpecNoPhase :: Bool -> Bool -> InlineSpecQ Source

inlineSpecPhase :: Bool -> Bool -> Bool -> Int -> InlineSpecQ Source

typeFam :: FamFlavour Source

dataFam :: FamFlavour Source

class Ppr a whereSource

Methods

ppr :: a -> Doc Source

ppr_list :: [a] -> Doc Source

Instances

Ppr Exp
Ppr Match
Ppr Clause
Ppr Pat
Ppr Type
Ppr Dec
Ppr Name
Ppr FunDep
Ppr Pred
Ppr TyVarBndr
Ppr Kind
Ppr Con
Ppr Pragma
Ppr Foreign
Ppr FamFlavour
Ppr Range
Ppr Stmt
Ppr Info
Ppr a => Ppr [a]

pprint :: Ppr a => a -> String Source

pprExp :: Precedence -> Exp -> Doc Source

pprLit :: Precedence -> Lit -> Doc Source

pprPat :: Precedence -> Pat -> Doc Source

pprParendType :: Type -> Doc Source