`d      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                    !"#$%&' ( )*+,-./0123456789:; < = > ? @ A B C D E F G H I J K L M N O P Q RSTUVWXYZ[\]^_`abcportablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Infered ?A class to work over all kinds of source location information. `A portion of the source, extended with information on the position of entities within the span. !An entity located in the source. NA portion of the source, spanning one or more lines and zero or more columns. !!A single position in the source. &Returns  and  in a pair. 'Returns  and   in a pair. (6Combine two locations in the source to denote a span. )FMerge two source spans into a single span from the start of the first F to the end of the second. Assumes that the two spans relate to the  same source file. *;Test if a given span starts and ends at the same location. , Generate a . with no positional information for entities. - Generate a 8 with the supplied positional information for entities. . Combine two 2s into one that spans the combined source area of < the two arguments, leaving positional information blank. /Short name for . 07Optionally combine the first argument with the second, 4 or return it unchanged if the second argument is d. 17Optionally combine the second argument with the first, 3 or return it unchanged if the first argument is d. 28Add more positional information for entities of a span. 3 Merge two s and lift them to a  SrcInfoSpan with + no positional information for entities. ,  !"#$%&'()*+,-./0123efg)  !"#$%&'()*+,-./0123)!"#$% &'()*+,-./0123    !"#$%&'()*+,-./0123efgportablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Infered24PAST nodes are annotated, and this class allows manipulation of the annotations. 5(Retrieve the annotation of an AST node. 6GChange the annotation of an AST node. Note that only the annotation of L the node itself is affected, and not the annotations of any child nodes. 8 if all nodes in the AST tree are to be affected, use h. 7A guarded case alternative | stmts -> exp. 9The right-hand sides of a case alternative, . which may be a single right-hand side or a  set of guarded ones. :gdpat ;-> exp <An alt alternative in a case expression. >An fbind1 in a labeled construction or update expression. ?record field wildcard @record field pun Aordinary label-expresion pair B A general  transqual in a list comprehension, 6 which could potentially be a transform of the kind ! enabled by TransformListComp. Cthen group by exp using exp Dthen group using exp Ethen group by exp Fthen exp by exp Gthen exp Han ordinary statement I!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. J%a recursive binding group for arrows Klocal bindings Lan exp by itself: in a do -expression, ( an action whose result is discarded; . in a list comprehension and pattern guard,  a guard expression M a generator: pat <- exp NAn fpat in a labeled record pattern. Orecord field wildcard Precord field pun Qordinary label-pattern pair R An entity in a regular pattern. San ordinary pattern T!parenthesised pattern, e.g. (2*) U!linear variable binding, e.g. foo@(1 | 2) V&non-linear variable binding, e.g. (foo@ :(1 | 2))* Wguarded pattern, e.g. (| p | p < 3 |) X%sequence pattern, e.g. (| 1, 2, 3 |) Ychoice pattern, e.g. (1 | 2) Zoperator pattern, e.g. pat* [A regular pattern operator. \?! = 0 or 1, greedy ]? = 0 or 1 ^+! = 1 or more, greedy _+ = 1 or more `*! = 0 or more, greedy a* = 0 or more bAn XML attribute in a pattern. d*A pattern, to be matched against a value. estrict (bang) pattern:  f !x = ... fquasi quote pattern: [$name| string |] g+Explicit generics style type argument e.g. f {| Int |} x = ... hXML regular list pattern iXML embedded pattern jXML PCDATA pattern kXML singleton element pattern lXML element pattern mregular list pattern nview patterns of the form (exp -> pat) opattern with type signature pirrefutable pattern: ~pat qwildcard pattern: _ r@ -pattern slabelled pattern, record style tparenthesized pattern u list pattern vtuple pattern w'data constructor and argument patterns x'pattern with an infix data constructor y n+k pattern znegated pattern {literal constant | variable }<Warning text to optionally use in the module header of e.g.  a deprecated module. BVariables used in a RULES pragma, optionally annotated with types The body of a RULES pragma. %Activation clause of a RULES pragma. &Recognised tools for OPTIONS pragmas. 9A top level options pragma, preceding the module header. ANN pragma with module scope AOPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC LANGUAGE pragma 3The calling convention of a foreign function call. 'The safety of a foreign function call. safe (i) or threadsafe (j) unsafe %A template haskell splice expression !parenthesised expression splice: $(exp) variable splice: $var 'A template haskell bracket expression. declaration bracket:  [d| ... |] type bracket:  [t| ... |] pattern bracket:  [p| ... |] expression bracket: [| ... |] 3An xml attribute, which is a name-expression pair. )The name of an xml element or attribute, ( possibly qualified with a namespace. Haskell expressions. -higher-order arrow application (from right): exp >>- exp ,higher-order arrow application (from left): exp -<< exp  arrow application (from right): exp >- exp arrow application (from left): exp -< exp  arrows proc: proc pat -> exp GENERATED pragma  SCC pragma  CORE pragma children of an xml element &escaped haskell expression inside xml PCDATA child element #empty xml element, with attributes *xml element, with attributes and children quasi-quotaion: [$name| string |] #template haskell splice expression $template haskell bracket expression ''T( for template haskell reifying of types 'x. for template haskell reifying of expressions (expression with explicit type signature parallel list comprehension ordinary list comprehension bounded arithmetic sequence, ! with first two elements given [from, then .. to] unbounded arithmetic sequence, ! with first two elements given [from, then ..] bounded arithmetic sequence,  incrementing by 1  [from .. to] unbounded arithmetic sequence,  incrementing by 1: [from ..] record update expression record construction expression right section (qop exp)  left section (exp qop) parenthesised expression list expression tuple section expression, e.g. (,,3) tuple expression mdo -expression do -expression: " the last statement in the list  should be an expression. case exp of alts if exp then exp else exp local declarations with let ... in ... lambda expression negation expression -exp (unary minus) ordinary application infix application literal constant data constructor implicit parameter variable  variable literal L Values of this type hold the abstract value of the literal, along with the 3 precise string representation used. For example, 10, 0o12 and 0xa W have the same value representation, but each carry a different string representation. unboxed string literal unboxed character literal unboxed double literal unboxed float literal unboxed word literal unboxed integer literal floating point literal integer literal string literal character literal Class assertions. * In Haskell 98, the argument would be a tyvar, but this definition 5 allows multiple parameters, and allows them to be types. P Also extended with support for implicit parameters and equality constraints. type equality constraint implicit parameter assertion 4class assertion where the class name is given infix ordinary class assertion !A context is a set of assertions +A functional dependency, given on the form  l1 l2 ... ln -> r2 r3 .. rn An explicit kind annotation. 5a kind variable (as-of-yet unsupported by compilers) a parenthesised kind ->!, the kind of a type constructor !, the kind of unboxed types *, the kind of types JA type variable declaration, optionally with an explicit kind annotation. ordinary variable binding &variable binding with kind annotation 3Flag denoting whether a tuple is boxed or unboxed. !A type qualified with a context. - An unqualified type has an empty context. "type with explicit kind signature infix type constructor type surrounded by parentheses named type or type constructor type variable "application of a type constructor list syntax, e.g. [a], as opposed to [] a tuple type, possibly boxed function type qualified type A guarded right hand side | stmts = exp. B The guard is a series of statements when using pattern guards, 7 otherwise it will be a single qualifier expression. 6The right hand side of a function or pattern binding. guarded right hand side (gdrhs) unguarded right hand side (exp) BThe type of a constructor argument or field, optionally including  a strictness annotation.  0unboxed component, marked with an UNPACK pragma  non-strict component  strict component, marked with "!"  -Declarations inside an instance declaration.  5an associated data type implemented using GADT style 'an associated data type implementation an associated type definition ordinary declaration )Declarations inside a class declaration. .default choice for an associated type synonym *declaration of an associated type synonym 'declaration of an associated data type ordinary declaration BA single constructor declaration in a GADT data type declaration. +Declaration of a (list of) named field(s). -Declaration of an ordinary data constructor. record constructor infix data constructor ordinary data constructor AA single constructor declaration within a data type declaration, 9 which may have an existential quantification binding.  Clauses of a function binding. !DA clause defined with infix notation, i.e. first its first argument C pattern, then the function name, then its following argument(s), 4 the right-hand side and an optional where clause. H Note that there can be more than two arguments to a function declared . infix, hence the list of pattern arguments. "?A clause defined with prefix notation, i.e. the function name @ followed by its argument patterns, the right-hand side and an  optional where clause. #$A binding of an implicit parameter. %A binding group inside a let or where clause. &(A binding group for implicit parameters 'An ordinary binding group (5A deriving clause following a data type declaration. *%The head of an instance declaration. .)The head of a type or class declaration. 2GA flag stating whether a declaration is a data or newtype declaration. 5%An annotation through an ANN pragma. 6'An annotation for the defining module. 7#An annotation for a declared type. 8#An annotation for a declared name. 9A top-level declaration. :An ANN pragma ;A SPECIALISE instance pragma <A SPECIALISE INLINE pragma =A SPECIALISE pragma >An INLINE CONLIKE pragma ?An INLINE pragma @A WARNING pragma AA DEPRECATED pragma BA RULES pragma CA foreign export declaration DA foreign import declaration EA pattern binding F"A set of function binding clauses GA type signature declaration H(A Template Haskell splicing declaration IA declaration of default types J!A declaration of operator fixity K"A standalone deriving declaration L(An declaration of a type class instance MA declaration of a type class N/A data family instance declaration, GADT style O#A data family instance declaration P#A type family instance declaration QA data family declaration R*A data OR newtype declaration, GADT style SA data OR newtype declaration TA type family declaration UA type declaration VAssociativity of an operator. W*right-associative operator (declared with infixr) X)left-associative operator (declared with infixl). Y(non-associative operator (declared with infix) ZFAn import specification, representing a single explicit item imported  (or hidden) from a module. [T(C_1,...,C_n): 1 a class imported with some of its methods, or 6 a datatype imported with some of its constructors. \T(..): 0 a class imported with all of its methods, or 5 a datatype imported with all of its constructors. ]T: 2 the name of a class, datatype or type synonym. ^ variable _'An explicit import specification list. aAn import declaration. c/annotation, used by parser for position of the import keyword. dname of the module imported. e imported  qualified? fimported with {-# SOURCE #-}? g$imported with explicit package name hoptional alias name in an as clause. i(optional list of import specifications. jAn item in a module's export specification. kmodule M:  re-export a module. lT(C_1,...,C_n): 1 a class exported with some of its methods, or 6 a datatype exported with some of its constructors. mT(..): 0 a class exported with all of its methods, or 5 a datatype exported with all of its constructors. nT: , a class or datatype exported abstractly,  or a type synonym. o variable p"An explicit export specification. rCThe head of a module, including the name and export specification. t"A complete Haskell source module. uBa hybrid module combining an XML document with an ordinary module vYa module consisting of a single XML document. The ModuleName never appears in the source N but is needed for semantic purposes, it will be the same as the file name. wan ordinary Haskell module xA name (cname/) of a component of a class or data type in an import  or export specification. yname of a data constructor zname of a method or field {Operators appearing in infix# declarations are never qualified. |constructor operator (conop) }variable operator (varop) ~$Possibly qualified infix operators (qop), appearing in expressions. constructor operator (qconop) variable operator (qvarop) An implicit parameter name. %ident, linear implicit parameter ?ident , non-linear implicit parameter AThis type is used to represent variables, and also constructors. varsym or consym varid or conid. =This type is used to represent qualified variables, and also  qualified constructors. )built-in constructor with special syntax unqualified local name "name qualified with a module name "Constructors with special syntax. F These names are never qualified, and always refer to builtin type or  data constructors. $unboxed singleton tuple constructor (# #) list data constructor (:) n-ary tuple type and data  constructors (,) etc, possibly boxed (#,#) function type constructor -> list type constructor [] unit type and data constructor () The name of a Haskell module. 7Test if two AST elements are equal modulo annotations. 456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~klmnopqrstuvwxyz{|}~456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~twvurs}~pqjonmlkabcdefghi_`Z^]\[VYXW9UTSRQPONMLKJIHGFEDCBA@?>=<;:.10/*-,+%'&#$  ()243    "!IMLKJBHGFEDC>A@?<=9;:78d|{zyxwvutsrqponmlkjihgfeNQPObcRZYXWVUTS[a`_^]\~{}|xzy5876456456789;:<=>A@?BHGFEDCIMLKJNQPORZYXWVUTS[a`_^]\bcd|{zyxwvutsrqponmlkjihgfe}~.        "!#$%'&()*-,+.10/24358769UTSRQPONMLKJIHGFEDCBA@?>=<;:VYXWZ^]\[_`abcdefghijonmlkpqrstwvuxzy{}|~klmnopqrstuvwxyz{|}~ Safe-Infered?"type with explicit kind signature infix type constructor #assertion of an implicit parameter type surrounded by parentheses named type or type constructor type variable "application of a type constructor list syntax, e.g. [a], as opposed to [] a tuple type, possibly boxed function type e >>- e e -<< e e >- e e -< e  proc p -> do  f !a = ... f {| Int |} x = ... {- GENERATED ...  -} pragma {- SCC  -} pragma {- CORE  -} pragma  [ ... ]  % ...  /%  % ... % PCDATA  Name /  Name... /Name  $...|... ''T 'x regular patterns only  regular patterns only  regular patterns only  regular patterns only  patterns only  pre-ops  post-ops patterns only patterns only patterns only expression type signature parallel list comprehension bounded arithmetic sequence, ! with first two elements given unbounded arithmetic sequence, ! with first two elements given bounded arithmetic sequence,  incrementing by 1 unbounded arithmetic sequence,  incrementing by 1 record update expression record construction expression parenthesized expression = RightSection QOp PExp -- ^ right section (qop exp) list expression tuple section expression, e.g. (,,3) mdo -expression  | Tuple [PExp]. -- ^ tuple expression do -expression: " the last statement in the list  should be an expression. case exp of alts  if exp then exp else exp !local declarations with let "lambda expression #negation expression - exp $ordinary application %infix application &literal constant 'data constructor (implicit parameter variable ) variable h*+,-./0123456789:;<=>      !"#$%&'()?@ABCDEFGHIJKLMNOPQR\*+,-./0123456789:;<=>      !"#$%&'()?@ABCDEF*.-,+/ 015432678;:9<7)('&%$#"!      >=?@ABCDEFGHIJKLMNOPQRportable experimental$Niklas Broberg, d00nibro@chalmers.se Safe-Infered.1An identifier with the given string as its name. 4 The string should be a valid Haskell identifier. 2A symbol identifier. The string should be a valid  Haskell symbol identifier.  A local variable as expression. )Use the given identifier as an operator. $A qualified variable as expression. A pattern variable. -Application of expressions by juxtaposition. Apply an operator infix. )Apply a function to a list of arguments. /A constructor pattern, with argument patterns. A tuple expression. A tuple pattern. 1A tuple expression consisting of variables only. .A tuple pattern consisting of variables only. A function with a given name. A literal string expression.  A literal character expression. A literal integer expression. A literal string pattern. A literal character pattern. A literal integer pattern. +A do block formed by the given statements. , The last statement in the list should be  a L expression. -Lambda abstraction, given a list of argument $ patterns and an expression body. A let ... in block. A case expression. An unguarded alternative in a case expression. (An alternative with a single guard in a case expression. A list expression. The empty list expression. The empty list pattern. &Put parentheses around an expression. "Put parentheses around a pattern. "A qualifier expression statement. A generator statement: pat <- exp A let binding group as a statement. 0Hoist a set of declarations to a binding group. An empty binding group. The wildcard pattern: _ EGenerate k names by appending numbers 1 through k to a given string.  A function with a single clause >A function with a single clause, a single argument, no guards  and no where declarations :A pattern bind where the pattern is a variable, and where  there are no guards and no 'where' clause. :A pattern bind where the pattern is a variable, and where ! there are no guards, but with a 'where' clause. %Bind an identifier to an expression. 7Apply function of a given name to a list of arguments. 9Apply a constructor of a given name to a list of pattern - arguments, forming a constructor pattern. .... Safe-InferedA Haskell comment. The S is j$ if the comment is multi-line, i.e. {- -}.  portable stable %Niklas Broberg, d00nibro@chalmers.se  Safe-InferedOPrint an AST exactly as specified by the annotations on the nodes in the tree. CTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~CTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ portable  transient %Niklas Broberg, d00nibro@chalmers.se  Safe-Infered+This datatype is a copy of the one in Cabal'%s Language.Haskell.Extension module. P The intention is to eventually import it from Cabal, but we need to wait for K the next release of Cabal which includes XmlSyntax and RegularPatterns. +=Certain extensions imply other extensions, and this function @ makes the implication explicit. This also handles deprecated / extensions, which imply their replacements. < The returned valued is the transitive closure of implied  extensions. ,"The list of extensions enabled by  GHC'#s portmanteau -fglasgow-exts flag. /&List of all known extensions. Poor man's  instance  (we can't enum with the  constructor). 0)A clever version of read that returns an  $ if the string is not recognised. I      !"#$%&'()*+,-./0I      !"#$%&'()*+,-./0I*)('&%$#"!      0+-.,/B*)('&%$#"!      +,-./0 portable stable %Niklas Broberg, d00nibro@chalmers.se  Safe-Infered portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Infered!1A guarded case alternative | stmts -> exp. 3The right-hand sides of a case alternative, . which may be a single right-hand side or a  set of guarded ones. 4gdpat 5-> exp 6An alt alternative in a case expression. 8An fbind1 in a labeled construction or update expression. 9record field wildcard :record field pun ;ordinary label-expresion pair < A general  transqual in a list comprehension, 6 which could potentially be a transform of the kind ! enabled by TransformListComp. =then group by exp using exp >then group using exp ?then group by exp @then exp by exp Athen exp Ban ordinary statement C!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. D%a recursive binding group for arrows Elocal bindings Fan exp by itself: in a do -expression, ( an action whose result is discarded; . in a list comprehension and pattern guard,  a guard expression G a generator: pat <- exp HAn fpat in a labeled record pattern. Irecord field wildcard Jrecord field pun Kordinary label-pattern pair L An entity in a regular pattern. Man ordinary pattern N!parenthesised pattern, e.g. (2*) O!linear variable binding, e.g. foo@(1 | 2) P&non-linear variable binding, e.g. (foo@ :(1 | 2))* Qguarded pattern, e.g. (| p | p < 3 |) R%sequence pattern, e.g. (| 1, 2, 3 |) Schoice pattern, e.g. (1 | 2) Toperator pattern, e.g. pat* UA regular pattern operator. V?! = 0 or 1, greedy W? = 0 or 1 X+! = 1 or more, greedy Y+ = 1 or more Z*! = 0 or more, greedy [* = 0 or more \An XML attribute in a pattern. ^*A pattern, to be matched against a value. _strict (bang) pattern:  f !x = ... `quasi quote patter: [$name| string |] a+Explicit generics style type argument e.g. f {| Int |} x = ... bXML regular list pattern cXML embedded pattern dXML PCDATA pattern eXML singleton element pattern fXML element pattern gregular list pattern hview patterns of the form (exp -> pat) ipattern with type signature jirrefutable pattern: ~pat kwildcard pattern: _ l@ -pattern mlabelled pattern, record style nparenthesized pattern o list pattern ptuple pattern q'data constructor and argument patterns r'pattern with an infix data constructor s n+k pattern tnegated pattern uliteral constant v variable w<Warning text to optionally use in the module header of e.g.  a deprecated module. zBVariables used in a RULES pragma, optionally annotated with types }The body of a RULES pragma. %Activation clause of a RULES pragma. 9A top level options pragma, preceding the module header. ANN pragma with module scope AOPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC LANGUAGE pragma 3The calling convention of a foreign function call. 'The safety of a foreign function call. safe (i) or threadsafe (j) unsafe %A template haskell splice expression !parenthesised expression splice: $(exp) variable splice: $var 'A template haskell bracket expression. declaration bracket:  [d| ... |] type bracket:  [t| ... |] pattern bracket:  [p| ... |] expression bracket: [| ... |] 3An xml attribute, which is a name-expression pair. )The name of an xml element or attribute, ( possibly qualified with a namespace. Haskell expressions. -higher-order arrow application (from right): exp >>- exp ,higher-order arrow application (from left): exp -<< exp  arrow application (from right): exp >- exp arrow application (from left): exp -< exp  arrows proc: proc pat -> exp GENERATED pragma  SCC pragma  CORE pragma children of an xml element &escaped haskell expression inside xml PCDATA child element #empty xml element, with attributes *xml element, with attributes and children quasi-quotaion: [$name| string |] #template haskell splice expression $template haskell bracket expression ''T( for template haskell reifying of types 'x. for template haskell reifying of expressions (expression with explicit type signature parallel list comprehension ordinary list comprehension bounded arithmetic sequence, ! with first two elements given [from, then .. to] unbounded arithmetic sequence, ! with first two elements given [from, then ..] bounded arithmetic sequence,  incrementing by 1  [from .. to] unbounded arithmetic sequence,  incrementing by 1: [from ..] record update expression record construction expression right section (qop exp)  left section (exp qop) parenthesised expression list expression tuple section expression, e.g. (,,3) tuple expression mdo -expression do -expression: " the last statement in the list  should be an expression. case exp of alts if exp then exp else exp local declarations with let ... in ... lambda expression negation expression -exp (unary minus) ordinary application infix application literal constant data constructor implicit parameter variable  variable literal E Values of this type hold the abstract value of the literal, not the 3 precise string representation used. For example, 10, 0o12 and 0xa  have the same representation. unboxed string literal unboxed character literal unboxed double literal unboxed float literal unboxed word literal unboxed integer literal floating point literal integer literal string literal character literal Class assertions. * In Haskell 98, the argument would be a tyvar, but this definition 5 allows multiple parameters, and allows them to be types. P Also extended with support for implicit parameters and equality constraints. type equality constraint implicit parameter assertion 4class assertion where the class name is given infix ordinary class assertion !A context is a set of assertions +A functional dependency, given on the form  l1 l2 ... ln -> r2 r3 .. rn An explicit kind annotation. 5a kind variable (as of yet unsupported by compilers) !a kind surrounded by parentheses ->!, the kind of a type constructor !, the kind of unboxed types *, the kind of types JA type variable declaration, optionally with an explicit kind annotation. ordinary variable binding &variable binding with kind annotation !A type qualified with a context. - An unqualified type has an empty context. "type with explicit kind signature infix type constructor type surrounded by parentheses named type or type constructor type variable "application of a type constructor list syntax, e.g. [a], as opposed to [] a tuple type, possibly boxed function type qualified type A guarded right hand side | stmts = exp. B The guard is a series of statements when using pattern guards, 7 otherwise it will be a single qualifier expression. 6The right hand side of a function or pattern binding. guarded right hand side (gdrhs) unguarded right hand side (exp) BThe type of a constructor argument or field, optionally including  a strictness annotation. 0unboxed component, marked with an UNPACK pragma non-strict component strict component, marked with "!" -Declarations inside an instance declaration. 5an associated data type implemented using GADT style 'an associated data type implementation an associated type definition ordinary declaration )Declarations inside a class declaration. .default choice for an associated type synonym *declaration of an associated type synonym 'declaration of an associated data type ordinary declaration BA single constructor declaration in a GADT data type declaration. -Declaration of an ordinary data constructor. record constructor infix data constructor ordinary data constructor  AA single constructor declaration within a data type declaration, 9 which may have an existential quantification binding.  Clauses of a function binding.  $A binding of an implicit parameter. A binding group inside a let or where clause. (A binding group for implicit parameters An ordinary binding group GA flag stating whether a declaration is a data or newtype declaration. %An annotation through an ANN pragma. 'An annotation for the defining module. #An annotation for a declared type. #An annotation for a declared name. A top-level declaration. An ANN pragma A SPECIALISE instance pragma A SPECIALISE INLINE pragma A SPECIALISE pragma An INLINE CONLIKE pragma An INLINE pragma  A WARNING pragma !A DEPRECATED pragma "A RULES pragma #A foreign export declaration $A foreign import declaration %A pattern binding &"A set of function binding clauses 'A type signature declaration ((A Template Haskell splicing declaration )A declaration of default types *!A declaration of operator fixity +"A standalone deriving declaration ,(An declaration of a type class instance -A declaration of a type class ./A data family instance declaration, GADT style /#A data family instance declaration 0#A type family instance declaration 1A data family declaration 2*A data OR newtype declaration, GADT style 3A data OR newtype declaration 4A type family declaration 5A type declaration 6LA single derived instance, which may have arguments since it may be a MPTC. 7Associativity of an operator. 8*right-associative operator (declared with infixr) 9)left-associative operator (declared with infixl). :(non-associative operator (declared with infix) ;FAn import specification, representing a single explicit item imported  (or hidden) from a module. <T(C_1,...,C_n): 1 a class imported with some of its methods, or 6 a datatype imported with some of its constructors. =T(..): 0 a class imported with all of its methods, or 5 a datatype imported with all of its constructors. >T: 2 the name of a class, datatype or type synonym. ? variable @An import declaration. Bposition of the import keyword. Cname of the module imported. D imported  qualified? Eimported with {-# SOURCE #-}? F$imported with explicit package name Goptional alias name in an as clause. H(optional list of import specifications.  The S is j if the names are excluded  by hiding. IAn item in a module's export specification. Jmodule M:  re-export a module. KT(C_1,...,C_n): 1 a class exported with some of its methods, or 6 a datatype exported with some of its constructors. LT(..): 0 a class exported with all of its methods, or 5 a datatype exported with all of its constructors. MT: , a class or datatype exported abstractly,  or a type synonym. N variable O"A complete Haskell source module. QA name (cname/) of a component of a class or data type in an import  or export specification. Rname of a data constructor Sname of a method or field TOperators appearing in infix# declarations are never qualified. Uconstructor operator (conop) Vvariable operator (varop) W$Possibly qualified infix operators (qop), appearing in expressions. Xconstructor operator (qconop) Yvariable operator (qvarop) ZAn implicit parameter name. [%ident, linear implicit parameter \?ident , non-linear implicit parameter ]AThis type is used to represent variables, and also constructors. ^varsym or consym _varid or conid. `=This type is used to represent qualified variables, and also  qualified constructors. a)built-in constructor with special syntax bunqualified local name c"name qualified with a module name d"Constructors with special syntax. F These names are never qualified, and always refer to builtin type or  data constructors. e$unboxed singleton tuple constructor (# #) flist data constructor (:) gn-ary tuple type and data  constructors (,) etc, possibly boxed (#,#) hfunction type constructor -> ilist type constructor [] junit type and data constructor () kThe name of a Haskell module. ]123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~l!"#$%123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~lOPwyxINMLKJ@ABCDEFGH;?>=<7:98543210/.-,+*)('&%$#"!  6    CGFED<BA@?>=8;:96735412^vutsrqponmlkjihgfedcba`_HKJI\]LTSRQPONMU[ZYXWVkl`cba]_^WYXTVUdjihgfeQSRZ\[}~z|{mnopqrstuvw}|{zyx~!"#$%[12354678;:9<BA@?>=CGFEDHKJILTSRQPONMU[ZYXWV\]^vutsrqponmlkjihgfedcba`_wyxz|{}~.       543210/.-,+*)('&%$#"! 67:98;?>=<@ABCDEFGHINMLKJOPQSRTVUWYXZ\[]_^`cbadjihgfeklmnopqrstuvwxyz{|}~ portable experimental$Niklas Broberg, d00nibro@chalmers.se Safe-Infered.1An identifier with the given string as its name. 4 The string should be a valid Haskell identifier. 2A symbol identifier. The string should be a valid  Haskell symbol identifier.  A local variable as expression. )Use the given identifier as an operator. $A qualified variable as expression. A pattern variable. -Application of expressions by juxtaposition. Apply an operator infix. )Apply a function to a list of arguments. /A constructor pattern, with argument patterns. A tuple expression. A tuple pattern. 1A tuple expression consisting of variables only. .A tuple pattern consisting of variables only. A function with a given name. A literal string expression.  A literal character expression. A literal integer expression. A literal string pattern. A literal character pattern. A literal integer pattern. +A do block formed by the given statements. , The last statement in the list should be  a F expression. -Lambda abstraction, given a list of argument $ patterns and an expression body. A let ... in block. A case expression. An unguarded alternative in a case expression. (An alternative with a single guard in a case expression. A list expression. The empty list expression. The empty list pattern. &Put parentheses around an expression. "Put parentheses around a pattern. "A qualifier expression statement. A generator statement: pat <- exp A let binding group as a statement. 0Hoist a set of declarations to a binding group. An empty binding group. The wildcard pattern: _ EGenerate k names by appending numbers 1 through k to a given string.  A function with a single clause >A function with a single clause, a single argument, no guards  and no where declarations :A pattern bind where the pattern is a variable, and where  there are no guards and no 'where' clause. :A pattern bind where the pattern is a variable, and where ! there are no guards, but with a 'where' clause. %Bind an identifier to an expression. 7Apply function of a given name to a list of arguments. 9Apply a constructor of a given name to a list of pattern - arguments, forming a constructor pattern. .... portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Infered@All AST elements that may include expressions which in turn may 9 need fixity tweaking will be instances of this class. 8Tweak any expressions in the element to account for the = fixities given. Assumes that all operator expressions are 0 fully left associative chains to begin with. 9Operator fixities are represented by their associativity 5 (left, right or none) and their precedence (0-9). %All fixities defined in the Prelude. *All fixities defined in the base package. Note that the +++- operator appears in both Control.Arrows and ; Text.ParserCombinators.ReadP. The listed precedence for +++ in ( this list is that of Control.Arrows. !The fixities to account for. The element to tweak. GThe same element, but with operator expressions updated, or a failure.   portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-InferedMonad for parsing %Static parameters governing a parse. , Note that the various parse functions in Language.Haskell.Exts.Parser 1 never look at LANGUAGE pragmas, regardless of  what the ignoreLanguagePragmas flag is set to.  Only the various  parseFile functions in Language.Haskell.Exts will  act on it, when set to i. 'original name of the file being parsed 'list of extensions enabled for parsing if j, the parser won' t care about further extensions ' in LANGUAGE pragmas in source files if j, the parser won'!t read line position information % from LINE pragmas in source files  list of fixities to be aware of The result of a parse. "The parse failed at the specified ) source location, with an error message. 'The parse succeeded, yielding a value. 7Retrieve the result of a successful parse, throwing an 2 error if the parse is actually not successful.  Default parameters for a parse. ' The default is an unknown filename, $ no extensions (i.e. Haskell 98),  don'3t ignore LANGUAGE pragmas, do ignore LINE pragmas, % and be aware of fixities from the Prelude. IDiscard some input characters (these must not include tabs or newlines). 5Discard the next character, which must be a newline. 1Discard the next character, which must be a tab. ?9.portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Infered) ]       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      qr  portable  experimental %Niklas Broberg, d00nibro@chalmers.se  Safe-InferedDTranslate an annotated AST node representing a Haskell module, into F a simpler version that retains (almost) only abstract information. N In particular, XML and hybrid XML pages enabled by the XmlSyntax extension 7 are translated into standard Haskell modules with a page function. CTranslate an annotated AST node representing a Haskell declaration M into a simpler version. Note that in the simpler version, all declaration  nodes are still annotated by !s. @     @     @     @     portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-InferedGThings that can be pretty-printed, including all the syntactic objects  in Language.Haskell.Exts.Syntax and &Language.Haskell.Exts.Annotated.Syntax. Pretty-printing parameters. Note: the 3 must be positive and less than all other indents. #indentation of a class or instance indentation of a do -expression indentation of the body of a  case expression %indentation of the declarations in a  let expression %indentation of the declarations in a  where clause #indentation added for continuation ' lines that would otherwise be offside  blank lines between statements? Pretty-printing style to use add GHC-style LINE pragmas to output?  Varieties of layout we can use. everything on a single line  )inline decls, with newlines between them !classical layout made explicit "classical layout #CThe default mode: pretty-print using the offside rule and sensible  defaults. $*pretty-print with a given style and mode. %6pretty-print with the default style and a given mode. &(pretty-print with the default style and #.  !"#$%&stuvwxyz{|}~!  !"#$%&!$%&  "! # "! #$%&stuvwxyz{|}~portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Infered#     v*+,-./016789:;<=>      !"#$%&'()?@A     #       portable stable %Niklas Broberg, d00nibro@chalmers.se  Safe-Infered'@All AST elements that may include expressions which in turn may 9 need fixity tweaking will be instances of this class. (8Tweak any expressions in the element to account for the = fixities given. Assumes that all operator expressions are 0 fully left associative chains to begin with. '(The fixities to account for. The element to tweak. GThe same element, but with operator expressions updated, or a failure.  !"#$%&'()*+, '( '('( !"#$%&'()*+,portablestable$Niklas Broberg, d00nibro@chalmers.seNone)CParse of a string, which should contain a complete Haskell module. *PParse of a string containing a complete Haskell module, using an explicit mode. +dParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. ,3Parse of a string containing a Haskell expression. -KParse of a string containing a Haskell expression, using an explicit mode. .dParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. /0Parse of a string containing a Haskell pattern. 0HParse of a string containing a Haskell pattern, using an explicit mode. 1dParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. 2>Parse of a string containing a Haskell top-level declaration. 3VParse of a string containing a Haskell top-level declaration, using an explicit mode. 4dParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. 5-Parse of a string containing a Haskell type. 6EParse of a string containing a Haskell type, using an explicit mode. 7dParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. 82Parse of a string containing a Haskell statement. 9EParse of a string containing a Haskell type, using an explicit mode. :dParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. -NPartial parse of a string starting with a series of top-level option pragmas. .CParse of a string, which should contain a complete Haskell module. /PParse of a string containing a complete Haskell module, using an explicit mode. 0dParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. )*+,-./0123456789:-./0")*+,-./0123456789:-./0)*+,-./0123456789:-./0  Safe-Infered;;Class to reuse the parse function at many different types. <"Parse a string with default mode. =&Parse a string with an explicit mode. >KParse a string with an explicit mode, returning all comments along the AST @CParse of a string, which should contain a complete Haskell module. APParse of a string containing a complete Haskell module, using an explicit mode. BdParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. C3Parse of a string containing a Haskell expression. DKParse of a string containing a Haskell expression, using an explicit mode. EdParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. F0Parse of a string containing a Haskell pattern. GHParse of a string containing a Haskell pattern, using an explicit mode. HdParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. I>Parse of a string containing a Haskell top-level declaration. JVParse of a string containing a Haskell top-level declaration, using an explicit mode. KdParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. L-Parse of a string containing a Haskell type. MEParse of a string containing a Haskell type, using an explicit mode. NdParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. O-Parse of a string containing a Haskell type. PEParse of a string containing a Haskell type, using an explicit mode. QdParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. ";<=>?@ABCDEFGHIJKLMNOPQ123456789:;#;<=>?@ABCDEFGHIJKLMNOPQ#;<=>@ABCDEOPQFGHIJKLMN?;<=>?@ABCDEFGHIJKLMNOPQ123456789:;portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-InferedR;Parse a source file on disk, using the default parse mode. SKParse a source file on disk, with an extra set of extensions to know about , on top of what the file itself declares. T<Parse a source file on disk, supplying a custom parse mode. V@Parse a source file from a string using the default parse mode. WQParse a source file from a string, with an extra set of extensions to know about , on top of what the file itself declares. X=Parse a source file from a string using a custom parse mode. Z3Gather the extensions declared in LANGUAGE pragmas # at the top of the file. Returns d if the  parse of the pragmas fails. RSTUVWXYZ{  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0 !"#$%&'()*+,-./0123456789:;<=>RSTUVWXYZRTSUVXWY)*+,-.89:/01234567Z RSTUVWXYZportablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Infered [;Parse a source file on disk, using the default parse mode. \KParse a source file on disk, with an extra set of extensions to know about , on top of what the file itself declares. ]<Parse a source file on disk, supplying a custom parse mode. ^TParse a source file on disk, supplying a custom parse mode, and retaining comments. _@Parse a source file from a string using the default parse mode. `QParse a source file from a string, with an extra set of extensions to know about , on top of what the file itself declares. a=Parse a source file from a string using a custom parse mode. bTParse a source file from a string using a custom parse mode and retaining comments. c3Gather the extensions declared in LANGUAGE pragmas # at the top of the file. Returns d if the  parse of the pragmas fails. [\]^_`abc; !"#$%      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&;<=>?@ABCDEFGHIJKLMNOPQ[\]^_`abc []\^_a`bc [\]^_`abc< !"#$%&'())*+,,-.//01234556789:;<=>?@ABCDEFGHIJJKKLMMNOPNQRSTUVQWXYZ[\]^_`abcdefghijklmnoppqrstuvwxyz{|}~       !!"#"$$%&'(()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]]^_`abcdefghijkkllmnompqrstuvwxyz{|}~      !"#$%&JJKKLMMNOPNQRSTUVQWXYZ[\]^_`abcdefghijklmnoppqrstuvwxyz{|}~'       !!""$$%&'123456789:;<=>?@ABCDEFGHIJKLMNOPQR(STUVWXYZ[]](_`abcdefghijmmpqrstuvwxyz{|}~                                               ) * + + , - . / 01123456789:; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z {|}}~ ) *                             !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL MNOOPNPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                              !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"                        #$% & ' ( ) * + , - . / 01haskell-src-exts-1.13.0Language.Haskell.Exts.PrettyLanguage.Haskell.Exts.SrcLoc&Language.Haskell.Exts.Annotated.Syntax%Language.Haskell.Exts.Annotated.BuildLanguage.Haskell.Exts.Comments*Language.Haskell.Exts.Annotated.ExactPrintLanguage.Haskell.Exts.ExtensionLanguage.Haskell.Exts.SyntaxLanguage.Haskell.Exts.BuildLanguage.Haskell.Exts.FixityLanguage.Haskell.Exts.Parser(Language.Haskell.Exts.Annotated.Simplify&Language.Haskell.Exts.Annotated.FixityLanguage.Haskell.Exts.AnnotatedLanguage.Haskell.Exts!Language.Haskell.Exts.ParseSyntaxLanguage.Haskell.Exts.ExtScheme Language.Haskell.Exts.ParseMonadLanguage.Haskell.Exts.Lexer Language.Haskell.Exts.ParseUtils$Language.Haskell.Exts.InternalParserpretty-1.1.1.0Text.PrettyPrint.HughesPJstyleribbonsPerLine lineLengthmodeStylePageMode ZigZagModeLeftMode OneLineModeModeSrcInfo toSrcInfo fromSrcInfo getPointLocfileName startLine startColumn SrcSpanInfo srcInfoSpan srcInfoPointsLoclocunLocSrcSpansrcSpanFilenamesrcSpanStartLinesrcSpanStartColumnsrcSpanEndLinesrcSpanEndColumnSrcLoc srcFilenamesrcLine srcColumn srcSpanStart srcSpanEnd mkSrcSpan mergeSrcSpan isNullSpanspanSize noInfoSpaninfoSpan combSpanInfo<++><+?><**<^^> Annotatedannamap GuardedAlt GuardedAlts UnGuardedAltAlt FieldUpdate FieldWildcardFieldPunQualStmt GroupByUsing GroupUsingGroupByThenBy ThenTransStmtRecStmtLetStmt Qualifier GeneratorPatFieldPFieldWildcard PFieldPun PFieldPatRPatRPPatRPParenRPAsRPCAsRPGuardRPSeqRPEitherRPOpRPatOpRPOptGRPOptRPPlusGRPPlusRPStarGRPStarPXAttrPatPBangPat PQuasiQuote PExplTypeArgPXRPatsPXPatTagPXPcdataPXETagPXTagPRPatPViewPat PatTypeSigPIrrPat PWildCardPAsPatPRecPParenPListPTuplePApp PInfixAppPNPlusKPNegPLitPVar WarningTextWarnTextDeprTextRuleVar TypedRuleVarRule Activation ActiveUntil ActiveFromTool UnknownToolHADDOCKYHCNHC98HUGSGHC ModulePragmaAnnModulePragma OptionsPragmaLanguagePragmaCallConvCCallStdCallSafetyPlaySafe PlayRiskySplice ParenSpliceIdSpliceBracket DeclBracket TypeBracket PatBracket ExpBracketXAttrXNameXDomNameExpRightArrHighAppLeftArrHighApp RightArrApp LeftArrAppProc GenPragma SCCPragma CorePragma XChildTagXExpTagXPcdataXETagXTag QuasiQuote SpliceExp BracketExpTypQuoteVarQuote ExpTypeSigParCompListCompEnumFromThenTo EnumFromThen EnumFromToEnumFrom RecUpdate RecConstr RightSection LeftSectionParenList TupleSectionTupleMDoDoCaseIfLetLambdaNegAppAppInfixAppLitConIPVarVarLiteral PrimStringPrimChar PrimDouble PrimFloatPrimWordPrimIntFracIntStringCharAsstEqualPIParamInfixAClassAContextCxEmptyCxParenCxTupleCxSingleFunDepKindKindVar KindParenKindFnKindBangKindStar TyVarBind UnkindedVar KindedVarBoxedUnboxedTypeTyKindTyInfixTyParenTyConTyVarTyAppTyListTyTupleTyFunTyForall GuardedRhsRhs GuardedRhss UnGuardedRhsBangType UnpackedTy UnBangedTyBangedTyInstDeclInsGDataInsDataInsTypeInsDecl ClassDeclClsTyDefClsTyFam ClsDataFamClsDeclGadtDecl FieldDeclConDeclRecDecl InfixConDecl QualConDeclMatch InfixMatchIPBindBindsIPBindsBDeclsDerivingInstHeadIHParenIHInfixIHeadDeclHeadDHParenDHInfixDHead DataOrNewNewTypeDataType Annotation ModuleAnnTypeAnnAnnDecl AnnPragmaInstSig SpecInlineSigSpecSigInlineConlikeSig InlineSigWarnPragmaDeclDeprPragmaDeclRulePragmaDeclForExpForImpPatBindFunBindTypeSig SpliceDecl DefaultDecl InfixDecl DerivDecl GDataInsDecl DataInsDecl TypeInsDecl DataFamDecl GDataDeclDataDecl TypeFamDeclTypeDeclAssoc AssocRight AssocLeft AssocNone ImportSpec IThingWith IThingAllIAbsIVarImportSpecList ImportDecl importAnn importModuleimportQualified importSrc importPkgimportAs importSpecs ExportSpecEModuleContents EThingWith EThingAllEAbsEVarExportSpecList ModuleHeadModule XmlHybridXmlPageCNameConNameVarNameOpConOpVarOpQOpQConOpQVarOpIPNameIPLinIPDupNameSymbolIdentQNameSpecialUnQualQual SpecialConUnboxedSingleConConsTupleConFunConListConUnitCon ModuleName prelude_modmain_mod main_name unit_con_nametuple_con_namelist_cons_nameunboxed_singleton_con_nameunit_con tuple_conunboxed_singleton_conas_namequalified_name hiding_name minus_name bang_namedot_name star_name export_name safe_name unsafe_namethreadsafe_name stdcall_name ccall_nameunit_tycon_namefun_tycon_namelist_tycon_nameunboxed_singleton_tycon_nametuple_tycon_name unit_tycon fun_tycon list_tyconunboxed_singleton_tycon tuple_tycon=~=namesymvaropqvarpvarappinfixAppappFunpApptuplepTuplevarTuple pvarTuplefunctionstrEcharEintEstrPcharPintPdoElamEletEcaseEaltaltGWlistEeListpeListparenpParenqualStmtgenStmtletStmtbindsnoBindswildcardgenNamessfun simpleFunpatBind patBindWherenameBind metaFunction metaConPatCommentExactP exactPrint ExtensionUnknownExtension TupleSectionsRegularPatterns XmlSyntax ViewPatternsTransformListComp QuasiQuotesPostfixOperatorsNewQualifiedOperatorsImpredicativeTypesDoAndIfThenElsePackageImportsNPlusKPatternsConstrainedClassMethodsDeriveDataTypeable UnboxedTuplesExtendedDefaultRulesRelaxedPolyRecNoMonoPatBinds MonoPatBindsGADTsOverloadedStringsDisambiguateRecordFields RecordPunsRecordWildCards TypeOperatorsLiberalTypeSynonymsUnliftedFFITypesPatternSignatures UnicodeSyntaxStandaloneDeriving TypeFamilies MagicHash HereDocumentsRestrictedTypeSynonymsExtensibleRecordsGeneralizedNewtypeDeriving PatternGuardsNamedFieldPunsNoImplicitPreludeGenericsArrowsForeignFunctionInterfaceTemplateHaskellTypeSynonymInstances BangPatternsKindSignaturesCPPEmptyDataDeclsFlexibleInstancesFlexibleContextsImplicitParamsScopedTypeVariablesExistentialQuantificationPolymorphicComponents RankNTypes Rank2TypesExplicitForAllFunctionalDependenciesNoMonomorphismRestrictionMultiParamTypeClassesParallelListComp RecursiveDoIncoherentInstancesUndecidableInstancesOverlappingInstances impliesExts glasgowExts haskell98 haskell2010knownExtensionsclassifyExtension AlwaysActive importLoc AppFixity applyFixitiesFixitypreludeFixities baseFixitiesinfixr_infixl_infix_ ParseMode parseFilename extensionsignoreLanguagePragmasignoreLinePragmasfixities ParseResult ParseFailedParseOkfromParseResultdefaultParseModesModulesDecl sAnnotation sModuleName sSpecialConsQNamesNamesIPNamesQOpsOpsCName sModuleHeadsExportSpecList sExportSpec sImportDeclsImportSpecList sImportSpecsAssoc sDeclHead sInstHead sDataOrNew sDerivingsBindssIPBindsMatch sQualConDeclsConDecl sFieldDecl sGadtDecl sClassDecl sInstDecl sBangTypesRhs sGuardedRhssType sTyVarBindsKindsFunDepsContextsAsstsLiteralsExpsXNamesXAttrsBracketsSplicesSafety sCallConv sModulePragma sActivationsRulesRuleVar sWarningTextsPatsPXAttrsRPatOpsRPat sPatFieldsStmt sQualStmt sFieldUpdatesAlt sGuardedAlts sGuardedAltPrettyPPHsMode classIndentdoIndent caseIndent letIndent whereIndent onsideIndentspacinglayout linePragmasIndentPPLayout PPNoLayoutPPInLine PPSemiColon PPOffsideRule defaultModeprettyPrintStyleModeprettyPrintWithMode prettyPrint parseModuleparseModuleWithModeparseModuleWithCommentsparseExpparseExpWithModeparseExpWithCommentsparsePatparsePatWithModeparsePatWithComments parseDeclparseDeclWithModeparseDeclWithComments parseTypeparseTypeWithModeparseTypeWithComments parseStmtparseStmtWithModeparseStmtWithComments Parseableparse parseWithModeparseWithComments getTopPragmas parseFileparseFileWithExtsparseFileWithModeparseFileWithCommentsparseFileContentsparseFileContentsWithExtsparseFileContentsWithModeparseFileContentsWithCommentsreadExtensionsbase Data.MaybeNothing$fSrcInfoSrcSpanInfo$fSrcInfoSrcSpan$fSrcInfoSrcLocGHC.Basefmapghc-prim GHC.TypesFalseTrue$fAnnotatedGuardedAlt$fAnnotatedGuardedAlts$fAnnotatedAlt$fAnnotatedFieldUpdate$fAnnotatedQualStmt$fAnnotatedStmt$fAnnotatedPatField$fAnnotatedRPat$fAnnotatedRPatOp$fAnnotatedPXAttr$fAnnotatedPat$fAnnotatedWarningText$fAnnotatedRuleVar$fAnnotatedRule$fAnnotatedActivation$fAnnotatedModulePragma$fAnnotatedCallConv$fAnnotatedSafety$fAnnotatedSplice$fAnnotatedBracket$fAnnotatedXAttr$fAnnotatedXName$fAnnotatedExp$fAnnotatedLiteral$fAnnotatedAsst$fAnnotatedContext$fAnnotatedFunDep$fAnnotatedKind$fAnnotatedTyVarBind$fAnnotatedType$fAnnotatedGuardedRhs$fAnnotatedRhs$fAnnotatedBangType$fAnnotatedInstDecl$fAnnotatedClassDecl$fAnnotatedGadtDecl$fAnnotatedFieldDecl$fAnnotatedConDecl$fAnnotatedQualConDecl$fAnnotatedMatch$fAnnotatedIPBind$fAnnotatedBinds$fAnnotatedInstHead$fAnnotatedDeclHead$fAnnotatedDataOrNew$fAnnotatedAnnotation$fAnnotatedDecl$fAnnotatedDeriving$fAnnotatedAssoc$fAnnotatedImportSpec$fAnnotatedImportSpecList$fAnnotatedImportDecl$fAnnotatedExportSpec$fAnnotatedExportSpecList$fAnnotatedModuleHead$fAnnotatedModule$fAnnotatedCName $fAnnotatedOp$fAnnotatedQOp$fAnnotatedIPName$fAnnotatedName$fAnnotatedQName$fAnnotatedSpecialCon$fAnnotatedModuleName$fFunctorGuardedAlt$fFunctorGuardedAlts $fFunctorAlt$fFunctorFieldUpdate$fFunctorQualStmt $fFunctorStmt$fFunctorPatField $fFunctorRPat$fFunctorRPatOp$fFunctorPXAttr $fFunctorPat$fFunctorWarningText$fFunctorRuleVar $fFunctorRule$fFunctorActivation$fFunctorModulePragma$fFunctorCallConv$fFunctorSafety$fFunctorSplice$fFunctorBracket$fFunctorXAttr$fFunctorXName $fFunctorExp$fFunctorLiteral $fFunctorAsst$fFunctorContext$fFunctorFunDep $fFunctorKind$fFunctorTyVarBind $fFunctorType$fFunctorGuardedRhs $fFunctorRhs$fFunctorBangType$fFunctorInstDecl$fFunctorClassDecl$fFunctorGadtDecl$fFunctorFieldDecl$fFunctorConDecl$fFunctorQualConDecl$fFunctorMatch$fFunctorIPBind$fFunctorBinds$fFunctorDeriving$fFunctorInstHead$fFunctorDeclHead$fFunctorDataOrNew$fFunctorAnnotation $fFunctorDecl$fFunctorAssoc$fFunctorImportSpec$fFunctorImportSpecList$fFunctorImportDecl$fFunctorExportSpec$fFunctorExportSpecList$fFunctorModuleHead$fFunctorModule$fFunctorCName $fFunctorOp $fFunctorQOp$fFunctorIPName $fFunctorName$fFunctorQName$fFunctorSpecialCon$fFunctorModuleNameTyPredBangPat ExplTypeArgXRPatsCAsRPEitherRPGuardRPSeqRPViewPatPreOpPostOpIrrPatWildCardAsPatPAsstPTypePContext ParseXAttr PFieldUpdatePExp p_unit_con p_tuple_conp_unboxed_singleton_con$fAnnotatedPAsst$fFunctorPAsst$fAnnotatedPType$fFunctorPType$fAnnotatedPContext$fFunctorPContext$fAnnotatedParseXAttr$fFunctorParseXAttr$fAnnotatedPFieldUpdate$fFunctorPFieldUpdate $fFunctorPExp$fAnnotatedPExpBool$fExactPIPBind$fExactPFieldDecl$fExactPActivation$fExactPRuleVar $fExactPRule$fExactPSafety$fExactPCallConv $fExactPBinds $fExactPXName$fExactPPXAttr$fExactPRPatOp $fExactPRPat$fExactPPatField $fExactPPat$fExactPGuardedRhs $fExactPRhs $fExactPMatch$fExactPGuardedAlt$fExactPGuardedAlts $fExactPAlt $fExactPXAttr$fExactPBracket$fExactPQualStmt $fExactPStmt$fExactPFieldUpdate $fExactPExp$fExactPSplice$fExactPBangType$fExactPGadtDecl$fExactPConDecl$fExactPQualConDecl$fExactPFunDep$fExactPInstDecl$fExactPClassDecl$fExactPDeriving $fExactPAsst$fExactPContext $fExactPType $fExactPKind$fExactPTyVarBind$fExactPInstHead$fExactPDeclHead$fExactPAnnotation $fExactPDecl$fExactPDataOrNew $fExactPAssoc$fExactPWarningText$fExactPModulePragma$fExactPModuleHead$fExactPModule$fExactPImportDecl$fExactPImportSpec$fExactPImportSpecList$fExactPExportSpecList$fExactPExportSpec $fExactPCName $fExactPOp $fExactPQOp$fExactPIPName $fExactPName $fExactPQName$fExactPSpecialCon$fExactPModuleName$fExactPLiteral $fMonadEPGHC.EnumEnumEnabled isEnabled MExtScheme ExtSchemeAllAny$fEnabledMaybe$fEnabledExtScheme$fEnabledExtension$fAppFixityXAttr$fAppFixitySplice$fAppFixityBracket$fAppFixityQualStmt$fAppFixityGuardedAlt$fAppFixityGuardedAlts$fAppFixityAlt$fAppFixityFieldUpdate$fAppFixityIPBind$fAppFixityBinds$fAppFixityStmt$fAppFixityPXAttr$fAppFixityRPat$fAppFixityPatField$fAppFixityGuardedRhs$fAppFixityRhs$fAppFixityMatch$fAppFixityInstDecl$fAppFixityClassDecl$fAppFixityAnnotation$fAppFixityDecl$fAppFixityModule$fAppFixityPat$fAppFixityExpPdiscard lexNewlinelexTabLexrunL ExtContext CodeTagCtxt CloseTagCtxt ChildCtxtTagCtxtHarpCtxtCodeCtxt LexContextLayoutNoLayoutrunParserWithMode runParserrunParserWithModeCommentsatSrcLoc getSrcLoc getModuleNamepushCurrentContext popContext getExtensionsgetInputlexWhile alternativecheckBOLsetBOL startToken getOffside getSrcLocL setSrcLineL pushContextL popContextL pullCtxtFlagflagDo getExtContextpushExtContextLpopExtContextLgetExtensionsLignoreLinePragmasLsetLineFilenameL pushComment $fMonadLex$fMonadP$fMonoidParseResult$fMonadParseResult$fApplicativeParseResult$fFunctorParseResultRPCAt THIdEscapeTokenEOFKW_CCall KW_StdCall KW_Threadsafe KW_UnsafeKW_Safe KW_Export KW_Foreign KW_QualifiedKW_WhereKW_UsingKW_TypeKW_ThenKW_RecKW_ProcKW_Of KW_NewType KW_ModuleKW_Let KW_Instance KW_InfixR KW_InfixLKW_InfixKW_In KW_ImportKW_If KW_HidingKW_Group KW_Forall KW_FamilyKW_ElseKW_MDoKW_Do KW_Deriving KW_DefaultKW_DataKW_ClassKW_CaseKW_ByKW_AsANNLANGUAGEOPTIONSUNPACKCORE GENERATEDSCCWARNING DEPRECATEDSOURCESPECIALISE_INLINE SPECIALISEINLINE_CONLIKEINLINERULES PragmaEnd XRPatClose XRPatOpenXPCDATA XChildTagOpenXEmptyTagClose XCloseTagOpen XStdTagClose XStdTagOpen XCodeTagClose XCodeTagOpen RPGuardClose RPGuardOpen THQuasiQuote THTyQuote THVarQuote THParenEscape THCloseQuote THTypQuote THDecQuote THPatQuote THExpQuoteRightDblArrowTailLeftDblArrowTailRightArrowTail LeftArrowTailStar ExclamationMinus DoubleArrowTildeAt RightArrow LeftArrowBar BackslashEquals DoubleColonColonDotDotDot BackQuote UnderscoreComma RightSquare LeftSquare VRightCurly RightCurly LeftCurly SemiColon RightCurlyBar LeftCurlyBarRightHashParen LeftHashParen RightParen LeftParen StringHash CharacterHash DoubleTokHash FloatTokHash WordTokHash IntTokHash StringTok CharacterFloatTokIntTokQConSymQVarSymConSymVarSymDVarIdQConIdConId ILinVarId IDupVarIdQVarIdVarIdlexer showToken $fPrettyPType $fPrettyPAsst$fPrettyPContext$fPrettyParseXAttr$fPrettyPFieldUpdate $fPrettyPExp $fPrettyAsst$fPrettyContext $fPrettyCName$fPrettyIPBind$fPrettyIPName $fPrettyName $fPrettyOp $fPrettyQName $fPrettyQOp$fPrettyFieldUpdate$fPrettyQualStmt $fPrettyStmt$fPrettyGuardedAlt$fPrettyGuardedAlts $fPrettyAlt$fPrettyRPatOp $fPrettyRPat$fPrettyPatField$fPrettyPXAttr $fPrettyPat$fPrettySplice$fPrettyBracket $fPrettyXName $fPrettyXAttr $fPrettyExp$fPrettyLiteral$fPrettyGuardedRhs $fPrettyRhs$fPrettyFunDep $fPrettyKind$fPrettyTyVarBind $fPrettyType$fPrettyDeriving$fPrettyBangType$fPrettyFieldDecl$fPrettyConDecl$fPrettyGadtDecl$fPrettyQualConDecl$fPrettyAnnotation$fPrettyModulePragma$fPrettyRuleVar$fPrettyActivation $fPrettyRule$fPrettyCallConv$fPrettySafety$fPrettyInstDecl$fPrettyClassDecl $fPrettyMatch $fPrettyAssoc$fPrettyDataOrNew$fPrettyInstHead$fPrettyDeclHead $fPrettyDecl$fPrettyImportSpec$fPrettyImportSpecList$fPrettyImportDecl$fPrettyExportSpec$fPrettyExportSpecList$fPrettyModuleName$fPrettyWarningText$fPrettyModuleHead$fPrettyModule$fPrettySrcSpan$fPrettySrcLoc $fPrettyAsst0$fPrettySpecialCon$fPrettyCName0$fPrettyIPBind0$fPrettyIPName0 $fPrettyName0 $fPrettyOp0$fPrettyQName0 $fPrettyQOp0$fPrettyFieldUpdate0$fPrettyQualStmt0 $fPrettyStmt0$fPrettyGuardedAlt0$fPrettyGuardedAlts0 $fPrettyAlt0$fPrettyRPatOp0 $fPrettyRPat0$fPrettyPatField0$fPrettyPXAttr0 $fPrettyPat0$fPrettySplice0$fPrettyBracket0$fPrettyXName0$fPrettyXAttr0 $fPrettyExp0$fPrettyLiteral0$fPrettyGuardedRhs0 $fPrettyRhs0$fPrettyFunDep0 $fPrettyKind0$fPrettyTyVarBind0 $fPrettyType0$fPrettyBangType0$fPrettyConDecl0$fPrettyGadtDecl0$fPrettyQualConDecl0 $fPrettyTool$fPrettyModulePragma0$fPrettyRuleVar0$fPrettyActivation0 $fPrettyRule0$fPrettyCallConv0$fPrettySafety0$fPrettyInstDecl0$fPrettyClassDecl0$fPrettyMatch0$fPrettyAssoc0$fPrettyDataOrNew0$fPrettyAnnotation0 $fPrettyDecl0$fPrettyImportSpec0$fPrettyImportDecl0$fPrettyExportSpec0$fPrettyModuleName0$fPrettyModule0 $fMonadDocM $fFunctorDocM splitTyConApp checkEnabledcheckPatternGuards checkPContextcheckAssertion checkContextcheckDataHeadercheckClassHeadercheckInstHeader checkDeriving checkPattern checkRPattern checkExpr checkRuleExprreadTool getGConName checkValDef checkSigVarcheckClassBody checkInstBody checkUnQual checkEqNames checkPrecmkRecConstrOrUpdate checkRevDeclscheckRevClsDeclscheckRevInstDeclscheckDataOrNewcheckDataOrNewGcheckSimpleType checkTypecheckPageModulecheckHybridModulemkDVar mkTyForall parseModulesparseModulesWithModeparseModulesWithComments$fParseableType$fParseableDecl$fParseablePat$fParseableExp$fParseableModule$fParseableStmt$fParseableType0$fParseableDecl0$fParseablePat0$fParseableExp0$fParseableModule0