template-haskell-2.10.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 => 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
- 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_tc :: String -> String -> String -> Name
- mkNameG_d :: 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]
  - | StaticE Exp
- 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]
  - | StandaloneDerivD Cxt Type
  - | DefaultSigD Name Type
- 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
  - | 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
- type Cxt = [Pred]
- type Pred = 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
  - | EqualityT
  - | 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 => Quasi m where

Methods

qNewName

Arguments

:: String |
-> m Name | Fresh names

qReport

Arguments

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

qRecover

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)

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

Input/output (dangerous)

qAddDependentFile :: FilePath -> m ()

qAddTopDecls :: [Dec] -> m ()

qAddModFinalizer :: Q () -> m ()

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

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

Instances

Quasi IO |
Quasi Q |

badIO :: String -> IO a

counter :: IORef Int

newtype Q a

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

newtype TExp a

Constructors

TExp |

Fields

unType :: Exp

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

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

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

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

Deprecated: Use reportError or reportWarning instead

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

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.

recover

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)

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.

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

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

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

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

`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

`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

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

location :: Q Loc

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

addDependentFile :: FilePath -> Q ()

Record external files that runIO is using (dependent upon). The compiler can then recognize that it should re-compile the Haskell file when an external file changes.

Expects an absolute file path.

Notes:

- ghc -M does not know about these dependencies - it does not execute TH.
- The dependency is based on file content, not a modification time

addTopDecls :: [Dec] -> Q ()

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

addModFinalizer :: Q () -> Q ()

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)

Get state from the Q monad.

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

Replace the state in the Q monad.

returnQ :: a -> Q a

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

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

class Lift t where

Methods

lift :: t -> Q Exp

Instances

Lift Bool |
Lift Char |
Lift Double |
Lift Float |
Lift Int |
Lift Int8 |
Lift Int16 |
Lift Int32 |
Lift Int64 |
Lift Integer |
Lift Word |
Lift Word8 |
Lift Word16 |
Lift Word32 |
Lift Word64 |
Lift () |
Lift Natural |
Lift a => Lift [a] |
Integral a => Lift (Ratio 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

trueName :: Name

falseName :: Name

nothingName :: Name

justName :: Name

leftName :: Name

rightName :: Name

newtype ModName

Constructors

ModName String |

Instances

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

newtype PkgName

Constructors

PkgName String |

Instances

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

data Module

Obtained from `reifyModule` and `thisModule`.

Constructors

Module PkgName ModName |

Instances

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

newtype OccName

Constructors

OccName String |

Instances

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

mkModName :: String -> ModName

modString :: ModName -> String

mkPkgName :: String -> PkgName

pkgString :: PkgName -> String

mkOccName :: String -> OccName

occString :: OccName -> String

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

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.

Constructors

Name OccName NameFlavour |

Instances

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

data NameFlavour

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 |
Ord NameFlavour |
Generic NameFlavour |
type Rep NameFlavour |

data NameSpace

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 |
Generic NameSpace |
type Rep NameSpace |

type Uniq = Int

nameBase :: Name -> String

The name without its module prefix

nameModule :: Name -> Maybe String

Module prefix of a name, if it exists

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

mkNameU :: String -> Uniq -> Name

Only used internally

mkNameL :: String -> Uniq -> Name

Only used internally

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

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

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

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

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

data NameIs

Constructors

Alone |
Applied |
Infix |

showName :: Name -> String

showName' :: NameIs -> Name -> String

tupleDataName :: Int -> Name

Tuple data constructor

tupleTypeName :: Int -> Name

Tuple type constructor

mk_tup_name :: Int -> NameSpace -> Name

unboxedTupleDataName :: Int -> Name

Unboxed tuple data constructor

unboxedTupleTypeName :: Int -> Name

Unboxed tuple type constructor

mk_unboxed_tup_name :: Int -> NameSpace -> Name

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 |

type CharPos

Arguments

= (Int, Int) | Line and character position

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

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`

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 |

maxPrecedence :: Int

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

defaultFixity :: Fixity

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

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 |

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 FieldPat = (Name, Pat)

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

type FieldExp = (Name, Exp)

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

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 Strict

Constructors

IsStrict |
NotStrict |
Unpacked |

Instances

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

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 |

type StrictType = (Strict, Type)

type VarStrictType = (Name, Strict, Type)

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 |

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 |

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 |

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

cmpEq :: Ordering -> Bool

thenCmp :: Ordering -> Ordering -> Ordering