template-haskell-2.10.0.0: Support library for Template Haskell

Safe Haskell | None
Language | Haskell2010

Language.Haskell.TH

Contents

- The monad and its operations
  - Administration: errors, locations and IO
  - Querying the compiler
    - Reify
    - Name lookup
    - Instance lookup
    - Roles lookup
    - Annotation lookup
- Typed expressions
- Names
  - Constructing names
  - Deconstructing names
  - Built-in names
- The algebraic data types
  - Declarations
  - Expressions
  - Patterns
  - Types
- Library functions
  - Abbreviations
  - Constructors lifted to `Q`
    - Literals
    - Patterns
    - Pattern Guards
    - Expressions
      - Ranges
        - Ranges with more indirection
      - Statements
    - Types
      - Type literals
      - Strictness
      - Class Contexts
    - Kinds
    - Roles
    - Top Level Declarations
      - Data
      - Class
      - Role annotations
      - Type Family / Data Family
      - Foreign Function Interface (FFI)
      - Pragmas
- Pretty-printer

Description

The public face of Template Haskell

For other documentation, refer to: http://www.haskell.org/haskellwiki/Template_Haskell

Synopsis

- data Q a
- runQ :: Quasi m => Q a -> m a
- reportError :: String -> Q ()
- reportWarning :: String -> Q ()
- report :: Bool -> String -> Q ()
- recover :: Q a -> Q a -> Q a
- location :: Q Loc
- data Loc = Loc {
  - loc_filename :: String
  - loc_package :: String
  - loc_module :: String
  - loc_start :: CharPos
  - loc_end :: CharPos
  }
- runIO :: IO a -> Q a
- reify :: Name -> Q Info
- reifyModule :: Module -> Q ModuleInfo
- thisModule :: Q Module
- data Info
  - = ClassI Dec [InstanceDec]
  - | ClassOpI Name Type ParentName Fixity
  - | TyConI Dec
  - | FamilyI Dec [InstanceDec]
  - | PrimTyConI Name Arity Unlifted
  - | DataConI Name Type ParentName Fixity
  - | VarI Name Type (Maybe Dec) Fixity
  - | TyVarI Name Type
- data ModuleInfo = ModuleInfo [Module]
- type InstanceDec = Dec
- type ParentName = Name
- type Arity = Int
- type Unlifted = Bool
- lookupTypeName :: String -> Q (Maybe Name)
- lookupValueName :: String -> Q (Maybe Name)
- reifyInstances :: Name -> [Type] -> Q [InstanceDec]
- isInstance :: Name -> [Type] -> Q Bool
- reifyRoles :: Name -> Q [Role]
- reifyAnnotations :: Data a => AnnLookup -> Q [a]
- data AnnLookup
  - = AnnLookupModule Module
  - | AnnLookupName Name
- data TExp a
- unType :: TExp a -> Exp
- data Name
- data NameSpace
- mkName :: String -> Name
- newName :: String -> Q Name
- nameBase :: Name -> String
- nameModule :: Name -> Maybe String
- tupleTypeName :: Int -> Name
- tupleDataName :: Int -> Name
- unboxedTupleTypeName :: Int -> Name
- unboxedTupleDataName :: 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
  - | InfixD Fixity Name
  - | PragmaD Pragma
  - | FamilyD FamFlavour Name [TyVarBndr] (Maybe Kind)
  - | DataInstD Cxt Name [Type] [Con] [Name]
  - | NewtypeInstD Cxt Name [Type] Con [Name]
  - | TySynInstD Name TySynEqn
  - | ClosedTypeFamilyD Name [TyVarBndr] (Maybe Kind) [TySynEqn]
  - | RoleAnnotD Name [Role]
  - | StandaloneDerivD Cxt Type
  - | DefaultSigD Name Type
- data Con
  - = NormalC Name [StrictType]
  - | RecC Name [VarStrictType]
  - | InfixC StrictType Name StrictType
  - | ForallC [TyVarBndr] Cxt Con
- data Clause = Clause [Pat] Body [Dec]
- data Strict
  - = IsStrict
  - | NotStrict
  - | Unpacked
- data Foreign
  - = ImportF Callconv Safety String Name Type
  - | ExportF Callconv String Name Type
- data Callconv
  - = CCall
  - | StdCall
  - | CApi
  - | Prim
  - | JavaScript
- data Safety
  - = Unsafe
  - | Safe
  - | Interruptible
- data Pragma
  - = InlineP Name Inline RuleMatch Phases
  - | SpecialiseP Name Type (Maybe Inline) Phases
  - | SpecialiseInstP Type
  - | RuleP String [RuleBndr] Exp Exp Phases
  - | AnnP AnnTarget Exp
  - | LineP Int String
- data Inline
  - = NoInline
  - | Inline
  - | Inlinable
- data RuleMatch
  - = ConLike
  - | FunLike
- data Phases
  - = AllPhases
  - | FromPhase Int
  - | BeforePhase Int
- data RuleBndr
  - = RuleVar Name
  - | TypedRuleVar Name Type
- data AnnTarget
  - = ModuleAnnotation
  - | TypeAnnotation Name
  - | ValueAnnotation Name
- data FunDep = FunDep [Name] [Name]
- data FamFlavour
  - = TypeFam
  - | DataFam
- data TySynEqn = TySynEqn [Type] Type
- data Fixity = Fixity Int FixityDirection
- data FixityDirection
  - = InfixL
  - | InfixR
  - | InfixN
- defaultFixity :: Fixity
- maxPrecedence :: Int
- data Exp
  - = VarE Name
  - | ConE Name
  - | LitE Lit
  - | AppE Exp Exp
  - | InfixE (Maybe Exp) Exp (Maybe Exp)
  - | UInfixE Exp Exp Exp
  - | ParensE Exp
  - | LamE [Pat] Exp
  - | LamCaseE [Match]
  - | TupE [Exp]
  - | UnboxedTupE [Exp]
  - | CondE Exp Exp Exp
  - | MultiIfE [(Guard, Exp)]
  - | LetE [Dec] Exp
  - | CaseE Exp [Match]
  - | DoE [Stmt]
  - | CompE [Stmt]
  - | ArithSeqE Range
  - | ListE [Exp]
  - | SigE Exp Type
  - | RecConE Name [FieldExp]
  - | RecUpdE Exp [FieldExp]
  - | StaticE Exp
- data Match = Match 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 [Word8]
- data Pat
  - = LitP Lit
  - | VarP Name
  - | TupP [Pat]
  - | UnboxedTupP [Pat]
  - | ConP Name [Pat]
  - | InfixP Pat Name Pat
  - | UInfixP Pat Name Pat
  - | ParensP 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 Type
  - = ForallT [TyVarBndr] Cxt Type
  - | AppT Type Type
  - | SigT Type Kind
  - | VarT Name
  - | ConT Name
  - | PromotedT Name
  - | TupleT Int
  - | UnboxedTupleT Int
  - | ArrowT
  - | EqualityT
  - | ListT
  - | PromotedTupleT Int
  - | PromotedNilT
  - | PromotedConsT
  - | StarT
  - | ConstraintT
  - | LitT TyLit
- data TyVarBndr
  - = PlainTV Name
  - | KindedTV Name Kind
- data TyLit
  - = NumTyLit Integer
  - | StrTyLit String
- type Kind = Type
- type Cxt = [Pred]
- type Pred = Type
- data Role
  - = NominalR
  - | RepresentationalR
  - | PhantomR
  - | InferR
- 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 TyLitQ = Q TyLit
- 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 RuleBndrQ = Q RuleBndr
- type TySynEqnQ = Q TySynEqn
- 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 :: [Word8] -> Lit
- litP :: Lit -> PatQ
- varP :: Name -> PatQ
- tupP :: [PatQ] -> PatQ
- conP :: Name -> [PatQ] -> PatQ
- uInfixP :: PatQ -> Name -> PatQ -> PatQ
- parensP :: 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 -> ExpQ
- global :: Name -> ExpQ
- varE :: Name -> ExpQ
- conE :: Name -> ExpQ
- litE :: Lit -> ExpQ
- appE :: ExpQ -> ExpQ -> ExpQ
- uInfixE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
- parensE :: ExpQ -> ExpQ
- staticE :: 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
- lamCaseE :: [MatchQ] -> ExpQ
- tupE :: [ExpQ] -> ExpQ
- condE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
- multiIfE :: [Q (Guard, Exp)] -> 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
- equalityT :: TypeQ
- listT :: TypeQ
- tupleT :: Int -> TypeQ
- sigT :: TypeQ -> Kind -> TypeQ
- litT :: TyLitQ -> TypeQ
- promotedT :: Name -> TypeQ
- promotedTupleT :: Int -> TypeQ
- promotedNilT :: TypeQ
- promotedConsT :: TypeQ
- numTyLit :: Integer -> TyLitQ
- strTyLit :: String -> TyLitQ
- isStrict :: Q Strict
- notStrict :: Q Strict
- strictType :: Q Strict -> TypeQ -> StrictTypeQ
- varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ
- cxt :: [PredQ] -> CxtQ
- classP :: Name -> [Q Type] -> Q Pred
- equalP :: TypeQ -> TypeQ -> PredQ
- normalC :: Name -> [StrictTypeQ] -> ConQ
- recC :: Name -> [VarStrictTypeQ] -> ConQ
- infixC :: Q (Strict, Type) -> Name -> Q (Strict, Type) -> ConQ
- forallC :: [TyVarBndr] -> CxtQ -> ConQ -> ConQ
- varK :: Name -> Kind
- conK :: Name -> Kind
- tupleK :: Int -> Kind
- arrowK :: Kind
- listK :: Kind
- appK :: Kind -> Kind -> Kind
- starK :: Kind
- constraintK :: Kind
- nominalR :: Role
- representationalR :: Role
- phantomR :: Role
- inferR :: Role
- 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
- standaloneDerivD :: CxtQ -> TypeQ -> DecQ
- defaultSigD :: Name -> TypeQ -> DecQ
- roleAnnotD :: Name -> [Role] -> DecQ
- familyNoKindD :: FamFlavour -> Name -> [TyVarBndr] -> DecQ
- familyKindD :: FamFlavour -> Name -> [TyVarBndr] -> Kind -> DecQ
- dataInstD :: CxtQ -> Name -> [TypeQ] -> [ConQ] -> [Name] -> DecQ
- closedTypeFamilyNoKindD :: Name -> [TyVarBndr] -> [TySynEqnQ] -> DecQ
- closedTypeFamilyKindD :: Name -> [TyVarBndr] -> Kind -> [TySynEqnQ] -> DecQ
- newtypeInstD :: CxtQ -> Name -> [TypeQ] -> ConQ -> [Name] -> DecQ
- tySynInstD :: Name -> TySynEqnQ -> DecQ
- typeFam :: FamFlavour
- dataFam :: FamFlavour
- tySynEqn :: [TypeQ] -> TypeQ -> TySynEqnQ
- cCall :: Callconv
- stdCall :: Callconv
- cApi :: Callconv
- prim :: Callconv
- javaScript :: Callconv
- unsafe :: Safety
- safe :: Safety
- forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ
- ruleVar :: Name -> RuleBndrQ
- typedRuleVar :: Name -> TypeQ -> RuleBndrQ
- pragInlD :: Name -> Inline -> RuleMatch -> Phases -> DecQ
- pragSpecD :: Name -> TypeQ -> Phases -> DecQ
- pragSpecInlD :: Name -> TypeQ -> Inline -> Phases -> DecQ
- pragSpecInstD :: TypeQ -> DecQ
- pragRuleD :: String -> [RuleBndrQ] -> ExpQ -> ExpQ -> Phases -> DecQ
- pragAnnD :: AnnTarget -> ExpQ -> DecQ
- pragLineD :: Int -> String -> 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

data Q a

Instances

Monad Q |
Functor Q |
Applicative Q |
Quasi Q |

runQ :: Quasi m => Q a -> m a

## Administration: errors, locations and IO

reportError :: String -> Q ()

Report an error to the user, but allow the current splice's computation to carry on. To abort the computation, use `fail`.

reportWarning :: String -> Q ()

Report a warning to the user, and carry on.

report :: Bool -> String -> Q ()

Deprecated: Use reportError or reportWarning instead

Report an error (True) or warning (False), but carry on; use `fail` to stop.

recover

Arguments

:: Q a | handler to invoke on failure
-> Q a | computation to run
-> Q a |

Recover from errors raised by `reportError` or `fail`.

location :: Q Loc

The location at which this computation is spliced.

data Loc

Constructors

Loc |

Fields

loc_filename :: String
loc_package :: String
loc_module :: String
loc_start :: CharPos
loc_end :: CharPos

Instances

Eq Loc |
Data Loc |
Ord Loc |
Show Loc |
Generic Loc |
Ppr Loc |
type Rep Loc |

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 necessarily flushed when the compiler finishes running, so you should flush them yourself.

## Querying the compiler

### Reify

reify :: Name -> Q Info

`reify` looks up information about the `Name`.

It is sometimes useful to construct the argument name using `lookupTypeName` or `lookupValueName` to ensure that we are reifying from the right namespace. For instance, in this context:

    data D = D

which `D` does `reify (mkName "D")` return information about? (Answer: `D`-the-type, but don't rely on it.) To ensure we get information about `D`-the-value, use `lookupValueName`:

    do
      Just nm <- lookupValueName "D"
      reify nm

and to get information about `D`-the-type, use `lookupTypeName`.

reifyModule :: Module -> Q ModuleInfo

`reifyModule mod` looks up information about module `mod`. To look up the current module, call this function with the return value of `thisModule`.

thisModule :: Q Module

Return the Module at the place of splicing. Can be used as an input for `reifyModule`.

data Info

Obtained from `reify` in the `Q` Monad.

Constructors

ClassI Dec [InstanceDec] | A class, with a list of its visible instances
ClassOpI Name Type ParentName Fixity | A class method
TyConI Dec | A "plain" type constructor. "Fancier" type constructors are returned using `PrimTyConI` or `FamilyI` as appropriate
FamilyI Dec [InstanceDec] | A type or data family, with a list of its visible instances. A closed type family is returned with 0 instances.
PrimTyConI Name Arity Unlifted | A "primitive" type constructor, which can't be expressed with a `Dec`. Examples: `(->)`, `Int#`.
DataConI Name Type ParentName Fixity | A data constructor

VarI Name Type (Maybe Dec) Fixity

A "value" variable (as opposed to a type variable, see `TyVarI`).

The `Maybe Dec` field contains `Just` the declaration which defined the variable -- including the RHS of the declaration -- or else `Nothing`, in the case where the RHS is unavailable to the compiler. At present, this value is _always_ `Nothing`: returning the RHS has not yet been implemented because of lack of interest.

TyVarI Name Type | A type variable. The `Type` field contains the type which underlies the variable. At present, this is always ``VarT` theName`, but future changes may permit refinement of this.

Instances

Eq Info |
Data Info |
Ord Info |
Show Info |
Generic Info |
Ppr Info |
type Rep Info |

data ModuleInfo

Obtained from `reifyModule` in the `Q` Monad.

Constructors

ModuleInfo [Module] | Contains the import list of the module.

Instances

Eq ModuleInfo |
Data ModuleInfo |
Ord ModuleInfo |
Show ModuleInfo |
Generic ModuleInfo |
Ppr ModuleInfo |
type Rep ModuleInfo |

type InstanceDec = Dec

`InstanceDec` desribes a single instance of a class or type function. It is just a `Dec`, but guaranteed to be one of the following:

- `InstanceD` (with empty `[`Dec`]`)
- `DataInstD` or `NewtypeInstD` (with empty derived `[`Name`]`)
- `TySynInstD`

type ParentName = Name

In `ClassOpI` and `DataConI`, name of the parent class or type

type Arity = Int

In `PrimTyConI`, arity of the type constructor

type Unlifted = Bool

In `PrimTyConI`, is the type constructor unlifted?

### Name lookup

lookupTypeName :: String -> Q (Maybe Name)

Look up the given name in the (type namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.

lookupValueName :: String -> Q (Maybe Name)

Look up the given name in the (value namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.

### Instance lookup

reifyInstances :: Name -> [Type] -> Q [InstanceDec]

`reifyInstances nm tys` returns a list of visible instances of `nm tys`. That is, if `nm` is the name of a type class, then all instances of this class at the types `tys` are returned. Alternatively, if `nm` is the name of a data family or type family, all instances of this family at the types `tys` are returned.

isInstance :: Name -> [Type] -> Q Bool

Is the list of instances returned by `reifyInstances` nonempty?

### Roles lookup

reifyRoles :: Name -> Q [Role]

`reifyRoles nm` returns the list of roles associated with the parameters of the tycon `nm`. Fails if `nm` cannot be found or is not a tycon. The returned list should never contain `InferR`.

### Annotation lookup

reifyAnnotations :: Data a => AnnLookup -> Q [a]

`reifyAnnotations target` returns the list of annotations associated with `target`. Only the annotations that are appropriately typed is returned. So if you have `Int` and `String` annotations for the same target, you have to call this function twice.

data AnnLookup

Annotation target for reifyAnnotations

Constructors

AnnLookupModule Module |
AnnLookupName Name |

Instances

Eq AnnLookup |
Data AnnLookup |
Ord AnnLookup |
Show AnnLookup |
Generic AnnLookup |
type Rep AnnLookup |

# Typed expressions

data TExp a

unType :: TExp a -> Exp

# Names

data Name

An abstract type representing names in the syntax tree.

`Name`s can be constructed in several ways, which come with different name-capture guarantees (see Language.Haskell.TH.Syntax for an explanation of name capture):

- the built-in syntax `'f` and `''T` can be used to construct names, The expression `'f` gives a `Name` which refers to the value `f` currently in scope, and `''T` gives a `Name` which refers to the type `T` currently in scope. These names can never be captured.
- `lookupValueName` and `lookupTypeName` are similar to `'f` and `''T` respectively, but the `Name`s are looked up at the point where the current splice is being run. These names can never be captured.
- `newName` monadically generates a new name, which can never be captured.
- `mkName` generates a capturable name.

Names constructed using `newName` and `mkName` may be used in bindings (such as `let x = ...` or `x -> ...`), but names constructed using `lookupValueName`, `lookupTypeName`, `'f`, `''T` may not.

Instances

Eq Name |
Data Name |
Ord Name |
Show Name |
Generic Name |
Ppr Name |
type Rep Name |

data NameSpace

Instances

Eq NameSpace |
Data NameSpace |
Ord NameSpace |
Generic NameSpace |
type Rep NameSpace |

## Constructing names

mkName :: String -> Name

Generate a capturable name. Occurrences of such names will be resolved according to the Haskell scoping rules at the occurrence site.

For example:

    f = [| pi + $(varE (mkName "pi")) |]
    ...
    g = let pi = 3 in $f

In this case, `g` is desugared to

    g = Prelude.pi + 3

Note that `mkName` may be used with qualified names:

    mkName "Prelude.pi"

See also `dyn` for a useful combinator. The above example could be rewritten using `dyn` as

    f = [| pi + $(dyn "pi") |]

newName :: String -> Q Name

Generate a fresh name, which cannot be captured.

For example, this:

    f = $(do
      nm1 <- newName "x"
      let nm2 = mkName "x"
      return (LamE [VarP nm1] (LamE [VarP nm2] (VarE nm1)))
     )

will produce the splice

    f = \x0 -> \x -> x0

In particular, the occurrence `VarE nm1` refers to the binding `VarP nm1`, and is not captured by the binding `VarP nm2`.

Although names generated by `newName` cannot be captured, they can capture other names. For example, this:

    g = $(do
      nm1 <- newName "x"
      let nm2 = mkName "x"
      return (LamE [VarP nm2] (LamE [VarP nm1] (VarE nm2)))
     )

will produce the splice

    g = \x -> \x0 -> x0

since the occurrence `VarE nm2` is captured by the innermost binding of `x`, namely `VarP nm1`.

## Deconstructing names

nameBase :: Name -> String

The name without its module prefix

nameModule :: Name -> Maybe String

Module prefix of a name, if it exists

## Built-in names

tupleTypeName :: Int -> Name

Tuple type constructor

tupleDataName :: Int -> Name

Tuple data constructor

unboxedTupleTypeName :: Int -> Name

Unboxed tuple type constructor

unboxedTupleDataName :: Int -> Name

Unboxed tuple data constructor

# The algebraic data types

The lowercase versions (syntax operators) of these constructors are preferred to these constructors, since they compose better with quotations (`[| |]`) and splices (`$( ... )`)

## Declarations

data Dec

Constructors

FunD Name [Clause]

    { f p1 p2 = b where decs }

ValD Pat Body [Dec]

    { p = b where decs }

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

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

NewtypeD Cxt Name [TyVarBndr] Con [Name]

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

TySynD Name [TyVarBndr] Type

    { type T x = (x,x) }

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

    { class Eq a => Ord a where ds }

InstanceD Cxt Type [Dec]

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

SigD Name Type

    { length :: [a] -> Int }

ForeignD Foreign

    { foreign import ... }
    { foreign export ... }

InfixD Fixity Name

    { infix 3 foo }

PragmaD Pragma

    { {--} }

FamilyD FamFlavour Name [TyVarBndr] (Maybe Kind)

    { type family T a b c :: * }

DataInstD Cxt Name [Type] [Con] [Name]

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

NewtypeInstD Cxt Name [Type] Con [Name]

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

TySynInstD Name TySynEqn

    { type instance ... }

ClosedTypeFamilyD Name [TyVarBndr] (Maybe Kind) [TySynEqn]

    { type family F a b :: * where ... }

RoleAnnotD Name [Role]

    { type role T nominal representational }

StandaloneDerivD Cxt Type

    { deriving instance Ord a => Ord (Foo a) }

DefaultSigD Name Type

    { default size :: Data a => a -> Int }

Instances

Eq Dec |
Data Dec |
Ord Dec |
Show Dec |
Generic Dec |
Ppr Dec |
type Rep Dec |

data Con

Constructors

NormalC Name [StrictType]

    C Int a

RecC Name [VarStrictType]

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

InfixC StrictType Name StrictType

    Int :+ a

ForallC [TyVarBndr] Cxt Con

    forall a. Eq a => C [a]

Instances

Eq Con |
Data Con |
Ord Con |
Show Con |
Generic Con |
Ppr Con |
type Rep Con |

data Clause

Constructors

Clause [Pat] Body [Dec]

    f { p1 p2 = body where decs }

Instances

Eq Clause |
Data Clause |
Ord Clause |
Show Clause |
Generic Clause |
Ppr Clause |
type Rep Clause |

data Strict

Constructors

IsStrict |
NotStrict |
Unpacked |

Instances

Eq Strict |
Data Strict |
Ord Strict |
Show Strict |
Generic Strict |
type Rep Strict |

data Foreign

Constructors

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

Instances

Eq Foreign |
Data Foreign |
Ord Foreign |
Show Foreign |
Generic Foreign |
Ppr Foreign |
type Rep Foreign |

data Callconv

Constructors

CCall |
StdCall |
CApi |
Prim |
JavaScript |

Instances

Eq Callconv |
Data Callconv |
Ord Callconv |
Show Callconv |
Generic Callconv |
type Rep Callconv |

data Safety

Constructors

Unsafe |
Safe |
Interruptible |

Instances

Eq Safety |
Data Safety |
Ord Safety |
Show Safety |
Generic Safety |
type Rep Safety |

data Pragma

Constructors

InlineP Name Inline RuleMatch Phases |
SpecialiseP Name Type (Maybe Inline) Phases |
SpecialiseInstP Type |
RuleP String [RuleBndr] Exp Exp Phases |
AnnP AnnTarget Exp |
LineP Int String |

Instances

Eq Pragma |
Data Pragma |
Ord Pragma |
Show Pragma |
Generic Pragma |
Ppr Pragma |
type Rep Pragma |

data Inline

Constructors

NoInline |
Inline |
Inlinable |

Instances

Eq Inline |
Data Inline |
Ord Inline |
Show Inline |
Generic Inline |
Ppr Inline |
type Rep Inline |

data RuleMatch

Constructors

ConLike |
FunLike |

Instances

Eq RuleMatch |
Data RuleMatch |
Ord RuleMatch |
Show RuleMatch |
Generic RuleMatch |
Ppr RuleMatch |
type Rep RuleMatch |

data Phases

Constructors

AllPhases |
FromPhase Int |
BeforePhase Int |

Instances

Eq Phases |
Data Phases |
Ord Phases |
Show Phases |
Generic Phases |
Ppr Phases |
type Rep Phases |

data RuleBndr

Constructors

RuleVar Name |
TypedRuleVar Name Type |

Instances

Eq RuleBndr |
Data RuleBndr |
Ord RuleBndr |
Show RuleBndr |
Generic RuleBndr |
Ppr RuleBndr |
type Rep RuleBndr |

data AnnTarget

Constructors

ModuleAnnotation |
TypeAnnotation Name |
ValueAnnotation Name |

Instances

Eq AnnTarget |
Data AnnTarget |
Ord AnnTarget |
Show AnnTarget |
Generic AnnTarget |
type Rep AnnTarget |

data FunDep

Constructors

FunDep [Name] [Name] |

Instances

Eq FunDep |
Data FunDep |
Ord FunDep |
Show FunDep |
Generic FunDep |
Ppr FunDep |
type Rep FunDep |

data FamFlavour

Constructors

TypeFam |
DataFam |

Instances

Eq FamFlavour |
Data FamFlavour |
Ord FamFlavour |
Show FamFlavour |
Generic FamFlavour |
Ppr FamFlavour |
type Rep FamFlavour |

data TySynEqn

One equation of a type family instance or closed type family. The arguments are the left-hand-side type patterns and the right-hand-side result.

Constructors

TySynEqn [Type] Type |

Instances

Eq TySynEqn |
Data TySynEqn |
Ord TySynEqn |
Show TySynEqn |
Generic TySynEqn |
type Rep TySynEqn |

data Fixity

Constructors

Fixity Int FixityDirection |

Instances

Eq Fixity |
Data Fixity |
Ord Fixity |
Show Fixity |
Generic Fixity |
type Rep Fixity |

data FixityDirection

Constructors

InfixL |
InfixR |
InfixN |

Instances

Eq FixityDirection |
Data FixityDirection |
Ord FixityDirection |
Show FixityDirection |
Generic FixityDirection |
type Rep FixityDirection |

defaultFixity :: Fixity

Default fixity: `infixl 9`

maxPrecedence :: Int

Highest allowed operator precedence for `Fixity` constructor (answer: 9)

## Expressions

data Exp

Constructors

VarE Name

    { x }

ConE Name

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

LitE Lit

    { 5 or c}

AppE Exp Exp

    { f x }

InfixE (Maybe Exp) Exp (Maybe Exp)

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

UInfixE Exp Exp Exp

    {x + y}

See Language.Haskell.TH.Syntax

ParensE Exp

    { (e) }

See Language.Haskell.TH.Syntax

LamE [Pat] Exp

    {  p1 p2 -> e }

LamCaseE [Match]

    { case m1; m2 }

TupE [Exp]

    { (e1,e2) }

UnboxedTupE [Exp]

    { () }

CondE Exp Exp Exp

    { if e1 then e2 else e3 }

MultiIfE [(Guard, Exp)]

    { if | g1 -> e1 | g2 -> e2 }

LetE [Dec] Exp

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

CaseE Exp [Match]

    { case e of m1; m2 }

DoE [Stmt]

    { do { p <- e1; e2 }  }

CompE [Stmt]

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

The result expression of the comprehension is the last of the ``Stmt``s, and should be a `NoBindS`.

E.g. translation:

    [ f x | x <- xs ]

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

ArithSeqE Range

    { [ 1 ,2 .. 10 ] }

ListE [Exp]

    { [1,2,3] }

SigE Exp Type

    { e :: t }

RecConE Name [FieldExp]

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

RecUpdE Exp [FieldExp]

    { (f x) { z = w } }

StaticE Exp

    { static e }

Instances

Eq Exp |
Data Exp |
Ord Exp |
Show Exp |
Generic Exp |
Ppr Exp |
type Rep Exp |

data Match

Constructors

Match Pat Body [Dec]

    case e of { pat -> body where decs }

Instances

Eq Match |
Data Match |
Ord Match |
Show Match |
Generic Match |
Ppr Match |
type Rep Match |

data Body

Constructors

GuardedB [(Guard, Exp)]

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

NormalB Exp

    f p { = e } where ds

Instances

Eq Body |
Data Body |
Ord Body |
Show Body |
Generic Body |
type Rep Body |

data Guard

Constructors

NormalG Exp

    f x { | odd x } = x

PatG [Stmt]

    f x { | Just y <- x, Just z <- y } = z

Instances

Eq Guard |
Data Guard |
Ord Guard |
Show Guard |
Generic Guard |
type Rep Guard |

data Stmt

Constructors

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

Instances

Eq Stmt |
Data Stmt |
Ord Stmt |
Show Stmt |
Generic Stmt |
Ppr Stmt |
type Rep Stmt |

data Range

Constructors

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

Instances

Eq Range |
Data Range |
Ord Range |
Show Range |
Generic Range |
Ppr Range |
type Rep Range |

data Lit

Constructors

CharL Char |
StringL String |
IntegerL Integer | Used for overloaded and non-overloaded literals. We don't have a good way to represent non-overloaded literals at the moment. Maybe that doesn't matter?
RationalL Rational |
IntPrimL Integer |
WordPrimL Integer |
FloatPrimL Rational |
DoublePrimL Rational |
StringPrimL [Word8] | A primitive C-style string, type Addr#

Instances

Eq Lit |
Data Lit |
Ord Lit |
Show Lit |
Generic Lit |
Ppr Lit |
type Rep Lit |

## Patterns

data Pat

Pattern in Haskell given in `{}`

Constructors

LitP Lit

    { 5 or c }

VarP Name

    { x }

TupP [Pat]

    { (p1,p2) }

UnboxedTupP [Pat]

    { () }

ConP Name [Pat]

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

InfixP Pat Name Pat

    foo ({x :+ y}) = e

UInfixP Pat Name Pat

    foo ({x :+ y}) = e

See Language.Haskell.TH.Syntax

ParensP Pat

    {(p)}

See Language.Haskell.TH.Syntax

TildeP Pat

    { ~p }

BangP Pat

    { !p }

AsP Name Pat

    { x @ p }

WildP

    { _ }

RecP Name [FieldPat]

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

ListP [Pat]

    { [1,2,3] }

SigP Pat Type

    { p :: t }

ViewP Exp Pat

    { e -> p }

Instances

Eq Pat |
Data Pat |
Ord Pat |
Show Pat |
Generic Pat |
Ppr Pat |
type Rep Pat |

type FieldExp = (Name, Exp)

type FieldPat = (Name, Pat)

## Types

data Type

Constructors

ForallT [TyVarBndr] Cxt Type

    forall <vars>. <ctxt> -> <type>

AppT Type Type

    T a b

SigT Type Kind

    t :: k

VarT Name

    a

ConT Name

    T

PromotedT Name

    'T

TupleT Int

    (,), (,,), etc.

UnboxedTupleT Int

    (), (), etc.

ArrowT

    ->

EqualityT

    ~

ListT

    []

PromotedTupleT Int

    '(), '(,), '(,,), etc.

PromotedNilT

    '[]

PromotedConsT

    (':)

StarT

    *

ConstraintT

    Constraint

LitT TyLit

    0,1,2, etc.

Instances

Eq Type |
Data Type |
Ord Type |
Show Type |
Generic Type |
Ppr Type |
type Rep Type |

data TyVarBndr

Constructors

PlainTV Name

    a

KindedTV Name Kind

    (a :: k)

Instances

Eq TyVarBndr |
Data TyVarBndr |
Ord TyVarBndr |
Show TyVarBndr |
Generic TyVarBndr |
Ppr TyVarBndr |
type Rep TyVarBndr |

data TyLit

Constructors

NumTyLit Integer

    2

StrTyLit String

    Hello

Instances

Eq TyLit |
Data TyLit |
Ord TyLit |
Show TyLit |
Generic TyLit |
Ppr TyLit |
type Rep TyLit |

type Kind = Type

To avoid duplication between kinds and types, they are defined to be the same. Naturally, you would never have a type be `StarT` and you would never have a kind be `SigT`, but many of the other constructors are shared. Note that the kind `Bool` is denoted with `ConT`, not `PromotedT`. Similarly, tuple kinds are made with `TupleT`, not `PromotedTupleT`.

type Cxt

Arguments

= [Pred]

    (Eq a, Ord b)

type Pred = Type

Since the advent of `ConstraintKinds`, constraints are really just types. Equality constraints use the `EqualityT` constructor. Constraints may also be tuples of other constraints.

data Role

Role annotations

Constructors

NominalR

    nominal

RepresentationalR

    representational

PhantomR

    phantom

InferR

    _

Instances

Eq Role |
Data Role |
Ord Role |
Show Role |
Generic Role |
Ppr Role |
type Rep Role |

# Library functions

## Abbreviations

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 TyLitQ = Q TyLit

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 RuleBndrQ = Q RuleBndr

type TySynEqnQ = Q TySynEqn

## Constructors lifted to `Q`

### Literals

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 :: [Word8] -> Lit

### Patterns

litP :: Lit -> PatQ

varP :: Name -> PatQ

tupP :: [PatQ] -> PatQ

conP :: Name -> [PatQ] -> PatQ

uInfixP :: PatQ -> Name -> PatQ -> PatQ

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

### Pattern Guards

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

Use with `caseE`

clause :: [PatQ] -> BodyQ -> [DecQ] -> ClauseQ

Use with `funD`

### Expressions

dyn :: String -> ExpQ

Dynamically binding a variable (unhygenic)

global :: Name -> ExpQ

Deprecated: Use varE instead

varE :: Name -> ExpQ

conE :: Name -> ExpQ

litE :: Lit -> ExpQ

appE :: ExpQ -> ExpQ -> ExpQ

uInfixE :: ExpQ -> ExpQ -> ExpQ -> ExpQ

parensE :: ExpQ -> ExpQ

staticE :: ExpQ -> ExpQ

    staticE x = [| static x |]

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

Single-arg lambda

lamCaseE :: [MatchQ] -> ExpQ

tupE :: [ExpQ] -> ExpQ

condE :: ExpQ -> ExpQ -> ExpQ -> ExpQ

multiIfE :: [Q (Guard, Exp)] -> 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)

#### Ranges

fromE :: ExpQ -> ExpQ

fromThenE :: ExpQ -> ExpQ -> ExpQ

fromToE :: ExpQ -> ExpQ -> ExpQ

fromThenToE :: ExpQ -> ExpQ -> ExpQ -> ExpQ

#### Ranges with more indirection

arithSeqE :: RangeQ -> ExpQ

fromR :: ExpQ -> RangeQ

fromThenR :: ExpQ -> ExpQ -> RangeQ

fromToR :: ExpQ -> ExpQ -> RangeQ

fromThenToR :: ExpQ -> ExpQ -> ExpQ -> RangeQ

#### Statements

doE :: [StmtQ] -> ExpQ

compE :: [StmtQ] -> ExpQ

bindS :: PatQ -> ExpQ -> StmtQ

letS :: [DecQ] -> StmtQ

noBindS :: ExpQ -> StmtQ

parS :: [[StmtQ]] -> StmtQ

### Types

forallT :: [TyVarBndr] -> CxtQ -> TypeQ -> TypeQ

varT :: Name -> TypeQ

conT :: Name -> TypeQ

appT :: TypeQ -> TypeQ -> TypeQ

arrowT :: TypeQ

equalityT :: TypeQ

listT :: TypeQ

tupleT :: Int -> TypeQ

sigT :: TypeQ -> Kind -> TypeQ

litT :: TyLitQ -> TypeQ

promotedT :: Name -> TypeQ

promotedTupleT :: Int -> TypeQ

promotedNilT :: TypeQ

promotedConsT :: TypeQ

#### Type literals

numTyLit :: Integer -> TyLitQ

strTyLit :: String -> TyLitQ

#### Strictness

isStrict :: Q Strict

notStrict :: Q Strict

strictType :: Q Strict -> TypeQ -> StrictTypeQ

varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ

#### Class Contexts

cxt :: [PredQ] -> CxtQ

classP :: Name -> [Q Type] -> Q Pred

Deprecated: As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please use `conT` and `appT`.

equalP :: TypeQ -> TypeQ -> PredQ

Deprecated: As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please see `equalityT`.

normalC :: Name -> [StrictTypeQ] -> ConQ

recC :: Name -> [VarStrictTypeQ] -> ConQ

infixC :: Q (Strict, Type) -> Name -> Q (Strict, Type) -> ConQ

forallC :: [TyVarBndr] -> CxtQ -> ConQ -> ConQ

### Kinds

varK :: Name -> Kind

conK :: Name -> Kind

tupleK :: Int -> Kind

arrowK :: Kind

listK :: Kind

appK :: Kind -> Kind -> Kind

starK :: Kind

constraintK :: Kind

### Roles

nominalR :: Role

representationalR :: Role

phantomR :: Role

inferR :: Role

### Top Level Declarations

#### Data

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

#### Class

classD :: CxtQ -> Name -> [TyVarBndr] -> [FunDep] -> [DecQ] -> DecQ

instanceD :: CxtQ -> TypeQ -> [DecQ] -> DecQ

sigD :: Name -> TypeQ -> DecQ

standaloneDerivD :: CxtQ -> TypeQ -> DecQ

defaultSigD :: Name -> TypeQ -> DecQ

#### Role annotations

roleAnnotD :: Name -> [Role] -> DecQ

#### Type Family / Data Family

familyNoKindD :: FamFlavour -> Name -> [TyVarBndr] -> DecQ

familyKindD :: FamFlavour -> Name -> [TyVarBndr] -> Kind -> DecQ

dataInstD :: CxtQ -> Name -> [TypeQ] -> [ConQ] -> [Name] -> DecQ

closedTypeFamilyNoKindD :: Name -> [TyVarBndr] -> [TySynEqnQ] -> DecQ

closedTypeFamilyKindD :: Name -> [TyVarBndr] -> Kind -> [TySynEqnQ] -> DecQ

newtypeInstD :: CxtQ -> Name -> [TypeQ] -> ConQ -> [Name] -> DecQ

tySynInstD :: Name -> TySynEqnQ -> DecQ

typeFam :: FamFlavour

dataFam :: FamFlavour

tySynEqn :: [TypeQ] -> TypeQ -> TySynEqnQ

#### Foreign Function Interface (FFI)

cCall :: Callconv

stdCall :: Callconv

cApi :: Callconv

prim :: Callconv

javaScript :: Callconv

unsafe :: Safety

safe :: Safety

forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ

#### Pragmas

ruleVar :: Name -> RuleBndrQ

typedRuleVar :: Name -> TypeQ -> RuleBndrQ

pragInlD :: Name -> Inline -> RuleMatch -> Phases -> DecQ

pragSpecD :: Name -> TypeQ -> Phases -> DecQ

pragSpecInlD :: Name -> TypeQ -> Inline -> Phases -> DecQ

pragSpecInstD :: TypeQ -> DecQ

pragRuleD :: String -> [RuleBndrQ] -> ExpQ -> ExpQ -> Phases -> DecQ

pragAnnD :: AnnTarget -> ExpQ -> DecQ

pragLineD :: Int -> String -> DecQ

# Pretty-printer

class Ppr a where

Minimal complete definition

ppr

Methods

ppr :: a -> Doc

ppr_list :: [a] -> Doc

Instances

Ppr Exp |
Ppr Match |
Ppr Clause |
Ppr Pat |
Ppr Type |
Ppr Dec |
Ppr Name |
Ppr FunDep |
Ppr TyVarBndr |
Ppr Role |
Ppr TyLit |
Ppr Con |
Ppr RuleBndr |
Ppr Phases |
Ppr RuleMatch |
Ppr Inline |
Ppr Pragma |
Ppr Foreign |
Ppr FamFlavour |
Ppr Range |
Ppr Stmt |
Ppr Lit |
Ppr ModuleInfo |
Ppr Info |
Ppr Loc |
Ppr Module |
Ppr a => Ppr [a] |

pprint :: Ppr a => a -> String

pprExp :: Precedence -> Exp -> Doc

pprLit :: Precedence -> Lit -> Doc

pprPat :: Precedence -> Pat -> Doc

pprParendType :: Type -> Doc