| template-haskell-2.2.0.0 | 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
currentModule :: Q String
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
| 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 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
floatPrimL :: Rational -> Lit
doublePrimL :: Rational -> Lit
integerL :: Integer -> Lit
charL :: Char -> Lit
stringL :: String -> Lit
rationalL :: Rational -> 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

Functor Q
Monad 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`

currentModule :: Q String | Source

`currentModule` gives you the name of the module in 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

Data Name
Eq Name
Ord Name
Ppr Name
Show Name
Typeable 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

Data Dec
Eq Dec
Ppr Dec
Show Dec
Typeable 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

Data Exp
Eq Exp
Ppr Exp
Show Exp
Typeable Exp

data Con | Source

Constructors

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

Instances

Data Con
Eq Con
Ppr Con
Show Con
Typeable Con

data Type | Source

Constructors

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

Instances

Data Type
Eq Type
Ppr Type
Show Type
Typeable Type

type Cxt = [Type] | Source

data Match | Source

Constructors

Match Pat Body [Dec] |

Instances

Data Match
Eq Match
Ppr Match
Show Match
Typeable Match

data Clause | Source

Constructors

Clause [Pat] Body [Dec] |

Instances

Data Clause
Eq Clause
Ppr Clause
Show Clause
Typeable Clause

data Body | Source

Constructors

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

Instances

Data Body
Eq Body
Show Body
Typeable Body

data Guard | Source

Constructors

NormalG Exp |
PatG [Stmt] |

Instances

Data Guard
Eq Guard
Show Guard
Typeable Guard

data Stmt | Source

Constructors

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

Instances

Data Stmt
Eq Stmt
Ppr Stmt
Show Stmt
Typeable Stmt

data Range | Source

Constructors

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

Instances

Data Range
Eq Range
Ppr Range
Show Range
Typeable Range

data Lit | Source

Constructors

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

Instances

Data Lit
Eq 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

Data Pat
Eq Pat
Ppr Pat
Show Pat
Typeable Pat

type FieldExp = (Name, Exp) | Source

type FieldPat = (Name, Pat) | Source

data Strict | Source

Constructors

IsStrict |
NotStrict |

Instances

Data Strict
Eq Strict
Show Strict
Typeable Strict

data Foreign | Source

Constructors

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

Instances

Data Foreign
Eq Foreign
Ppr Foreign
Show Foreign
Typeable Foreign

data Callconv | Source

Constructors

CCall |
StdCall |

Instances

Data Callconv
Eq Callconv
Show Callconv
Typeable Callconv

data Safety | Source

Constructors

Unsafe |
Safe |
Threadsafe |

Instances

Data Safety
Eq Safety
Show Safety
Typeable Safety

data FunDep | Source

Constructors

FunDep [Name] [Name] |

Instances

Data FunDep
Eq FunDep
Ppr FunDep
Show FunDep
Typeable 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
Ppr Info
Show Info
Typeable Info

data Fixity | Source

Constructors

Fixity Int FixityDirection |

Instances

Data Fixity
Eq Fixity
Show Fixity
Typeable Fixity

data FixityDirection | Source

Constructors

InfixL |
InfixR |
InfixN |

Instances

Data FixityDirection
Eq 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

floatPrimL :: Rational -> Lit | Source

doublePrimL :: Rational -> Lit | Source

integerL :: Integer -> Lit | Source

charL :: Char -> Lit | Source

stringL :: String -> Lit | Source

rationalL :: Rational -> 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 Clause
Ppr Con
Ppr Dec
Ppr Exp
Ppr Foreign
Ppr FunDep
Ppr Info
Ppr Match
Ppr Name
Ppr Pat
Ppr Range
Ppr Stmt
Ppr Type
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 0.8