| 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
Contents
Description
Abstract syntax definitions for Template Haskell.
- class MonadFail m => Quasi m where
- badIO :: String -> IO a
- counter :: IORef Int
- newtype Q a = Q {}
- runQ :: Quasi m => Q a -> m a
- newtype TExp a = TExp {}
- 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
- reifyFixity :: Name -> Q (Maybe Fixity)
- reifyInstances :: Name -> [Type] -> Q [InstanceDec]
- reifyRoles :: Name -> Q [Role]
- reifyAnnotations :: Data a => AnnLookup -> Q [a]
- reifyModule :: Module -> Q ModuleInfo
- reifyConStrictness :: Name -> Q [DecidedStrictness]
- 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 ()
- isExtEnabled :: Extension -> Q Bool
- extsEnabled :: Q [Extension]
- returnQ :: a -> Q a
- bindQ :: Q a -> (a -> Q b) -> Q b
- sequenceQ :: [Q a] -> Q [a]
- class Lift t where
- liftString :: String -> Q Exp
- trueName :: Name
- falseName :: Name
- nothingName :: Name
- justName :: Name
- leftName :: Name
- rightName :: Name
- dataToQa :: forall a k q. Data a => (Name -> k) -> (Lit -> Q q) -> (k -> [Q q] -> Q q) -> (forall b. Data b => b -> Maybe (Q q)) -> a -> Q q
- dataToExpQ :: Data a => (forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp
- liftData :: Data a => a -> Q Exp
- dataToPatQ :: Data a => (forall b. Data b => b -> Maybe (Q Pat)) -> a -> Q Pat
- 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
- data NameSpace
- type Uniq = Int
- nameBase :: Name -> String
- nameModule :: Name -> Maybe String
- namePackage :: Name -> Maybe String
- nameSpace :: Name -> Maybe NameSpace
- mkName :: String -> Name
- mkNameU :: String -> Uniq -> Name
- mkNameL :: String -> Uniq -> Name
- mkNameG :: NameSpace -> String -> String -> String -> Name
- mkNameS :: String -> Name
- mkNameG_v :: String -> String -> String -> Name
- mkNameG_tc :: String -> String -> String -> Name
- mkNameG_d :: String -> String -> String -> Name
- data NameIs
- 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 {}
- type CharPos = (Int, Int)
- data Info
- data ModuleInfo = ModuleInfo [Module]
- type ParentName = Name
- type Arity = Int
- type Unlifted = Bool
- type InstanceDec = Dec
- data Fixity = Fixity Int FixityDirection
- data FixityDirection
- maxPrecedence :: Int
- defaultFixity :: Fixity
- data Lit
- data 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
- | UnboundVarE Name
- type FieldExp = (Name, Exp)
- data Body
- data Guard
- data Stmt
- data Range
- data Dec
- = FunD Name [Clause]
- | ValD Pat Body [Dec]
- | DataD Cxt Name [TyVarBndr] (Maybe Kind) [Con] Cxt
- | NewtypeD Cxt Name [TyVarBndr] (Maybe Kind) Con Cxt
- | TySynD Name [TyVarBndr] Type
- | ClassD Cxt Name [TyVarBndr] [FunDep] [Dec]
- | InstanceD (Maybe Overlap) Cxt Type [Dec]
- | SigD Name Type
- | ForeignD Foreign
- | InfixD Fixity Name
- | PragmaD Pragma
- | DataFamilyD Name [TyVarBndr] (Maybe Kind)
- | DataInstD Cxt Name [Type] (Maybe Kind) [Con] Cxt
- | NewtypeInstD Cxt Name [Type] (Maybe Kind) Con Cxt
- | TySynInstD Name TySynEqn
- | OpenTypeFamilyD TypeFamilyHead
- | ClosedTypeFamilyD TypeFamilyHead [TySynEqn]
- | RoleAnnotD Name [Role]
- | StandaloneDerivD Cxt Type
- | DefaultSigD Name Type
- data Overlap
- data TypeFamilyHead = TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn)
- data TySynEqn = TySynEqn [Type] Type
- data FunDep = FunDep [Name] [Name]
- data FamFlavour
- data Foreign
- data Callconv
- = CCall
- | StdCall
- | CApi
- | Prim
- | JavaScript
- data Safety
- = Unsafe
- | Safe
- | Interruptible
- data Pragma
- data Inline
- data RuleMatch
- data Phases
- data RuleBndr
- data AnnTarget
- type Cxt = [Pred]
- type Pred = Type
- data SourceUnpackedness
- data SourceStrictness
- data DecidedStrictness
- data Con
- data Bang = Bang SourceUnpackedness SourceStrictness
- type BangType = (Bang, Type)
- type VarBangType = (Name, Bang, Type)
- type Strict = Bang
- type StrictType = BangType
- type VarStrictType = VarBangType
- data Type
- = ForallT [TyVarBndr] Cxt Type
- | AppT Type Type
- | SigT Type Kind
- | VarT Name
- | ConT Name
- | PromotedT Name
- | InfixT Type Name Type
- | UInfixT Type Name Type
- | ParensT Type
- | TupleT Int
- | UnboxedTupleT Int
- | ArrowT
- | EqualityT
- | ListT
- | PromotedTupleT Int
- | PromotedNilT
- | PromotedConsT
- | StarT
- | ConstraintT
- | LitT TyLit
- | WildCardT
- data TyVarBndr
- data FamilyResultSig
- data InjectivityAnn = InjectivityAnn Name [Name]
- data TyLit
- data Role
- data AnnLookup
- type Kind = Type
- cmpEq :: Ordering -> Bool
- thenCmp :: Ordering -> Ordering -> Ordering
- module Language.Haskell.TH.LanguageExtensions
Documentation
class MonadFail m => Quasi m where Source #
Minimal complete definition
qNewName, qReport, qRecover, qLookupName, qReify, qReifyFixity, qReifyInstances, qReifyRoles, qReifyAnnotations, qReifyModule, qReifyConStrictness, qLocation, qRunIO, qAddDependentFile, qAddTopDecls, qAddModFinalizer, qGetQ, qPutQ, qIsExtEnabled, qExtsEnabled
Methods
qNewName :: String -> m Name Source #
qReport :: Bool -> String -> m () Source #
qRecover :: m a -> m a -> m a Source #
qLookupName :: Bool -> String -> m (Maybe Name) Source #
qReify :: Name -> m Info Source #
qReifyFixity :: Name -> m (Maybe Fixity) Source #
qReifyInstances :: Name -> [Type] -> m [Dec] Source #
qReifyRoles :: Name -> m [Role] Source #
qReifyAnnotations :: Data a => AnnLookup -> m [a] Source #
qReifyModule :: Module -> m ModuleInfo Source #
qReifyConStrictness :: Name -> m [DecidedStrictness] 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 #
qIsExtEnabled :: Extension -> m Bool Source #
qExtsEnabled :: m [Extension] 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[VarPnm1] (LamE [VarP nm2] (VarEnm1))) )
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 from errors raised by reportError or fail.
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 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 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.
reifyFixity :: Name -> Q (Maybe Fixity) Source #
reifyFixity nm attempts to find a fixity declaration for nm. For
example, if the function foo has the fixity declaration infixr 7 foo, then
reifyFixity 'foo would return Just (Fixity 7 InfixR)bar does not have a fixity declaration, then reifyFixity 'bar returns
Nothing, so you may assume bar has defaultFixity.
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.
reifyConStrictness :: Name -> Q [DecidedStrictness] Source #
reifyConStrictness nm looks up the strictness information for the fields
of the constructor with the name nm. Note that the strictness information
that reifyConStrictness returns may not correspond to what is written in
the source code. For example, in the following data declaration:
data Pair a = Pair a a
reifyConStrictness would return [ under most
circumstances, but it would return DecidedLazy, DecidedLazy][ if the
DecidedStrict, DecidedStrict]-XStrictData language extension was enabled.
isInstance :: Name -> [Type] -> Q Bool Source #
Is the list of instances returned by reifyInstances nonempty?
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 () Source #
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 () 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.
The finalizer is given the local type environment at the splice point. Thus
reify is able to find the local definitions when executed inside the
finalizer.
getQ :: Typeable a => Q (Maybe a) Source #
Get state from the Q monad. Note that the state is local to the
Haskell module in which the Template Haskell expression is executed.
putQ :: Typeable a => a -> Q () Source #
Replace the state in the Q monad. Note that the state is local to the
Haskell module in which the Template Haskell expression is executed.
isExtEnabled :: Extension -> Q Bool Source #
Determine whether the given language extension is enabled in the Q monad.
extsEnabled :: Q [Extension] Source #
List all enabled language extensions.
A Lift instance can have any of its values turned into a Template
Haskell expression. This is needed when a value used within a Template
Haskell quotation is bound outside the Oxford brackets ([| ... |]) but not
at the top level. As an example:
add1 :: Int -> Q Exp add1 x = [| x + 1 |]
Template Haskell has no way of knowing what value x will take on at
splice-time, so it requires the type of x to be an instance of Lift.
Lift instances can be derived automatically by use of the -XDeriveLift
GHC language extension:
{-# LANGUAGE DeriveLift #-}
module Foo where
import Language.Haskell.TH.Syntax
data Bar a = Bar1 a (Bar a) | Bar2 String
deriving LiftMethods
Turn a value into a Template Haskell expression, suitable for use in a splice.
lift :: Data t => t -> Q Exp Source #
Turn a value into a Template Haskell expression, suitable for use in a splice.
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] # | |
| Lift a => Lift (Maybe a) # | |
| Integral a => Lift (Ratio 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) # | |
nothingName :: Name Source #
dataToQa :: forall a k q. Data a => (Name -> k) -> (Lit -> Q q) -> (k -> [Q q] -> Q q) -> (forall b. Data b => b -> Maybe (Q q)) -> a -> Q q Source #
dataToQa is an internal utility function for constructing generic
conversion functions from types with Data instances to various
quasi-quoting representations. See the source of dataToExpQ and
dataToPatQ for two example usages: mkCon, mkLit
and appQ are overloadable to account for different syntax for
expressions and patterns; antiQ allows you to override type-specific
cases, a common usage is just const Nothing, which results in
no overloading.
dataToExpQ :: Data a => (forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp Source #
dataToExpQ converts a value to a 'Q Exp' representation of the
same value, in the SYB style. It is generalized to take a function
override type-specific cases; see liftData for a more commonly
used variant.
dataToPatQ :: Data a => (forall b. Data b => b -> Maybe (Q Pat)) -> a -> Q Pat Source #
dataToPatQ converts a value to a 'Q Pat' representation of the same
value, in the SYB style. It takes a function to handle type-specific cases,
alternatively, pass const Nothing to get default behavior.
Obtained from reifyModule and thisModule.
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.
An abstract type representing names in the syntax tree.
Names 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
'fand''Tcan be used to construct names, The expression'fgives aNamewhich refers to the valuefcurrently in scope, and''Tgives aNamewhich refers to the typeTcurrently in scope. These names can never be captured. lookupValueNameandlookupTypeNameare similar to'fand''Trespectively, but theNames are looked up at the point where the current splice is being run. These names can never be captured.newNamemonadically generates a new name, which can never be captured.mkNamegenerates 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 |
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
nameBase :: Name -> String Source #
The name without its module prefix.
Examples
>>>nameBase ''Data.Either.Either"Either">>>nameBase (mkName "foo")"foo">>>nameBase (mkName "Module.foo")"foo"
nameModule :: Name -> Maybe String Source #
Module prefix of a name, if it exists.
Examples
>>>nameModule ''Data.Either.EitherJust "Data.Either">>>nameModule (mkName "foo")Nothing>>>nameModule (mkName "Module.foo")Just "Module"
namePackage :: Name -> Maybe String Source #
A name's package, if it exists.
Examples
>>>namePackage ''Data.Either.EitherJust "base">>>namePackage (mkName "foo")Nothing>>>namePackage (mkName "Module.foo")Nothing
nameSpace :: Name -> Maybe NameSpace Source #
Returns whether a name represents an occurrence of a top-level variable
(VarName), data constructor (DataName), type constructor, or type class
(TcClsName). If we can't be sure, it returns Nothing.
Examples
>>>nameSpace 'Prelude.idJust VarName>>>nameSpace (mkName "id")Nothing -- only works for top-level variable names>>>nameSpace 'Data.Maybe.JustJust DataName>>>nameSpace ''Data.Maybe.MaybeJust TcClsName>>>nameSpace ''Data.Ord.OrdJust TcClsName
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") |]
mkNameG :: NameSpace -> String -> String -> String -> Name Source #
Used for 'x etc, but not available to the programmer
tupleDataName :: Int -> Name Source #
Tuple data constructor
tupleTypeName :: Int -> Name Source #
Tuple type constructor
unboxedTupleDataName :: Int -> Name Source #
Unboxed tuple data constructor
unboxedTupleTypeName :: Int -> Name Source #
Unboxed tuple type constructor
Constructors
| Loc | |
Fields
| |
Constructors
| ClassI Dec [InstanceDec] | A class, with a list of its visible instances |
| ClassOpI Name Type ParentName | A class method |
| TyConI Dec | A "plain" type constructor. "Fancier" type constructors are returned using |
| 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 |
| DataConI Name Type ParentName | A data constructor |
| VarI Name Type (Maybe Dec) | A "value" variable (as opposed to a type variable, see The |
| TyVarI Name Type | A type variable. The |
data ModuleInfo Source #
Obtained from reifyModule in the Q Monad.
Constructors
| ModuleInfo [Module] | Contains the import list of the module. |
Instances
In PrimTyConI, arity of the type constructor
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]DataInstDorNewtypeInstD(with empty derived[)Name]TySynInstD
Constructors
| Fixity Int FixityDirection |
data FixityDirection Source #
Instances
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, UInfixP, or UInfixT, which stand for
"unresolved infix expressionpatterntype", respectively. 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,ParensP, orParensT, which are of use for parsing expressions like
(a + b * c) + d * e
InfixE,InfixP, andInfixTexpressions are never reassociated.- The
UInfixEconstructor doesn't support sections. Sections such as(a *)have no ambiguity, soInfixEsuffices. For longer sections such as(a + b * c -), use anInfixEconstructor for the outer-most section, and useUInfixEconstructors for all other operators:
InfixE Just (UInfixE ...a + b * c...) op Nothing
Sections such as (a + b +) and ((a + b) +) should be rendered
into Exps 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 [t| T + T |] :: Q Type
will never contain UInfixE, UInfixP, UInfixT, InfixT, ParensE,
ParensP, or ParensT constructors.
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# |
| CharPrimL Char |
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 |
| ParensP Pat | {(p)} |
| 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 } |
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} |
| ParensE Exp | { (e) } |
| 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 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 } |
| UnboundVarE Name |
|
Constructors
| FunD Name [Clause] | { f p1 p2 = b where decs } |
| ValD Pat Body [Dec] | { p = b where decs } |
| DataD Cxt Name [TyVarBndr] (Maybe Kind) [Con] Cxt | { data Cxt x => T x = A x | B (T x)
deriving (Z,W)} |
| NewtypeD Cxt Name [TyVarBndr] (Maybe Kind) Con Cxt | { newtype Cxt x => T x = A (B x)
deriving (Z,W Q)} |
| TySynD Name [TyVarBndr] Type | { type T x = (x,x) } |
| ClassD Cxt Name [TyVarBndr] [FunDep] [Dec] | { class Eq a => Ord a where ds } |
| InstanceD (Maybe Overlap) Cxt Type [Dec] | { instance {-# OVERLAPS #-}
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 #-} } |
| DataFamilyD Name [TyVarBndr] (Maybe Kind) | { data family T a b c :: * } |
| DataInstD Cxt Name [Type] (Maybe Kind) [Con] Cxt | { data instance Cxt x => T [x]
= A x | B (T x) deriving (Z,W)} |
| NewtypeInstD Cxt Name [Type] (Maybe Kind) Con Cxt | { newtype instance Cxt x => T [x]
= A (B x) deriving (Z,W)} |
| TySynInstD Name TySynEqn | { type instance ... } |
| OpenTypeFamilyD TypeFamilyHead | { type family T a b c = (r :: *) | r -> a b } |
| ClosedTypeFamilyD TypeFamilyHead [TySynEqn] | { type family F a b = (r :: *) | r -> a 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 } |
Varieties of allowed instance overlap.
Constructors
| Overlappable | May be overlapped by more specific instances |
| Overlapping | May overlap a more general instance |
| Overlaps | Both |
| Incoherent | Both |
data TypeFamilyHead Source #
Common elements of OpenTypeFamilyD and ClosedTypeFamilyD.
By analogy with with "head" for type classes and type class instances as
defined in Type classes: an exploration of the design space, the
TypeFamilyHead is defined to be the elements of the declaration between
type family and where.
Constructors
| TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn) |
Instances
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.
data FamFlavour Source #
Instances
Constructors
| CCall | |
| StdCall | |
| CApi | |
| Prim | |
| JavaScript |
Constructors
| Unsafe | |
| Safe | |
| Interruptible |
Constructors
| AllPhases | |
| FromPhase Int | |
| BeforePhase Int |
Constructors
| RuleVar Name | |
| TypedRuleVar Name Type |
Constructors
| ModuleAnnotation | |
| TypeAnnotation Name | |
| ValueAnnotation Name |
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 SourceUnpackedness Source #
Constructors
| NoSourceUnpackedness | C a |
| SourceNoUnpack | C { {-# NOUNPACK #-} } a |
| SourceUnpack | C { {-# UNPACK #-} } a |
data SourceStrictness Source #
Constructors
| NoSourceStrictness | C a |
| SourceLazy | C {~}a |
| SourceStrict | C {!}a |
data DecidedStrictness Source #
Unlike SourceStrictness and SourceUnpackedness, DecidedStrictness
refers to the strictness that the compiler chooses for a data constructor
field, which may be different from what is written in source code. See
reifyConStrictness for more information.
Constructors
| DecidedLazy | |
| DecidedStrict | |
| DecidedUnpack |
Constructors
| Bang SourceUnpackedness SourceStrictness | C { {-# UNPACK #-} !}a |
type StrictType = BangType Source #
As of template-haskell-2.11.0.0, StrictType has been replaced by
BangType.
type VarStrictType = VarBangType Source #
As of template-haskell-2.11.0.0, VarStrictType has been replaced by
VarBangType.
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 |
| InfixT Type Name Type | T + T |
| UInfixT Type Name Type | T + T |
| ParensT Type | (T) |
| TupleT Int | (,), (,,), etc. |
| UnboxedTupleT Int | (#,#), (#,,#), etc. |
| ArrowT | -> |
| EqualityT | ~ |
| ListT | [] |
| PromotedTupleT Int | '(), '(,), '(,,), etc. |
| PromotedNilT | '[] |
| PromotedConsT | (':) |
| StarT | * |
| ConstraintT | Constraint |
| LitT TyLit | 0,1,2, etc. |
| WildCardT | @_, |
Role annotations
Constructors
| NominalR | nominal |
| RepresentationalR | representational |
| PhantomR | phantom |
| InferR | _ |
Annotation target for reifyAnnotations
Constructors
| AnnLookupModule Module | |
| AnnLookupName Name |
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.