Language.Haskell.TH
- 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
- 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
- type Cxt = [Type]
- data Match = Match Pat Body [Dec]
- data Clause = Clause [Pat] Body [Dec]
- data Body
- data Guard
- data Stmt
- data Range
- data Lit
- data Pat
- type FieldExp = (Name, Exp)
- type FieldPat = (Name, Pat)
- data Strict
- data Foreign
- data Callconv
- data Safety
- = Unsafe
- | Safe
- | Threadsafe
- data FunDep = FunDep [Name] [Name]
- data Info
- data Fixity = Fixity Int FixityDirection
- data 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
- pprint :: Ppr a => a -> String
- pprExp :: Precedence -> Exp -> Doc
- pprLit :: Precedence -> Lit -> Doc
- pprPat :: Precedence -> Pat -> Doc
- pprParendType :: Type -> Doc
Documentation
currentModule :: Q StringSource
currentModule
gives you the name of the module in which this
computation is spliced.
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.
nameModule :: Name -> Maybe StringSource
tupleTypeName :: Int -> NameSource
tupleDataName :: Int -> NameSource
Constructors
NormalC Name [StrictType] | |
RecC Name [VarStrictType] | |
InfixC StrictType Name StrictType | |
ForallC [Name] Cxt Con |
Constructors
Unsafe | |
Safe | |
Threadsafe |
Constructors
Fixity Int FixityDirection |
data FixityDirection Source
type StrictTypeQ = Q StrictTypeSource
type VarStrictTypeQ = Q VarStrictTypeSource
floatPrimL :: Rational -> LitSource
doublePrimL :: Rational -> LitSource
normalC :: Name -> [StrictTypeQ] -> ConQSource
recC :: Name -> [VarStrictTypeQ] -> ConQSource
strictType :: Q Strict -> TypeQ -> StrictTypeQSource
varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQSource
pprExp :: Precedence -> Exp -> DocSource
pprLit :: Precedence -> Lit -> DocSource
pprPat :: Precedence -> Pat -> DocSource
pprParendType :: Type -> DocSource