template-haskell-2.7.0.0

Safe Haskell | None

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

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
- report :: Bool -> String -> Q ()
- recover :: Q a -> Q a -> Q a
- reify :: Name -> Q Info
- location :: Q Loc
- runIO :: IO a -> Q a
- lookupTypeName :: String -> Q (Maybe Name)
- lookupValueName :: String -> Q (Maybe Name)
- isInstance :: Name -> [Type] -> Q Bool
- reifyInstances :: Name -> [Type] -> Q [Dec]
- data Name
- data NameSpace
- 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)
  - | UInfixE Exp Exp Exp
  - | ParensE 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
  - | 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 Strict
  - = IsStrict
  - | NotStrict
  - | Unpacked
- 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 [InstanceDec]
  - | ClassOpI Name Type Name Fixity
  - | TyConI Dec
  - | FamilyI Dec [InstanceDec]
  - | PrimTyConI Name Int Bool
  - | DataConI Name Type Name Fixity
  - | VarI Name Type (Maybe Dec) Fixity
  - | TyVarI Name 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
- 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 -> Q Exp
- global :: Name -> ExpQ
- varE :: Name -> ExpQ
- conE :: Name -> ExpQ
- litE :: Lit -> ExpQ
- appE :: ExpQ -> ExpQ -> ExpQ
- uInfixE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
- parensE :: 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 :: Q Strict
- 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 :: FamFlavour
- dataFam :: FamFlavour
- cCall :: Callconv
- stdCall :: Callconv
- unsafe :: Safety
- 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

data Q a

Instances

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

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

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

recover

Arguments

:: Q a | recover with this one
-> Q a | failing action
-> Q a |

reify :: Name -> Q Info

`reify` looks up information about the `Name`

location :: Q Loc

`location` gives you the `Location` at 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.

lookupTypeName :: String -> Q (Maybe Name)

lookupValueName :: String -> Q (Maybe Name)

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

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

`classInstances` looks up instaces of a class

# Names

data Name

For global names (`NameG`) we need a totally unique name, so we must include the name-space of the thing

For unique-numbered things (`NameU`), we've got a unique reference anyway, so no need for name space

For dynamically bound thing (`NameS`) we probably want them to in a context-dependent way, so again we don't want the name space. For example:

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

Here we use the same Name for both type constructor and data constructor

NameL and NameG are bound *outside* the TH syntax tree either globally (NameG) or locally (NameL). Ex:

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

The `map` will be a NameG, and `x` wil be a NameL

These Names should never appear in a binding position in a TH syntax tree

Instances

Eq Name |
Data Name |
Ord Name |
Show Name |
Typeable Name |
Ppr Name |

data NameSpace

Instances

Eq NameSpace |
Data NameSpace |
Ord NameSpace |
Typeable NameSpace |

mkName :: String -> Name

The string can have a `.`, thus Foo.baz, giving a dynamically-bound qualified name, in which case we want to generate a NameQ

Parse the string to see if it has a . in it so we know whether to generate a qualified or unqualified name It's a bit tricky because we need to parse

     Foo.Baz.x   as    Qual Foo.Baz x

So we parse it from back to front

newName :: String -> Q Name

nameBase :: Name -> String

Base, unqualified name.

nameModule :: Name -> Maybe String

tupleTypeName

Arguments

:: Int |
-> Name | Type constructor

tupleDataName

Arguments

:: Int |
-> Name | 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 (`$( ... )`)

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 |

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 [Type] Type

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

Instances

Eq Dec |
Data Dec |
Show Dec |
Typeable Dec |
Ppr Dec |

data Exp

The `CompE` constructor represents a list comprehension, and takes a [`Stmt`]. The result expression of the comprehension is the *last* of these, and should be a `NoBindS`.

E.g. translation:

     [ f x | x <- xs ]

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

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 {(+)}

It's a bit gruesome to use an Exp as the operator, but how else can we distinguish constructors from non-constructors? Maybe there should be a var-or-con type? Or maybe we should leave it to the String itself?

UInfixE Exp Exp Exp

    {x + y}

See Note [Unresolved infix] at Language.Haskell.TH.Syntax

ParensE Exp

    { (e) }

See Note [Unresolved infix] at Language.Haskell.TH.Syntax

LamE [Pat] Exp

    {  p1 p2 -> e }

TupE [Exp]

    { (e1,e2) }

UnboxedTupE [Exp]

    { () }

CondE Exp Exp Exp

    { if e1 then e2 else e3 }

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

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

Instances

Eq Exp |
Data Exp |
Show Exp |
Typeable Exp |
Ppr Exp |

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 |
Show Con |
Typeable Con |
Ppr Con |

data Type

Constructors

ForallT [TyVarBndr] Cxt Type

    forall vars. ctxt -> type

VarT Name

    a

ConT Name

    T

TupleT Int

    (,), (,,), etc.

UnboxedTupleT Int

    (), (), etc.

ArrowT

    ->

ListT

    []

AppT Type Type

    T a b

SigT Type Kind

    t :: k

Instances

Eq Type |
Data Type |
Show Type |
Typeable Type |
Ppr Type |

data TyVarBndr

Constructors

PlainTV Name

    a

KindedTV Name Kind

    (a :: k)

Instances

Eq TyVarBndr |
Data TyVarBndr |
Show TyVarBndr |
Typeable TyVarBndr |
Ppr TyVarBndr |

data Kind

Constructors

StarK

    *

ArrowK Kind Kind

    k1 -> k2

Instances

Eq Kind |
Data Kind |
Show Kind |
Typeable Kind |
Ppr Kind |

type Cxt

Arguments

= [Pred]

    (Eq a, Ord b)

data Pred

Constructors

ClassP Name [Type]

    Eq (Int, a)

EqualP Type Type

    F a ~ Bool

Instances

Eq Pred |
Data Pred |
Show Pred |
Typeable Pred |
Ppr Pred |

data Match

Constructors

Match Pat Body [Dec]

    case e of { pat -> body where decs }

Instances

Eq Match |
Data Match |
Show Match |
Typeable Match |
Ppr Match |

data Clause

Constructors

Clause [Pat] Body [Dec]

    f { p1 p2 = body where decs }

Instances

Eq Clause |
Data Clause |
Show Clause |
Typeable Clause |
Ppr Clause |

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 |
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 | 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 String | A primitive C-style string, type Addr#

Instances

Eq Lit |
Data Lit |
Show Lit |
Typeable Lit |

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 Note [Unresolved infix] at Language.Haskell.TH.Syntax

ParensP Pat

    {(p)}

See Note [Unresolved infix] at 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 |
Show Pat |
Typeable Pat |
Ppr Pat |

type FieldExp = (Name, Exp)

type FieldPat = (Name, Pat)

data Strict

Constructors

IsStrict |
NotStrict |
Unpacked |

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

Instances

Eq Safety |
Data Safety |
Show Safety |
Typeable Safety |

data Pragma

Constructors

InlineP Name InlineSpec |
SpecialiseP Name Type (Maybe InlineSpec) |

Instances

Eq Pragma |
Data Pragma |
Show Pragma |
Typeable Pragma |
Ppr Pragma |

data InlineSpec

Constructors

InlineSpec Bool Bool (Maybe (Bool, Int)) |

Instances

Eq InlineSpec |
Data InlineSpec |
Show InlineSpec |
Typeable InlineSpec |

data FunDep

Constructors

FunDep [Name] [Name] |

Instances

Eq FunDep |
Data FunDep |
Show FunDep |
Typeable FunDep |
Ppr FunDep |

data FamFlavour

Constructors

TypeFam |
DataFam |

Instances

Eq FamFlavour |
Data FamFlavour |
Show FamFlavour |
Typeable FamFlavour |
Ppr FamFlavour |

data Info

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

Constructors

ClassI Dec [InstanceDec] | A class is reified to its declaration and a list of its instances
ClassOpI Name Type Name Fixity |
TyConI Dec |
FamilyI Dec [InstanceDec] |
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 Loc

Constructors

Loc |

Fields

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

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

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

## 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 :: String -> 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 -> Q Exp

Dynamically binding a variable (unhygenic)

global :: Name -> ExpQ

varE :: Name -> ExpQ

conE :: Name -> ExpQ

litE :: Lit -> ExpQ

appE :: ExpQ -> ExpQ -> ExpQ

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

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

Single-arg lambda

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)

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

listT :: TypeQ

tupleT :: Int -> TypeQ

sigT :: TypeQ -> Kind -> TypeQ

#### Strictness

isStrict :: Q Strict

notStrict :: Q Strict

strictType :: Q Strict -> TypeQ -> StrictTypeQ

varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ

#### Class Contexts

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

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

#### Type Family / Data Family

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

dataFam :: FamFlavour

#### Foreign Function Interface (FFI)

cCall :: Callconv

stdCall :: Callconv

unsafe :: Safety

safe :: Safety

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

#### Pragmas

Just inline supported so far

inlineSpecNoPhase :: Bool -> Bool -> InlineSpecQ

inlineSpecPhase :: Bool -> Bool -> Bool -> Int -> InlineSpecQ

pragInlD :: Name -> InlineSpecQ -> DecQ

pragSpecD :: Name -> TypeQ -> DecQ

# Pretty-printer

class Ppr a where

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 Pred |
Ppr TyVarBndr |
Ppr Kind |
Ppr Con |
Ppr Pragma |
Ppr Foreign |
Ppr FamFlavour |
Ppr Range |
Ppr Stmt |
Ppr Info |
Ppr a => Ppr [a] |

pprint :: Ppr a => a -> String

pprExp :: Precedence -> Exp -> Doc

pprLit :: Precedence -> Lit -> Doc

pprPat :: Precedence -> Pat -> Doc

pprParendType :: Type -> Doc