 | haskell-src-exts-1.9.6: Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer | Contents | Index |
|
| Language.Haskell.Exts.Syntax | | Portability | portable | | Stability | stable | | Maintainer | Niklas Broberg, d00nibro@chalmers.se |
|
|
|
|
|
| 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 |
|
|
|
|
| Modules
|
|
| data Module |
| A complete Haskell source module.
| | Constructors | | Instances | |
|
|
| data WarningText |
| Warning text to optionally use in the module header of e.g.
a deprecated module.
| | Constructors | | Instances | |
|
|
| 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 | |
|
|
| data ImportDecl |
| An import declaration.
| | Constructors | | ImportDecl | | | 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 | |
|
|
| 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 | |
|
|
| 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 | |
|
|
| Declarations
|
|
| data Decl |
| A top-level declaration.
| | Constructors | | Instances | |
|
|
| 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 | |
|
|
| data IPBind |
| A binding of an implicit parameter.
| | Constructors | | Instances | |
|
|
| Type classes and instances
|
|
| data ClassDecl |
| Declarations inside a class declaration.
| | Constructors | | Instances | |
|
|
| data InstDecl |
| Declarations inside an instance declaration.
| | Constructors | | Instances | |
|
|
| 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 | | Instances | |
|
|
| data ConDecl |
| Declaration of an ordinary data constructor.
| | Constructors | | Instances | |
|
|
| data QualConDecl |
| A single constructor declaration within a data type declaration,
which may have an existential quantification binding.
| | Constructors | | Instances | |
|
|
| data GadtDecl |
| A single constructor declaration in a GADT data type declaration.
| | Constructors | | Instances | |
|
|
| 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 | |
|
|
| Function bindings
|
|
| data Match |
| Clauses of a function binding.
| | Constructors | | Instances | |
|
|
| 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 | |
|
|
| 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 | | Instances | |
|
|
| 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 | | Instances | |
|
|
| 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 | |
|
|
| Types
|
|
| data Type |
| A type qualified with a context.
An unqualified type has an empty context.
| | Constructors | | Instances | |
|
|
| data Boxed |
| Flag denoting whether a tuple is boxed or unboxed.
| | Constructors | | Instances | |
|
|
| 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 | |
|
|
| 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 | |
|
|
| 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
| | 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 | |
|
|
| 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 | |
|
|
| 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 | |
|
|
| 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 | |
|
|
| data Alt |
| An alt alternative in a case expression.
| | Constructors | | Instances | |
|
|
| 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 | | Instances | |
|
|
| data GuardedAlt |
| A guarded case alternative | stmts -> exp.
| | Constructors | | Instances | |
|
|
| data XAttr |
| An xml attribute, which is a name-expression pair.
| | Constructors | | Instances | |
|
|
| 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 | |
|
|
| 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 | |
|
|
| data PXAttr |
| An XML attribute in a pattern.
| | Constructors | | Instances | |
|
|
| 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 | |
|
|
| 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 | |
|
|
| 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 | |
|
|
| Variables, Constructors and Operators
|
|
| newtype ModuleName |
| The name of a Haskell module.
| | Constructors | | Instances | |
|
|
| 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 | |
|
|
| data Name |
| This type is used to represent variables, and also constructors.
| | Constructors | | Instances | |
|
|
| data QOp |
| Possibly qualified infix operators (qop), appearing in expressions.
| | Constructors | | QVarOp QName | variable operator (qvarop)
| | QConOp QName | constructor operator (qconop)
|
| Instances | |
|
|
| data Op |
| Operators appearing in infix declarations are never qualified.
| | Constructors | | VarOp Name | variable operator (varop)
| | ConOp Name | constructor operator (conop)
|
| Instances | |
|
|
| 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 | |
|
|
| 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 | |
|
|
| data IPName |
| An implicit parameter name.
| | Constructors | | IPDup String | ?ident, non-linear implicit parameter
| | IPLin String | %ident, linear implicit parameter
|
| Instances | |
|
|
| data XName |
| The name of an xml element or attribute,
possibly qualified with a namespace.
| | Constructors | | Instances | |
|
|
| 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 | |
|
|
| data Splice |
| A template haskell splice expression
| | Constructors | | IdSplice String | variable splice: $var
| | ParenSplice Exp | parenthesised expression splice: $(exp)
|
| Instances | |
|
|
| FFI
|
|
| data Safety |
| The safety of a foreign function call.
| | Constructors | | Instances | |
|
|
| data CallConv |
| The calling convention of a foreign function call.
| | Constructors | | Instances | |
|
|
| Pragmas
|
|
| data ModulePragma |
| A top level options pragma, preceding the module header.
| | Constructors | | Instances | |
|
|
| data Tool |
| Recognised tools for OPTIONS pragmas.
| | Constructors | | GHC | | | HUGS | | | NHC98 | | | YHC | | | HADDOCK | | | UnknownTool String | |
| Instances | |
|
|
| data Rule |
| The body of a RULES pragma.
| | Constructors | | Instances | |
|
|
| data RuleVar |
| Variables used in a RULES pragma, optionally annotated with types
| | Constructors | | Instances | |
|
|
| data Activation |
| Activation clause of a RULES pragma.
| | Constructors | | AlwaysActive | | | ActiveFrom Int | | | ActiveUntil Int | |
| Instances | |
|
|
| 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 | |
|
|
| 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 | | Instances | |
|
|
| Produced by Haddock version 2.7.2 |