Language.Haskell.Exts.Syntax

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

Portability | portable
Stability | stable
Maintainer | Niklas Broberg, d00nibro@chalmers.se

Language.Haskell.Exts.Syntax

Contents

- Modules
- Declarations
  - Type classes and instances
  - Data type declarations
  - Function bindings
- Class Assertions and Contexts
- Types
- Expressions
- Patterns
- Literals
- Variables, Constructors and Operators
- Template Haskell
- FFI
- Pragmas
- Builtin names
  - Modules
  - Main function of a program
  - Constructors
  - Special identifiers
  - Type constructors
- Source coordinates

Description

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)

Synopsis

- data Module = Module SrcLoc ModuleName [ModulePragma] (Maybe WarningText) (Maybe [ExportSpec]) [ImportDecl] [Decl]
- data WarningText
  - = DeprText String
  - | WarnText String
- data ExportSpec
  - = EVar QName
  - | EAbs QName
  - | EThingAll QName
  - | EThingWith QName [CName]
  - | EModuleContents ModuleName
- data ImportDecl = ImportDecl {
  - importLoc :: SrcLoc
  - importModule :: ModuleName
  - importQualified :: Bool
  - importSrc :: Bool
  - importPkg :: Maybe String
  - importAs :: Maybe ModuleName
  - importSpecs :: Maybe (Bool, [ImportSpec])
  }
- data ImportSpec
  - = IVar Name
  - | IAbs Name
  - | IThingAll Name
  - | IThingWith Name [CName]
- data Assoc
  - = AssocNone
  - | AssocLeft
  - | AssocRight
- data Decl
  - = TypeDecl SrcLoc Name [TyVarBind] Type
  - | TypeFamDecl SrcLoc Name [TyVarBind] (Maybe Kind)
  - | DataDecl SrcLoc DataOrNew Context Name [TyVarBind] [QualConDecl] [Deriving]
  - | GDataDecl SrcLoc DataOrNew Context Name [TyVarBind] (Maybe Kind) [GadtDecl] [Deriving]
  - | DataFamDecl SrcLoc Context Name [TyVarBind] (Maybe Kind)
  - | TypeInsDecl SrcLoc Type Type
  - | DataInsDecl SrcLoc DataOrNew Type [QualConDecl] [Deriving]
  - | GDataInsDecl SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving]
  - | ClassDecl SrcLoc Context Name [TyVarBind] [FunDep] [ClassDecl]
  - | InstDecl SrcLoc Context QName [Type] [InstDecl]
  - | DerivDecl SrcLoc Context QName [Type]
  - | InfixDecl SrcLoc Assoc Int [Op]
  - | DefaultDecl SrcLoc [Type]
  - | SpliceDecl SrcLoc Exp
  - | TypeSig SrcLoc [Name] Type
  - | FunBind [Match]
  - | PatBind SrcLoc Pat (Maybe Type) Rhs Binds
  - | ForImp SrcLoc CallConv Safety String Name Type
  - | ForExp SrcLoc CallConv String Name Type
  - | RulePragmaDecl SrcLoc [Rule]
  - | DeprPragmaDecl SrcLoc [([Name], String)]
  - | WarnPragmaDecl SrcLoc [([Name], String)]
  - | InlineSig SrcLoc Bool Activation QName
  - | InlineConlikeSig SrcLoc Activation QName
  - | SpecSig SrcLoc QName [Type]
  - | SpecInlineSig SrcLoc Bool Activation QName [Type]
  - | InstSig SrcLoc Context QName [Type]
  - | AnnPragma SrcLoc Annotation
- data Binds
  - = BDecls [Decl]
  - | IPBinds [IPBind]
- data IPBind = IPBind SrcLoc IPName Exp
- data ClassDecl
  - = ClsDecl Decl
  - | ClsDataFam SrcLoc Context Name [TyVarBind] (Maybe Kind)
  - | ClsTyFam SrcLoc Name [TyVarBind] (Maybe Kind)
  - | ClsTyDef SrcLoc Type Type
- data InstDecl
  - = InsDecl Decl
  - | InsType SrcLoc Type Type
  - | InsData SrcLoc DataOrNew Type [QualConDecl] [Deriving]
  - | InsGData SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving]
- type Deriving = (QName, [Type])
- data DataOrNew
  - = DataType
  - | NewType
- data ConDecl
  - = ConDecl Name [BangType]
  - | InfixConDecl BangType Name BangType
  - | RecDecl Name [([Name], BangType)]
- data QualConDecl = QualConDecl SrcLoc [TyVarBind] Context ConDecl
- data GadtDecl = GadtDecl SrcLoc Name Type
- data BangType
  - = BangedTy Type
  - | UnBangedTy Type
  - | UnpackedTy Type
- data Match = Match SrcLoc Name [Pat] (Maybe Type) Rhs Binds
- data Rhs
  - = UnGuardedRhs Exp
  - | GuardedRhss [GuardedRhs]
- data GuardedRhs = GuardedRhs SrcLoc [Stmt] Exp
- type Context = [Asst]
- data FunDep = FunDep [Name] [Name]
- data Asst
  - = ClassA QName [Type]
  - | InfixA Type QName Type
  - | IParam IPName Type
  - | EqualP Type Type
- data Type
  - = TyForall (Maybe [TyVarBind]) Context Type
  - | TyFun Type Type
  - | TyTuple Boxed [Type]
  - | TyList Type
  - | TyApp Type Type
  - | TyVar Name
  - | TyCon QName
  - | TyParen Type
  - | TyInfix Type QName Type
  - | TyKind Type Kind
- data Boxed
  - = Boxed
  - | Unboxed
- data Kind
  - = KindStar
  - | KindBang
  - | KindFn Kind Kind
  - | KindParen Kind
  - | KindVar Name
- data TyVarBind
  - = KindedVar Name Kind
  - | UnkindedVar Name
- data Exp
  - = Var QName
  - | IPVar IPName
  - | Con QName
  - | Lit Literal
  - | InfixApp Exp QOp Exp
  - | App Exp Exp
  - | NegApp Exp
  - | Lambda SrcLoc [Pat] Exp
  - | Let Binds Exp
  - | If Exp Exp Exp
  - | Case Exp [Alt]
  - | Do [Stmt]
  - | MDo [Stmt]
  - | Tuple [Exp]
  - | TupleSection [Maybe Exp]
  - | List [Exp]
  - | Paren Exp
  - | LeftSection Exp QOp
  - | RightSection QOp Exp
  - | RecConstr QName [FieldUpdate]
  - | RecUpdate Exp [FieldUpdate]
  - | EnumFrom Exp
  - | EnumFromTo Exp Exp
  - | EnumFromThen Exp Exp
  - | EnumFromThenTo Exp Exp Exp
  - | ListComp Exp [QualStmt]
  - | ParComp Exp [[QualStmt]]
  - | ExpTypeSig SrcLoc Exp Type
  - | VarQuote QName
  - | TypQuote QName
  - | BracketExp Bracket
  - | SpliceExp Splice
  - | QuasiQuote String String
  - | XTag SrcLoc XName [XAttr] (Maybe Exp) [Exp]
  - | XETag SrcLoc XName [XAttr] (Maybe Exp)
  - | XPcdata String
  - | XExpTag Exp
  - | XChildTag SrcLoc [Exp]
  - | CorePragma String Exp
  - | SCCPragma String Exp
  - | GenPragma String (Int, Int) (Int, Int) Exp
  - | Proc SrcLoc Pat Exp
  - | LeftArrApp Exp Exp
  - | RightArrApp Exp Exp
  - | LeftArrHighApp Exp Exp
  - | RightArrHighApp Exp Exp
- data Stmt
  - = Generator SrcLoc Pat Exp
  - | Qualifier Exp
  - | LetStmt Binds
  - | RecStmt [Stmt]
- data QualStmt
  - = QualStmt Stmt
  - | ThenTrans Exp
  - | ThenBy Exp Exp
  - | GroupBy Exp
  - | GroupUsing Exp
  - | GroupByUsing Exp Exp
- data FieldUpdate
  - = FieldUpdate QName Exp
  - | FieldPun Name
  - | FieldWildcard
- data Alt = Alt SrcLoc Pat GuardedAlts Binds
- data GuardedAlts
  - = UnGuardedAlt Exp
  - | GuardedAlts [GuardedAlt]
- data GuardedAlt = GuardedAlt SrcLoc [Stmt] Exp
- data XAttr = XAttr XName Exp
- data Pat
  - = PVar Name
  - | PLit Literal
  - | PNeg Pat
  - | PNPlusK Name Integer
  - | PInfixApp Pat QName Pat
  - | PApp QName [Pat]
  - | PTuple [Pat]
  - | PList [Pat]
  - | PParen Pat
  - | PRec QName [PatField]
  - | PAsPat Name Pat
  - | PWildCard
  - | PIrrPat Pat
  - | PatTypeSig SrcLoc Pat Type
  - | PViewPat Exp Pat
  - | PRPat [RPat]
  - | PXTag SrcLoc XName [PXAttr] (Maybe Pat) [Pat]
  - | PXETag SrcLoc XName [PXAttr] (Maybe Pat)
  - | PXPcdata String
  - | PXPatTag Pat
  - | PXRPats [RPat]
  - | PExplTypeArg QName Type
  - | PQuasiQuote String String
  - | PBangPat Pat
- data PatField
  - = PFieldPat QName Pat
  - | PFieldPun Name
  - | PFieldWildcard
- data PXAttr = PXAttr XName Pat
- data RPat
  - = RPOp RPat RPatOp
  - | RPEither RPat RPat
  - | RPSeq [RPat]
  - | RPGuard Pat [Stmt]
  - | RPCAs Name RPat
  - | RPAs Name RPat
  - | RPParen RPat
  - | RPPat Pat
- data RPatOp
  - = RPStar
  - | RPStarG
  - | RPPlus
  - | RPPlusG
  - | RPOpt
  - | RPOptG
- data Literal
  - = Char Char
  - | String String
  - | Int Integer
  - | Frac Rational
  - | PrimInt Integer
  - | PrimWord Integer
  - | PrimFloat Rational
  - | PrimDouble Rational
  - | PrimChar Char
  - | PrimString String
- newtype ModuleName = ModuleName String
- data QName
  - = Qual ModuleName Name
  - | UnQual Name
  - | Special SpecialCon
- data Name
  - = Ident String
  - | Symbol String
- data QOp
  - = QVarOp QName
  - | QConOp QName
- data Op
  - = VarOp Name
  - | ConOp Name
- data SpecialCon
  - = UnitCon
  - | ListCon
  - | FunCon
  - | TupleCon Boxed Int
  - | Cons
  - | UnboxedSingleCon
- data CName
  - = VarName Name
  - | ConName Name
- data IPName
  - = IPDup String
  - | IPLin String
- data XName
  - = XName String
  - | XDomName String String
- data Bracket
  - = ExpBracket Exp
  - | PatBracket Pat
  - | TypeBracket Type
  - | DeclBracket [Decl]
- data Splice
  - = IdSplice String
  - | ParenSplice Exp
- data Safety
  - = PlayRisky
  - | PlaySafe Bool
- data CallConv
  - = StdCall
  - | CCall
- data ModulePragma
  - = LanguagePragma SrcLoc [Name]
  - | OptionsPragma SrcLoc (Maybe Tool) String
  - | AnnModulePragma SrcLoc Annotation
- data Tool
  - = GHC
  - | HUGS
  - | NHC98
  - | YHC
  - | HADDOCK
  - | UnknownTool String
- data Rule = Rule String Activation (Maybe [RuleVar]) Exp Exp
- data RuleVar
  - = RuleVar Name
  - | TypedRuleVar Name Type
- data Activation
  - = AlwaysActive
  - | ActiveFrom Int
  - | ActiveUntil Int
- data Annotation
  - = Ann Name Exp
  - | TypeAnn Name Exp
  - | ModuleAnn Exp
- prelude_mod :: ModuleName
- main_mod :: ModuleName
- main_name :: Name
- unit_con_name :: QName
- tuple_con_name :: Boxed -> Int -> QName
- list_cons_name :: QName
- unboxed_singleton_con_name :: QName
- unit_con :: Exp
- tuple_con :: Boxed -> Int -> Exp
- unboxed_singleton_con :: Exp
- as_name :: Name
- qualified_name :: Name
- hiding_name :: Name
- minus_name :: Name
- bang_name :: Name
- dot_name :: Name
- star_name :: Name
- export_name :: Name
- safe_name :: Name
- unsafe_name :: Name
- threadsafe_name :: Name
- stdcall_name :: Name
- ccall_name :: Name
- unit_tycon_name :: QName
- fun_tycon_name :: QName
- list_tycon_name :: QName
- tuple_tycon_name :: Boxed -> Int -> QName
- unboxed_singleton_tycon_name :: QName
- unit_tycon :: Type
- fun_tycon :: Type
- list_tycon :: Type
- tuple_tycon :: Boxed -> Int -> Type
- unboxed_singleton_tycon :: Type
- data SrcLoc = SrcLoc {
  - srcFilename :: String
  - srcLine :: Int
  - srcColumn :: Int
  }

# Modules

data Module

A complete Haskell source module.

Constructors

Module SrcLoc ModuleName [ModulePragma] (Maybe WarningText) (Maybe [ExportSpec]) [ImportDecl] [Decl] |

Instances

Eq Module |
Data Module |
Ord Module |
Show Module |
Typeable Module |
AppFixity Module |
Pretty Module |
Parseable Module |

data WarningText

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

Constructors

DeprText String |
WarnText String |

Instances

Eq WarningText |
Data WarningText |
Ord WarningText |
Show WarningText |
Typeable WarningText |

data ExportSpec

An item in a module's export specification.

Constructors

EVar QName | variable
EAbs QName | `T`: a class or datatype exported abstractly, or a type synonym.
EThingAll QName | `T(..)`: a class exported with all of its methods, or a datatype exported with all of its constructors.
EThingWith QName [CName] | `T(C_1,...,C_n)`: a class exported with some of its methods, or a datatype exported with some of its constructors.
EModuleContents ModuleName | `module M`: re-export a module.

Instances

Eq ExportSpec |
Data ExportSpec |
Ord ExportSpec |
Show ExportSpec |
Typeable ExportSpec |
Pretty ExportSpec |

data ImportDecl

An import declaration.

Constructors

ImportDecl |
Fields importLoc :: SrcLoc position of the `import` keyword. importModule :: ModuleName 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 optional alias name in an `as` clause. importSpecs :: Maybe (Bool, [ImportSpec]) optional list of import specifications. The `Bool` is `True` if the names are excluded by `hiding`.

Instances

Eq ImportDecl |
Data ImportDecl |
Ord ImportDecl |
Show ImportDecl |
Typeable ImportDecl |
Pretty ImportDecl |

data ImportSpec

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

Constructors

IVar Name | variable
IAbs Name | `T`: the name of a class, datatype or type synonym.
IThingAll Name | `T(..)`: a class imported with all of its methods, or a datatype imported with all of its constructors.
IThingWith Name [CName] | `T(C_1,...,C_n)`: a class imported with some of its methods, or a datatype imported with some of its constructors.

Instances

Eq ImportSpec |
Data ImportSpec |
Ord ImportSpec |
Show ImportSpec |
Typeable ImportSpec |
Pretty ImportSpec |

data Assoc

Associativity of an operator.

Constructors

AssocNone | non-associative operator (declared with `infix`)
AssocLeft | left-associative operator (declared with `infixl`).
AssocRight | right-associative operator (declared with `infixr`)

Instances

Eq Assoc |
Data Assoc |
Ord Assoc |
Show Assoc |
Typeable Assoc |
Pretty Assoc |

# Declarations

data Decl

A top-level declaration.

Constructors

TypeDecl SrcLoc Name [TyVarBind] Type | A type declaration
TypeFamDecl SrcLoc Name [TyVarBind] (Maybe Kind) | A type family declaration
DataDecl SrcLoc DataOrNew Context Name [TyVarBind] [QualConDecl] [Deriving] | A data OR newtype declaration
GDataDecl SrcLoc DataOrNew Context Name [TyVarBind] (Maybe Kind) [GadtDecl] [Deriving] | A data OR newtype declaration, GADT style
DataFamDecl SrcLoc Context Name [TyVarBind] (Maybe Kind) | A data family declaration
TypeInsDecl SrcLoc Type Type | A type family instance declaration
DataInsDecl SrcLoc DataOrNew Type [QualConDecl] [Deriving] | A data family instance declaration
GDataInsDecl SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving] | A data family instance declaration, GADT style
ClassDecl SrcLoc Context Name [TyVarBind] [FunDep] [ClassDecl] | A declaration of a type class
InstDecl SrcLoc Context QName [Type] [InstDecl] | An declaration of a type class instance
DerivDecl SrcLoc Context QName [Type] | A standalone deriving declaration
InfixDecl SrcLoc Assoc Int [Op] | A declaration of operator fixity
DefaultDecl SrcLoc [Type] | A declaration of default types
SpliceDecl SrcLoc Exp | A Template Haskell splicing declaration
TypeSig SrcLoc [Name] Type | A type signature declaration
FunBind [Match] | A set of function binding clauses
PatBind SrcLoc Pat (Maybe Type) Rhs Binds | A pattern binding
ForImp SrcLoc CallConv Safety String Name Type | A foreign import declaration
ForExp SrcLoc CallConv String Name Type | A foreign export declaration
RulePragmaDecl SrcLoc [Rule] | A RULES pragma
DeprPragmaDecl SrcLoc [([Name], String)] | A DEPRECATED pragma
WarnPragmaDecl SrcLoc [([Name], String)] | A WARNING pragma
InlineSig SrcLoc Bool Activation QName | An INLINE pragma
InlineConlikeSig SrcLoc Activation QName | An INLINE CONLIKE pragma
SpecSig SrcLoc QName [Type] | A SPECIALISE pragma
SpecInlineSig SrcLoc Bool Activation QName [Type] | A SPECIALISE INLINE pragma
InstSig SrcLoc Context QName [Type] | A SPECIALISE instance pragma
AnnPragma SrcLoc Annotation | An ANN pragma

Instances

Eq Decl |
Data Decl |
Ord Decl |
Show Decl |
Typeable Decl |
AppFixity Decl |
Pretty Decl |
Parseable Decl |

data Binds

A binding group inside a `let` or `where` clause.

Constructors

BDecls [Decl] | An ordinary binding group
IPBinds [IPBind] | A binding group for implicit parameters

Instances

Eq Binds |
Data Binds |
Ord Binds |
Show Binds |
Typeable Binds |
AppFixity Binds |

data IPBind

A binding of an implicit parameter.

Constructors

IPBind SrcLoc IPName Exp |

Instances

Eq IPBind |
Data IPBind |
Ord IPBind |
Show IPBind |
Typeable IPBind |
AppFixity IPBind |
Pretty IPBind |

## Type classes and instances

data ClassDecl

Declarations inside a class declaration.

Constructors

ClsDecl Decl | ordinary declaration
ClsDataFam SrcLoc Context Name [TyVarBind] (Maybe Kind) | declaration of an associated data type
ClsTyFam SrcLoc Name [TyVarBind] (Maybe Kind) | declaration of an associated type synonym
ClsTyDef SrcLoc Type Type | default choice for an associated type synonym

Instances

Eq ClassDecl |
Data ClassDecl |
Ord ClassDecl |
Show ClassDecl |
Typeable ClassDecl |
AppFixity ClassDecl |
Pretty ClassDecl |

data InstDecl

Declarations inside an instance declaration.

Constructors

InsDecl Decl | ordinary declaration
InsType SrcLoc Type Type | an associated type definition
InsData SrcLoc DataOrNew Type [QualConDecl] [Deriving] | an associated data type implementation
InsGData SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving] | an associated data type implemented using GADT style

Instances

Eq InstDecl |
Data InstDecl |
Ord InstDecl |
Show InstDecl |
Typeable InstDecl |
AppFixity InstDecl |
Pretty InstDecl |

type Deriving = (QName, [Type])

A single derived instance, which may have arguments since it may be a MPTC.

## Data type declarations

data DataOrNew

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

Constructors

DataType |
NewType |

Instances

Eq DataOrNew |
Data DataOrNew |
Ord DataOrNew |
Show DataOrNew |
Typeable DataOrNew |
Pretty DataOrNew |

data ConDecl

Declaration of an ordinary data constructor.

Constructors

ConDecl Name [BangType] | ordinary data constructor
InfixConDecl BangType Name BangType | infix data constructor
RecDecl Name [([Name], BangType)] | record constructor

Instances

Eq ConDecl |
Data ConDecl |
Ord ConDecl |
Show ConDecl |
Typeable ConDecl |
Pretty ConDecl |

data QualConDecl

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

Constructors

QualConDecl SrcLoc [TyVarBind] Context ConDecl |

Instances

Eq QualConDecl |
Data QualConDecl |
Ord QualConDecl |
Show QualConDecl |
Typeable QualConDecl |
Pretty QualConDecl |

data GadtDecl

A single constructor declaration in a GADT data type declaration.

Constructors

GadtDecl SrcLoc Name Type |

Instances

Eq GadtDecl |
Data GadtDecl |
Ord GadtDecl |
Show GadtDecl |
Typeable GadtDecl |
Pretty GadtDecl |

data BangType

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

Constructors

BangedTy Type | strict component, marked with "`!`"
UnBangedTy Type | non-strict component
UnpackedTy Type | unboxed component, marked with an UNPACK pragma

Instances

Eq BangType |
Data BangType |
Ord BangType |
Show BangType |
Typeable BangType |
Pretty BangType |

## Function bindings

data Match

Clauses of a function binding.

Constructors

Match SrcLoc Name [Pat] (Maybe Type) Rhs Binds |

Instances

Eq Match |
Data Match |
Ord Match |
Show Match |
Typeable Match |
AppFixity Match |
Pretty Match |

data Rhs

The right hand side of a function or pattern binding.

Constructors

UnGuardedRhs Exp | unguarded right hand side (exp)
GuardedRhss [GuardedRhs] | guarded right hand side (gdrhs)

Instances

Eq Rhs |
Data Rhs |
Ord Rhs |
Show Rhs |
Typeable Rhs |
AppFixity Rhs |
Pretty Rhs |

data GuardedRhs

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.

Constructors

GuardedRhs SrcLoc [Stmt] Exp |

Instances

Eq GuardedRhs |
Data GuardedRhs |
Ord GuardedRhs |
Show GuardedRhs |
Typeable GuardedRhs |
AppFixity GuardedRhs |
Pretty GuardedRhs |

# Class Assertions and Contexts

type Context = [Asst]

A context is a set of assertions

data FunDep

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

Constructors

FunDep [Name] [Name] |

Instances

Eq FunDep |
Data FunDep |
Ord FunDep |
Show FunDep |
Typeable FunDep |
Pretty FunDep |

data Asst

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.

Constructors

ClassA QName [Type] | ordinary class assertion
InfixA Type QName Type | class assertion where the class name is given infix
IParam IPName Type | implicit parameter assertion
EqualP Type Type | type equality constraint

Instances

Eq Asst |
Data Asst |
Ord Asst |
Show Asst |
Typeable Asst |
Pretty Asst |

# Types

data Type

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

Constructors

TyForall (Maybe [TyVarBind]) Context Type | qualified type
TyFun Type Type | function type
TyTuple Boxed [Type] | tuple type, possibly boxed
TyList Type | list syntax, e.g. [a], as opposed to [] a
TyApp Type Type | application of a type constructor
TyVar Name | type variable
TyCon QName | named type or type constructor
TyParen Type | type surrounded by parentheses
TyInfix Type QName Type | infix type constructor
TyKind Type Kind | type with explicit kind signature

Instances

Eq Type |
Data Type |
Ord Type |
Show Type |
Typeable Type |
Pretty Type |
Parseable Type |

data Boxed

Flag denoting whether a tuple is boxed or unboxed.

Constructors

Boxed |
Unboxed |

Instances

Eq Boxed |
Data Boxed |
Ord Boxed |
Show Boxed |
Typeable Boxed |

data Kind

An explicit kind annotation.

Constructors

KindStar | `*`, the kind of types
KindBang | `!`, the kind of unboxed types
KindFn Kind Kind | `->`, the kind of a type constructor
KindParen Kind | a kind surrounded by parentheses
KindVar Name | a kind variable (as of yet unsupported by compilers)

Instances

Eq Kind |
Data Kind |
Ord Kind |
Show Kind |
Typeable Kind |
Pretty Kind |

data TyVarBind

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

Constructors

KindedVar Name Kind | variable binding with kind annotation
UnkindedVar Name | ordinary variable binding

Instances

Eq TyVarBind |
Data TyVarBind |
Ord TyVarBind |
Show TyVarBind |
Typeable TyVarBind |
Pretty TyVarBind |

# Expressions

data Exp

Haskell expressions.

Constructors

Var QName | variable
IPVar IPName | implicit parameter variable
Con QName | data constructor
Lit Literal | literal constant
InfixApp Exp QOp Exp | infix application
App Exp Exp | ordinary application
NegApp Exp | negation expression `-exp` (unary minus)
Lambda SrcLoc [Pat] Exp | lambda expression
Let Binds Exp | local declarations with `let` ... `in` ...
If Exp Exp Exp | `if` exp `then` exp `else` exp
Case Exp [Alt] | `case` exp `of` alts
Do [Stmt] | `do`-expression: the last statement in the list should be an expression.
MDo [Stmt] | `mdo`-expression
Tuple [Exp] | tuple expression
TupleSection [Maybe Exp] | tuple section expression, e.g. `(,,3)`
List [Exp] | list expression
Paren Exp | parenthesised expression
LeftSection Exp QOp | left section `(`exp qop`)`
RightSection QOp Exp | right section `(`qop exp`)`
RecConstr QName [FieldUpdate] | record construction expression
RecUpdate Exp [FieldUpdate] | record update expression
EnumFrom Exp | unbounded arithmetic sequence, incrementing by 1: `[from ..]`
EnumFromTo Exp Exp | bounded arithmetic sequence, incrementing by 1 `[from .. to]`
EnumFromThen Exp Exp | unbounded arithmetic sequence, with first two elements given `[from, then ..]`
EnumFromThenTo Exp Exp Exp | bounded arithmetic sequence, with first two elements given `[from, then .. to]`
ListComp Exp [QualStmt] | ordinary list comprehension
ParComp Exp [[QualStmt]] | parallel list comprehension
ExpTypeSig SrcLoc Exp Type | expression with explicit type signature
VarQuote QName | `'x` for template haskell reifying of expressions
TypQuote QName | `''T` for template haskell reifying of types
BracketExp Bracket | template haskell bracket expression
SpliceExp Splice | template haskell splice expression
QuasiQuote String String | quasi-quotaion: `[$name| string |]`
XTag SrcLoc XName [XAttr] (Maybe Exp) [Exp] | xml element, with attributes and children
XETag SrcLoc XName [XAttr] (Maybe Exp) | empty xml element, with attributes
XPcdata String | PCDATA child element
XExpTag Exp | escaped haskell expression inside xml
XChildTag SrcLoc [Exp] | children of an xml element
CorePragma String Exp | CORE pragma
SCCPragma String Exp | SCC pragma
GenPragma String (Int, Int) (Int, Int) Exp | GENERATED pragma
Proc SrcLoc Pat Exp | arrows proc: `proc` pat `->` exp
LeftArrApp Exp Exp | arrow application (from left): exp `-<` exp
RightArrApp Exp Exp | arrow application (from right): exp `>-` exp
LeftArrHighApp Exp Exp | higher-order arrow application (from left): exp `-<<` exp
RightArrHighApp Exp Exp | higher-order arrow application (from right): exp `>>-` exp

Instances

Eq Exp |
Data Exp |
Ord Exp |
Show Exp |
Typeable Exp |
AppFixity Exp |
Pretty Exp |
Parseable Exp |

data Stmt

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.

Constructors

Generator SrcLoc Pat Exp | a generator: pat `<-` exp
Qualifier Exp | 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 Binds | local bindings
RecStmt [Stmt] | a recursive binding group for arrows

Instances

Eq Stmt |
Data Stmt |
Ord Stmt |
Show Stmt |
Typeable Stmt |
AppFixity Stmt |
Pretty Stmt |

data QualStmt

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

Constructors

QualStmt Stmt | an ordinary statement
ThenTrans Exp | `then` exp
ThenBy Exp Exp | `then` exp `by` exp
GroupBy Exp | `then` `group` `by` exp
GroupUsing Exp | `then` `group` `using` exp
GroupByUsing Exp Exp | `then` `group` `by` exp `using` exp

Instances

Eq QualStmt |
Data QualStmt |
Ord QualStmt |
Show QualStmt |
Typeable QualStmt |
AppFixity QualStmt |
Pretty QualStmt |

data FieldUpdate

An fbind in a labeled construction or update expression.

Constructors

FieldUpdate QName Exp | ordinary label-expresion pair
FieldPun Name | record field pun
FieldWildcard | record field wildcard

Instances

Eq FieldUpdate |
Data FieldUpdate |
Ord FieldUpdate |
Show FieldUpdate |
Typeable FieldUpdate |
AppFixity FieldUpdate |
Pretty FieldUpdate |

data Alt

An alt alternative in a `case` expression.

Constructors

Alt SrcLoc Pat GuardedAlts Binds |

Instances

Eq Alt |
Data Alt |
Ord Alt |
Show Alt |
Typeable Alt |
AppFixity Alt |
Pretty Alt |

data GuardedAlts

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

Constructors

UnGuardedAlt Exp | `->` exp
GuardedAlts [GuardedAlt] | gdpat

Instances

Eq GuardedAlts |
Data GuardedAlts |
Ord GuardedAlts |
Show GuardedAlts |
Typeable GuardedAlts |
AppFixity GuardedAlts |
Pretty GuardedAlts |

data GuardedAlt

A guarded case alternative `|` stmts `->` exp.

Constructors

GuardedAlt SrcLoc [Stmt] Exp |

Instances

Eq GuardedAlt |
Data GuardedAlt |
Ord GuardedAlt |
Show GuardedAlt |
Typeable GuardedAlt |
AppFixity GuardedAlt |
Pretty GuardedAlt |

data XAttr

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

Constructors

XAttr XName Exp |

Instances

Eq XAttr |
Data XAttr |
Ord XAttr |
Show XAttr |
Typeable XAttr |
AppFixity XAttr |
Pretty XAttr |

# Patterns

data Pat

A pattern, to be matched against a value.

Constructors

PVar Name | variable
PLit Literal | literal constant
PNeg Pat | negated pattern
PNPlusK Name Integer | n+k pattern
PInfixApp Pat QName Pat | pattern with an infix data constructor
PApp QName [Pat] | data constructor and argument patterns
PTuple [Pat] | tuple pattern
PList [Pat] | list pattern
PParen Pat | parenthesized pattern
PRec QName [PatField] | labelled pattern, record style
PAsPat Name Pat | `@`-pattern
PWildCard | wildcard pattern: `_`
PIrrPat Pat | irrefutable pattern: `~pat`
PatTypeSig SrcLoc Pat Type | pattern with type signature
PViewPat Exp Pat | view patterns of the form `(exp -> pat)`
PRPat [RPat] | regular list pattern
PXTag SrcLoc XName [PXAttr] (Maybe Pat) [Pat] | XML element pattern
PXETag SrcLoc XName [PXAttr] (Maybe Pat) | XML singleton element pattern
PXPcdata String | XML PCDATA pattern
PXPatTag Pat | XML embedded pattern
PXRPats [RPat] | XML regular list pattern
PExplTypeArg QName Type | Explicit generics style type argument e.g. `f {| Int |} x = ...`
PQuasiQuote String String | quasi quote patter: `[$name| string |]`
PBangPat Pat | strict (bang) pattern: `f !x = ...`

Instances

Eq Pat |
Data Pat |
Ord Pat |
Show Pat |
Typeable Pat |
AppFixity Pat |
Pretty Pat |
Parseable Pat |

data PatField

An fpat in a labeled record pattern.

Constructors

PFieldPat QName Pat | ordinary label-pattern pair
PFieldPun Name | record field pun
PFieldWildcard | record field wildcard

Instances

Eq PatField |
Data PatField |
Ord PatField |
Show PatField |
Typeable PatField |
AppFixity PatField |
Pretty PatField |

data PXAttr

An XML attribute in a pattern.

Constructors

PXAttr XName Pat |

Instances

Eq PXAttr |
Data PXAttr |
Ord PXAttr |
Show PXAttr |
Typeable PXAttr |
AppFixity PXAttr |
Pretty PXAttr |

data RPat

An entity in a regular pattern.

Constructors

RPOp RPat RPatOp | operator pattern, e.g. pat*
RPEither RPat RPat | choice pattern, e.g. (1 | 2)
RPSeq [RPat] | sequence pattern, e.g. (| 1, 2, 3 |)
RPGuard Pat [Stmt] | guarded pattern, e.g. (| p | p < 3 |)
RPCAs Name RPat | non-linear variable binding, e.g. (foo@:(1 | 2))*
RPAs Name RPat | linear variable binding, e.g. foo@(1 | 2)
RPParen RPat | parenthesised pattern, e.g. (2*)
RPPat Pat | an ordinary pattern

Instances

Eq RPat |
Data RPat |
Ord RPat |
Show RPat |
Typeable RPat |
AppFixity RPat |
Pretty RPat |

data RPatOp

A regular pattern operator.

Constructors

RPStar | `*` = 0 or more
RPStarG | `*!` = 0 or more, greedy
RPPlus | `+` = 1 or more
RPPlusG | `+!` = 1 or more, greedy
RPOpt | `?` = 0 or 1
RPOptG | `?!` = 0 or 1, greedy

Instances

Eq RPatOp |
Data RPatOp |
Ord RPatOp |
Show RPatOp |
Typeable RPatOp |
Pretty RPatOp |

# Literals

data Literal

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.

Constructors

Char Char | character literal
String String | string literal
Int Integer | integer literal
Frac Rational | floating point literal
PrimInt Integer | unboxed integer literal
PrimWord Integer | unboxed word literal
PrimFloat Rational | unboxed float literal
PrimDouble Rational | unboxed double literal
PrimChar Char | unboxed character literal
PrimString String | unboxed string literal

Instances

Eq Literal |
Data Literal |
Ord Literal |
Show Literal |
Typeable Literal |
Pretty Literal |

# Variables, Constructors and Operators

newtype ModuleName

The name of a Haskell module.

Constructors

ModuleName String |

Instances

Eq ModuleName |
Data ModuleName |
Ord ModuleName |
Show ModuleName |
Typeable ModuleName |
Pretty ModuleName |

data QName

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

Constructors

Qual ModuleName Name | name qualified with a module name
UnQual Name | unqualified local name
Special SpecialCon | built-in constructor with special syntax

Instances

Eq QName |
Data QName |
Ord QName |
Show QName |
Typeable QName |
Pretty QName |

data Name

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

Constructors

Ident String | varid or conid.
Symbol String | varsym or consym

Instances

Eq Name |
Data Name |
Ord Name |
Show Name |
Typeable Name |
Pretty Name |

data QOp

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

Constructors

QVarOp QName | variable operator (qvarop)
QConOp QName | constructor operator (qconop)

Instances

Eq QOp |
Data QOp |
Ord QOp |
Show QOp |
Typeable QOp |
Pretty QOp |

data Op

Operators appearing in `infix` declarations are never qualified.

Constructors

VarOp Name | variable operator (varop)
ConOp Name | constructor operator (conop)

Instances

Eq Op |
Data Op |
Ord Op |
Show Op |
Typeable Op |
Pretty Op |

data SpecialCon

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

Constructors

UnitCon | unit type and data constructor `()`
ListCon | list type constructor `[]`
FunCon | function type constructor `->`
TupleCon Boxed Int | n-ary tuple type and data constructors `(,)` etc, possibly boxed `(#,#)`
Cons | list data constructor `(:)`
UnboxedSingleCon | unboxed singleton tuple constructor `(# #)`

Instances

Eq SpecialCon |
Data SpecialCon |
Ord SpecialCon |
Show SpecialCon |
Typeable SpecialCon |
Pretty SpecialCon |

data CName

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

Constructors

VarName Name | name of a method or field
ConName Name | name of a data constructor

Instances

Eq CName |
Data CName |
Ord CName |
Show CName |
Typeable CName |
Pretty CName |

data IPName

An implicit parameter name.

Constructors

IPDup String | ?ident, non-linear implicit parameter
IPLin String | %ident, linear implicit parameter

Instances

Eq IPName |
Data IPName |
Ord IPName |
Show IPName |
Typeable IPName |
Pretty IPName |

data XName

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

Constructors

XName String |
XDomName String String |

Instances

Eq XName |
Data XName |
Ord XName |
Show XName |
Typeable XName |
Pretty XName |

# Template Haskell

data Bracket

A template haskell bracket expression.

Constructors

ExpBracket Exp | expression bracket: `[| ... |]`
PatBracket Pat | pattern bracket: `[p| ... |]`
TypeBracket Type | type bracket: `[t| ... |]`
DeclBracket [Decl] | declaration bracket: `[d| ... |]`

Instances

Eq Bracket |
Data Bracket |
Ord Bracket |
Show Bracket |
Typeable Bracket |
AppFixity Bracket |
Pretty Bracket |

data Splice

A template haskell splice expression

Constructors

IdSplice String | variable splice: `$var`
ParenSplice Exp | parenthesised expression splice: `$(exp)`

Instances

Eq Splice |
Data Splice |
Ord Splice |
Show Splice |
Typeable Splice |
AppFixity Splice |
Pretty Splice |

# FFI

data Safety

The safety of a foreign function call.

Constructors

PlayRisky | unsafe
PlaySafe Bool | safe (`False`) or threadsafe (`True`)

Instances

Eq Safety |
Data Safety |
Ord Safety |
Show Safety |
Typeable Safety |
Pretty Safety |

data CallConv

The calling convention of a foreign function call.

Constructors

StdCall |
CCall |

Instances

Eq CallConv |
Data CallConv |
Ord CallConv |
Show CallConv |
Typeable CallConv |
Pretty CallConv |

# Pragmas

data ModulePragma

A top level options pragma, preceding the module header.

Constructors

LanguagePragma SrcLoc [Name] | LANGUAGE pragma
OptionsPragma SrcLoc (Maybe Tool) String | OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC
AnnModulePragma SrcLoc Annotation | ANN pragma with module scope

Instances

Eq ModulePragma |
Data ModulePragma |
Ord ModulePragma |
Show ModulePragma |
Typeable ModulePragma |
Pretty ModulePragma |

data Tool

Recognised tools for OPTIONS pragmas.

Constructors

GHC |
HUGS |
NHC98 |
YHC |
HADDOCK |
UnknownTool String |

Instances

Eq Tool |
Data Tool |
Ord Tool |
Show Tool |
Typeable Tool |
Pretty Tool |

data Rule

The body of a RULES pragma.

Constructors

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

Instances

Eq Rule |
Data Rule |
Ord Rule |
Show Rule |
Typeable Rule |
Pretty Rule |

data RuleVar

Variables used in a RULES pragma, optionally annotated with types

Constructors

RuleVar Name |
TypedRuleVar Name Type |

Instances

Eq RuleVar |
Data RuleVar |
Ord RuleVar |
Show RuleVar |
Typeable RuleVar |
Pretty RuleVar |

data Activation

Activation clause of a RULES pragma.

Constructors

AlwaysActive |
ActiveFrom Int |
ActiveUntil Int |

Instances

Eq Activation |
Data Activation |
Ord Activation |
Show Activation |
Typeable Activation |
Pretty Activation |

data Annotation

An annotation through an ANN pragma.

Constructors

Ann Name Exp | An annotation for a declared name.
TypeAnn Name Exp | An annotation for a declared type.
ModuleAnn Exp | An annotation for the defining module.

Instances

Eq Annotation |
Data Annotation |
Ord Annotation |
Show Annotation |
Typeable Annotation |
AppFixity Annotation |
Pretty Annotation |

# Builtin names

## Modules

prelude_mod :: ModuleName

main_mod :: ModuleName

## Main function of a program

main_name :: Name

## Constructors

unit_con_name :: QName

tuple_con_name :: Boxed -> Int -> QName

list_cons_name :: QName

unboxed_singleton_con_name :: QName

unit_con :: Exp

tuple_con :: Boxed -> Int -> Exp

unboxed_singleton_con :: Exp

## Special identifiers

as_name :: Name

qualified_name :: Name

hiding_name :: Name

minus_name :: Name

bang_name :: Name

dot_name :: Name

star_name :: Name

export_name :: Name

safe_name :: Name

unsafe_name :: Name

threadsafe_name :: Name

stdcall_name :: Name

ccall_name :: Name

## Type constructors

unit_tycon_name :: QName

fun_tycon_name :: QName

list_tycon_name :: QName

tuple_tycon_name :: Boxed -> Int -> QName

unboxed_singleton_tycon_name :: QName

unit_tycon :: Type

fun_tycon :: Type

list_tycon :: Type

tuple_tycon :: Boxed -> Int -> Type

unboxed_singleton_tycon :: Type

# Source coordinates

data SrcLoc

A single position in the source.

Constructors

SrcLoc |
Fields srcFilename :: String srcLine :: Int srcColumn :: Int

Instances

Eq SrcLoc |
Data SrcLoc |
Ord SrcLoc |
Show SrcLoc |
Typeable SrcLoc |
SrcInfo SrcLoc |
Pretty SrcLoc |