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

type FieldExpQ = Q FieldExp

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