Language.Haskell.TH

Contents

• The monad and its operations
• Names
• The algebraic data types
• Library functions
  • Abbreviations
  • Constructors lifted to Q
    • Literals
    • Patterns
    • Pattern Guards
    • Expressions
      • Ranges
        • Ranges with more indirection
      • Statements
    • Types
      • Strictness
      • Class Contexts
    • Top Level Declarations
      • Data
      • Class
      • Type Family / Data Family
      • Foreign Function Interface (FFI)
      • Pragmas
• Pretty-printer

Description

Synopsis

• 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
• location :: Q Loc
• runIO :: IO a -> Q a
• isClassInstance :: Name -> [Type] -> Q Bool
• classInstances :: Name -> [Type] -> Q [ClassInstance]
• data Name
• mkName :: String -> Name
• newName :: String -> Q Name
• nameBase :: Name -> String
• nameModule :: Name -> Maybe String
• tupleTypeName :: Int -> Name
• tupleDataName :: Int -> Name
• data Dec
  • = 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
• data Exp
  • = VarE Name
  • | ConE Name
  • | LitE Lit
  • | AppE Exp Exp
  • | InfixE (Maybe Exp) Exp (Maybe Exp)
  • | LamE [Pat] Exp
  • | TupE [Exp]
  • | UnboxedTupE [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 [TyVarBndr] Cxt Con
• data Type
  • = ForallT [TyVarBndr] Cxt Type
  • | VarT Name
  • | ConT Name
  • | TupleT Int
  • | UnboxedTupleT Int
  • | ArrowT
  • | ListT
  • | AppT Type Type
  • | SigT Type Kind
• data TyVarBndr
  • = PlainTV Name
  • | KindedTV Name Kind
• data Kind
  • = StarK
  • | ArrowK Kind Kind
• type Cxt = [Pred]
• data Pred
  • = ClassP Name [Type]
  • | EqualP Type Type
• data Match = Match Pat Body [Dec]
• data Clause = Clause [Pat] Body [Dec]
• data Body
  • = GuardedB [(Guard, Exp)]
  • | NormalB Exp
• data Guard
  • = NormalG Exp
  • | PatG [Stmt]
• data Stmt
  • = BindS Pat Exp
  • | LetS [Dec]
  • | NoBindS Exp
  • | ParS [[Stmt]]
• data Range
  • = FromR Exp
  • | FromThenR Exp Exp
  • | FromToR Exp Exp
  • | FromThenToR Exp Exp Exp
• data Lit
  • = CharL Char
  • | StringL String
  • | IntegerL Integer
  • | RationalL Rational
  • | IntPrimL Integer
  • | WordPrimL Integer
  • | FloatPrimL Rational
  • | DoublePrimL Rational
  • | StringPrimL String
• data Pat
  • = LitP Lit
  • | VarP Name
  • | TupP [Pat]
  • | UnboxedTupP [Pat]
  • | ConP Name [Pat]
  • | InfixP Pat Name Pat
  • | TildeP Pat
  • | BangP Pat
  • | AsP Name Pat
  • | WildP
  • | RecP Name [FieldPat]
  • | ListP [Pat]
  • | SigP Pat Type
  • | ViewP Exp Pat
• type FieldExp = (Name, Exp)
• type FieldPat = (Name, Pat)
• data Strict
  • = IsStrict
  • | NotStrict
• data Foreign
  • = ImportF Callconv Safety String Name Type
  • | ExportF Callconv String Name Type
• data Callconv
  • = CCall
  • | StdCall
• data Safety
  • = Unsafe
  • | Safe
  • | Interruptible
• data Pragma
  • = InlineP Name InlineSpec
  • | SpecialiseP Name Type (Maybe InlineSpec)
• data InlineSpec = InlineSpec Bool Bool (Maybe (Bool, Int))
• data FunDep = FunDep [Name] [Name]
• data FamFlavour
  • = TypeFam
  • | DataFam
• data Info
  • = ClassI Dec [ClassInstance]
  • | 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
• data ClassInstance = ClassInstance {
  • ci_dfun :: Name
  • ci_tvs :: [TyVarBndr]
  • ci_cxt :: Cxt
  • ci_cls :: Name
  • ci_tys :: [Type]
  }
• data Loc = Loc {
  • loc_filename :: String
  • loc_package :: String
  • loc_module :: String
  • loc_start :: CharPos
  • loc_end :: CharPos
  }
• data Fixity = Fixity Int FixityDirection
• data FixityDirection
  • = InfixL
  • | InfixR
  • | InfixN
• defaultFixity :: Fixity
• maxPrecedence :: Int
• type InfoQ = Q Info
• type ExpQ = Q Exp
• type DecQ = Q Dec
• type DecsQ = 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
• stringPrimL :: 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
• viewP :: ExpQ -> PatQ -> PatQ
• fieldPat :: Name -> PatQ -> FieldPatQ
• 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
• appsE :: [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)
• fromE :: ExpQ -> ExpQ
• fromThenE :: ExpQ -> ExpQ -> ExpQ
• fromToE :: ExpQ -> ExpQ -> ExpQ
• fromThenToE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
• arithSeqE :: RangeQ -> ExpQ
• fromR :: ExpQ -> RangeQ
• fromThenR :: ExpQ -> ExpQ -> RangeQ
• fromToR :: ExpQ -> ExpQ -> RangeQ
• fromThenToR :: ExpQ -> ExpQ -> ExpQ -> RangeQ
• doE :: [StmtQ] -> ExpQ
• compE :: [StmtQ] -> ExpQ
• bindS :: PatQ -> ExpQ -> StmtQ
• letS :: [DecQ] -> StmtQ
• noBindS :: ExpQ -> StmtQ
• parS :: [[StmtQ]] -> StmtQ
• 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, notStrict :: Q Strict
• strictType :: Q Strict -> TypeQ -> StrictTypeQ
• varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ
• 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
• 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
• 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
• typeFam, dataFam :: FamFlavour
• cCall, stdCall :: Callconv
• unsafe, safe :: Safety
• forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ
• inlineSpecNoPhase :: Bool -> Bool -> InlineSpecQ
• inlineSpecPhase :: Bool -> Bool -> Bool -> Int -> InlineSpecQ
• pragInlD :: Name -> InlineSpecQ -> DecQ
• pragSpecD :: Name -> TypeQ -> DecQ
• class Ppr a where
  • ppr :: a -> Doc
  • ppr_list :: [a] -> Doc
• pprint :: Ppr a => a -> String
• pprExp :: Precedence -> Exp -> Doc
• pprLit :: Precedence -> Lit -> Doc
• pprPat :: Precedence -> Pat -> Doc
• pprParendType :: Type -> Doc

The monad and its operations

Names

 let v = mkName "T" in [| data $v = $v |]

 f x = $(h [| (map, x) |])

 Foo.Baz.x   as    Qual Foo.Baz x

The algebraic data types

{ f p1 p2 = b where decs }

{ p = b where decs }

{ data Cxt x => T x = A x | B (T x)
       deriving (Z,W)}

{ newtype Cxt x => T x = A (B x)
       deriving (Z,W)}

{ type T x = (x,x) }

{ class Eq a => Ord a where ds }

{ instance Show w => Show [w]
       where ds }

{ length :: [a] -> Int }

{ {--} }

{ type family T a b c :: * }

{ data instance Cxt x => T [x] = A x 
                                | B (T x)
       deriving (Z,W)}

{ newtype instance Cxt x => T [x] = A (B x)
       deriving (Z,W)}

{ type instance T (Maybe x) = (x,x) }

 [ f x | x <- xs ]

 CompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))]

{ x }

data T1 = C1 t1 t2; p = {C1} e1 e2

{ 5 or c}

{ f x }

{x + y} or {(x+)} or {(+ x)} or {(+)}

{  p1 p2 -> e }

{ (e1,e2) }

{ () }

{ if e1 then e2 else e3 }

{ let x=e1;   y=e2 in e3 }

{ case e of m1; m2 }

{ do { p <- e1; e2 }  }

{ [ (x,y) | x <- xs, y <- ys ] }

{ [ 1 ,2 .. 10 ] }

{ [1,2,3] }

{ e :: t }

{ T { x = y, z = w } }

{ (f x) { z = w } }

C Int a

C { v :: Int, w :: a }

Int :+ a

forall a. Eq a => C [a]

forall vars. ctxt -> type

a

T

(,), (,,), etc.

(), (), etc.

->

[]

T a b

t :: k

a

(a :: k)

*

k1 -> k2

(Eq a, Ord b)

Eq (Int, a)

F a ~ Bool

case e of { pat -> body where decs }

f { p1 p2 = body where decs }

f p { | e1 = e2 | e3 = e4 } where ds

f p { = e } where ds

{ 5 or c }

{ x }

{ (p1,p2) }

{ () }

data T1 = C1 t1 t2; {C1 p1 p1} = e

foo ({x :+ y}) = e

{ ~p }

{ !p }

{ x @ p }

{ _ }

f (Pt { pointx = x }) = g x

{ [1,2,3] }

{ p :: t }

{ e -> p }

Library functions

Abbreviations

Constructors lifted to Q

Literals

Patterns

Pattern Guards

Expressions

Ranges

Ranges with more indirection

Statements

Types

Strictness

Class Contexts

Top Level Declarations

Data

Class

Type Family / Data Family

Foreign Function Interface (FFI)

Pragmas

Pretty-printer