template-haskell-2.2.0.0

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

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

currentModule :: Q String Source

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

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]

ForeignD Foreign

Instances

data Exp Source

Constructors

InfixE (Maybe Exp) Exp (Maybe Exp)

CondE Exp Exp Exp

CaseE Exp [Match]

ArithSeqE Range

RecConE Name [FieldExp]

RecUpdE Exp [FieldExp]

Instances

data Con Source

Constructors

NormalC Name [StrictType]

RecC Name [VarStrictType]

InfixC StrictType Name StrictType

ForallC [Name] Cxt Con

Instances

data Type Source

Constructors

ForallT [Name] Cxt Type

Instances

type Cxt = [Type]Source

data Match Source

Constructors

Match Pat Body [Dec]

Instances

data Clause Source

Constructors

Clause [Pat] Body [Dec]

Instances

Typeable Clause

data Body Source

Constructors

GuardedB [(Guard, Exp)]

Instances

data Guard Source

Constructors

Instances

data Stmt Source

Constructors

Instances

data Range Source

Constructors

FromThenR Exp Exp

FromToR Exp Exp

FromThenToR Exp Exp Exp

Instances

data Lit Source

Constructors

IntegerL Integer

RationalL Rational

IntPrimL Integer

FloatPrimL Rational

DoublePrimL Rational

Instances

data Pat Source

Constructors

ConP Name [Pat]

InfixP Pat Name Pat

RecP Name [FieldPat]

Instances

type FieldExp = (Name, Exp)Source

type FieldPat = (Name, Pat)Source

data Strict Source

Constructors

Instances

Typeable Strict

data Foreign Source

Constructors

ImportF Callconv Safety String Name Type

ExportF Callconv String Name Type

Instances

Typeable Foreign

data Callconv Source

Constructors

Instances

Typeable Callconv

data Safety Source

Constructors

Instances

Typeable Safety

data FunDep Source

Constructors

FunDep [Name] [Name]

Instances

Typeable FunDep

data Info Source

Constructors

ClassOpI Name Type Name Fixity

PrimTyConI Name Int Bool

DataConI Name Type Name Fixity

VarI Name Type (Maybe Dec) Fixity

TyVarI Name Type

Instances

data Fixity Source

Constructors

Fixity Int FixityDirection

Instances

Typeable Fixity

data FixityDirection Source

Constructors

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

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 whereSource

Methods

ppr :: a -> Doc Source

ppr_list :: [a] -> Doc Source

Instances

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