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

location :: Q Loc

location gives you the Location at 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 [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

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

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

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

Constructors

PlainTV Name

KindedTV Name Kind

Instances

Eq TyVarBndr

Data TyVarBndr

Show TyVarBndr

Typeable TyVarBndr

Ppr TyVarBndr

data Kind

Constructors

StarK

ArrowK Kind Kind

Instances

Eq Kind

Data Kind

Show Kind

Typeable Kind

Ppr Kind

type Cxt = [Pred]

data Pred

Constructors

ClassP Name [Type]

EqualP Type Type

Instances

Eq Pred

Data Pred

Show Pred

Typeable Pred

Ppr Pred

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

WordPrimL 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

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)

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 Pragma

Constructors

InlineP Name InlineSpec

SpecialiseP Name Type (Maybe InlineSpec)

Instances

Eq Pragma

Data Pragma

Show Pragma

Typeable Pragma

Ppr Pragma

data InlineSpec

Constructors

InlineSpec Bool Bool (Maybe (Bool, Int))

Instances

Eq InlineSpec

Data InlineSpec

Show InlineSpec

Typeable InlineSpec

data FunDep

Constructors

FunDep [Name] [Name]

Instances

Eq FunDep

Data FunDep

Show FunDep

Typeable FunDep

Ppr FunDep

data FamFlavour

Constructors

TypeFam

DataFam

Instances

Eq FamFlavour

Data FamFlavour

Show FamFlavour

Typeable FamFlavour

Ppr FamFlavour

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 Loc

Constructors

Loc

Fields

loc_filename :: String

loc_package :: String

loc_module :: String

loc_start :: CharPos

loc_end :: CharPos

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 PredQ = Q Pred

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

type InlineSpecQ = Q InlineSpec

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

bangP :: 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 -> [TyVarBndr] -> TypeQ -> DecQ

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

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

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

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

sigD :: Name -> TypeQ -> DecQ

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

pragInlD :: Name -> InlineSpecQ -> DecQ

pragSpecD :: Name -> TypeQ -> DecQ

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

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

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

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

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

cxt :: [PredQ] -> CxtQ

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

equalP :: TypeQ -> TypeQ -> PredQ

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

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

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

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

varT :: Name -> TypeQ

conT :: Name -> TypeQ

appT :: TypeQ -> TypeQ -> TypeQ

arrowT :: TypeQ

listT :: TypeQ

tupleT :: Int -> TypeQ

sigT :: TypeQ -> Kind -> 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

inlineSpecNoPhase :: Bool -> Bool -> InlineSpecQ

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

typeFam :: FamFlavour

dataFam :: FamFlavour

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

pprExp :: Precedence -> Exp -> Doc

pprLit :: Precedence -> Lit -> Doc

pprPat :: Precedence -> Pat -> Doc

pprParendType :: Type -> Doc