haskell-src-exts-1.1.4: Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer

MaintainerNiklas Broberg, d00nibro@chalmers.se




A suite of datatypes describing the abstract syntax of Haskell 98 http://www.haskell.org/onlinereport/ plus registered extensions, including:

  • multi-parameter type classes with functional dependencies (MultiParamTypeClasses, FunctionalDependencies)
  • parameters of type class assertions are unrestricted (FlexibleContexts)
  • forall types as universal and existential quantification (RankNTypes, ExistentialQuantification, etc)
  • pattern guards (PatternGuards)
  • implicit parameters (ImplicitParameters)
  • generalised algebraic data types (GADTs)
  • template haskell (TemplateHaskell)
  • empty data type declarations (EmptyDataDecls)
  • unboxed tuples (UnboxedTuples)
  • regular patterns (RegularPatterns)
  • HSP-style XML expressions and patterns (XmlSyntax)



data Module l Source

A complete Haskell source module.


Module l (Maybe (ModuleHead l)) [OptionPragma l] [ImportDecl l] [Decl l]

an ordinary Haskell module

XmlPage l [OptionPragma l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]

a module consisting of a single XML document

XmlHybrid l (Maybe (ModuleHead l)) [OptionPragma l] [ImportDecl l] [Decl l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]

a hybrid module combining an XML document with an ordinary module

data ModuleHead l Source

The head of a module, including the name and export specification.


ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l)) 

data WarningText l Source

Warning text to optionally use in the module header of e.g. a deprecated module.


DeprText l String 
WarnText l String 

data ExportSpec l Source

An item in a module's export specification.


EVar l (QName l)


EAbs l (QName l)

T: a class or datatype exported abstractly, or a type synonym.

EThingAll l (QName l)

T(..): a class exported with all of its methods, or a datatype exported with all of its constructors.

EThingWith l (QName l) [CName l]

T(C_1,...,C_n): a class exported with some of its methods, or a datatype exported with some of its constructors.

EModuleContents l (ModuleName l)

module M: re-export a module.

data ImportDecl l Source

An import declaration.




importAnn :: l

annotation, used by parser for position of the import keyword.

importModule :: ModuleName l

name of the module imported.

importQualified :: Bool

imported qualified?

importSrc :: Bool

imported with {-# SOURCE #-}?

importPkg :: Maybe String

imported with explicit package name

importAs :: Maybe (ModuleName l)

optional alias name in an as clause.

importSpecs :: Maybe (ImportSpecList l)

optional list of import specifications.

data ImportSpec l Source

An import specification, representing a single explicit item imported (or hidden) from a module.


IVar l (Name l)


IAbs l (Name l)

T: the name of a class, datatype or type synonym.

IThingAll l (Name l)

T(..): a class imported with all of its methods, or a datatype imported with all of its constructors.

IThingWith l (Name l) [CName l]

T(C_1,...,C_n): a class imported with some of its methods, or a datatype imported with some of its constructors.

data Assoc l Source

Associativity of an operator.


AssocNone l

non-associative operator (declared with infix)

AssocLeft l

left-associative operator (declared with infixl).

AssocRight l

right-associative operator (declared with infixr)



data Decl l Source

A top-level declaration.


TypeDecl l (DeclHead l) (Type l)

A type declaration

TypeFamDecl l (DeclHead l) (Maybe (Kind l))

A type family declaration

DataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) [QualConDecl l] (Maybe (Deriving l))

A data OR newtype declaration

GDataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))

A data OR newtype declaration, GADT style

DataFamDecl l (Maybe (Context l)) (DeclHead l) (Maybe (Kind l))

A data family declaration

TypeInsDecl l (Type l) (Type l)

A type family instance declaration

DataInsDecl l (DataOrNew l) (Type l) [QualConDecl l] (Maybe (Deriving l))

A data family instance declaration

GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))

A data family instance declaration, GADT style

ClassDecl l (Maybe (Context l)) (DeclHead l) [FunDep l] (Maybe [ClassDecl l])

A declaration of a type class

InstDecl l (Maybe (Context l)) (InstHead l) (Maybe [InstDecl l])

An declaration of a type class instance

DerivDecl l (Maybe (Context l)) (InstHead l)

A standalone deriving declaration

InfixDecl l (Assoc l) (Maybe Int) [Op l]

A declaration of operator fixity

DefaultDecl l [Type l]

A declaration of default types

SpliceDecl l (Splice l)

A Template Haskell splicing declaration

TypeSig l [Name l] (Type l)

A type signature declaration

FunBind l [Match l]

A set of function binding clauses

PatBind l (Pat l) (Maybe (Type l)) (Rhs l) (Maybe (Binds l))

A pattern binding

ForImp l (CallConv l) (Maybe (Safety l)) (Maybe String) (Name l) (Type l)

A foreign import declaration

ForExp l (CallConv l) (Maybe String) (Name l) (Type l)

A foreign export declaration

RulePragmaDecl l [Rule l]

A RULES pragma

DeprPragmaDecl l [([Name l], String)]


WarnPragmaDecl l [([Name l], String)]

A WARNING pragma

InlineSig l Bool (Maybe (Activation l)) (QName l)

An INLINE pragma

SpecSig l (QName l) [Type l]


SpecInlineSig l Bool (Maybe (Activation l)) (QName l) [Type l]


InstSig l (Maybe (Context l)) (InstHead l)

A SPECIALISE instance pragma


Functor Decl 
Typeable1 Decl 
Annotated Decl 
AppFixity Decl 
ExactP Decl 
Eq l => Eq (Decl l) 
Data l => Data (Decl l) 
Show l => Show (Decl l) 
SrcInfo pos => Pretty (Decl pos) 
SrcInfo loc => Parseable (Decl loc) 

data DeclHead l Source

The head of a type or class declaration.


DHead l (Name l) [TyVarBind l] 
DHInfix l (TyVarBind l) (Name l) (TyVarBind l) 
DHParen l (DeclHead l) 

data InstHead l Source

The head of an instance declaration.


IHead l (QName l) [Type l] 
IHInfix l (Type l) (QName l) (Type l) 
IHParen l (InstHead l) 

data Binds l Source

A binding group inside a let or where clause.


BDecls l [Decl l]

An ordinary binding group

IPBinds l [IPBind l]

A binding group for implicit parameters

data IPBind l Source

A binding of an implicit parameter.


IPBind l (IPName l) (Exp l) 

Type classes and instances

data ClassDecl l Source

Declarations inside a class declaration.


ClsDecl l (Decl l)

ordinary declaration

ClsDataFam l (Maybe (Context l)) (DeclHead l) (Maybe (Kind l))

declaration of an associated data type

ClsTyFam l (DeclHead l) (Maybe (Kind l))

declaration of an associated type synonym

ClsTyDef l (Type l) (Type l)

default choice for an associated type synonym

data InstDecl l Source

Declarations inside an instance declaration.


InsDecl l (Decl l)

ordinary declaration

InsType l (Type l) (Type l)

an associated type definition

InsData l (DataOrNew l) (Type l) [QualConDecl l] (Maybe (Deriving l))

an associated data type implementation

InsGData l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))

an associated data type implemented using GADT style

InsInline l Bool (Maybe (Activation l)) (QName l)

an INLINE pragma

data Deriving l Source

A deriving clause following a data type declaration.


Deriving l [InstHead l] 

Data type declarations

data DataOrNew l Source

A flag stating whether a declaration is a data or newtype declaration.


DataType l 
NewType l 

data ConDecl l Source

Declaration of an ordinary data constructor.


ConDecl l (Name l) [BangType l]

ordinary data constructor

InfixConDecl l (BangType l) (Name l) (BangType l)

infix data constructor

RecDecl l (Name l) [FieldDecl l]

record constructor

data FieldDecl l Source

Declaration of a (list of) named field(s).


FieldDecl l [Name l] (BangType l) 

data QualConDecl l Source

A single constructor declaration within a data type declaration, which may have an existential quantification binding.


QualConDecl l (Maybe [TyVarBind l]) (Maybe (Context l)) (ConDecl l) 

data GadtDecl l Source

A single constructor declaration in a GADT data type declaration.


GadtDecl l (Name l) (Type l) 

data BangType l Source

The type of a constructor argument or field, optionally including a strictness annotation.


BangedTy l (Type l)

strict component, marked with "!"

UnBangedTy l (Type l)

non-strict component

UnpackedTy l (Type l)

unboxed component, marked with an UNPACK pragma

Function bindings

data Match l Source

Clauses of a function binding.


Match l (Name l) [Pat l] (Rhs l) (Maybe (Binds l)) 
InfixMatch l (Pat l) (Name l) (Pat l) (Rhs l) (Maybe (Binds l)) 


data Rhs l Source

The right hand side of a function or pattern binding.


UnGuardedRhs l (Exp l)

unguarded right hand side (exp)

GuardedRhss l [GuardedRhs l]

guarded right hand side (gdrhs)


Functor Rhs 
Typeable1 Rhs 
Annotated Rhs 
AppFixity Rhs 
ExactP Rhs 
Eq l => Eq (Rhs l) 
Data l => Data (Rhs l) 
Show l => Show (Rhs l) 
SrcInfo loc => Pretty (Rhs loc) 

data GuardedRhs l Source

A guarded right hand side | stmts = exp. The guard is a series of statements when using pattern guards, otherwise it will be a single qualifier expression.


GuardedRhs l [Stmt l] (Exp l) 

Class Assertions and Contexts

data Context l Source

A context is a set of assertions


CxSingle l (Asst l) 
CxTuple l [Asst l] 
CxParen l (Context l) 
CxEmpty l 

data FunDep l Source

A functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rn


FunDep l [Name l] [Name l] 

data Asst l Source

Class assertions. In Haskell 98, the argument would be a tyvar, but this definition allows multiple parameters, and allows them to be types. Also extended with support for implicit parameters and equality constraints.


ClassA l (QName l) [Type l]

ordinary class assertion

InfixA l (Type l) (QName l) (Type l)

class assertion where the class name is given infix

IParam l (IPName l) (Type l)

implicit parameter assertion

EqualP l (Type l) (Type l)

type equality constraint



data Type l Source

A type qualified with a context. An unqualified type has an empty context.


TyForall l (Maybe [TyVarBind l]) (Maybe (Context l)) (Type l)

qualified type

TyFun l (Type l) (Type l)

function type

TyTuple l Boxed [Type l]

tuple type, possibly boxed

TyList l (Type l)

list syntax, e.g. [a], as opposed to [] a

TyApp l (Type l) (Type l)

application of a type constructor

TyVar l (Name l)

type variable

TyCon l (QName l)

named type or type constructor

TyParen l (Type l)

type surrounded by parentheses

TyInfix l (Type l) (QName l) (Type l)

infix type constructor

TyKind l (Type l) (Kind l)

type with explicit kind signature


Functor Type 
Typeable1 Type 
Annotated Type 
ExactP Type 
Eq l => Eq (Type l) 
Data l => Data (Type l) 
Show l => Show (Type l) 
Pretty (Type l) 
SrcInfo loc => Parseable (Type loc) 

data Boxed Source

Flag denoting whether a tuple is boxed or unboxed.



data Kind l Source

An explicit kind annotation.


KindStar l

*, the kind of types

KindBang l

!, the kind of unboxed types

KindFn l (Kind l) (Kind l)

->, the kind of a type constructor

KindParen l (Kind l)

a parenthesised kind


data TyVarBind l Source

A type variable declaration, optionally with an explicit kind annotation.


KindedVar l (Name l) (Kind l)

variable binding with kind annotation

UnkindedVar l (Name l)

ordinary variable binding


data Exp l Source

Haskell expressions.


Var l (QName l)


IPVar l (IPName l)

implicit parameter variable

Con l (QName l)

data constructor

Lit l (Literal l)

literal constant

InfixApp l (Exp l) (QOp l) (Exp l)

infix application

App l (Exp l) (Exp l)

ordinary application

NegApp l (Exp l)

negation expression -exp (unary minus)

Lambda l [Pat l] (Exp l)

lambda expression

Let l (Binds l) (Exp l)

local declarations with let ... in ...

If l (Exp l) (Exp l) (Exp l)

if exp then exp else exp

Case l (Exp l) [Alt l]

case exp of alts

Do l [Stmt l]

do-expression: the last statement in the list should be an expression.

MDo l [Stmt l]


Tuple l [Exp l]

tuple expression

TupleSection l [Maybe (Exp l)]

tuple section expression, e.g. (,,3)

List l [Exp l]

list expression

Paren l (Exp l)

parenthesised expression

LeftSection l (Exp l) (QOp l)

left section (exp qop)

RightSection l (QOp l) (Exp l)

right section (qop exp)

RecConstr l (QName l) [FieldUpdate l]

record construction expression

RecUpdate l (Exp l) [FieldUpdate l]

record update expression

EnumFrom l (Exp l)

unbounded arithmetic sequence, incrementing by 1: [from ..]

EnumFromTo l (Exp l) (Exp l)

bounded arithmetic sequence, incrementing by 1 [from .. to]

EnumFromThen l (Exp l) (Exp l)

unbounded arithmetic sequence, with first two elements given [from, then ..]

EnumFromThenTo l (Exp l) (Exp l) (Exp l)

bounded arithmetic sequence, with first two elements given [from, then .. to]

ListComp l (Exp l) [QualStmt l]

ordinary list comprehension

ParComp l (Exp l) [[QualStmt l]]

parallel list comprehension

ExpTypeSig l (Exp l) (Type l)

expression with explicit type signature

VarQuote l (QName l)

'x for template haskell reifying of expressions

TypQuote l (QName l)

''T for template haskell reifying of types

BracketExp l (Bracket l)

template haskell bracket expression

SpliceExp l (Splice l)

template haskell splice expression

QuasiQuote l String String

quasi-quotaion: [$name| string |]

XTag l (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]

xml element, with attributes and children

XETag l (XName l) [XAttr l] (Maybe (Exp l))

empty xml element, with attributes

XPcdata l String

PCDATA child element

XExpTag l (Exp l)

escaped haskell expression inside xml

CorePragma l String (Exp l)

CORE pragma

SCCPragma l String (Exp l)

SCC pragma

GenPragma l String (Int, Int) (Int, Int) (Exp l)


Proc l (Pat l) (Exp l)

arrows proc: proc pat -> exp

LeftArrApp l (Exp l) (Exp l)

arrow application (from left): exp -< exp

RightArrApp l (Exp l) (Exp l)

arrow application (from right): exp >- exp

LeftArrHighApp l (Exp l) (Exp l)

higher-order arrow application (from left): exp -<< exp

RightArrHighApp l (Exp l) (Exp l)

higher-order arrow application (from right): exp >>- exp


Functor Exp 
Typeable1 Exp 
Annotated Exp 
AppFixity Exp 
ExactP Exp 
Eq l => Eq (Exp l) 
Data l => Data (Exp l) 
Show l => Show (Exp l) 
SrcInfo loc => Pretty (Exp loc) 
SrcInfo loc => Parseable (Exp loc) 

data Stmt l Source

A statement, representing both a stmt in a do-expression, an ordinary qual in a list comprehension, as well as a stmt in a pattern guard.


Generator l (Pat l) (Exp l)

a generator: pat <- exp

Qualifier l (Exp l)

an exp by itself: in a do-expression, an action whose result is discarded; in a list comprehension and pattern guard, a guard expression

LetStmt l (Binds l)

local bindings

RecStmt l [Stmt l]

a recursive binding group for arrows


data QualStmt l Source

A general transqual in a list comprehension, which could potentially be a transform of the kind enabled by TransformListComp.


QualStmt l (Stmt l)

an ordinary statement

ThenTrans l (Exp l)

then exp

ThenBy l (Exp l) (Exp l)

then exp by exp

GroupBy l (Exp l)

then group by exp

GroupUsing l (Exp l)

then group using exp

GroupByUsing l (Exp l) (Exp l)

then group by exp using exp

data FieldUpdate l Source

An fbind in a labeled construction or update expression.


FieldUpdate l (QName l) (Exp l)

ordinary label-expresion pair

FieldPun l (Name l)

record field pun

FieldWildcard l

record field wildcard

data Alt l Source

An alt alternative in a case expression.


Alt l (Pat l) (GuardedAlts l) (Maybe (Binds l)) 


Functor Alt 
Typeable1 Alt 
Annotated Alt 
AppFixity Alt 
ExactP Alt 
Eq l => Eq (Alt l) 
Data l => Data (Alt l) 
Show l => Show (Alt l) 
SrcInfo loc => Pretty (Alt loc) 

data GuardedAlts l Source

The right-hand sides of a case alternative, which may be a single right-hand side or a set of guarded ones.


UnGuardedAlt l (Exp l)

-> exp

GuardedAlts l [GuardedAlt l]


data GuardedAlt l Source

A guarded case alternative | stmts -> exp.


GuardedAlt l [Stmt l] (Exp l) 

data XAttr l Source

An xml attribute, which is a name-expression pair.


XAttr l (XName l) (Exp l) 



data Pat l Source

A pattern, to be matched against a value.


PVar l (Name l)


PLit l (Literal l)

literal constant

PNeg l (Pat l)

negated pattern

PNPlusK l (Name l) Integer

n+k pattern

PInfixApp l (Pat l) (QName l) (Pat l)

pattern with an infix data constructor

PApp l (QName l) [Pat l]

data constructor and argument patterns

PTuple l [Pat l]

tuple pattern

PList l [Pat l]

list pattern

PParen l (Pat l)

parenthesized pattern

PRec l (QName l) [PatField l]

labelled pattern, record style

PAsPat l (Name l) (Pat l)


PWildCard l

wildcard pattern: _

PIrrPat l (Pat l)

irrefutable pattern: ~pat

PatTypeSig l (Pat l) (Type l)

pattern with type signature

PViewPat l (Exp l) (Pat l)

view patterns of the form (exp -> pat)

PRPat l [RPat l]

regular list pattern

PXTag l (XName l) [PXAttr l] (Maybe (Pat l)) [Pat l]

XML element pattern

PXETag l (XName l) [PXAttr l] (Maybe (Pat l))

XML singleton element pattern

PXPcdata l String

XML PCDATA pattern

PXPatTag l (Pat l)

XML embedded pattern

PXRPats l [RPat l]

XML regular list pattern

PExplTypeArg l (QName l) (Type l)

Explicit generics style type argument e.g. f {| Int |} x = ...

PQuasiQuote l String String

quasi quote pattern: [$name| string |]

PBangPat l (Pat l)

strict (bang) pattern: f !x = ...


Functor Pat 
Typeable1 Pat 
Annotated Pat 
AppFixity Pat 
ExactP Pat 
Eq l => Eq (Pat l) 
Data l => Data (Pat l) 
Show l => Show (Pat l) 
SrcInfo loc => Pretty (Pat loc) 
SrcInfo loc => Parseable (Pat loc) 

data PatField l Source

An fpat in a labeled record pattern.


PFieldPat l (QName l) (Pat l)

ordinary label-pattern pair

PFieldPun l (Name l)

record field pun

PFieldWildcard l

record field wildcard

data PXAttr l Source

An XML attribute in a pattern.


PXAttr l (XName l) (Pat l) 

data RPat l Source

An entity in a regular pattern.


RPOp l (RPat l) (RPatOp l) 
RPEither l (RPat l) (RPat l) 
RPSeq l [RPat l] 
RPGuard l (Pat l) [Stmt l] 
RPCAs l (Name l) (RPat l) 
RPAs l (Name l) (RPat l) 
RPParen l (RPat l) 
RPPat l (Pat l) 


data RPatOp l Source

A regular pattern operator.


RPStar l

* = 0 or more

RPStarG l

*! = 0 or more, greedy

RPPlus l

+ = 1 or more

RPPlusG l

+! = 1 or more, greedy

RPOpt l

? = 0 or 1

RPOptG l

?! = 0 or 1, greedy


data Literal l Source

literal Values of this type hold the abstract value of the literal, not the precise string representation used. For example, 10, 0o12 and 0xa have the same representation.


Char l Char String

character literal

String l String String

string literal

Int l Integer String

integer literal

Frac l Rational String

floating point literal

PrimInt l Integer String

unboxed integer literal

PrimWord l Integer String

unboxed word literal

PrimFloat l Rational String

unboxed float literal

PrimDouble l Rational String

unboxed double literal

PrimChar l Char String

unboxed character literal

PrimString l String String

unboxed string literal

Variables, Constructors and Operators

data ModuleName l Source

The name of a Haskell module.


ModuleName l String 

data QName l Source

This type is used to represent qualified variables, and also qualified constructors.


Qual l (ModuleName l) (Name l)

name qualified with a module name

UnQual l (Name l)

unqualified local name

Special l (SpecialCon l)

built-in constructor with special syntax


data Name l Source

This type is used to represent variables, and also constructors.


Ident l String

varid or conid.

Symbol l String

varsym or consym


Functor Name 
Typeable1 Name 
Annotated Name 
ExactP Name 
Eq l => Eq (Name l) 
Data l => Data (Name l) 
Ord l => Ord (Name l) 
Show l => Show (Name l) 
Pretty (Name l) 

data QOp l Source

Possibly qualified infix operators (qop), appearing in expressions.


QVarOp l (QName l)

variable operator (qvarop)

QConOp l (QName l)

constructor operator (qconop)


Functor QOp 
Typeable1 QOp 
Annotated QOp 
ExactP QOp 
Eq l => Eq (QOp l) 
Data l => Data (QOp l) 
Ord l => Ord (QOp l) 
Show l => Show (QOp l) 
Pretty (QOp l) 

data Op l Source

Operators appearing in infix declarations are never qualified.


VarOp l (Name l)

variable operator (varop)

ConOp l (Name l)

constructor operator (conop)


Functor Op 
Typeable1 Op 
Annotated Op 
ExactP Op 
Eq l => Eq (Op l) 
Data l => Data (Op l) 
Ord l => Ord (Op l) 
Show l => Show (Op l) 
Pretty (Op l) 

data SpecialCon l Source

Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.


UnitCon l

unit type and data constructor ()

ListCon l

list type constructor []

FunCon l

function type constructor ->

TupleCon l Boxed Int

n-ary tuple type and data constructors (,) etc, possibly boxed (#,#)

Cons l

list data constructor (:)

UnboxedSingleCon l

unboxed singleton tuple constructor (# #)

data CName l Source

A name (cname) of a component of a class or data type in an import or export specification.


VarName l (Name l)

name of a method or field

ConName l (Name l)

name of a data constructor


data IPName l Source

An implicit parameter name.


IPDup l String

?ident, non-linear implicit parameter

IPLin l String

%ident, linear implicit parameter


data XName l Source

The name of an xml element or attribute, possibly qualified with a namespace.


XName l String 
XDomName l String String 


Template Haskell

data Bracket l Source

A template haskell bracket expression.


ExpBracket l (Exp l)

expression bracket: [| ... |]

PatBracket l (Pat l)

pattern bracket: [p| ... |]

TypeBracket l (Type l)

type bracket: [t| ... |]

DeclBracket l [Decl l]

declaration bracket: [d| ... |]

data Splice l Source

A template haskell splice expression


IdSplice l String

variable splice: $var

ParenSplice l (Exp l)

parenthesised expression splice: $(exp)


data Safety l Source

The safety of a foreign function call.


PlayRisky l


PlaySafe l Bool

safe (False) or threadsafe (True)

data CallConv l Source

The calling convention of a foreign function call.


StdCall l 
CCall l 


data OptionPragma l Source

A top level options pragma, preceding the module header.


LanguagePragma l [Name l]


IncludePragma l String

INCLUDE pragma

CFilesPragma l String

CFILES pragma

OptionsPragma l (Maybe Tool) String

OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC

data Tool Source

Recognised tools for OPTIONS pragmas.

data Rule l Source

The body of a RULES pragma.


Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l) 


Functor Rule 
Typeable1 Rule 
Annotated Rule 
ExactP Rule 
Eq l => Eq (Rule l) 
Data l => Data (Rule l) 
Show l => Show (Rule l) 
SrcInfo loc => Pretty (Rule loc) 

data RuleVar l Source

Variables used in a RULES pragma, optionally annotated with types


RuleVar l (Name l) 
TypedRuleVar l (Name l) (Type l) 

data Activation l Source

Activation clause of a RULES pragma.


ActiveFrom l Int 
ActiveUntil l Int 

Builtin names


Main function of a program


tuple_con :: l -> Boxed -> Int -> Exp lSource

Special identifiers

Type constructors

Source coordinates

Annotated trees

(=~=) :: (Functor a, Eq (a ())) => a l1 -> a l2 -> BoolSource