(`%      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                                                                                                            !"#$portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Inferred3 PAST nodes are annotated, and this class allows manipulation of the annotations. (Retrieve the annotation of an AST node. GChange 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 %. A guarded case alternative | stmts -> exp. The 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 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 then exp an ordinary statement !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. !%a recursive binding group for arrows "local bindings #an exp by itself: in a do -expression, ( an action whose result is discarded; . in a list comprehension and pattern guard,  a guard expression $ a generator: pat <- exp %An fpat in a labeled record pattern. &record field wildcard 'record field pun (ordinary label-pattern pair ) An entity in a regular pattern. *an ordinary pattern +!parenthesised pattern, e.g. (2*) ,!linear variable binding, e.g. foo@(1 | 2) -&non-linear variable binding, e.g. (foo@ :(1 | 2))* .guarded pattern, e.g. (| p | p < 3 |) /%sequence pattern, e.g. (| 1, 2, 3 |) 0choice pattern, e.g. (1 | 2) 1operator pattern, e.g. pat* 2A regular pattern operator. 3?! = 0 or 1, greedy 4? = 0 or 1 5+! = 1 or more, greedy 6+ = 1 or more 7*! = 0 or more, greedy 8* = 0 or more 9An XML attribute in a pattern. ;*A pattern, to be matched against a value. <strict (bang) pattern:  f !x = ... =quasi quote pattern: [$name| string |] >+Explicit generics style type argument e.g. f {| Int |} x = ... ?XML regular list pattern @XML embedded pattern AXML PCDATA pattern BXML singleton element pattern CXML element pattern Dregular list pattern Eview patterns of the form (exp -> pat) Fpattern with type signature Girrefutable pattern: ~pat Hwildcard pattern: _ I@ -pattern Jlabelled pattern, record style Kparenthesized pattern L list pattern Mtuple pattern N'data constructor and argument patterns O'pattern with an infix data constructor P n+k pattern Qnegated pattern Rliteral constant S variable T<Warning text to optionally use in the module header of e.g.  a deprecated module. WBVariables used in a RULES pragma, optionally annotated with types ZThe body of a RULES pragma. \%Activation clause of a RULES pragma. _&Recognised tools for OPTIONS pragmas. f9A top level options pragma, preceding the module header. gANN pragma with module scope hAOPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC iLANGUAGE pragma j3The calling convention of a foreign function call. r'The safety of a foreign function call. sinterruptible tsafe (&) or threadsafe (') uunsafe v%A template haskell splice expression w!parenthesised expression splice: $(exp) xvariable splice: $var y'A template haskell bracket expression. zdeclaration 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. 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 -#A type family instance declaration .A data family declaration /*A data OR newtype declaration, GADT style 0A data OR newtype declaration 1A type family declaration 2A type declaration 3Associativity of an operator. 4*right-associative operator (declared with infixr) 5)left-associative operator (declared with infixl). 6(non-associative operator (declared with infix) 7FAn import specification, representing a single explicit item imported  (or hidden) from a module. 8T(C_1,...,C_n): 1 a class imported with some of its methods, or 6 a datatype imported with some of its constructors. 9T(..): 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. >An import declaration. @/annotation, used by parser for position of the import keyword. Aname of the module imported. B imported  qualified? Cimported with {-# SOURCE #-}? D$imported with explicit package name Eoptional alias name in an as clause. F(optional list of import specifications. GAn item in a module's export specification. Hmodule M:  re-export a module. IT(C_1,...,C_n): 1 a class exported with some of its methods, or 6 a datatype exported with some of its constructors. JT(..): 0 a class exported with all of its methods, or 5 a datatype exported with all of its constructors. KT: , a class or datatype exported abstractly,  or a type synonym. L variable M"An explicit export specification. OCThe head of a module, including the name and export specification. Q"A complete Haskell source module. RBa hybrid module combining an XML document with an ordinary module SYa 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. Tan ordinary Haskell module UA name (cname/) of a component of a class or data type in an import  or export specification. Vname of a data constructor Wname of a method or field XOperators appearing in infix# declarations are never qualified. Yconstructor operator (conop) Zvariable 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 aAThis type is used to represent variables, and also constructors. bvarsym or consym cvarid or conid. d=This type is used to represent qualified variables, and also  qualified constructors. e)built-in constructor with special syntax funqualified local name g"name qualified with a module name h"Constructors with special syntax. F These names are never qualified, and always refer to builtin type or  data constructors. i$unboxed singleton tuple constructor (# #) jlist data constructor (:) kn-ary tuple type and data  constructors (,) etc, possibly boxed (#,#) lfunction type constructor -> mlist type constructor [] nunit type and data constructor () oThe name of a Haskell module. 7Test if two AST elements are equal modulo annotations.   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~QTSROPTVUMNGLKJIH>?@ABCDEF<=7;:983654210/.-,+*)('&%$#"!       $#"!~;SRQPONMLKJIHGFEDCBA@?>=<%('&9:)10/.-,+*2876543opdgfeacb[]\XZYhnmlkjiUWV^`_y}|{zvxwrutsjqponmlkfihg_edcba`Z[WYX\^]qrstuvwxyz{|}~    $#"!%('&)10/.-,+*28765439:;SRQPONMLKJIHGFEDCBA@?>=<TVUWYXZ[\^]_edcba`fihgjqponmlkrutsvxwy}|{z~.       210/.-,+*)('&%$#"! 36547;:98<=>?@ABCDEFGLKJIHMNOPQTSRUWVXZY[]\^`_acbdgfehnmlkjiopqrstuvwxyz{|}~()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred?"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     \ 7     portable experimental$Niklas Broberg, d00nibro@chalmers.se Safe-Inferred11An 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 # 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. !An unguarded righthand side of a case alternative. )An list of guarded righthand sides for a case alternative. &A single guarded righthand side for a case alternative. 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. 1..1portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Inferred?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  7Optionally combine the first argument with the second, 4 or return it unchanged if the second argument is . 7Optionally combine the second argument with the first, 3 or return it unchanged if the first argument is . 8Add more positional information for entities of a span.  Merge two s and lift them to a  SrcInfoSpan with + no positional information for entities. -** Safe-InferredA Haskell comment. The  is '$ if the comment is multi-line, i.e. {- -}. portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-InferredOPrint an AST exactly as specified by the annotations on the nodes in the tree. u !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~s !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~portable transient*Niklas Broberg, niklas.broberg@chalmers.se Safe-InferredY GHC  8.1.5 Enable the capi calling convention in the  foreign function interface.  GHC  8.1.4 Enable interruptible FFI. &Enable non-decreasing indentation for 'do' blocks. Enable deriving for the Data.Foldable.Foldable class. Enable deriving for the Data.Traversable.Traversable class. Enable deriving for the Data.Functor.Functor class. Local (let and where) bindings are monomorphic. 0Allow contexts to be put on datatypes, e.g. the Eq a in  /data Eq a => Set a = NilSet | ConsSet a (Set a). Make forall3 a keyword in types, which can be used to give the  generalisation explicitly. ?Makes much of the Haskell sugar be desugared into calls to the 3 function with a particular name that is in scope. Improve the layout rule when if expressions are used in a do  block. !Support for patterns of the form n + k, where k is an  integer literal. BAllows GHC primops, written in C--, to be imported into a Haskell  file. (Enables the use of tuple sections, e.g. (, True) desugars into  x -> (x, True). ?Allow regular pattern matching over lists, as discussed in the  paper "Regular Expression Patterns"" by Niklas Broberg, Andreas Farre # and Josef Svenningsson, from ICFP '04. BAllow concrete XML syntax to be used in expressions and patterns, 5 as per the Haskell Server Pages extension language:   &http://www.haskell.org/haskellwiki/HSP. The ideas behind it are  discussed in the paper ",Haskell Server Pages through Dynamic Loading" * by Niklas Broberg, from Haskell Workshop '05.  GHC  7.3.6. Enable view patterns, which match a value by 1 applying a function and matching on the result.  GHC  7.3.10) Enable generalized list comprehensions, 5 supporting operations such as sorting and grouping.  GHC  7.9.52 Enable quasi-quotation, a mechanism for defining 3 new concrete syntax for expressions and patterns.  GHC  7.3.12+ Relax the interpretation of left operator , sections to allow unary postfix operators.  GHC  7.3.3' Change the syntax for qualified infix  operators.  GHC  7.8.6/ Deprecated in GHC 6.12 and will be removed in 7 GHC 7. Allow a type variable to be instantiated at a  polymorphic type.   GHC  7.3.18. Allow imports to be qualified by the package 7 name the module is intended to be imported from, e.g. ! import "network" Network.Socket  GHC  7.6.1.3 Allow a class method's type to place 2 additional constraints on a class type variable.  GHC  7.5.3 Enable deriving for classes  Data.Typeable.Typeable and Data.Generics.Data.  GHC  7.2.2 Enable unboxed tuples.  GHC  2.4.5, Allow default instantiation of polymorphic  types in more situations.  GHC  7.8.8. Relax the requirements on mutually-recursive  polymorphic functions.  GHC  7.17.2$ Make pattern bindings monomorphic.  GHC  7.4.6- Enable generalized algebraic data types, in ? which type variables may be instantiated on a per-constructor  basis. Implies GADTSyntax.  GHC  7.6.4/ Enable overloading of string literals using a ) type class, much like integer literals.  GHC  7.3.14/ Allow a record field name to be disambiguated  by the type of the record it's in. Deprecated, use $ instead.  GHC  7.3.162 Enable syntax for implicitly binding local names A corresponding to the field names of a record. A wildcard binds  all unmentioned names, unlike $.  GHC  7.4.23 Allow the name of a type constructor, type class, + or type variable to be an infix operator.  GHC  7.4.3. Defer validity checking of types until after C expanding type synonyms, relaxing the constraints on how synonyms  may be used.  GHC  8.1.12 Allow the use of unboxed types as foreign types,  e.g. in foreign import and foreign export.  GHC  7.3.1/ Allow certain Unicode characters to stand for C certain ASCII character sequences, e.g. keywords and punctuation.  GHC  7.5.22 Allow a standalone declaration which invokes the  type class deriving mechanism.  GHC  7.7. Allow data types and type synonyms which are 7 indexed by types, i.e. ad-hoc polymorphism for types.  GHC  7.3.2 Allow the character # as a postfix modifier on ? identifiers. Also enables literal syntax for unboxed values.  Hugs  7.31 Enable an alternate syntax for string literals,  with string templating.  Hugs  7.2/ Enable type synonyms which are transparent in B some definitions and opaque elsewhere, as a way of implementing  abstract datatypes. ! Hugs  7.1 Enable the "Trex" extensible records system. " GHC  7.5.4 Allow a type declared with newtype to use  deriving9 for any class with an instance for the underlying type. # GHC  7.3.54 Enable a form of guard which matches a pattern and  binds variables. $ GHC  7.3.152 Enable syntax for implicitly binding local names C corresponding to the field names of a record. Puns bind specific  names, unlike . % GHC  7.3.11- Enable the implicit importing of the module  Prelude:. When disabled, when desugaring certain built-in syntax E into ordinary identifiers, use whatever is in scope rather than the  Prelude -- version. & GHC  7.165 Enable generic type classes, with default instances 8 defined in terms of the algebraic structure of a type. ' GHC  7.10 Enable arrow notation. ( GHC  81 Enable the Foreign Function Interface. In GHC, ? implements the standard Haskell 98 Foreign Function Interface . Addendum, plus some GHC-specific extensions. ) GHC  7.94 Enable Template Haskell, a system for compile-time  metaprogramming. * GHC  7.6.3.1( Allow type synonyms in instance heads. + GHC  7.112 Enable a form of pattern which forces evaluation 1 before an attempted match, and a form of strict let/where  binding. , GHC  7.8.45 Allow an explicit kind signature giving the kind of * types over which a type variable ranges. - GHC  4.10.30 Run the C preprocessor on Haskell source code. . GHC  7.4.14 Allow data type declarations with no constructors. / GHC  7.6.3.2, Relax some restrictions on the form of the % context of an instance declaration. 0 GHC  7.8.24 Relax some restrictions on the form of the context  of a type signature. 1 GHC  7.8.32 Enable implicit function parameters with dynamic  scope. 2Deprecated, use 3 instead. 3 GHC  7.8.74 Cause a type variable in a signature, which has an  explicit forall1 quantifier, to scope over the definition of the ! accompanying value declaration. 4 GHC  7.4.43 Allow existentially-quantified data constructors. 5 GHC  7.8.5- Allow data constructors to have polymorphic  arguments. Unlike 6#, does not allow this for ordinary  functions. 6 GHC  7.8.51 Allow a universally-quantified type to occur on  the left of a function arrow. 7 GHC  7.8.5 Like 6 but does not allow a = higher-rank type to itself appear on the left of a function  arrow. 8 GHC  7.6.2% Allow a specification attached to a A multi-parameter type class which indicates that some parameters B are entirely determined by others. The implementation will check C that this property holds for the declared instances, and will use ; this property to reduce ambiguity in instance resolution. 9 GHC  7.17. Enable the dreaded monomorphism restriction. : GHC  7.6.1.1, Allow multiple parameters in a type class. ; GHC  7.3.9! Provide syntax for writing list @ comprehensions which iterate over several lists together, like  the  family of functions. < GHC  7.3.8.2/ Deprecated in GHC. Allows recursive bindings  using mdo, a variant of do. DoRec provides a different,  preferred syntax. = GHC  7.6.3.4 Implies ? . Allow the ? implementation to choose an instance even when it is possible B that further instantiation of types will lead to a more specific  instance being applicable. > GHC  7.6.3.3* Ignore structural rules guaranteeing the ; termination of class instance resolution. Termination is > guaranteed by a fixed-depth recursion stack, and compilation % may fail if this depth is exceeded. ? GHC  7.6.3.4$ Allow overlapping class instances, A provided there is a unique most specific instance for each use. @2This represents language extensions beyond a base D definition  (such as H6) that are supported by some implementations, usually  in some special mode. A4An unknown extension, identified by the name of its LANGUAGE  pragma. BDisable a known extension CEnable a known extension E-An unknown language, identified by its name. F=The minimal language resulting from disabling all recognized A extensions - including ones that are part of all known language + definitions e.g. MonomorphismRestriction. GAThe Haskell 2010 language as defined by the Haskell 2010 report.   /http://www.haskell.org/onlinereport/haskell2010 H=The Haskell 98 language as defined by the Haskell 98 report.   http://haskell.org/onlinereport/ L=Certain extensions imply other extensions, and this function @ makes the implication explicit. This also handles deprecated / extensions, which imply their replacements. ; The returned value is the transitive closure of implied  extensions. M"The list of extensions enabled by  GHC'#s portmanteau -fglasgow-exts flag. O+List of all known extensions, all enabled. PCExtensions that have been deprecated, possibly paired with another  extension that replaces it. Q)A clever version of read that returns an A $ if the string is not recognised. R0Parse an enabled or disabled extension; returns  A if the parse fails. SAPretty print an extension. Disabled extensions are prefixed with  'No'. d      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST`      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST`DHGFEIJK@CBA?>=<;:9876543210/.-,+*)('&%$#"!      QRSNMOPLTJ?>=<;:9876543210/.-,+*)('&%$#"!      @CBADHGFEIJKLMNOPQRSTportablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Inferred portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Inferred"UA guarded case alternative | stmts -> exp. WThe right-hand sides of a case alternative, . which may be a single right-hand side or a  set of guarded ones. Xgdpat Y-> exp ZAn alt alternative in a case expression. \An fbind1 in a labeled construction or update expression. ]record 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. athen group by exp using exp bthen group using exp cthen group by exp dthen exp by exp ethen exp fan ordinary statement g!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. h%a recursive binding group for arrows ilocal bindings jan exp by itself: in a do -expression, ( an action whose result is discarded; . in a list comprehension and pattern guard,  a guard expression k a generator: pat <- exp lAn fpat in a labeled record pattern. mrecord field wildcard nrecord field pun oordinary label-pattern pair p An entity in a regular pattern. qan ordinary pattern r!parenthesised pattern, e.g. (2*) s!linear variable binding, e.g. foo@(1 | 2) t&non-linear variable binding, e.g. (foo@ :(1 | 2))* uguarded pattern, e.g. (| p | p < 3 |) v%sequence pattern, e.g. (| 1, 2, 3 |) wchoice pattern, e.g. (1 | 2) xoperator pattern, e.g. pat* yA regular pattern operator. z?! = 0 or 1, greedy {? = 0 or 1 |+! = 1 or more, greedy }+ = 1 or more ~*! = 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 |] +Explicit generics style type argument e.g. f {| Int |} x = ... XML regular list pattern XML embedded pattern XML PCDATA pattern XML singleton element pattern XML element pattern regular list pattern view patterns of the form (exp -> pat) pattern with type signature irrefutable pattern: ~pat wildcard pattern: _ @ -pattern labelled pattern, record style parenthesized pattern  list pattern tuple pattern 'data constructor and argument patterns 'pattern with an infix data constructor  n+k pattern negated 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. 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. interruptible safe (&) or threadsafe (') 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. 0record constructor 1infix data constructor 2ordinary data constructor 3AA single constructor declaration within a data type declaration, 9 which may have an existential quantification binding. 5Clauses of a function binding. 7$A binding of an implicit parameter. 9A 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. A#An annotation for a declared type. B#An annotation for a declared name. CA top-level declaration. DAn ANN pragma EA SPECIALISE instance pragma FA SPECIALISE INLINE pragma GA SPECIALISE pragma HAn INLINE CONLIKE pragma IAn INLINE pragma JA WARNING pragma KA DEPRECATED pragma LA RULES pragma MA foreign export declaration NA foreign import declaration OA pattern binding P"A set of function binding clauses QA type signature declaration R(A Template Haskell splicing declaration SA declaration of default types T!A declaration of operator fixity U"A standalone deriving declaration V(An declaration of a type class instance WA declaration of a type class X/A data family instance declaration, GADT style Y#A data family instance declaration Z#A type family instance declaration [A data family declaration \*A data OR newtype declaration, GADT style ]A data OR newtype declaration ^A type family declaration _A type declaration `LA single derived instance, which may have arguments since it may be a MPTC. aAssociativity of an operator. b*right-associative operator (declared with infixr) c)left-associative operator (declared with infixl). d(non-associative operator (declared with infix) eFAn import specification, representing a single explicit item imported  (or hidden) from a module. fT(C_1,...,C_n): 1 a class imported with some of its methods, or 6 a datatype imported with some of its constructors. gT(..): 0 a class imported with all of its methods, or 5 a datatype imported with all of its constructors. hT: 2 the name of a class, datatype or type synonym. i variable jAn import declaration. lposition of the import keyword. mname of the module imported. n imported  qualified? oimported with {-# SOURCE #-}? p$imported with explicit package name qoptional alias name in an as clause. r(optional list of import specifications.  The  is ' if the names are excluded  by hiding. sAn item in a module's export specification. tmodule M:  re-export a module. uT(C_1,...,C_n): 1 a class exported with some of its methods, or 6 a datatype exported with some of its constructors. vT(..): 0 a class exported with all of its methods, or 5 a datatype exported with all of its constructors. wT: , a class or datatype exported abstractly,  or a type synonym. x variable y"A complete Haskell source module. {A name (cname/) of a component of a class or data type in an import  or export specification. |name of a data constructor }name 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. iUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~x_`abcdeUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~xyzsxwvutjklmnopqreihgfadcbC_^]\[ZYXWVUTSRQPONMLKJIHGFED9;:78(,+*)#'&%$`<>=/21034-."! 56     gkjih`fedcba\_^]Z[WYXUVlonmpxwvutsrqy~}|{z~{}|_edcba`?BA@aUVWYXZ[\_^]`fedcbagkjihlonmpxwvutsrqy~}|{z.       "! #'&%$(,+*)-./2103456789;:<>=?BA@C_^]\[ZYXWVUTSRQPONMLKJIHGFED`adcbeihgfjklmnopqrsxwvutyz{}|~ portable experimental$Niklas Broberg, d00nibro@chalmers.se Safe-Inferred11An 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 j 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. !An unguarded righthand side of a case alternative. )An list of guarded righthand sides for a case alternative. &A single guarded righthand side for a case alternative. 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. 1..1 portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Inferred@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). !Built-in fixity for prefix minus %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-InferredMonad 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 &. 'original name of the file being parsed ,base language (e.g. Haskell98, Haskell2010) 'list of extensions enabled for parsing if ', the parser won' t care about further extensions ' in LANGUAGE pragmas in source files if ', 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. Y:<portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-InferredL) S]       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~,'~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!            !"#$%&'()*+, portablestable*Niklas Broberg, niklas.broberg@chalmers.se Safe-Inferred8Lex a string into a list of Haskell 2010 source tokens. KLex a string into a list of Haskell source tokens, using an explicit mode.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!       portable experimental$Niklas Broberg, d00nibro@chalmers.se Safe-InferredDTranslate 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-InferredGThings that can be pretty-printed, including all the syntactic objects  in Language.Haskell.Exts.Syntax and &Language.Haskell.Exts.Annotated.Syntax. -%Pretty-print something in isolation. .0Pretty-print something in a precedence context. /;The document type produced by these pretty printers uses a   environment. 0Pretty printing monad 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. 11render the document with a given style and mode. 2'render the document with a given mode. 3render the document with . *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 . -./0456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a123bcdefghijklmnopqrstuvwxyz{|}~     ! !  -./04 56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a123bcdefghijklmnopqrstuvwxyz{|}~     portablestable$Niklas Broberg, d00nibro@chalmers.se Safe-InferredC !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSv!#$*/78:;=>?ABCDEFGHIJKPQRSC !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSportablestable$Niklas Broberg, d00nibro@chalmers.se Safe-Inferred@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. TUVWXYZ[\]^_`abcdefghijklmnopqrs  !TUVWXYZ[\]^_`abcdefghijklmnopqrsportablestable$Niklas Broberg, d00nibro@chalmers.seNoneCParse 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. HParse of a string containing a Haskell pattern, using an explicit mode. dParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. >Parse of a string containing a Haskell top-level declaration. VParse of a string containing a Haskell top-level declaration, using an explicit mode. dParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. -Parse of a string containing a Haskell type. EParse 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. 2Parse of a string containing a Haskell statement. EParse 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. tNPartial parse of a string starting with a series of top-level option pragmas. uCParse of a string, which should contain a complete Haskell module. vPParse of a string containing a complete Haskell module, using an explicit mode. wdParse of a string containing a complete Haskell module, using an explicit mode, retaining comments. xyz{|}~                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=tuvw>?@ABCDEFGHIJKLMNOPQR#tuvwxyz{|}~                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=tuvw>?@ABCDEFGHIJKLMNOPQR portablestable*Niklas Broberg, niklas.broberg@chalmers.seNone;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. 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. HParse of a string containing a Haskell pattern, using an explicit mode.  dParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.  >Parse of a string containing a Haskell top-level declaration.  VParse of a string containing a Haskell top-level declaration, using an explicit mode.  dParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.  -Parse of a string containing a Haskell type. EParse 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. -Parse of a string containing a Haskell type. EParse 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. "     STUVWXYZ[\]$     $          STUVWXYZ[\]portablestable$Niklas Broberg, d00nibro@chalmers.seNone;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. @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. =Parse a source file from a string using a custom parse mode. 3Gather the extensions declared in LANGUAGE pragmas # at the top of the file. Returns  if the  parse of the pragmas fails. ^_/  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ^_portablestable$Niklas Broberg, d00nibro@chalmers.seNone ;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. "=Parse a source file from a string using a custom parse mode. #TParse a source file from a string using a custom parse mode and retaining comments. $3Gather the extensions declared in LANGUAGE pragmas # at the top of the file. Returns  if the  parse of the pragmas fails.  !"#$`a _`abcde      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$  "!#$  !"#$`ab !"#$%&&''())*+,*-./012-3456789:;<=>?@ABCDEFGHIJKLLMNOPQRSTUVWXYZ[\]^_`abcdefghijikklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>>??@ABCDEFGHIJKLMMNNOPQORSTUVWXYZ[\]^_`abcdefghijkllmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK&&''())*+,*-./012-3456789:;<=>?@ABCDEFGHIJKLLMNOPQRSTUVWXYZ[\]^_`abcdefghijikklmnLvwxyz{|}~  !"#$%&'()*+,-./01234 56789:;<=??MABCDEFGHIJKLOORSTUVWXYZ[\]^_`abcdefghijkllmnopqrstuvwxyz{|}~                                               N O P P Q R S T U VWWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                  ! " # $ % & ' ( ) * + , - . / 0 1233456789:;<=>?@ABCDEFNOGHIJKLMNOPQRSTUVWX Y Z [ \ ] G H I J K L M N O P Q R S T U V W X^_`abcdef^_`abcdefghijkljkmnopqrstuvwxyz{|}~+,*     gjk !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~g                                        !"#$%&'()*+,-./0-123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx@Ayz{7|}4~     ? !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL]MNOPQRRST  UVVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                                                                                                                                             Q                      ! " # $ % & ' ( ) * + , - . / 0 1 2 1 2 3haskell-src-exts-1.14.0Language.Haskell.Exts.Pretty&Language.Haskell.Exts.Annotated.Syntax%Language.Haskell.Exts.Annotated.BuildLanguage.Haskell.Exts.SrcLocLanguage.Haskell.Exts.Comments*Language.Haskell.Exts.Annotated.ExactPrintLanguage.Haskell.Exts.ExtensionLanguage.Haskell.Exts.SyntaxLanguage.Haskell.Exts.BuildLanguage.Haskell.Exts.FixityLanguage.Haskell.Exts.ParserLanguage.Haskell.Exts.Lexer(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.ParseMonad#Language.Haskell.Exts.InternalLexer Language.Haskell.Exts.ParseUtils$Language.Haskell.Exts.InternalParserpretty-1.1.1.0Text.PrettyPrint.HughesPJstyleribbonsPerLine lineLengthmodeStylePageMode ZigZagModeLeftMode OneLineModeMode 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 OptionsPragmaLanguagePragmaCallConvCApiJsJvmDotNet CPlusPlusCCallStdCallSafetyPlayInterruptiblePlaySafe 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_namecplusplus_name dotnet_namejvm_namejs_name forall_name family_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 metaConPatSrcInfo toSrcInfo fromSrcInfo getPointLocfileName startLine startColumn SrcSpanInfo srcInfoSpan srcInfoPointsLoclocunLocSrcSpansrcSpanFilenamesrcSpanStartLinesrcSpanStartColumnsrcSpanEndLinesrcSpanEndColumnSrcLoc srcFilenamesrcLine srcColumnnoLoc srcSpanStart srcSpanEnd mkSrcSpan mergeSrcSpan isNullSpanspanSize noInfoSpaninfoSpan combSpanInfo<++><+?><**<^^>CommentExactP exactPrintKnownExtensionCApiFFIInterruptibleFFINondecreasingIndentationDeriveFoldableDeriveTraversable DeriveFunctorMonoLocalBindsDatatypeContextsExplicitForAllRebindableSyntaxDoAndIfThenElseNPlusKPatternsGHCForeignImportPrim TupleSectionsRegularPatterns XmlSyntax ViewPatternsTransformListComp QuasiQuotesPostfixOperatorsNewQualifiedOperatorsImpredicativeTypesPackageImportsConstrainedClassMethodsDeriveDataTypeable UnboxedTuplesExtendedDefaultRulesRelaxedPolyRec MonoPatBindsGADTsOverloadedStringsDisambiguateRecordFields RecordPunsRecordWildCards TypeOperatorsLiberalTypeSynonymsUnliftedFFITypes UnicodeSyntaxStandaloneDeriving TypeFamilies MagicHash HereDocumentsRestrictedTypeSynonymsExtensibleRecordsGeneralizedNewtypeDeriving PatternGuardsNamedFieldPunsImplicitPreludeGenericsArrowsForeignFunctionInterfaceTemplateHaskellTypeSynonymInstances BangPatternsKindSignaturesCPPEmptyDataDeclsFlexibleInstancesFlexibleContextsImplicitParamsPatternSignaturesScopedTypeVariablesExistentialQuantificationPolymorphicComponents RankNTypes Rank2TypesFunctionalDependenciesMonomorphismRestrictionMultiParamTypeClassesParallelListComp RecursiveDoIncoherentInstancesUndecidableInstancesOverlappingInstances ExtensionUnknownExtensionDisableExtensionEnableExtensionLanguageUnknownLanguageHaskellAllDisabled Haskell2010 Haskell98knownLanguagesclassifyLanguageprettyLanguage impliesExts glasgowExts ghcDefaultknownExtensionsdeprecatedExtensionsclassifyExtensionparseExtensionprettyExtensiontoExtensionList AlwaysActive importLoc AppFixity applyFixitiesFixityprefixMinusFixitypreludeFixities baseFixitiesinfixr_infixl_infix_ ParseMode parseFilename baseLanguage extensionsignoreLanguagePragmasignoreLinePragmasfixities ParseResult ParseFailedParseOkfromParseResultdefaultParseModeTokenEOFKW_CApiKW_JsKW_Jvm KW_DotNet KW_CPlusPlusKW_CCall KW_StdCallKW_Interruptible 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 XCodeTagOpenRPCAt RPGuardClose RPGuardOpen THQuasiQuote THTyQuote THVarQuote THParenEscape THIdEscape 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 IDupVarIdQVarIdVarIdlexTokenStreamlexTokenStreamWithModesModulesDecl 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 parseFileparseFileWithExtsparseFileWithModeparseFileWithCommentsparseFileContentsparseFileContentsWithExtsparseFileContentsWithModeparseFileContentsWithCommentsreadExtensionsbaseGHC.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$fAnnotatedPExpunGAltgAltsgAlt Data.MaybeNothing$fSrcInfoSrcSpanInfo$fSrcInfoSrcSpan$fSrcInfoSrcLocBoolexactPEPPosposrunEPgetPossetPos printString getComment dropCommentnewLinepadUntilmPrintComments printCommentprintWhitespace printStringAterrorEPexactPCprintSeq printStrs printPointsprintInterleavedprintInterleaved' printStreams interleavemaybeEP bracketListpListpList' parenList squareList curlyList parenHashList layoutListlListlList' printSemiisSymbolgetName specialNameepQName epInfixQNameepName epInfixNameprintWarndeprs sepFunBindssepClassFunBindssepInstFunBinds printContext$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.ListzipWithallLangDefaultclassifyKnownExtensionknownExtensionTablereadMayEnabled isEnabled MExtScheme ExtSchemeAllAny$fEnabledMaybe$fEnabledExtScheme$fEnabledKnownExtension askFixity askFixityPaskFixfixity appFixDeclsleafFixleafFixP$fAppFixityXAttr$fAppFixitySplice$fAppFixityBracket$fAppFixityQualStmt$fAppFixityGuardedAlt$fAppFixityGuardedAlts$fAppFixityAlt$fAppFixityFieldUpdate$fAppFixityIPBind$fAppFixityBinds$fAppFixityStmt$fAppFixityPXAttr$fAppFixityRPat$fAppFixityPatField$fAppFixityGuardedRhs$fAppFixityRhs$fAppFixityMatch$fAppFixityInstDecl$fAppFixityClassDecl$fAppFixityAnnotation$fAppFixityDecl$fAppFixityModule$fAppFixityPat$fAppFixityExpPdiscard lexNewlinelexTabLexrunLrunPInternalParseMode IParseModeiParseFilename iExtensionsiIgnoreLanguagePragmasiIgnoreLinePragmas iFixities ParseStateCtxtFlag ExtContext CodeTagCtxt CloseTagCtxt ChildCtxtTagCtxtHarpCtxtCodeCtxt LexContextLayoutNoLayout ParseStatusFailedOkindentOfParseStatetoInternalParseModerunParserWithMode runParserrunParserWithModeCommentsatSrcLoc getSrcLoc getModuleNamepushCurrentContext currentIndent pushContext popContextpushExtContext popExtContext getExtensions pushCtxtFlag pullDoStatusgetInputnextTab tAB_LENGTHlexWhile alternativecheckBOLsetBOL startToken getOffside getSrcLocL setSrcLineL pushContextL popContextL pullCtxtFlagflagDo getExtContextpushExtContextLpopExtContextLgetExtensionsLignoreLinePragmasLsetLineFilenameL pushComment $fMonadLex$fMonadP$fMonoidParseResult$fMonadParseResult$fApplicativeParseResult$fFunctorParseResult reserved_opsspecial_varops reserved_idsspecial_varidspragmasisIdent isHSymbol matchCharlexertopLexer lexWhiteSpaceisRecognisedPragma isLinePragma lexLinePragmalexNestedCommentlexBOLlexToken lexChildCtxt lexPCDATAlexCodeTagCtxtlexCloseTagCtxt lexTagCtxt lexHarpToken lexStdTokenlexPragmaStart lexRawPragmalexDecimalOrFloatlexHashlexConIdOrQual lexCharacter lexString lexEscapelexOctallexHexadecimal lexDecimal parseIntegerflagKW showTokenpretty prettyPrecDocDocMrenderStyleModerenderWithModerenderthenDocM then_DocMretDocMunDocMgetPPEnvemptynesttextptextcharintintegerfloatdoublerationalparensbracketsbracesquotes doubleQuotesparensIfsemicommacolonspaceequalslparenrparenlbrackrbracklbracerbrace<><+>$$$+$hcathsepvcatsepcatfsepfcathang punctuatefullRenderWithMode fullRenderppModuleHeader ppWarnTxtppWhereppSig ppWarnDepr ppRuleVarsppField ppDerivingppBTypeppAType prec_btype prec_atypeppForall ppOptKind ppFunDepsppLetExpppWith withIndent ppBracket ppLetStmt ppQNameInfixppQName ppNameInfixppName isSymbolName ppContext colonFollowmaybePP hashParenList braceList flatBlock prettyBlock blanklinetopLevelppBody$$$mySepmyVcat myFsepSimplemyFsep layoutChoicemarkLine $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 $fFunctorDocMSL splitTyConApp checkEnabledcheckPatternGuards checkPContextcheckAssertion checkSContext checkContext checkAsstcheckAsstParamcheckDataHeadercheckClassHeader checkSimple mkTyVarBindcheckInstHeader checkInsts checkDeriving checkPatterncheckPat splitBang checkPatField checkPAttrpatFail checkRPattern checkRPatOprpOpFail fixRPOpPrec mkChildrenPat checkExpr checkAttrcheckDo check1Expr check2Exprs check3ExprscheckManyExprs mCheckExpr checkRuleExprreadTool checkField getGConName checkValDefisFunLhs checkSigVarcheckClassBody checkInstBodycheckMethodDef checkUnQual checkEqNames checkPrecmkRecConstrOrUpdate checkRevDeclscheckRevClsDeclscheckRevInstDeclscheckDataOrNewcheckDataOrNewGcheckSimpleType checkTypecheckT check1Type check2Types checkTypescheckPageModulecheckHybridModulemkDVar mkTyForall getFixities getFixity parseModulesparseModulesWithModeparseModulesWithComments HappyAddrHappyA#HappyStk Happy_IntList HappyConsHappyAny HappyAbsSyn happyIn11 happyOut11 happyIn12 happyOut12 happyIn13 happyOut13 happyIn14 happyOut14 happyIn15 happyOut15 happyIn16 happyOut16 happyIn17 happyOut17 happyIn18 happyOut18 happyIn19 happyOut19 happyIn20 happyOut20 happyIn21 happyOut21 happyIn22 happyOut22 happyIn23 happyOut23 happyIn24 happyOut24 happyIn25 happyOut25 happyIn26 happyOut26 happyIn27 happyOut27 happyIn28 happyOut28 happyIn29 happyOut29 happyIn30 happyOut30 happyIn31 happyOut31 happyIn32 happyOut32 happyIn33 happyOut33 happyIn34 happyOut34 happyIn35 happyOut35 happyIn36 happyOut36 happyIn37 happyOut37 happyIn38 happyOut38 happyIn39 happyOut39 happyIn40 happyOut40 happyIn41 happyOut41 happyIn42 happyOut42 happyIn43 happyOut43 happyIn44 happyOut44 happyIn45 happyOut45 happyIn46 happyOut46 happyIn47 happyOut47 happyIn48 happyOut48 happyIn49 happyOut49 happyIn50 happyOut50 happyIn51 happyOut51 happyIn52 happyOut52 happyIn53 happyOut53 happyIn54 happyOut54 happyIn55 happyOut55 happyIn56 happyOut56 happyIn57 happyOut57 happyIn58 happyOut58 happyIn59 happyOut59 happyIn60 happyOut60 happyIn61 happyOut61 happyIn62 happyOut62 happyIn63 happyOut63 happyIn64 happyOut64 happyIn65 happyOut65 happyIn66 happyOut66 happyIn67 happyOut67 happyIn68 happyOut68 happyIn69 happyOut69 happyIn70 happyOut70 happyIn71 happyOut71 happyIn72 happyOut72 happyIn73 happyOut73 happyIn74 happyOut74 happyIn75 happyOut75 happyIn76 happyOut76 happyIn77 happyOut77 happyIn78 happyOut78 happyIn79 happyOut79 happyIn80 happyOut80 happyIn81 happyOut81 happyIn82 happyOut82 happyIn83 happyOut83 happyIn84 happyOut84 happyIn85 happyOut85 happyIn86 happyOut86 happyIn87 happyOut87 happyIn88 happyOut88 happyIn89 happyOut89 happyIn90 happyOut90 happyIn91 happyOut91 happyIn92 happyOut92 happyIn93 happyOut93 happyIn94 happyOut94 happyIn95 happyOut95 happyIn96 happyOut96 happyIn97 happyOut97 happyIn98 happyOut98 happyIn99 happyOut99 happyIn100 happyOut100 happyIn101 happyOut101 happyIn102 happyOut102 happyIn103 happyOut103 happyIn104 happyOut104 happyIn105 happyOut105 happyIn106 happyOut106 happyIn107 happyOut107 happyIn108 happyOut108 happyIn109 happyOut109 happyIn110 happyOut110 happyIn111 happyOut111 happyIn112 happyOut112 happyIn113 happyOut113 happyIn114 happyOut114 happyIn115 happyOut115 happyIn116 happyOut116 happyIn117 happyOut117 happyIn118 happyOut118 happyIn119 happyOut119 happyIn120 happyOut120 happyIn121 happyOut121 happyIn122 happyOut122 happyIn123 happyOut123 happyIn124 happyOut124 happyIn125 happyOut125 happyIn126 happyOut126 happyIn127 happyOut127 happyIn128 happyOut128 happyIn129 happyOut129 happyIn130 happyOut130 happyIn131 happyOut131 happyIn132 happyOut132 happyIn133 happyOut133 happyIn134 happyOut134 happyIn135 happyOut135 happyIn136 happyOut136 happyIn137 happyOut137 happyIn138 happyOut138 happyIn139 happyOut139 happyIn140 happyOut140 happyIn141 happyOut141 happyIn142 happyOut142 happyIn143 happyOut143 happyIn144 happyOut144 happyIn145 happyOut145 happyIn146 happyOut146 happyIn147 happyOut147 happyIn148 happyOut148 happyIn149 happyOut149 happyIn150 happyOut150 happyIn151 happyOut151 happyIn152 happyOut152 happyIn153 happyOut153 happyIn154 happyOut154 happyIn155 happyOut155 happyIn156 happyOut156 happyIn157 happyOut157 happyIn158 happyOut158 happyIn159 happyOut159 happyIn160 happyOut160 happyIn161 happyOut161 happyIn162 happyOut162 happyIn163 happyOut163 happyIn164 happyOut164 happyIn165 happyOut165 happyIn166 happyOut166 happyIn167 happyOut167 happyIn168 happyOut168 happyIn169 happyOut169 happyIn170 happyOut170 happyIn171 happyOut171 happyIn172 happyOut172 happyIn173 happyOut173 happyIn174 happyOut174 happyIn175 happyOut175 happyIn176 happyOut176 happyIn177 happyOut177 happyIn178 happyOut178 happyIn179 happyOut179 happyIn180 happyOut180 happyIn181 happyOut181 happyIn182 happyOut182 happyIn183 happyOut183 happyIn184 happyOut184 happyIn185 happyOut185 happyIn186 happyOut186 happyIn187 happyOut187 happyIn188 happyOut188 happyIn189 happyOut189 happyIn190 happyOut190 happyIn191 happyOut191 happyIn192 happyOut192 happyIn193 happyOut193 happyIn194 happyOut194 happyIn195 happyOut195 happyIn196 happyOut196 happyIn197 happyOut197 happyIn198 happyOut198 happyIn199 happyOut199 happyIn200 happyOut200 happyIn201 happyOut201 happyIn202 happyOut202 happyIn203 happyOut203 happyIn204 happyOut204 happyIn205 happyOut205 happyIn206 happyOut206 happyIn207 happyOut207 happyIn208 happyOut208 happyIn209 happyOut209 happyIn210 happyOut210 happyIn211 happyOut211 happyIn212 happyOut212 happyIn213 happyOut213 happyIn214 happyOut214 happyIn215 happyOut215 happyIn216 happyOut216 happyIn217 happyOut217 happyIn218 happyOut218 happyIn219 happyOut219 happyIn220 happyOut220 happyIn221 happyOut221 happyIn222 happyOut222 happyIn223 happyOut223 happyIn224 happyOut224 happyIn225 happyOut225 happyIn226 happyOut226 happyIn227 happyOut227 happyIn228 happyOut228 happyIn229 happyOut229 happyIn230 happyOut230 happyIn231 happyOut231 happyIn232 happyOut232 happyIn233 happyOut233 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nonterms happyReduce_8happyReduction_8 happyReduce_9happyReduction_9happyReduce_10happyReduction_10happyReduce_11happyReduction_11happyReduce_12happyReduction_12happyReduce_13happyReduction_13happyReduce_14happyReduction_14happyReduce_15happyReduction_15happyReduce_16happyReduction_16happyReduce_17happyReduction_17happyReduce_18happyReduction_18happyReduce_19happyReduction_19happyReduce_20happyReduction_20happyReduce_21happyReduction_21happyReduce_22happyReduction_22happyReduce_23happyReduction_23happyReduce_24happyReduction_24happyReduce_25happyReduction_25happyReduce_26happyReduction_26happyReduce_27happyReduction_27happyReduce_28happyReduction_28happyReduce_29happyReduction_29happyReduce_30happyReduction_30happyReduce_31happyReduction_31happyReduce_32happyReduction_32happyReduce_33happyReduction_33happyReduce_34happyReduction_34happyReduce_35happyReduction_35happyReduce_36happyReduction_36happyReduce_37happyReduction_37happyReduce_38happyReduction_38happyReduce_39happyReduction_39happyReduce_40happyReduction_40happyReduce_41happyReduction_41happyReduce_42happyReduction_42happyReduce_43happyReduction_43happyReduce_44happyReduction_44happyReduce_45happyReduction_45happyReduce_46happyReduction_46happyReduce_47happyReduction_47happyReduce_48happyReduction_48happyReduce_49happyReduction_49happyReduce_50happyReduction_50happyReduce_51happyReduction_51happyReduce_52happyReduction_52happyReduce_53happyReduction_53happyReduce_54happyReduction_54happyReduce_55happyReduction_55happyReduce_56happyReduction_56happyReduce_57happyReduction_57happyReduce_58happyReduction_58happyReduce_59happyReduction_59happyReduce_60happyReduction_60happyReduce_61happyReduction_61happyReduce_62happyReduction_62happyReduce_63happyReduction_63happyReduce_64happyReduction_64happyReduce_65happyReduction_65happyReduce_66happyReduction_66happyReduce_67happyReduction_67happyReduce_68happyReduction_68happyReduce_69happyReduction_69happyReduce_70happyReduction_70happyReduce_71happyReduction_71happyReduce_72happyReduction_72happyReduce_73happyReduction_73happyReduce_74happyReduction_74happyReduce_75happyReduction_75happyReduce_76happyReduction_76happyReduce_77happyReduction_77happyReduce_78happyReduction_78happyReduce_79happyReduction_79happyReduce_80happyReduction_80happyReduce_81happyReduction_81happyReduce_82happyReduction_82happyReduce_83happyReduction_83happyReduce_84happyReduction_84happyReduce_85happyReduction_85happyReduce_86happyReduction_86happyReduce_87happyReduction_87happyReduce_88happyReduction_88happyReduce_89happyReduction_89happyReduce_90happyReduction_90happyReduce_91happyReduction_91happyReduce_92happyReduction_92happyReduce_93happyReduction_93happyReduce_94happyReduction_94happyReduce_95happyReduction_95happyReduce_96happyReduction_96happyReduce_97happyReduction_97happyReduce_98happyReduction_98happyReduce_99happyReduction_99happyReduce_100happyReduction_100happyReduce_101happyReduction_101happyReduce_102happyReduction_102happyReduce_103happyReduction_103happyReduce_104happyReduction_104happyReduce_105happyReduction_105happyReduce_106happyReduction_106happyReduce_107happyReduction_107happyReduce_108happyReduction_108happyReduce_109happyReduction_109happyReduce_110happyReduction_110happyReduce_111happyReduction_111happyReduce_112happyReduction_112happyReduce_113happyReduction_113happyReduce_114happyReduction_114happyReduce_115happyReduction_115happyReduce_116happyReduction_116happyReduce_117happyReduction_117happyReduce_118happyReduction_118happyReduce_119happyReduction_119happyReduce_120happyReduction_120happyReduce_121happyReduction_121happyReduce_122happyReduction_122happyReduce_123happyReduction_123happyReduce_124happyReduction_124happyReduce_125happyReduction_125happyReduce_126happyReduction_126happyReduce_127happyReduction_127happyReduce_128happyReduction_128happyReduce_129happyReduction_129happyReduce_130happyReduction_130happyReduce_131happyReduction_131happyReduce_132happyReduction_132happyReduce_133happyReduction_133happyReduce_134happyReduction_134happyReduce_135happyReduction_135happyReduce_136happyReduction_136happyReduce_137happyReduction_137happyReduce_138happyReduction_138happyReduce_139happyReduction_139happyReduce_140happyReduction_140happyReduce_141happyReduction_141happyReduce_142happyReduction_142happyReduce_143happyReduction_143happyReduce_144happyReduction_144happyReduce_145happyReduction_145happyReduce_146happyReduction_146happyReduce_147happyReduction_147happyReduce_148happyReduction_148happyReduce_149happyReduction_149happyReduce_150happyReduction_150happyReduce_151happyReduction_151happyReduce_152happyReduction_152happyReduce_153happyReduction_153happyReduce_154happyReduction_154happyReduce_155happyReduction_155happyReduce_156happyReduction_156happyReduce_157happyReduction_157happyReduce_158happyReduction_158happyReduce_159happyReduction_159happyReduce_160happyReduction_160happyReduce_161happyReduction_161happyReduce_162happyReduction_162happyReduce_163happyReduction_163happyReduce_164happyReduction_164happyReduce_165happyReduction_165happyReduce_166happyReduction_166happyReduce_167happyReduction_167happyReduce_168happyReduction_168happyReduce_169happyReduction_169happyReduce_170happyReduction_170happyReduce_171happyReduction_171happyReduce_172happyReduction_172happyReduce_173happyReduction_173happyReduce_174happyReduction_174happyReduce_175happyReduction_175happyReduce_176happyReduction_176happyReduce_177happyReduction_177happyReduce_178happyReduction_178happyReduce_179happyReduction_179happyReduce_180happyReduction_180happyReduce_181happyReduction_181happyReduce_182happyReduction_182happyReduce_183happyReduction_183happyReduce_184happyReduction_184happyReduce_185happyReduction_185happyReduce_186happyReduction_186happyReduce_187happyReduction_187happyReduce_188happyReduction_188happyReduce_189happyReduction_189happyReduce_190happyReduction_190happyReduce_191happyReduction_191happyReduce_192happyReduction_192happyReduce_193happyReduction_193happyReduce_194happyReduction_194happyReduce_195happyReduction_195happyReduce_196happyReduction_196happyReduce_197happyReduction_197happyReduce_198happyReduction_198happyReduce_199happyReduction_199happyReduce_200happyReduction_200happyReduce_201happyReduction_201happyReduce_202happyReduction_202happyReduce_203happyReduction_203happyReduce_204happyReduction_204happyReduce_205happyReduction_205happyReduce_206happyReduction_206happyReduce_207happyReduction_207happyReduce_208happyReduction_208happyReduce_209happyReduction_209happyReduce_210happyReduction_210happyReduce_211happyReduction_211happyReduce_212happyReduction_212happyReduce_213happyReduction_213happyReduce_214happyReduction_214happyReduce_215happyReduction_215happyReduce_216happyReduction_216happyReduce_217happyReduction_217happyReduce_218happyReduction_218happyReduce_219happyReduction_219happyReduce_220happyReduction_220happyReduce_221happyReduction_221happyReduce_222happyReduction_222happyReduce_223happyReduction_223happyReduce_224happyReduction_224happyReduce_225happyReduction_225happyReduce_226happyReduction_226happyReduce_227happyReduction_227happyReduce_228happyReduction_228happyReduce_229happyReduction_229happyReduce_230happyReduction_230happyReduce_231happyReduction_231happyReduce_232happyReduction_232happyReduce_233happyReduction_233happyReduce_234happyReduction_234happyReduce_235happyReduction_235happyReduce_236happyReduction_236happyReduce_237happyReduction_237happyReduce_238happyReduction_238happyReduce_239happyReduction_239happyReduce_240happyReduction_240happyReduce_241happyReduction_241happyReduce_242happyReduction_242happyReduce_243happyReduction_243happyReduce_244happyReduction_244happyReduce_245happyReduction_245happyReduce_246happyReduction_246happyReduce_247happyReduction_247happyReduce_248happyReduction_248happyReduce_249happyReduction_249happyReduce_250happyReduction_250happyReduce_251happyReduction_251happyReduce_252happyReduction_252happyReduce_253happyReduction_253happyReduce_254happyReduction_254happyReduce_255happyReduction_255happyReduce_256happyReduction_256happyReduce_257happyReduction_257happyReduce_258happyReduction_258happyReduce_259happyReduction_259happyReduce_260happyReduction_260happyReduce_261happyReduction_261happyReduce_262happyReduction_262happyReduce_263happyReduction_263happyReduce_264happyReduction_264happyReduce_265happyReduction_265happyReduce_266happyReduction_266happyReduce_267happyReduction_267happyReduce_268happyReduction_268happyReduce_269happyReduction_269happyReduce_270happyReduction_270happyReduce_271happyReduction_271happyReduce_272happyReduction_272happyReduce_273happyReduction_273happyReduce_274happyReduction_274happyReduce_275happyReduction_275happyReduce_276happyReduction_276happyReduce_277happyReduction_277happyReduce_278happyReduction_278happyReduce_279happyReduction_279happyReduce_280happyReduction_280happyReduce_281happyReduction_281happyReduce_282happyReduction_282happyReduce_283happyReduction_283happyReduce_284happyReduction_284happyReduce_285happyReduction_285happyReduce_286happyReduction_286happyReduce_287happyReduction_287happyReduce_288happyReduction_288happyReduce_289happyReduction_289happyReduce_290happyReduction_290happyReduce_291happyReduction_291happyReduce_292happyReduction_292happyReduce_293happyReduction_293happyReduce_294happyReduction_294happyReduce_295happyReduction_295happyReduce_296happyReduction_296happyReduce_297happyReduction_297happyReduce_298happyReduction_298happyReduce_299happyReduction_299happyReduce_300happyReduction_300happyReduce_301happyReduction_301happyReduce_302happyReduction_302happyReduce_303happyReduction_303happyReduce_304happyReduction_304happyReduce_305happyReduction_305happyReduce_306happyReduction_306happyReduce_307happyReduction_307happyReduce_308happyReduction_308happyReduce_309happyReduction_309happyReduce_310happyReduction_310happyReduce_311happyReduction_311happyReduce_312happyReduction_312happyReduce_313happyReduction_313happyReduce_314happyReduction_314happyReduce_315happyReduction_315happyReduce_316happyReduction_316happyReduce_317happyReduction_317happyReduce_318happyReduction_318happyReduce_319happyReduction_319happyReduce_320happyReduction_320happyReduce_321happyReduction_321happyReduce_322happyReduction_322happyReduce_323happyReduction_323happyReduce_324happyReduction_324happyReduce_325happyReduction_325happyReduce_326happyReduction_326happyReduce_327happyReduction_327happyReduce_328happyReduction_328happyReduce_329happyReduction_329happyReduce_330happyReduction_330happyReduce_331happyReduction_331happyReduce_332happyReduction_332happyReduce_333happyReduction_333happyReduce_334happyReduction_334happyReduce_335happyReduction_335happyReduce_336happyReduction_336happyReduce_337happyReduction_337happyReduce_338happyReduction_338happyReduce_339happyReduction_339happyReduce_340happyReduction_340happyReduce_341happyReduction_341happyReduce_342happyReduction_342happyReduce_343happyReduction_343happyReduce_344happyReduction_344happyReduce_345happyReduction_345happyReduce_346happyReduction_346happyReduce_347happyReduction_347happyReduce_348happyReduction_348happyReduce_349happyReduction_349happyReduce_350happyReduction_350happyReduce_351happyReduction_351happyReduce_352happyReduction_352happyReduce_353happyReduction_353happyReduce_354happyReduction_354happyReduce_355happyReduction_355happyReduce_356happyReduction_356happyReduce_357happyReduction_357happyReduce_358happyReduction_358happyReduce_359happyReduction_359happyReduce_360happyReduction_360happyReduce_361happyReduction_361happyReduce_362happyReduction_362happyReduce_363happyReduction_363happyReduce_364happyReduction_364happyReduce_365happyReduction_365happyReduce_366happyReduction_366happyReduce_367happyReduction_367happyReduce_368happyReduction_368happyReduce_369happyReduction_369happyReduce_370happyReduction_370happyReduce_371happyReduction_371happyReduce_372happyReduction_372happyReduce_373happyReduction_373happyReduce_374happyReduction_374happyReduce_375happyReduction_375happyReduce_376happyReduction_376happyReduce_377happyReduction_377happyReduce_378happyReduction_378happyReduce_379happyReduction_379happyReduce_380happyReduction_380happyReduce_381happyReduction_381happyReduce_382happyReduction_382happyReduce_383happyReduction_383happyReduce_384happyReduction_384happyReduce_385happyReduction_385happyReduce_386happyReduction_386happyReduce_387happyReduction_387happyReduce_388happyReduction_388happyReduce_389happyReduction_389happyReduce_390happyReduction_390happyReduce_391happyReduction_391happyReduce_392happyReduction_392happyReduce_393happyReduction_393happyReduce_394happyReduction_394happyReduce_395happyReduction_395happyReduce_396happyReduction_396happyReduce_397happyReduction_397happyReduce_398happyReduction_398happyReduce_399happyReduction_399happyReduce_400happyReduction_400happyReduce_401happyReduction_401happyReduce_402happyReduction_402happyReduce_403happyReduction_403happyReduce_404happyReduction_404happyReduce_405happyReduction_405happyReduce_406happyReduction_406happyReduce_407happyReduction_407happyReduce_408happyReduction_408happyReduce_409happyReduction_409happyReduce_410happyReduction_410happyReduce_411happyReduction_411happyReduce_412happyReduction_412happyReduce_413happyReduction_413happyReduce_414happyReduction_414happyReduce_415happyReduction_415happyReduce_416happyReduction_416happyReduce_417happyReduction_417happyReduce_418happyReduction_418happyReduce_419happyReduction_419happyReduce_420happyReduction_420happyReduce_421happyReduction_421happyReduce_422happyReduction_422happyReduce_423happyReduction_423happyReduce_424happyReduction_424happyReduce_425happyReduction_425happyReduce_426happyReduction_426happyReduce_427happyReduction_427happyReduce_428happyReduction_428happyReduce_429happyReduction_429happyReduce_430happyReduction_430happyReduce_431happyReduction_431happyReduce_432happyReduction_432happyReduce_433happyReduction_433happyReduce_434happyReduction_434happyReduce_435happyReduction_435happyReduce_436happyReduction_436happyReduce_437happyReduction_437happyReduce_438happyReduction_438happyReduce_439happyReduction_439happyReduce_440happyReduction_440happyReduce_441happyReduction_441happyReduce_442happyReduction_442happyReduce_443happyReduction_443happyReduce_444happyReduction_444happyReduce_445happyReduction_445happyReduce_446happyReduction_446happyReduce_447happyReduction_447happyReduce_448happyReduction_448happyReduce_449happyReduction_449happyReduce_450happyReduction_450happyReduce_451happyReduction_451happyReduce_452happyReduction_452happyReduce_453happyReduction_453happyReduce_454happyReduction_454happyReduce_455happyReduction_455happyReduce_456happyReduction_456happyReduce_457happyReduction_457happyReduce_458happyReduction_458happyReduce_459happyReduction_459happyReduce_460happyReduction_460happyReduce_461happyReduction_461happyReduce_462happyReduction_462happyReduce_463happyReduction_463happyReduce_464happyReduction_464happyReduce_465happyReduction_465happyReduce_466happyReduction_466happyReduce_467happyReduction_467happyReduce_468happyReduction_468happyReduce_469happyReduction_469happyReduce_470happyReduction_470happyReduce_471happyReduction_471happyReduce_472happyReduction_472happyReduce_473happyReduction_473happyReduce_474happyReduction_474happyReduce_475happyReduction_475happyReduce_476happyReduction_476happyReduce_477happyReduction_477happyReduce_478happyReduction_478happyReduce_479happyReduction_479happyReduce_480happyReduction_480happyReduce_481happyReduction_481happyReduce_482happyReduction_482happyReduce_483happyReduction_483happyReduce_484happyReduction_484happyReduce_485happyReduction_485happyReduce_486happyReduction_486happyReduce_487happyReduction_487happyReduce_488happyReduction_488happyReduce_489happyReduction_489happyReduce_490happyReduction_490happyReduce_491happyReduction_491happyReduce_492happyReduction_492happyReduce_493happyReduction_493happyReduce_494happyReduction_494happyReduce_495happyReduction_495happyReduce_496happyReduction_496happyReduce_497happyReduction_497happyReduce_498happyReduction_498happyReduce_499happyReduction_499happyReduce_500happyReduction_500happyReduce_501happyReduction_501happyReduce_502happyReduction_502happyReduce_503happyReduction_503happyReduce_504happyReduction_504happyReduce_505happyReduction_505happyReduce_506happyReduction_506happyReduce_507happyReduction_507happyReduce_508happyReduction_508happyReduce_509happyReduction_509happyReduce_510happyReduction_510happyReduce_511happyReduction_511happyReduce_512happyReduction_512happyReduce_513happyReduction_513happyReduce_514happyReduction_514happyReduce_515happyReduction_515happyReduce_516happyReduction_516happyReduce_517happyReduction_517happyReduce_518happyReduction_518happyReduce_519happyReduction_519happyReduce_520happyReduction_520happyReduce_521happyReduction_521happyReduce_522happyReduction_522happyReduce_523happyReduction_523happyReduce_524happyReduction_524happyReduce_525happyReduction_525happyReduce_526happyReduction_526happyReduce_527happyReduction_527happyReduce_528happyReduction_528happyReduce_529happyReduction_529happyReduce_530happyReduction_530happyReduce_531happyReduction_531happyReduce_532happyReduction_532happyReduce_533happyReduction_533happyReduce_534happyReduction_534happyReduce_535happyReduction_535happyReduce_536happyReduction_536happyReduce_537happyReduction_537happyReduce_538happyReduction_538happyReduce_539happyReduction_539happyReduce_540happyReduction_540happyReduce_541happyReduction_541happyReduce_542happyReduction_542happyReduce_543happyReduction_543happyReduce_544happyReduction_544happyReduce_545happyReduction_545happyReduce_546happyReduction_546happyReduce_547happyReduction_547happyReduce_548happyReduction_548happyReduce_549happyReduction_549happyReduce_550happyReduction_550happyReduce_551happyReduction_551happyReduce_552happyReduction_552happyReduce_553happyReduction_553happyReduce_554happyReduction_554happyReduce_555happyReduction_555happyReduce_556happyReduction_556happyReduce_557happyReduction_557happyReduce_558happyReduction_558happyReduce_559happyReduction_559happyReduce_560happyReduction_560happyReduce_561happyReduction_561happyReduce_562happyReduction_562happyReduce_563happyReduction_563happyReduce_564happyReduction_564happyReduce_565happyReduction_565happyReduce_566happyReduction_566happyReduce_567happyReduction_567happyReduce_568happyReduction_568happyReduce_569happyReduction_569happyReduce_570happyReduction_570happyReduce_571happyReduction_571happyReduce_572happyReduction_572happyReduce_573happyReduction_573happyReduce_574happyReduction_574happyReduce_575happyReduction_575happyReduce_576happyReduction_576happyReduce_577happyReduction_577happyReduce_578happyReduction_578happyReduce_579happyReduction_579happyReduce_580happyReduction_580happyReduce_581happyReduction_581happyReduce_582happyReduction_582happyReduce_583happyReduction_583happyReduce_584happyReduction_584happyReduce_585happyReduction_585happyReduce_586happyReduction_586happyReduce_587happyReduction_587happyReduce_588happyReduction_588happyReduce_589happyReduction_589happyReduce_590happyReduction_590happyReduce_591happyReduction_591happyReduce_592happyReduction_592happyReduce_593happyReduction_593happyReduce_594happyReduction_594happyReduce_595happyReduction_595happyReduce_596happyReduction_596happyReduce_597happyReduction_597happyReduce_598happyReduction_598happyReduce_599happyReduction_599happyReduce_600happyReduction_600happyReduce_601happyReduction_601happyReduce_602happyReduction_602happyReduce_603happyReduction_603happyReduce_604happyReduction_604happyReduce_605happyReduction_605happyReduce_606happyReduction_606happyReduce_607happyReduction_607happyReduce_608happyReduction_608happyReduce_609happyReduction_609happyReduce_610happyReduction_610happyReduce_611happyReduction_611happyReduce_612happyReduction_612happyReduce_613happyReduction_613happyReduce_614happyReduction_614happyReduce_615happyReduction_615happyReduce_616happyReduction_616happyReduce_617happyReduction_617happyReduce_618happyReduction_618happyReduce_619happyReduction_619happyReduce_620happyReduction_620happyReduce_621happyReduction_621happyReduce_622happyReduction_622happyReduce_623happyReduction_623happyReduce_624happyReduction_624happyReduce_625happyReduction_625happyReduce_626happyReduction_626happyReduce_627happyReduction_627happyReduce_628happyReduction_628happyReduce_629happyReduction_629 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError' mparseModule mparseExp mparsePat mparseDecl mparseType mparseStmt mparseModulesmfindOptPragmashappySeq parseErrornISiS simpleParse modeParse commentParseapplyFixities' happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeq$fParseableType$fParseableDecl$fParseablePat$fParseableExp$fParseableModule$fParseableStmt$fParseableType0$fParseableDecl0$fParseablePat0$fParseableExp0$fParseableModule0 ppContentsdelit