Language.Haskell.TH.Syntax

Abstract syntax definitions for Template Haskell.

Documentation

class (Monad m, Functor m) => Quasi m where

Methods

qNewName :: String -> m Name

qReport :: Bool -> String -> m ()

qRecover :: m a -> m a -> m a

qReify :: Name -> m Info

qCurrentModule :: m String

qRunIO :: IO a -> m a

Instances

Quasi IO

Quasi Q

class Lift t where

Methods

lift :: t -> Q Exp

Instances

Lift Bool

Lift Char

Lift Int

Lift Integer

Lift a => Lift [a]

Lift a => Lift (Maybe a)

(Lift a, Lift b) => Lift (Either a b)

(Lift a, Lift b) => Lift (a, b)

(Lift a, Lift b, Lift c) => Lift (a, b, c)

(Lift a, Lift b, Lift c, Lift d) => Lift (a, b, c, d)

(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift (a, b, c, d, e)

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift (a, b, c, d, e, f)

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift (a, b, c, d, e, f, g)

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

currentModule :: Q String

currentModule gives you the name of the module in 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

Constructors

Name OccName NameFlavour

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

showName :: Name -> String

showName' :: NameIs -> Name -> String

data NameIs

Constructors

Alone

Applied

Infix

data Dec

Constructors

FunD Name [Clause]

ValD Pat Body [Dec]

DataD Cxt Name [Name] [Con] [Name]

NewtypeD Cxt Name [Name] Con [Name]

TySynD Name [Name] Type

ClassD Cxt Name [Name] [FunDep] [Dec]

InstanceD Cxt Type [Dec]

SigD Name Type

ForeignD Foreign

Instances

Eq Dec

Data Dec

Show Dec

Typeable Dec

Ppr Dec

data Exp

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 [Name] Cxt Con

Instances

Eq Con

Data Con

Show Con

Typeable Con

Ppr Con

data Type

Constructors

ForallT [Name] Cxt Type

VarT Name

ConT Name

TupleT Int

ArrowT

ListT

AppT Type Type

Instances

Eq Type

Data Type

Show Type

Typeable Type

Ppr Type

type Cxt = [Type]

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

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

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

type StrictType = (Strict, Type)

type VarStrictType = (Name, Strict, Type)

data FunDep

Constructors

FunDep [Name] [Name]

Instances

Eq FunDep

Data FunDep

Show FunDep

Typeable FunDep

Ppr FunDep

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

returnQ :: a -> Q a

bindQ :: Q a -> (a -> Q b) -> Q b

sequenceQ :: [Q a] -> Q [a]

data NameFlavour

Constructors

NameS

NameQ ModName

NameU Int#

NameL Int#

NameG NameSpace PkgName ModName

Instances

Eq NameFlavour

Data NameFlavour

Ord NameFlavour

Typeable NameFlavour

data NameSpace

Constructors

VarName

DataName

TcClsName

Instances

Eq NameSpace

Data NameSpace

Ord NameSpace

Typeable NameSpace

mkNameG_v :: String -> String -> String -> Name

mkNameG_d :: String -> String -> String -> Name

mkNameG_tc :: String -> String -> String -> Name

type Uniq = Int

mkNameL :: String -> Uniq -> Name

mkNameU :: String -> Uniq -> Name

tupleTypeName :: Int -> Name

tupleDataName :: Int -> Name

type OccName = PackedString

mkOccName :: String -> OccName

occString :: OccName -> String

type ModName = PackedString

mkModName :: String -> ModName

modString :: ModName -> String

type PkgName = PackedString

mkPkgName :: String -> PkgName

pkgString :: PkgName -> String