| template-haskell-2.3.0.1 | Source code | Contents | Index

Language.Haskell.TH

Synopsis

data Q a
runQ :: Quasi m => Q a -> m a
report :: Bool -> String -> Q ()
recover :: Q a -> Q a -> Q a
reify :: Name -> Q Info
location :: Q Loc
runIO :: IO a -> Q a
data Name
mkName :: String -> Name
newName :: String -> Q Name
nameBase :: Name -> String
nameModule :: Name -> Maybe String
tupleTypeName :: Int -> Name
tupleDataName :: Int -> Name

data Dec

= FunD Name [Clause]
| ValD Pat Body [Dec]
| DataD Cxt Name [Name] [Con] [Name]
| NewtypeD Cxt Name [Name] Con [Name]
| TySynD Name [Name] Type
| ClassD Cxt Name [Name] [FunDep] [Dec]
| InstanceD Cxt Type [Dec]
| SigD Name Type
| ForeignD Foreign

data Exp

= 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]

data Con

= NormalC Name [StrictType]
| RecC Name [VarStrictType]
| InfixC StrictType Name StrictType
| ForallC [Name] Cxt Con

data Type

= ForallT [Name] Cxt Type
| VarT Name
| ConT Name
| TupleT Int
| ArrowT
| ListT
| AppT Type Type

type Cxt = [Type]
data Match = Match Pat Body [Dec]
data Clause = Clause [Pat] Body [Dec]

data Body

= GuardedB [(Guard, Exp)]
| NormalB Exp

data Guard

= NormalG Exp
| PatG [Stmt]

data Stmt

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

data Range

= FromR Exp
| FromThenR Exp Exp
| FromToR Exp Exp
| FromThenToR Exp Exp Exp

data Lit

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

data Pat

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

type FieldExp = (Name, Exp)
type FieldPat = (Name, Pat)

data Strict

= IsStrict
| NotStrict

data Foreign

= ImportF Callconv Safety String Name Type
| ExportF Callconv String Name Type

data Callconv

= CCall
| StdCall

data Safety

= Unsafe
| Safe
| Threadsafe

data FunDep = FunDep [Name] [Name]

data Info

= 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

data Loc = Loc {

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

}

data Fixity = Fixity Int FixityDirection

data FixityDirection

= InfixL
| InfixR
| InfixN

defaultFixity :: Fixity
maxPrecedence :: Int
type InfoQ = Q Info
type ExpQ = Q Exp
type DecQ = Q Dec
type ConQ = Q Con
type TypeQ = Q Type
type CxtQ = Q Cxt
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 StrictTypeQ = Q StrictType
type VarStrictTypeQ = Q VarStrictType
type PatQ = Q Pat
type FieldPatQ = Q FieldPat
intPrimL :: Integer -> Lit
wordPrimL :: Integer -> Lit
floatPrimL :: Rational -> Lit
doublePrimL :: Rational -> Lit
integerL :: Integer -> Lit
rationalL :: Rational -> Lit
charL :: Char -> Lit
stringL :: String -> Lit
litP :: Lit -> PatQ
varP :: Name -> PatQ
tupP :: [PatQ] -> PatQ
conP :: Name -> [PatQ] -> PatQ
infixP :: PatQ -> Name -> PatQ -> PatQ
tildeP :: PatQ -> PatQ
asP :: Name -> PatQ -> PatQ
wildP :: PatQ
recP :: Name -> [FieldPatQ] -> PatQ
listP :: [PatQ] -> PatQ
sigP :: PatQ -> TypeQ -> 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 -> Q Exp
global :: Name -> ExpQ
varE :: Name -> ExpQ
conE :: Name -> ExpQ
litE :: Lit -> ExpQ
appE :: 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
tupE :: [ExpQ] -> ExpQ
condE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
letE :: [DecQ] -> ExpQ -> ExpQ
caseE :: ExpQ -> [MatchQ] -> ExpQ
doE :: [StmtQ] -> ExpQ
compE :: [StmtQ] -> ExpQ
arithSeqE :: RangeQ -> ExpQ
appsE :: [ExpQ] -> ExpQ
fromE :: ExpQ -> ExpQ
fromThenE :: ExpQ -> ExpQ -> ExpQ
fromToE :: ExpQ -> ExpQ -> ExpQ
fromThenToE :: ExpQ -> ExpQ -> 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)
valD :: PatQ -> BodyQ -> [DecQ] -> DecQ
funD :: Name -> [ClauseQ] -> DecQ
tySynD :: Name -> [Name] -> TypeQ -> DecQ
dataD :: CxtQ -> Name -> [Name] -> [ConQ] -> [Name] -> DecQ
newtypeD :: CxtQ -> Name -> [Name] -> ConQ -> [Name] -> DecQ
classD :: CxtQ -> Name -> [Name] -> [FunDep] -> [DecQ] -> DecQ
instanceD :: CxtQ -> TypeQ -> [DecQ] -> DecQ
sigD :: Name -> TypeQ -> DecQ
forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ
cxt :: [TypeQ] -> CxtQ
normalC :: Name -> [StrictTypeQ] -> ConQ
recC :: Name -> [VarStrictTypeQ] -> ConQ
infixC :: Q (Strict, Type) -> Name -> Q (Strict, Type) -> ConQ
forallT :: [Name] -> CxtQ -> TypeQ -> TypeQ
varT :: Name -> TypeQ
conT :: Name -> TypeQ
appT :: TypeQ -> TypeQ -> TypeQ
arrowT :: TypeQ
listT :: TypeQ
tupleT :: Int -> TypeQ
isStrict :: Q Strict
notStrict :: Q Strict
strictType :: Q Strict -> TypeQ -> StrictTypeQ
varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ
cCall :: Callconv
stdCall :: Callconv
unsafe :: Safety
safe :: Safety
threadsafe :: Safety
class Ppr a where

ppr :: a -> Doc
ppr_list :: [a] -> Doc

pprint :: Ppr a => a -> String
pprExp :: Precedence -> Exp -> Doc
pprLit :: Precedence -> Lit -> Doc
pprPat :: Precedence -> Pat -> Doc
pprParendType :: Type -> Doc

Documentation

data Q a | Source

Instances

Monad Q
Functor Q
Quasi Q

runQ :: Quasi m => Q a -> m a | Source

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

recover :: Q a -> Q a -> Q a | Source

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 a | Source

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 [Name] [Con] [Name] |
NewtypeD Cxt Name [Name] Con [Name] |
TySynD Name [Name] Type |
ClassD Cxt Name [Name] [FunDep] [Dec] |
InstanceD Cxt Type [Dec] |
SigD Name Type |
ForeignD Foreign |

Instances

Eq Dec
Data Dec
Show Dec
Typeable Dec
Ppr Dec

data Exp | Source

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 [Name] Cxt Con |

Instances

Eq Con
Data Con
Show Con
Typeable Con
Ppr Con

data Type | Source

Constructors

ForallT [Name] Cxt Type |
VarT Name |
ConT Name |
TupleT Int |
ArrowT |
ListT |
AppT Type Type |

Instances

Eq Type
Data Type
Show Type
Typeable Type
Ppr Type

type Cxt = [Type] | Source

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 |
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 FunDep | Source

Constructors

FunDep [Name] [Name] |

Instances

Eq FunDep
Data FunDep
Show FunDep
Typeable FunDep
Ppr FunDep

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 |

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

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

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 -> [Name] -> TypeQ -> DecQ | Source

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

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

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

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

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

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

cxt :: [TypeQ] -> CxtQ | Source

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

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

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

forallT :: [Name] -> 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

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

class Ppr a where | Source

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 Con
Ppr Foreign
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

Produced by Haddock version 2.4.2