Language.Haskell.TH.Syntax

Abstract syntax definitions for Template Haskell.

Documentation

class (Monad m, Applicative 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]

qLocation :: m Loc

qRunIO :: IO a -> m a

Input/output (dangerous)

qAddDependentFile :: FilePath -> 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

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

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.

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

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

trueName, falseName :: Name

nothingName, justName :: Name

leftName, rightName :: Name

newtype ModName

Constructors

ModName String

Instances

Eq ModName

Data ModName

Ord ModName

Typeable ModName

newtype PkgName

Constructors

PkgName String

Instances

Eq PkgName

Data PkgName

Ord PkgName

Typeable PkgName

newtype OccName

Constructors

OccName String

Instances

Eq OccName

Data OccName

Ord OccName

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

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

Typeable Name

Ppr 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

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 seperately from GHC itself.

This instance cannot be derived automatically due to bug #2701

Ord NameFlavour

Typeable NameFlavour

con_NameS, con_NameG, con_NameL, con_NameU, con_NameQ :: Constr

ty_NameFlavour :: DataType

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

Typeable 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, mkNameG_d, mkNameG_tc :: 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

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

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

Typeable Info

Ppr Info

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

Show Fixity

Typeable Fixity

data FixityDirection

Constructors

InfixL

InfixR

InfixN

Instances

Eq FixityDirection

Data FixityDirection

Show FixityDirection

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

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

Show Lit

Typeable Lit

data Pat

Pattern in Haskell given in {}

Constructors

LitP Lit

{ 5 or c }

VarP Name

{ x }

TupP [Pat]

{ (p1,p2) }

UnboxedTupP [Pat]

{ () }

ConP Name [Pat]

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

InfixP Pat Name Pat

foo ({x :+ y}) = e

UInfixP Pat Name Pat

foo ({x :+ y}) = e

See 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

Show Pat

Typeable Pat

Ppr Pat

type FieldPat = (Name, Pat)

data Match

Constructors

Match Pat Body [Dec]

case e of { pat -> body where decs }

Instances

Eq Match

Data Match

Show Match

Typeable Match

Ppr Match

data Clause

Constructors

Clause [Pat] Body [Dec]

f { p1 p2 = body where decs }

Instances

Eq Clause

Data Clause

Show Clause

Typeable Clause

Ppr Clause

data 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 Stmts, 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

Typeable Exp

Ppr 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

Show Body

Typeable 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

Show Guard

Typeable Guard

data Stmt

Constructors

BindS Pat Exp

LetS [Dec]

NoBindS Exp

ParS [[Stmt]]

Instances

Eq Stmt

Data Stmt

Show Stmt

Typeable Stmt

Ppr Stmt

data Range

Constructors

FromR Exp

FromThenR Exp Exp

FromToR Exp Exp

FromThenToR Exp Exp Exp

Instances

Eq Range

Data Range

Show Range

Typeable Range

Ppr Range

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

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

Instances

Eq Dec

Data Dec

Show Dec

Typeable Dec

Ppr Dec

data FunDep

Constructors

FunDep [Name] [Name]

Instances

Eq FunDep

Data FunDep

Show FunDep

Typeable FunDep

Ppr FunDep

data FamFlavour

Constructors

TypeFam

DataFam

Instances

Eq FamFlavour

Data FamFlavour

Show FamFlavour

Typeable FamFlavour

Ppr FamFlavour

data Foreign

Constructors

ImportF Callconv Safety String Name Type

ExportF Callconv String Name Type

Instances

Eq Foreign

Data Foreign

Show Foreign

Typeable Foreign

Ppr Foreign

data Callconv

Constructors

CCall

StdCall

Instances

Eq Callconv

Data Callconv

Show Callconv

Typeable Callconv

data Safety

Constructors

Unsafe

Safe

Interruptible

Instances

Eq Safety

Data Safety

Show Safety

Typeable Safety

data Pragma

Constructors

InlineP Name Inline RuleMatch Phases

SpecialiseP Name Type (Maybe Inline) Phases

SpecialiseInstP Type

RuleP String [RuleBndr] Exp Exp Phases

Instances

Eq Pragma

Data Pragma

Show Pragma

Typeable Pragma

Ppr Pragma

data Inline

Constructors

NoInline

Inline

Inlinable

Instances

Eq Inline

Data Inline

Show Inline

Typeable Inline

Ppr Inline

data RuleMatch

Constructors

ConLike

FunLike

Instances

Eq RuleMatch

Data RuleMatch

Show RuleMatch

Typeable RuleMatch

Ppr RuleMatch

data Phases

Constructors

AllPhases

FromPhase Int

BeforePhase Int

Instances

Eq Phases

Data Phases

Show Phases

Typeable Phases

Ppr Phases

data RuleBndr

Constructors

RuleVar Name

TypedRuleVar Name Type

Instances

Eq RuleBndr

Data RuleBndr

Show RuleBndr

Typeable RuleBndr

Ppr RuleBndr

type Cxt

Arguments

 = [Pred]

(Eq a, Ord b)

data Pred

Constructors

ClassP Name [Type]

Eq (Int, a)

EqualP Type Type

F a ~ Bool

Instances

Eq Pred

Data Pred

Show Pred

Typeable Pred

Ppr Pred

data Strict

Constructors

IsStrict

NotStrict

Unpacked

Instances

Eq Strict

Data Strict

Show Strict

Typeable 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

Show Con

Typeable Con

Ppr 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

->

ListT

[]

PromotedTupleT Int

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

PromotedNilT

'[]

PromotedConsT

(':)

StarT

*

ConstraintT

Constraint

LitT TyLit

0,1,2, etc.

Instances

Eq Type

Data Type

Show Type

Typeable Type

Ppr Type

data TyVarBndr

Constructors

PlainTV Name

a

KindedTV Name Kind

(a :: k)

Instances

Eq TyVarBndr

Data TyVarBndr

Show TyVarBndr

Typeable TyVarBndr

Ppr TyVarBndr

data TyLit

Constructors

NumTyLit Integer

2

StrTyLit String

Hello

Instances

Eq TyLit

Data TyLit

Show TyLit

Typeable TyLit

Ppr TyLit

type Kind = Type

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

cmpEq :: Ordering -> Bool

thenCmp :: Ordering -> Ordering -> Ordering