| Haskell Hierarchical Libraries (haskell-src package) | Contents | Index

Language.Haskell.THSyntax

Portability | portable
Stability | experimental
Maintainer | libraries@haskell.org

Description
Abstract syntax definitions for Template Haskell.
Documentation
newtype Q a

Constructors

Q (IO a) |

Instances

Monad Q
MonadIO Q

unQ :: Q a -> IO a
qIO :: IO a -> Q a
runQ :: Q a -> IO a
returnQ :: a -> Q a
bindQ :: Q a -> (a -> Q b) -> Q b
sequenceQ :: [Q a] -> Q [a]
counter :: IORef Int
gensym :: String -> Q String
class Lift t where

Methods

lift :: t -> ExpQ

Instances

Lift Integer
Lift Int
Lift Char
Lift Bool
Lift a => Lift [a]

data Lit

Constructors

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

Instances

Show Lit
Eq Lit

data Pat

Constructors

LitP Lit |
VarP String |
TupP [Pat] |
ConP String [Pat] |
TildeP Pat |
AsP String Pat |
WildP |
RecP String [FieldPat] |
ListP [Pat] |

Instances

Show Pat
Eq Pat

type FieldPat = (String, Pat)
data Match

Constructors

Match Pat Body [Dec] |

Instances

Show Match
Eq Match

data Clause

Constructors

Clause [Pat] Body [Dec] |

Instances

Show Clause
Eq Clause

data Exp

Constructors

VarE String |
ConE String |
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 String [FieldExp] |
RecUpdE Exp [FieldExp] |

Instances

Show Exp
Eq Exp

type FieldExp = (String, Exp)
data Body

Constructors

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

Instances

Show Body
Eq Body

data Stmt

Constructors

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

Instances

Show Stmt
Eq Stmt

data Range

Constructors

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

Instances

Show Range
Eq Range

data Dec

Constructors

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

Instances

Show Dec
Eq Dec

data Foreign

Constructors

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

Instances

Show Foreign
Eq Foreign

data Callconv

Constructors

CCall |
StdCall |

Instances

Show Callconv
Eq Callconv

data Safety

Constructors

Unsafe |
Safe |
Threadsafe |

Instances

Show Safety
Eq Safety

type Cxt = [Type]
data Strict

Constructors

IsStrict |
NotStrict |

Instances

Show Strict
Eq Strict

data Con

Constructors

NormalC String [StrictType] |
RecC String [VarStrictType] |
InfixC StrictType String StrictType |

Instances

Show Con
Eq Con

type StrictType = (Strict, Type)
type StrictTypeQ = Q StrictType
type VarStrictType = (String, Strict, Type)
type VarStrictTypeQ = Q VarStrictType
data Module

Constructors

Module [Dec] |

Instances

Show Module
Eq Module

data Type

Constructors

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

Instances

Show Type
Eq Type

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 StmtQ = Q Stmt
type RangeQ = Q Range
intPrimL :: Integer -> Lit
floatPrimL :: Rational -> Lit
doublePrimL :: Rational -> Lit
integerL :: Integer -> Lit
charL :: Char -> Lit
stringL :: String -> Lit
rationalL :: Rational -> Lit
litP :: Lit -> Pat
varP :: String -> Pat
tupP :: [Pat] -> Pat
conP :: String -> [Pat] -> Pat
tildeP :: Pat -> Pat
asP :: String -> Pat -> Pat
wildP :: Pat
recP :: String -> [FieldPat] -> Pat
listP :: [Pat] -> Pat
fieldPat :: String -> Pat -> (String, Pat)
bindS :: Pat -> 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 :: [(ExpQ, ExpQ)] -> BodyQ
match :: Pat -> BodyQ -> [DecQ] -> MatchQ
clause :: [Pat] -> BodyQ -> [DecQ] -> ClauseQ
global :: String -> ExpQ
varE :: String -> ExpQ
conE :: String -> 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 :: [Pat] -> ExpQ -> ExpQ
lam1E :: Pat -> 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
fromE :: ExpQ -> ExpQ
fromThenE :: ExpQ -> ExpQ -> ExpQ
fromToE :: ExpQ -> ExpQ -> ExpQ
fromThenToE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
listE :: [ExpQ] -> ExpQ
sigE :: ExpQ -> TypeQ -> ExpQ
recConE :: String -> [Q (String, Exp)] -> ExpQ
recUpdE :: ExpQ -> [Q (String, Exp)] -> ExpQ
stringE :: String -> ExpQ
fieldExp :: String -> ExpQ -> Q (String, Exp)
valD :: Pat -> BodyQ -> [DecQ] -> DecQ
funD :: String -> [ClauseQ] -> DecQ
tySynD :: String -> [String] -> TypeQ -> DecQ
dataD :: CxtQ -> String -> [String] -> [ConQ] -> [String] -> DecQ
newtypeD :: CxtQ -> String -> [String] -> ConQ -> [String] -> DecQ
classD :: CxtQ -> String -> [String] -> [DecQ] -> DecQ
instanceD :: CxtQ -> TypeQ -> [DecQ] -> DecQ
sigD :: String -> TypeQ -> DecQ
cxt :: [TypeQ] -> CxtQ
normalC :: String -> [StrictTypeQ] -> ConQ
recC :: String -> [VarStrictTypeQ] -> ConQ
infixC :: Q (Strict, Type) -> String -> Q (Strict, Type) -> ConQ
forallT :: [String] -> CxtQ -> TypeQ -> TypeQ
varT :: String -> TypeQ
conT :: String -> TypeQ
appT :: TypeQ -> TypeQ -> TypeQ
arrowT :: TypeQ
listT :: TypeQ
tupleT :: Int -> TypeQ
isStrict :: Q Strict
notStrict :: Q Strict
strictType :: Q Strict -> TypeQ -> StrictTypeQ
varStrictType :: String -> StrictTypeQ -> VarStrictTypeQ
combine :: [([(String, String)], Pat)] -> ([(String, String)], [Pat])
rename :: Pat -> Q ([(String, String)], Pat)
genpat :: Pat -> Q (String -> ExpQ, Pat)
alpha :: [(String, String)] -> String -> ExpQ
genPE :: String -> Integer -> ([Pat], [ExpQ])
appsE :: [ExpQ] -> ExpQ
simpleMatch :: Pat -> Exp -> Match
nestDepth :: Int
type Precedence = Int
appPrec :: Precedence
opPrec :: Precedence
noPrec :: Precedence
parensIf :: Bool -> Doc -> Doc
pprExp :: Exp -> Doc
pprExpI :: Precedence -> Exp -> Doc
pprFields :: [(String, Exp)] -> Doc
pprMaybeExp :: Precedence -> Maybe Exp -> Doc
pprStmt :: Stmt -> Doc
pprMatch :: Match -> Doc
pprBody :: Bool -> Body -> Doc
pprLit :: Precedence -> Lit -> Doc
pprPat :: Pat -> Doc
pprPatI :: Precedence -> Pat -> Doc
pprDec :: Dec -> Doc
pprForeign :: Foreign -> Doc
pprClause :: Clause -> Doc
pprCon :: Con -> Doc
pprVarStrictType :: (String, Strict, Type) -> Doc
pprStrictType :: (Strict, Type) -> Doc
pprParendType :: Type -> Doc
pprType :: Type -> Doc
pprTyApp :: (Type, [Type]) -> Doc
split :: Type -> (Type, [Type])
pprCxt :: Cxt -> Doc
pprRange :: Range -> Doc
pprRangeI :: Range -> Doc
where_clause :: [Dec] -> Doc
showtextl :: Show a => a -> Doc
Produced by Haddock version 0.6