Language.Haskell.TH

Documentation

data Q a

Instances

Monad Q

Functor Q

Quasi Q

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

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

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

reify :: Name -> Q Info

reify looks up information about the Name

currentModule :: Q String

currentModule gives you the name of the module in which this computation is spliced.

runIO :: IO a -> Q a

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

Instances

Eq Name

Data Name

Ord Name

Show Name

Typeable Name

Ppr Name

mkName :: String -> Name

newName :: String -> Q Name

nameBase :: Name -> String

nameModule :: Name -> Maybe String

tupleTypeName :: Int -> Name

tupleDataName :: Int -> Name

data Dec

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

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

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

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]

data Match

Constructors

Match Pat Body [Dec]

Instances

Eq Match

Data Match

Show Match

Typeable Match

Ppr Match

data Clause

Constructors

Clause [Pat] Body [Dec]

Instances

Eq Clause

Data Clause

Show Clause

Typeable Clause

Ppr Clause

data Body

Constructors

GuardedB [(Guard, Exp)]

NormalB Exp

Instances

Eq Body

Data Body

Show Body

Typeable Body

data Guard

Constructors

NormalG Exp

PatG [Stmt]

Instances

Eq Guard

Data Guard

Show Guard

Typeable Guard

data Stmt

Constructors

BindS Pat Exp

LetS [Dec]

NoBindS Exp

ParS [[Stmt]]

Instances

Eq Stmt

Data Stmt

Show Stmt

Typeable Stmt

Ppr Stmt

data Range

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

Constructors

CharL Char

StringL String

IntegerL Integer

RationalL Rational

IntPrimL Integer

FloatPrimL Rational

DoublePrimL Rational

Instances

Eq Lit

Data Lit

Show Lit

Typeable Lit

data Pat

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)

type FieldPat = (Name, Pat)

data Strict

Constructors

IsStrict

NotStrict

Instances

Eq Strict

Data Strict

Show Strict

Typeable Strict

data Foreign

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

Constructors

CCall

StdCall

Instances

Eq Callconv

Data Callconv

Show Callconv

Typeable Callconv

data Safety

Constructors

Unsafe

Safe

Threadsafe

Instances

Eq Safety

Data Safety

Show Safety

Typeable Safety

data FunDep

Constructors

FunDep [Name] [Name]

Instances

Eq FunDep

Data FunDep

Show FunDep

Typeable FunDep

Ppr FunDep

data Info

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 Fixity

Constructors

Fixity Int FixityDirection

Instances

Eq Fixity

Data Fixity

Show Fixity

Typeable Fixity

data FixityDirection

Constructors

InfixL

InfixR

InfixN

Instances

Eq FixityDirection

Data FixityDirection

Show FixityDirection

Typeable FixityDirection

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

Methods

ppr :: a -> Doc

ppr_list :: [a] -> Doc

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

pprExp :: Precedence -> Exp -> Doc

pprLit :: Precedence -> Lit -> Doc

pprPat :: Precedence -> Pat -> Doc

pprParendType :: Type -> Doc