Language.Haskell.TH.Syntax

template-haskell-2.9.0.0: Support library for Template Haskell

Copyright | (c) The University of Glasgow 2003
License | BSD-style (see the file libraries/base/LICENSE)
Maintainer | libraries@haskell.org
Stability | experimental
Portability | portable
Safe Haskell | None
Language | Haskell2010

Language.Haskell.TH.Syntax

Description

Abstract syntax definitions for Template Haskell.

Synopsis

- class (Monad m, Applicative m) => Quasi m where
  - qNewName :: String -> m Name
  - qReport :: Bool -> String -> m ()
  - qRecover :: m a -> m a -> m a
  - qLookupName :: Bool -> String -> m (Maybe Name)
  - qReify :: Name -> m Info
  - qReifyInstances :: Name -> [Type] -> m [Dec]
  - qReifyRoles :: Name -> m [Role]
  - qReifyAnnotations :: Data a => AnnLookup -> m [a]
  - qReifyModule :: Module -> m ModuleInfo
  - qLocation :: m Loc
  - qRunIO :: IO a -> m a
  - qAddDependentFile :: FilePath -> m ()
  - qAddTopDecls :: [Dec] -> m ()
  - qAddModFinalizer :: Q () -> m ()
  - qGetQ :: Typeable a => m (Maybe a)
  - qPutQ :: Typeable a => a -> m ()
- badIO :: String -> IO a
- counter :: IORef Int
- newtype Q a = Q {
  - unQ :: forall m. Quasi m => m a
  }
- runQ :: Quasi m => Q a -> m a
- newtype TExp a = TExp {
  - unType :: Exp
  }
- unTypeQ :: Q (TExp a) -> Q Exp
- unsafeTExpCoerce :: Q Exp -> Q (TExp a)
- newName :: String -> Q Name
- report :: Bool -> String -> Q ()
- reportError :: String -> Q ()
- reportWarning :: String -> Q ()
- recover :: Q a -> Q a -> Q a
- lookupName :: Bool -> String -> Q (Maybe Name)
- lookupTypeName :: String -> Q (Maybe Name)
- lookupValueName :: String -> Q (Maybe Name)
- reify :: Name -> Q Info
- reifyInstances :: Name -> [Type] -> Q [InstanceDec]
- reifyRoles :: Name -> Q [Role]
- reifyAnnotations :: Data a => AnnLookup -> Q [a]
- reifyModule :: Module -> Q ModuleInfo
- isInstance :: Name -> [Type] -> Q Bool
- location :: Q Loc
- runIO :: IO a -> Q a
- addDependentFile :: FilePath -> Q ()
- addTopDecls :: [Dec] -> Q ()
- addModFinalizer :: Q () -> Q ()
- getQ :: Typeable a => Q (Maybe a)
- putQ :: Typeable a => a -> Q ()
- returnQ :: a -> Q a
- bindQ :: Q a -> (a -> Q b) -> Q b
- sequenceQ :: [Q a] -> Q [a]
- class Lift t where
  - lift :: t -> Q Exp
- liftString :: String -> Q Exp
- trueName :: Name
- falseName :: Name
- nothingName :: Name
- justName :: Name
- leftName :: Name
- rightName :: Name
- newtype ModName = ModName String
- newtype PkgName = PkgName String
- data Module = Module PkgName ModName
- newtype OccName = OccName String
- mkModName :: String -> ModName
- modString :: ModName -> String
- mkPkgName :: String -> PkgName
- pkgString :: PkgName -> String
- mkOccName :: String -> OccName
- occString :: OccName -> String
- data Name = Name OccName NameFlavour
- data NameFlavour
  - = NameS
  - | NameQ ModName
  - | NameU Int#
  - | NameL Int#
  - | NameG NameSpace PkgName ModName
- con_NameS :: Constr
- con_NameG :: Constr
- con_NameL :: Constr
- con_NameU :: Constr
- con_NameQ :: Constr
- ty_NameFlavour :: DataType
- data NameSpace
  - = VarName
  - | DataName
  - | TcClsName
- type Uniq = Int
- nameBase :: Name -> String
- nameModule :: Name -> Maybe String
- mkName :: String -> Name
- mkNameU :: String -> Uniq -> Name
- mkNameL :: String -> Uniq -> Name
- mkNameG :: NameSpace -> String -> String -> String -> Name
- mkNameG_v :: String -> String -> String -> Name
- mkNameG_d :: String -> String -> String -> Name
- mkNameG_tc :: String -> String -> String -> Name
- data NameIs
  - = Alone
  - | Applied
  - | Infix
- showName :: Name -> String
- showName' :: NameIs -> Name -> String
- tupleDataName :: Int -> Name
- tupleTypeName :: Int -> Name
- mk_tup_name :: Int -> NameSpace -> Name
- unboxedTupleDataName :: Int -> Name
- unboxedTupleTypeName :: Int -> Name
- mk_unboxed_tup_name :: Int -> NameSpace -> Name
- data Loc = Loc {
  - loc_filename :: String
  - loc_package :: String
  - loc_module :: String
  - loc_start :: CharPos
  - loc_end :: CharPos
  }
- type CharPos = (Int, Int)
- 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 ParentName = Name
- type Arity = Int
- type Unlifted = Bool
- type InstanceDec = Dec
- data Fixity = Fixity Int FixityDirection
- data FixityDirection
  - = InfixL
  - | InfixR
  - | InfixN
- maxPrecedence :: Int
- defaultFixity :: Fixity
- 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 FieldPat = (Name, Pat)
- data Match = Match Pat Body [Dec]
- data Clause = Clause [Pat] Body [Dec]
- 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]
- type FieldExp = (Name, Exp)
- 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 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]
- data TySynEqn = TySynEqn [Type] Type
- data FunDep = FunDep [Name] [Name]
- data FamFlavour
  - = TypeFam
  - | DataFam
- 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 Inline RuleMatch Phases
  - | SpecialiseP Name Type (Maybe Inline) Phases
  - | SpecialiseInstP Type
  - | RuleP String [RuleBndr] Exp Exp Phases
  - | AnnP AnnTarget Exp
- 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
- type Cxt = [Pred]
- data Pred
  - = ClassP Name [Type]
  - | EqualP Type Type
- data Strict
  - = IsStrict
  - | NotStrict
  - | Unpacked
- data Con
  - = NormalC Name [StrictType]
  - | RecC Name [VarStrictType]
  - | InfixC StrictType Name StrictType
  - | ForallC [TyVarBndr] Cxt Con
- type StrictType = (Strict, Type)
- type VarStrictType = (Name, Strict, Type)
- data Type
  - = ForallT [TyVarBndr] Cxt Type
  - | AppT Type Type
  - | SigT Type Kind
  - | VarT Name
  - | ConT Name
  - | PromotedT Name
  - | TupleT Int
  - | UnboxedTupleT Int
  - | ArrowT
  - | ListT
  - | PromotedTupleT Int
  - | PromotedNilT
  - | PromotedConsT
  - | StarT
  - | ConstraintT
  - | LitT TyLit
- data TyVarBndr
  - = PlainTV Name
  - | KindedTV Name Kind
- data TyLit
  - = NumTyLit Integer
  - | StrTyLit String
- data Role
  - = NominalR
  - | RepresentationalR
  - | PhantomR
  - | InferR
- data AnnLookup
  - = AnnLookupModule Module
  - | AnnLookupName Name
- type Kind = Type
- cmpEq :: Ordering -> Bool
- thenCmp :: Ordering -> Ordering -> Ordering

# Documentation

class (Monad m, Applicative m) => Quasi m where Source

Methods

qNewName Source

Arguments

:: String |
-> m Name | Fresh names

qReport Source

Arguments

:: Bool |
-> String |
-> m () | Report an error (True) or warning (False) ...but carry on; use `fail` to stop

qRecover Source

Arguments

:: m a | the error handler
-> m a | action which may fail
-> m a | Recover from the monadic `fail`

qLookupName :: Bool -> String -> m (Maybe Name) Source

qReify :: Name -> m Info Source

qReifyInstances :: Name -> [Type] -> m [Dec] Source

qReifyRoles :: Name -> m [Role] Source

qReifyAnnotations :: Data a => AnnLookup -> m [a] Source

qReifyModule :: Module -> m ModuleInfo Source

qLocation :: m Loc Source

qRunIO :: IO a -> m a Source

Input/output (dangerous)

qAddDependentFile :: FilePath -> m () Source

qAddTopDecls :: [Dec] -> m () Source

qAddModFinalizer :: Q () -> m () Source

qGetQ :: Typeable a => m (Maybe a) Source

qPutQ :: Typeable a => a -> m () Source

Instances

Quasi IO |
Quasi Q |

badIO :: String -> IO a Source

counter :: IORef Int Source

newtype Q a Source

Constructors

Q |
Fields unQ :: forall m. Quasi m => m a

Instances

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

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

newtype TExp a Source

Constructors

TExp |
Fields unType :: Exp

unTypeQ :: Q (TExp a) -> Q Exp Source

unsafeTExpCoerce :: Q Exp -> Q (TExp a) Source

newName :: String -> Q Name Source

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

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

Deprecated: Use reportError or reportWarning instead

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

reportError :: String -> Q () Source

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 () Source

Report a warning to the user, and carry on.

recover Source

Arguments

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

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

lookupName :: Bool -> String -> Q (Maybe Name) Source

lookupTypeName :: String -> Q (Maybe Name) Source

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

lookupValueName :: String -> Q (Maybe Name) Source

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

The functions `lookupTypeName` and `lookupValueName` provide a way to query the current splice's context for what names are in scope. The function `lookupTypeName` queries the type namespace, whereas `lookupValueName` queries the value namespace, but the functions are otherwise identical.

A call `lookupValueName s` will check if there is a value with name `s` in scope at the current splice's location. If there is, the `Name` of this value is returned; if not, then `Nothing` is returned.

The returned name cannot be "captured". For example:

    f = "global"
    g = $( do
             Just nm <- lookupValueName "f"
             [| let f = "local" in $( varE nm ) |]

In this case, `g = "global"`; the call to `lookupValueName` returned the global `f`, and this name was not captured by the local definition of `f`.

The lookup is performed in the context of the top-level splice being run. For example:

    f = "global"
    g = $( [| let f = "local" in
               $(do
                   Just nm <- lookupValueName "f"
                   varE nm
                ) |] )

Again in this example, `g = "global"`, because the call to `lookupValueName` queries the context of the outer-most `$(...)`.

Operators should be queried without any surrounding parentheses, like so:

    lookupValueName "+"

Qualified names are also supported, like so:

    lookupValueName "Prelude.+"
    lookupValueName "Prelude.map"

reify :: Name -> Q Info Source

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

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

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

reifyRoles :: Name -> Q [Role] Source

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

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

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

reifyModule :: Module -> Q ModuleInfo Source

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

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

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

location :: Q Loc Source

The location at which this computation is spliced.

runIO :: IO a -> Q a Source

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.

addDependentFile :: FilePath -> Q () Source

Record external files that runIO is using (dependent upon). The compiler can then recognize that it should re-compile the file using this TH when the external file changes. Note that ghc -M will still not know about these dependencies - it does not execute TH. Expects an absolute file path.

addTopDecls :: [Dec] -> Q () Source

Add additional top-level declarations. The added declarations will be type checked along with the current declaration group.

addModFinalizer :: Q () -> Q () Source

Add a finalizer that will run in the Q monad after the current module has been type checked. This only makes sense when run within a top-level splice.

getQ :: Typeable a => Q (Maybe a) Source

Get state from the Q monad.

putQ :: Typeable a => a -> Q () Source

Replace the state in the Q monad.

returnQ :: a -> Q a Source

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

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

class Lift t where Source

Methods

lift :: t -> Q Exp Source

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

liftString :: String -> Q Exp Source

trueName :: Name Source

falseName :: Name Source

nothingName :: Name Source

justName :: Name Source

leftName :: Name Source

rightName :: Name Source

newtype ModName Source

Constructors

ModName String |

Instances

Eq ModName |
Data ModName |
Ord ModName |
Show ModName |
Typeable * ModName |

newtype PkgName Source

Constructors

PkgName String |

Instances

Eq PkgName |
Data PkgName |
Ord PkgName |
Show PkgName |
Typeable * PkgName |

data Module Source

Obtained from `reifyModule` and `thisModule`.

Constructors

Module PkgName ModName |

Instances

Eq Module |
Data Module |
Ord Module |
Show Module |
Ppr Module |
Typeable * Module |

newtype OccName Source

Constructors

OccName String |

Instances

Eq OccName |
Data OccName |
Ord OccName |
Show OccName |
Typeable * OccName |

mkModName :: String -> ModName Source

modString :: ModName -> String Source

mkPkgName :: String -> PkgName Source

pkgString :: PkgName -> String Source

mkOccName :: String -> OccName Source

occString :: OccName -> String Source

Much of `Name` API is concerned with the problem of name capture, which can be seen in the following example.

    f expr = [| let x = 0 in $expr |]
    ...
    g x = $( f [| x |] )
    h y = $( f [| y |] )

A naive desugaring of this would yield:

    g x = let x = 0 in x
    h y = let x = 0 in y

All of a sudden, `g` and `h` have different meanings! In this case, we say that the `x` in the RHS of `g` has been captured by the binding of `x` in `f`.

What we actually want is for the `x` in `f` to be distinct from the `x` in `g`, so we get the following desugaring:

    g x = let x' = 0 in x
    h y = let x' = 0 in y

which avoids name capture as desired.

In the general case, we say that a `Name` can be captured if the thing it refers to can be changed by adding new declarations.

data Name Source

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#namecapture" 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.

Constructors

Name OccName NameFlavour |

Instances

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

data NameFlavour Source

Constructors

NameS | An unqualified name; dynamically bound
NameQ ModName | A qualified name; dynamically bound
NameU Int# | A unique local name
NameL Int# | Local name bound outside of the TH AST
NameG NameSpace PkgName ModName | Global name bound outside of the TH AST: An original name (occurrences only, not binders) Need the namespace too to be sure which thing we are naming

Instances

Eq NameFlavour |
Data NameFlavour | Although the NameFlavour type is abstract, the Data instance is not. The reason for this is that currently we use Data to serialize values in annotations, and in order for that to work for Template Haskell names introduced via the 'x syntax we need gunfold on NameFlavour to work. Bleh! The long term solution to this is to use the binary package for annotation serialization and then remove this instance. However, to do _that_ we need to wait on binary to become stable, since boot libraries cannot be upgraded separately from GHC itself. This instance cannot be derived automatically due to bug #2701
Ord NameFlavour |
Typeable * NameFlavour |

con_NameS :: Constr Source

con_NameG :: Constr Source

con_NameL :: Constr Source

con_NameU :: Constr Source

con_NameQ :: Constr Source

ty_NameFlavour :: DataType Source

data NameSpace Source

Constructors

VarName | Variables
DataName | Data constructors
TcClsName | Type constructors and classes; Haskell has them in the same name space for now.

Instances

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

type Uniq = Int Source

nameBase :: Name -> String Source

The name without its module prefix

nameModule :: Name -> Maybe String Source

Module prefix of a name, if it exists

mkName :: String -> Name Source

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") |]

mkNameU :: String -> Uniq -> Name Source

Only used internally

mkNameL :: String -> Uniq -> Name Source

Only used internally

mkNameG :: NameSpace -> String -> String -> String -> Name Source

Used for 'x etc, but not available to the programmer

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

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

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

data NameIs Source

Constructors

Alone |
Applied |
Infix |

showName :: Name -> String Source

showName' :: NameIs -> Name -> String Source

tupleDataName :: Int -> Name Source

Tuple data constructor

tupleTypeName :: Int -> Name Source

Tuple type constructor

mk_tup_name :: Int -> NameSpace -> Name Source

unboxedTupleDataName :: Int -> Name Source

Unboxed tuple data constructor

unboxedTupleTypeName :: Int -> Name Source

Unboxed tuple type constructor

mk_unboxed_tup_name :: Int -> NameSpace -> Name Source

data Loc Source

Constructors

Loc |
Fields loc_filename :: String loc_package :: String loc_module :: String loc_start :: CharPos loc_end :: CharPos

type CharPos Source

Arguments

= (Int, Int) | Line and character position

data Info Source

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

Data Info |
Show Info |
Ppr Info |
Typeable * Info |

data ModuleInfo Source

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

Constructors

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

Instances

Data ModuleInfo |
Show ModuleInfo |
Ppr ModuleInfo |
Typeable * ModuleInfo |

type ParentName = Name Source

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

type Arity = Int Source

In `PrimTyConI`, arity of the type constructor

type Unlifted = Bool Source

In `PrimTyConI`, is the type constructor unlifted?

type InstanceDec = Dec Source

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

data Fixity Source

Constructors

Fixity Int FixityDirection |

Instances

Eq Fixity |
Data Fixity |
Show Fixity |
Typeable * Fixity |

data FixityDirection Source

Constructors

InfixL |
InfixR |
InfixN |

Instances

Eq FixityDirection |
Data FixityDirection |
Show FixityDirection |
Typeable * FixityDirection |

maxPrecedence :: Int Source

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

defaultFixity :: Fixity Source

Default fixity: `infixl 9`

When implementing antiquotation for quasiquoters, one often wants to parse strings into expressions:

    parse :: String -> Maybe Exp

But how should we parse `a + b * c`? If we don't know the fixities of `+` and `*`, we don't know whether to parse it as `a + (b * c)` or `(a + b) * c`.

In cases like this, use `UInfixE` or `UInfixP`, which stand for "unresolved infix expression" and "unresolved infix pattern". When the compiler is given a splice containing a tree of `UInfixE` applications such as

    UInfixE
      (UInfixE e1 op1 e2)
      op2
      (UInfixE e3 op3 e4)

it will look up and the fixities of the relevant operators and reassociate the tree as necessary.

- trees will not be reassociated across `ParensE` or `ParensP`, which are of use for parsing expressions like

      (a + b * c) + d * e

- `InfixE` and `InfixP` expressions are never reassociated.
- The `UInfixE` constructor doesn't support sections. Sections such as `(a *)` have no ambiguity, so `InfixE` suffices. For longer sections such as `(a + b * c -)`, use an `InfixE` constructor for the outer-most section, and use `UInfixE` constructors for all other operators:

      InfixE
        Just (UInfixE ...a + b * c...)
        op
        Nothing

  Sections such as `(a + b +)` and `((a + b) +)` should be rendered into `Exp`s differently:

      (+ a + b)   ---> InfixE Nothing + (Just $ UInfixE a + b)
                         -- will result in a fixity error if (+) is left-infix
      (+ (a + b)) ---> InfixE Nothing + (Just $ ParensE $ UInfixE a + b)
                         -- no fixity errors

- Quoted expressions such as

      [| a * b + c |] :: Q Exp
      [p| a : b : c |] :: Q Pat

  will never contain `UInfixE`, `UInfixP`, `ParensE`, or `ParensP` constructors.

data Lit Source

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 |
Show Lit |
Typeable * Lit |

data Pat Source

Pattern in Haskell given in `{}`

Constructors

LitP Lit |
    { 5 or c }
VarP Name |
    { x }
TupP [Pat] |
    { (p1,p2) }
UnboxedTupP [Pat] |
    { (# p1,p2 #) }
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#infix"
ParensP Pat |
    {(p)}
See "Language.Haskell.TH.Syntax#infix"
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 |
Ppr Pat |
Typeable * Pat |

type FieldPat = (Name, Pat) Source

data Match Source

Constructors

Match Pat Body [Dec] |
    case e of { pat -> body where decs }

Instances

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

data Clause Source

Constructors

Clause [Pat] Body [Dec] |
    f { p1 p2 = body where decs }

Instances

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

data Exp Source

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#infix"
ParensE Exp |
    { (e) }
See "Language.Haskell.TH.Syntax#infix"
LamE [Pat] Exp |
    {  p1 p2 -> e }
LamCaseE [Match] |
    { case m1; m2 }
TupE [Exp] |
    { (e1,e2) }
UnboxedTupE [Exp] |
    { (# e1,e2 #) }
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 } }

Instances

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

type FieldExp = (Name, Exp) Source

data Body Source

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 Source

Constructors

NormalG Exp |
    f x { | odd x } = x
PatG [Stmt] |
    f x { | Just y <- x, Just z <- y } = z

Instances

Eq Guard |
Data Guard |
Show Guard |
Typeable * Guard |

data Stmt Source

Constructors

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

Instances

Eq Stmt |
Data Stmt |
Show Stmt |
Ppr Stmt |
Typeable * Stmt |

data Range Source

Constructors

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

Instances

Eq Range |
Data Range |
Show Range |
Ppr Range |
Typeable * Range |

data Dec Source

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 |
    { {-# INLINE [1] foo #-} }
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 }

Instances

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

data TySynEqn Source

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 |
Show TySynEqn |
Typeable * TySynEqn |

data FunDep Source

Constructors

FunDep [Name] [Name] |

Instances

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

data FamFlavour Source

Constructors

TypeFam |
DataFam |

Instances

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

data Foreign Source

Constructors

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

Instances

Eq Foreign |
Data Foreign |
Show Foreign |
Ppr Foreign |
Typeable * Foreign |

data Callconv Source

Constructors

CCall |
StdCall |

Instances

Eq Callconv |
Data Callconv |
Show Callconv |
Typeable * Callconv |

data Safety Source

Constructors

Unsafe |
Safe |
Interruptible |

Instances

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

data Pragma Source

Constructors

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

Instances

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

data Inline Source

Constructors

NoInline |
Inline |
Inlinable |

Instances

Eq Inline |
Data Inline |
Show Inline |
Ppr Inline |
Typeable * Inline |

data RuleMatch Source

Constructors

ConLike |
FunLike |

Instances

Eq RuleMatch |
Data RuleMatch |
Show RuleMatch |
Ppr RuleMatch |
Typeable * RuleMatch |

data Phases Source

Constructors

AllPhases |
FromPhase Int |
BeforePhase Int |

Instances

Eq Phases |
Data Phases |
Show Phases |
Ppr Phases |
Typeable * Phases |

data RuleBndr Source

Constructors

RuleVar Name |
TypedRuleVar Name Type |

Instances

Eq RuleBndr |
Data RuleBndr |
Show RuleBndr |
Ppr RuleBndr |
Typeable * RuleBndr |

data AnnTarget Source

Constructors

ModuleAnnotation |
TypeAnnotation Name |
ValueAnnotation Name |

Instances

Eq AnnTarget |
Data AnnTarget |
Show AnnTarget |
Typeable * AnnTarget |

type Cxt Source

Arguments

= [Pred] |
    (Eq a, Ord b)

data Pred Source

Constructors

ClassP Name [Type] |
    Eq (Int, a)
EqualP Type Type |
    F a ~ Bool

Instances

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

data Strict Source

Constructors

IsStrict |
NotStrict |
Unpacked |

Instances

Eq Strict |
Data Strict |
Show Strict |
Typeable * Strict |

data Con Source

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

type StrictType = (Strict, Type) Source

type VarStrictType = (Name, Strict, Type) Source

data Type Source

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 |
    ->
ListT |
    []
PromotedTupleT Int |
    '(), '(,), '(,,), etc.
PromotedNilT |
    '[]
PromotedConsT |
    (':)
StarT |
    *
ConstraintT |
    Constraint
LitT TyLit |
    0,1,2, etc.

Instances

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

data TyVarBndr Source

Constructors

PlainTV Name |
    a
KindedTV Name Kind |
    (a :: k)

Instances

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

data TyLit Source

Constructors

NumTyLit Integer |
    2
StrTyLit String |
    Hello

Instances

Eq TyLit |
Data TyLit |
Show TyLit |
Ppr TyLit |
Typeable * TyLit |

data Role Source

Role annotations

Constructors

NominalR |
    nominal
RepresentationalR |
    representational
PhantomR |
    phantom
InferR |
    _

Instances

Eq Role |
Data Role |
Show Role |
Ppr Role |
Typeable * Role |

data AnnLookup Source

Annotation target for reifyAnnotations

Constructors

AnnLookupModule Module |
AnnLookupName Name |

Instances

Eq AnnLookup |
Data AnnLookup |
Show AnnLookup |
Typeable * AnnLookup |

type Kind = Type Source

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

cmpEq :: Ordering -> Bool Source

thenCmp :: Ordering -> Ordering -> Ordering Source