1Q      !"#$%&'()*+,-./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 { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 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{|}~                                                              I(c) Niklas Broberg 2004-2009, (c) The GHC Team, 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe+-./0` OAST nodes are annotated, and this class allows manipulation of the annotations. 'Retrieve the annotation of an AST node. Change the annotation of an AST node. Note that only the annotation of the node itself is affected, and not the annotations of any child nodes. if all nodes in the AST tree are to be affected, use .An alt alternative in a case expression.An fbind0 in a labeled construction or update expression.ordinary label-expresion pairrecord field punrecord field wildcard A general  transqualp in a list comprehension, which could potentially be a transform of the kind enabled by TransformListComp.an ordinary statementthen expthen exp by expthen group by expthen group using expthen group by exp using exp!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 generator: pat <- expan exp by itself: in a dox-expression, an action whose result is discarded; in a list comprehension and pattern guard, a guard expressionlocal bindings$a recursive binding group for arrows An fpat in a labeled record pattern.!ordinary label-pattern pair"record field pun#record field wildcard$An entity in a regular pattern.%operator pattern, e.g. pat*&choice pattern, e.g. (1 | 2)'$sequence pattern, e.g. (| 1, 2, 3 |)(%guarded pattern, e.g. (| p | p < 3 |))1non-linear variable binding, e.g. (foo@:(1 | 2))**)linear variable binding, e.g. foo@(1 | 2)+ parenthesised pattern, e.g. (2*),an ordinary pattern-A regular pattern operator..* = 0 or more/*! = 0 or more, greedy0+ = 1 or more1+! = 1 or more, greedy2? = 0 or 13?! = 0 or 1, greedy4An XML attribute in a pattern.6)A pattern, to be matched against a value.7variable8literal constant9 n+k pattern:&pattern with an infix data constructor;&data constructor and argument patterns< tuple pattern= list pattern>parenthesized pattern?labelled pattern, record style@@-patternAwildcard pattern: _Birrefutable pattern: ~patCpattern with type signatureDview patterns of the form (exp -> pat)Eregular list patternFXML element patternGXML singleton element patternHXML PCDATA patternIXML embedded patternJXML regular list patternKquasi quote pattern: [$name| string |]Lstrict (bang) pattern:  f !x = ...MSWarning text to optionally use in the module header of e.g. a deprecated module.PAVariables used in a RULES pragma, optionally annotated with typesSThe body of a RULES pragma.U$Activation clause of a RULES pragma.X(Recognised overlaps for overlap pragmas.YNO_OVERLAP pragmaZOVERLAP pragma[INCOHERENT pragma\%Recognised tools for OPTIONS pragmas.c8A top level options pragma, preceding the module header.dLANGUAGE pragmae@OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHCfANN pragma with module scopeg2The calling convention of a foreign function call.p&The safety of a foreign function call.qunsafersafe () or threadsafe ()s interruptiblet$A template haskell splice expressionuvariable splice: $varv!parenthesised expression splice: $(exp)w&A template haskell bracket expression.xexpression bracket:  [| ... |]ypattern bracket:  [p| ... |]ztype bracket:  [t| ... |]{declaration bracket:  [d| ... |]|2An xml attribute, which is a name-expression pair.~PThe name of an xml element or attribute, possibly qualified with a namespace.Haskell expressions.variableimplicit parameter variabledata constructorliteral constantinfix applicationordinary applicationnegation expression -exp (unary minus)lambda expressionlocal declarations with let ... in ...if exp then exp else expif | stmts -> exp ...case exp of altsdoJ-expression: the last statement in the list should be an expression.mdo -expressiontuple expressiontuple section expression, e.g. (,,3)list expressionparallel array expressionparenthesised expression left section (exp qop)right section (qop exp)record construction expressionrecord update expression5unbounded arithmetic sequence, incrementing by 1:  [from ..]2bounded arithmetic sequence, incrementing by 1  [from .. to]@unbounded arithmetic sequence, with first two elements given [from, then ..]>bounded arithmetic sequence, with first two elements given [from, then .. to]AParallel array bounded arithmetic sequence, incrementing by 1 [:from .. to:]>bounded arithmetic sequence, with first two elements given [:from, then .. to:]ordinary list comprehensionparallel list comprehensionparallel array comprehension'expression with explicit type signature'x- for template haskell reifying of expressions''T' for template haskell reifying of types#template haskell bracket expression"template haskell splice expressionquasi-quotaion: [$name| string |])xml element, with attributes and children"empty xml element, with attributesPCDATA child element%escaped haskell expression inside xmlchildren of an xml element CORE pragma SCC pragmaGENERATED pragma arrows proc: proc pat -> exparrow application (from left): exp -< exp arrow application (from right): exp >- exp,higher-order arrow application (from left): exp -<< exp-higher-order arrow application (from right): exp >>- expcase altsExpression hole@An indication whether a literal pattern has been negated or not.literal Values of this type hold the abstract value of the literal, along with the precise string representation used. For example, 10, 0o12 and 0xaW have the same value representation, but each carry a different string representation.character literalstring literalinteger literalfloating point literalunboxed integer literalunboxed word literalunboxed float literalunboxed double literalunboxed character literalunboxed string literal<Class assertions. In Haskell 98, the argument would be a tyvarK, but this definition allows multiple parameters, and allows them to be typeRs. Also extended with support for implicit parameters and equality constraints.ordinary class assertionconstraint kind assertion, Dict :: cxt a => Dict cxt3class assertion where the class name is given infiximplicit parameter assertiontype equality constraintparenthesised class assertionContext Wildcard A context is a set of assertionsIA functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rnAn explicit kind annotation.*, the kind of types-> , the kind of a type constructora parenthesised kindk, a kind variable (-XPolyKinds) k1 k2 '(k1,k2,k3), a promoted tuple'[k1], a promoted list literalIA type variable declaration, optionally with an explicit kind annotation.%variable binding with kind annotationordinary variable binding2Flag denoting whether a tuple is boxed or unboxed.UBools here are True if there was a leading quote which may be left out. For example '[k1,k2] means the same thing as [k1,k2].parsed value and raw stringparsed value and raw stringMA type qualified with a context. An unqualified type has an empty context.qualified type function typetuple type, possibly boxed)list syntax, e.g. [a], as opposed to [] a!parallel array syntax, e.g. [:a:]!application of a type constructor type variablenamed type or type constructortype surrounded by parenthesesinfix type constructor!type with explicit kind signature'K%, a promoted data type (-XDataKinds).2type equality predicate enabled by ConstraintKindstemplate haskell splice typeStrict type marked with "!$" or type marked with UNPACK pragma.*Either an anonymous of named type wildcardA guarded right hand side | stmts = exp, or | stmts -> exp for case alternatives. The guard is a series of statements when using pattern guards, otherwise it will be a single qualifier expression.UThe right hand side of a function binding, pattern binding, or a case alternative.unguarded right hand side (exp)guarded right hand side (gdrhs)]The type of a constructor argument or field, optionally including a strictness annotation.strict component, marked with "!"/unboxed component, marked with an UNPACK pragma,Declarations inside an instance declaration.ordinary declarationan associated type definition&an associated data type implementation4an associated data type implemented using GADT style(Declarations inside a class declaration.ordinary declaration&declaration of an associated data type )declaration of an associated type synonym -default choice for an associated type synonym default signature AA single constructor declaration in a GADT data type declaration.5If the GADT is declared using the record syntax, e.g. ?data Ty where TCon :: { field1 :: Int, field2 :: Bool } -> Ty(then the fields are stored as a list of s, and the final type (Ty- in the above example) is stored in the last  field.7If the GADT is declared using the ordinary syntax, e.g. )data Ty where TCon :: Int -> Bool -> Tythen  [ l] is -, and the whole constructor's type (such as Int -> Bool -> Ty) is stored in the last  field.*Declaration of a (list of) named field(s).,Declaration of an ordinary data constructor.ordinary data constructorinfix data constructorrecord constructoryA single constructor declaration within a data type declaration, which may have an existential quantification binding.Clauses of a function binding.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.0A clause defined with infix notation, i.e. first its first argument pattern, then the function name, then its following argument(s), the right-hand side and an optional where clause. Note that there can be more than two arguments to a function declared infix, hence the list of pattern arguments.#A binding of an implicit parameter.A binding group inside a let or where clause.An ordinary binding group'A binding group for implicit parameters4A deriving clause following a data type declaration. FThe instance head. The split between rule/head allow us to represent )instance (Bounded a => Bounded [a]) where faithfully.The structure of   follows one of (. For example, instance C (Maybe a) Int where is represented as IHApp () (IHApp () (IHCon () (UnQual () (Ident () "C"))) (TyParen () (TyApp () (TyCon () (UnQual () (Ident () "Maybe"))) (TyVar () (Ident () "a"))))) (TyCon () (UnQual () (Ident () "Int")))))!type or class name"<infix application of the type/class name to the left operand#parenthesized instance head$application to one more type%bThe instance declaration rule, which is, roughly, the part of the instance declaration before the where keyword. Example: instance Ord a => Ord (Maybe a) is represented as qIRule () Nothing (Just (CxSingle () (ClassA () (UnQual () (Ident () "Ord")) [ TyVar () (Ident () "a") ]))) (IHApp () (IHCon () (UnQual () (Ident () "Ord"))) (TyParen () (TyApp () (TyCon () (UnQual () (Ident () "Maybe"))) (TyVar () (Ident () "a")))))"An optional explicit forall after instance is supported: 0instance forall a . Ord a => Ord (Maybe a) where becomes >IRule () (Just [ UnkindedVar () (Ident () "a") ]) ...(qThe head of a type or class declaration, which consists of the type or class name applied to some type variables class C a b is represented as |DHApp () (DHApp () (DHead () (Ident () "C")) (UnkindedVar () (Ident () "a"))) (UnkindedVar () (Ident () "b"))(where the annotation type l is instantiated with ())class (a :< b) c is represented as DHApp () (DHParen () (DHApp () (DHInfix () (UnkindedVar () (Ident () "a")) (Symbol () ":<")) (UnkindedVar () (Ident () "b")))) (UnkindedVar () (Ident () "c")))type or class name*<infix application of the type/class name to the left operand+parenthesized declaration head,%application to one more type variable-FA flag stating whether a declaration is a data or newtype declaration.5&A boolean formula for MINIMAL pragmas.6 A variable.7And boolean formulas.8Or boolean formulas.9Parenthesized boolean formulas.:$An annotation through an ANN pragma.;"An annotation for a declared name.<"An annotation for a declared type.=&An annotation for the defining module.>1A type equation as found in closed type families.A*A unidirectional pattern synonym with "<-"B(A bidirectional pattern synonym with "="C>A birectional pattern synonym with the construction specified.DA top-level declaration.EA type declarationFA type family declarationG A closed type family declarationHA data OR newtype declarationI)A data OR newtype declaration, GADT styleJA data family declarationK"A type family instance declarationL"A data family instance declarationM.A data family instance declaration, GADT styleNA declaration of a type classO'An declaration of a type class instanceP!A standalone deriving declarationQ A declaration of operator fixityRA declaration of default typesS'A Template Haskell splicing declarationTA type signature declarationU%A pattern synonym signature declationV!A set of function binding clausesWA pattern bindingXA pattern synonym bindingYA foreign import declarationZA foreign export declaration[A RULES pragma\A DEPRECATED pragma]A WARNING pragma^An INLINE pragma_An INLINE CONLIKE pragma`A SPECIALISE pragmaaA SPECIALISE INLINE pragmabA SPECIALISE instance pragmac An ANN pragmadA MINIMAL pragmaeA role annotationfAssociativity of an operator.g(non-associative operator (declared with infix)h)left-associative operator (declared with infixl).i*right-associative operator (declared with infixr)jcAn import specification, representing a single explicit item imported (or hidden) from a module.kvariablelT3: the name of a class, datatype or type synonym.mT(..)f: a class imported with all of its methods, or a datatype imported with all of its constructors.nT(C_1,...,C_n)h: a class imported with some of its methods, or a datatype imported with some of its constructors.o&An explicit import specification list.qAn import declaration.s/annotation, used by parser for position of the import keyword.tname of the module imported.u imported  qualified?vimported with {-# SOURCE #-}?wImport safe?x#imported with explicit package nameyoptional alias name in an as clause.z'optional list of import specifications.{Namespaces for imports/exports.+An item in a module's export specification. variable.TC: a class or datatype exported abstractly, or a type synonym.T(..)f: a class exported with all of its methods, or a datatype exported with all of its constructors.T(C_1,...,C_n)h: a class exported with some of its methods, or a datatype exported with some of its constructors.module M: re-export a module.!An explicit export specification.BThe head of a module, including the name and export specification.!A complete Haskell source module.an ordinary Haskell modulea module consisting of a single XML document. The ModuleName never appears in the source but is needed for semantic purposes, it will be the same as the file name.Aa hybrid module combining an XML document with an ordinary moduleA name (cname/) of a component of a class or data type in an import or export specification.name of a method or fieldname of a data constructorOperators appearing in infix" declarations are never qualified.variable operator (varop)constructor operator (conop)$Possibly qualified infix operators (qop), appearing in expressions.variable operator (qvarop)constructor operator (qconop)An implicit parameter name.?ident, non-linear implicit parameter%ident, linear implicit parameter@This type is used to represent variables, and also constructors.varid or conid.varsym or consymUThis type is used to represent qualified variables, and also qualified constructors.!name qualified with a module nameunqualified local name(built-in constructor with special syntax{Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.unit type and data constructor ()list type constructor []function type constructor ->n)-ary tuple type and data constructors (,) etc, possibly boxed (#,#)list data constructor (:)$unboxed singleton tuple constructor (# #)The name of a Haskell module.6Test if two AST elements are equal modulo annotations.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~MNOqrstuvwxyzopjklmnfghi{|}~DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde()*+,%&' !"#$@ABC   -./  >?|}6789:;<=>?@ABCDEFGHIJKL !"#45$%&'()*+,-./0123~01234wxyz{tuvpqrsghijklmnocdef\]^_`abXYZ[STPQRUVW:;<=56789    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~5       !"#$%&'()*+,-./0123456789:;<=>?@ABCD!EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq rstuvwxyz{|}~      !"#$%&'()*+,-.Safe-I/ function type0tuple type, possibly boxed1)list syntax, e.g. [a], as opposed to [] a2!parallel array syntax, e.g. [:a:]3!application of a type constructor4 type variable5named type or type constructor6type surrounded by parentheses7"assertion of an implicit parameter8infix type constructor9!type with explicit kind signature:promoted data type;template haskell splice type<Strict type marked with "!$" or type marked with UNPACK pragma.= Type wildcard>variable?implicit parameter variable@data constructorAliteral constantBinfix applicationCordinary applicationDnegation expression - expElambda expressionFlocal declarations with letGif exp then exp else expHif | stmts -> exp ...Icase exp of altsJdoJ-expression: the last statement in the list should be an expression.KmdoK-expression | Tuple [PExp] -- ^ tuple expressionLtuple section expression, e.g. (,,3)Mlist expressionNparallel array expressionOVparenthesized expression RightSection QOp PExp -- ^ right section (qop exp)Precord construction expressionQrecord update expressionR3unbounded arithmetic sequence, incrementing by 1S1bounded arithmetic sequence, incrementing by 1T?unbounded arithmetic sequence, with first two elements givenU=bounded arithmetic sequence, with first two elements givenV1bounded arithmetic sequence, incrementing by 1W=bounded arithmetic sequence, with first two elements givenXparallel list comprehensionYparallel array comprehensionZexpression type signature[ patterns only\ patterns only] patterns only^post-ops_pre-ops` patterns onlyaregular patterns onlybregular patterns onlycregular patterns onlydregular patterns onlye'xf''Tg $...|...h Name... /Namei Name/jPCDATAk %... %l % ... /%m [... ]n{- CORE  -} pragmao{- SCC  -} pragmap{- GENERATED ...  -} pragmaq f !a = ...r proc p -> dose -< ete >- eue -<< eve >>- ewcase altsnxyz{|}~/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwhxyz{|}~/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~/0123456789:;<=<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwD(c) The GHC Team, 1997-2000, (c) Niklas Broberg 2004$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.se experimentalportableSafe1dAn identifier with the given string as its name. The string should be a valid Haskell identifier.OA 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.0A 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.PLambda 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 <- expA let binding group as a statement./Hoist a set of declarations to a binding group.An empty binding group.The wildcard pattern: _DGenerate k names by appending numbers 1 through k to a given string.A function with a single clauseXA function with a single clause, a single argument, no guards and no where declarationsVA 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.6Apply function of a given name to a list of arguments.eApply a constructor of a given name to a list of pattern arguments, forming a constructor pattern.1..1(c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe+0>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.MA 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. 5Combine two locations in the source to denote a span.!Merge two source spans into a single span from the start of the first 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  7 with the supplied positional information for entities.& Combine two  ms into one that spans the combined source area of the two arguments, leaving positional information blank.'Like '( +?!)', but it also concatenates the  .(Short name for &)kOptionally combine the first argument with the second, or return it unchanged if the second argument is .*jOptionally combine the second argument with the first, or return it unchanged if the first argument is .+7Add more positional information for entities of a span., Merge two s and lift them to a  SrcInfoSpan0 with no positional information for entities.1      !"#$%&'()*+,-./012+      !"#$%&'()*+,121 !"#     0$%&'()*+,/.-      !"#$%&'()*+,-./012()*+,Safe+3An unknown pragma.5A Haskell comment. The  is $ if the comment is multi-line, i.e. {- -}.3456345656343456(c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe-8NPrint an AST exactly as specified by the annotations on the nodes in the tree.78      !"#$%788778      !"#$%(c) JP Moresmau 2015$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.se experimentalportableSafe&Represents a Haddock Comment'Comment before declaration(Comment after declaration)Non Haddock comment*The comment accumulator9NAssociates an AST with Source Span Information with relevant Haddock comments+9Merge existing association with post comment associations,3Ensure that if file ends with comment we process it-rAccumulate comments mappings, either directly with the source or in another association list for later processing.Create a new accumulator/Get comments to merge06Get the biggest src that ends where the first one does1,Is a Haddock comment before a given location2Is a comment not haddock?3Comments to Haddock Comments4Comment to Haddock Comment&'5()*69+,-./Stop before srcAll remaining commentsComments to merge, left overs0123499 &'()555*69+,-./01234(c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)*Niklas Broberg, niklas.broberg@chalmers.se transientportableSafe+i;  GHC 7.6.3.4cAllow overlapping class instances, provided there is a unique most specific instance for each use.<  GHC 7.6.3.3Ignore 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.4Implies ;. Allow the implementation to choose an instance even when it is possible that further instantiation of types will lead to a more specific instance being applicable.>  GHC 7.6.3.5#Allow type signatures in instances.?  GHC 7.3.8Allows recursive bindings in do blocks, using the rec keyword.@  GHC 7.3.8.25Deprecated in GHC. Allows recursive bindings using mdo, a variant of do. DoRec) provides a different, preferred syntax.A  GHC 7.3.9eProvide syntax for writing list comprehensions which iterate over several lists together, like the 7 family of functions.B  GHC 7.6.1.1*Allow multiple parameters in a type class.C  GHC 7.17,Enable the dreaded monomorphism restriction.D  GHC 7.6.2$Allow a specification attached to a multi-parameter type class which indicates that some parameters are entirely determined by others. The implementation will check that this property holds for the declared instances, and will use this property to reduce ambiguity in instance resolution.E  GHC 7.8.5Like FZ but does not allow a higher-rank type to itself appear on the left of a function arrow.F  GHC 7.8.5NAllow a universally-quantified type to occur on the left of a function arrow.G  GHC 7.8.5@Allow data constructors to have polymorphic arguments. Unlike F., does not allow this for ordinary functions.H  GHC 7.4.41Allow existentially-quantified data constructors.I  GHC 7.8.7=Cause a type variable in a signature, which has an explicit forallQ quantifier, to scope over the definition of the accompanying value declaration.JDeprecated, use I instead.K  GHC 7.8.38Enable implicit function parameters with dynamic scope.L  GHC 7.8.2HRelax some restrictions on the form of the context of a type signature.M  GHC 7.6.3.2ORelax some restrictions on the form of the context of an instance declaration.N  GHC 7.4.12Allow data type declarations with no constructors.O  GHC 4.10.3.Run the C preprocessor on Haskell source code.P  GHC 7.8.4]Allow an explicit kind signature giving the kind of types over which a type variable ranges.Q  GHC 7.11bEnable a form of pattern which forces evaluation before an attempted match, and a form of strict let/where binding.R  GHC 7.6.3.1&Allow type synonyms in instance heads.S  GHC 7.9DEnable Template Haskell, a system for compile-time metaprogramming.T GHC 8Enable the Foreign Function Interface. In GHC, implements the standard Haskell 98 Foreign Function Interface Addendum, plus some GHC-specific extensions.U  GHC 7.10Enable arrow notation.V  GHC 7.16kEnable generic type classes, with default instances defined in terms of the algebraic structure of a type.W  GHC 7.3.11-Enable the implicit importing of the module Prelude. When disabled, when desugaring certain built-in syntax into ordinary identifiers, use whatever is in scope rather than the Prelude -- version.X  GHC 7.3.15Enable syntax for implicitly binding local names corresponding to the field names of a record. Puns bind specific names, unlike g.Y  GHC 7.3.5DEnable a form of guard which matches a pattern and binds variables.Z  GHC 7.5.4Allow a type declared with newtype to use deriving8 for any class with an instance for the underlying type.[  Hugs 7.1,Enable the "Trex" extensible records system.\  Hugs 7.2Enable type synonyms which are transparent in some definitions and opaque elsewhere, as a way of implementing abstract datatypes.]  Hugs 7.3HEnable an alternate syntax for string literals, with string templating.^  GHC 7.3.2Allow the character #X as a postfix modifier on identifiers. Also enables literal syntax for unboxed values._Binary integer literals`  GHC 7.7cAllow data types and type synonyms which are indexed by types, i.e. ad-hoc polymorphism for types.a  GHC 7.5.2=Allow a standalone declaration which invokes the type class deriving mechanism.b  GHC 7.3.1pAllow certain Unicode characters to stand for certain ASCII character sequences, e.g. keywords and punctuation.c  GHC 8.1.1:Allow the use of unboxed types as foreign types, e.g. in foreign import and foreign export.d  GHC 7.4.3}Defer validity checking of types until after expanding type synonyms, relaxing the constraints on how synonyms may be used.e  GHC 7.4.2\Allow the name of a type constructor, type class, or type variable to be an infix operator.f  GHC 7.26.5*Parallel arrays for Data Parallel Haskell.g  GHC 7.3.16Enable syntax for implicitly binding local names corresponding to the field names of a record. A wildcard binds all unmentioned names, unlike X.hDeprecated, use X instead.i  GHC 7.3.14QAllow a record field name to be disambiguated by the type of the record it's in.j  GHC 7.6.4VEnable overloading of string literals using a type class, much like integer literals.k  GHC 7.4.6Enable generalized algebraic data types, in which type variables may be instantiated on a per-constructor basis. Implies GADTSyntax.l  GHC 7.17.2"Make pattern bindings monomorphic.m  GHC 7.8.8DRelax the requirements on mutually-recursive polymorphic functions.n  GHC 2.4.5EAllow default instantiation of polymorphic types in more situations.o  GHC 7.2.2Enable unboxed tuples.p  GHC 7.5.3Enable deriving for classes Data.Typeable.Typeable and Data.Generics.Data.q  GHC 7.6.1.3VAllow a class method's type to place additional constraints on a class type variable.r  GHC 7.3.18cAllow imports to be qualified by the package name the module is intended to be imported from, e.g. import "network" Network.Sockett  GHC 7.8.6wDeprecated in GHC 6.12 and will be removed in GHC 7. Allow a type variable to be instantiated at a polymorphic type.u  GHC 7.3.31Change the syntax for qualified infix operators.v  GHC 7.3.12URelax the interpretation of left operator sections to allow unary postfix operators.w  GHC 7.9.5cEnable quasi-quotation, a mechanism for defining new concrete syntax for expressions and patterns.x  GHC 7.3.10\Enable generalized list comprehensions, supporting operations such as sorting and grouping.y  GHC 7.3.6]Enable view patterns, which match a value by applying a function and matching on the result.zxAllow concrete XML syntax to be used in expressions and patterns, 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.{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.|(Enables the use of tuple sections, e.g. (, True) desugars into x -> (x, True).}HAllows GHC primops, written in C--, to be imported into a Haskell file.~!Support for patterns of the form n + k, where k is an integer literal.Improve the layout rule when if expressions are used in a do block.qMakes much of the Haskell sugar be desugared into calls to the function with a particular name that is in scope.Make forallN a keyword in types, which can be used to give the generalisation explicitly.0Allow contexts to be put on datatypes, e.g. the Eq a in /data Eq a => Set a = NilSet | ConsSet a (Set a).Local (let and where) bindings are monomorphic.Enable deriving for the Data.Functor.Functor class.  GHC 7.5.3Enable deriving for the Generic and Generic1 classes.Enable deriving for the Data.Traversable.Traversable class.Enable deriving for the Data.Foldable.Foldable class.&Enable non-decreasing indentation for 'do' blocks.  GHC 8.1.4Enable interruptible FFI.  GHC 8.1.5 Enable the capi7 calling convention in the foreign function interface.  GHC 7.3.27,Enable explicit namespaces in import/export.  GHC 7.3.16hEnable the multi-way if-expressions extension to accept conditional expressions with multiple branches.  GHC 7.20.3Allow imports to be qualified with a safe keyword that requires the imported module be trusted as according to the Safe Haskell definition of trust. import safe Network.Socket  GHC 7.20uCompile a module in the Safe, Safe Haskell mode -- a restricted form of the Haskell language to ensure type safety.  GHC 7.20Compile a module in the Trustworthy, Safe Haskell mode -- no restrictions apply but the module is marked as trusted as long as the package the module resides in is trusted.  GHC 7.6.1.4iAllow default signatures in class definitions. They apply to default methods implemented in this class.  GHC 7.40Allow type classimplicit parameterequality constraints to be used as types with the special kind Constraint. Also generalise the (ctxt => ty) syntax so that any type of kind Constraint can occur before the arrow.  GHC 7.25.3Allow role annotations.  GHC 7.3.84Enable giving names to parametrized pattern schemes  GHC 7.15Allow partial specified type signatures. Note that this extension does not affect parsing. It only affects whether the program is able to be run with partial signatures. GHC 7.15.1.2This extension treats type variables which start with an underscore as wildcards. For example, `foo :: _x` is equivalent to `foo :: _`.2This represents language extensions beyond a base  definition (such as L) that are supported by some implementations, usually in some special mode.Enable a known extensionDisable a known extension4An unknown extension, identified by the name of its LANGUAGE pragma.>The Haskell 98 language as defined by the Haskell 98 report. http://haskell.org/onlinereport/BThe Haskell 2010 language as defined by the Haskell 2010 report. /http://www.haskell.org/onlinereport/haskell2010The minimal language resulting from disabling all recognized extensions - including ones that are part of all known language definitions e.g. MonomorphismRestriction.,An unknown language, identified by its name.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.KThe list of extensions enabled by GHC's portmanteau -fglasgow-exts flag.;List of all known extensions, both "yes" and "no" versions._Extensions that have been deprecated, possibly paired with another extension that replaces it.)A clever version of read that returns an $ if the string is not recognised.1Parse an enabled or disabled extension; returns  if the parse fails.GPretty print an extension. Disabled extensions are prefixed with 'No'.w:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~89:;s:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~s:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~:];<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~89:;(c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe <=>?@ABCD<=>?@A<=>?@ABCD I(c) Niklas Broberg 2004-2009, (c) The GHC Team, 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe+0BAn alt alternative in a case expression.An fbind0 in a labeled construction or update expression.ordinary label-expresion pairrecord field punrecord field wildcard A general  transqualp in a list comprehension, which could potentially be a transform of the kind enabled by TransformListComp.an ordinary statementthen expthen exp by expthen group by expthen group using expthen group by exp using exp!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 generator: pat <- expan exp by itself: in a dox-expression, an action whose result is discarded; in a list comprehension and pattern guard, a guard expressionlocal bindings$a recursive binding group for arrowsAn fpat in a labeled record pattern.ordinary label-pattern pairrecord field punrecord field wildcardAn entity in a regular pattern.operator pattern, e.g. pat*choice pattern, e.g. (1 | 2)$sequence pattern, e.g. (| 1, 2, 3 |)%guarded pattern, e.g. (| p | p < 3 |)1non-linear variable binding, e.g. (foo@:(1 | 2))*)linear variable binding, e.g. foo@(1 | 2) parenthesised pattern, e.g. (2*)an ordinary patternA regular pattern operator.* = 0 or more*! = 0 or more, greedy+ = 1 or more+! = 1 or more, greedy? = 0 or 1?! = 0 or 1, greedyAn XML attribute in a pattern.)A pattern, to be matched against a value.variableliteral constant n+k pattern&pattern with an infix data constructor&data constructor and argument patterns tuple pattern list patternparenthesized patternlabelled pattern, record style@-patternwildcard pattern: _irrefutable pattern: ~patpattern with type signatureview patterns of the form (exp -> pat)regular list patternXML element patternXML singleton element patternXML PCDATA patternXML embedded patternXML regular list patternquasi quote patter: [$name| string |]strict (bang) pattern:  f !x = ...SWarning text to optionally use in the module header of e.g. a deprecated module.AVariables used in a RULES pragma, optionally annotated with typesThe body of a RULES pragma.$Activation clause of a RULES pragma.(Recognised overlaps for overlap pragmas.NO_OVERLAP pragmaOVERLAP pragmaINCOHERENT pragma8A top level options pragma, preceding the module header.LANGUAGE pragma@OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHCANN pragma with module scope2The calling convention of a foreign function call. &The safety of a foreign function call. unsafe safe () or threadsafe ()  interruptible $A template haskell splice expressionvariable splice: $var!parenthesised expression splice: $(exp)&A template haskell bracket expression.expression bracket:  [| ... |]pattern bracket:  [p| ... |]type bracket:  [t| ... |]declaration bracket:  [d| ... |]2An xml attribute, which is a name-expression pair.PThe name of an xml element or attribute, possibly qualified with a namespace.Haskell expressions.variableimplicit parameter variabledata constructorliteral constantinfix application ordinary application!negation expression -exp (unary minus)"lambda expression#local declarations with let ... in ...$if exp then exp else exp%if | exp -> exp ...&case exp of alts'doJ-expression: the last statement in the list should be an expression.(mdo -expression)tuple expression*tuple section expression, e.g. (,,3)+list expression,parallel array expression-parenthesised expression. left section (exp qop)/right section (qop exp)0record construction expression1record update expression25unbounded arithmetic sequence, incrementing by 1:  [from ..]32bounded arithmetic sequence, incrementing by 1  [from .. to]4@unbounded arithmetic sequence, with first two elements given [from, then ..]5>bounded arithmetic sequence, with first two elements given [from, then .. to]62bounded arithmetic sequence, incrementing by 1  [from .. to]7>bounded arithmetic sequence, with first two elements given [from, then .. to]8ordinary list comprehension9parallel list comprehension:parallel array comprehension;'expression with explicit type signature<'x- for template haskell reifying of expressions=''T' for template haskell reifying of types>#template haskell bracket expression?"template haskell splice expression@quasi-quotaion: [$name| string |]A)xml element, with attributes and childrenB"empty xml element, with attributesCPCDATA child elementD%escaped haskell expression inside xmlEchildren of an xml elementF CORE pragmaG SCC pragmaHGENERATED pragmaI arrows proc: proc pat -> expJarrow application (from left): exp -< expK arrow application (from right): exp >- expL,higher-order arrow application (from left): exp -<< expM-higher-order arrow application (from right): exp >>- expNcase altsOExpression holeP@An indication whether a literal pattern has been negated or not.Sliteraly Values of this type hold the abstract value of the literal, not the precise string representation used. For example, 10, 0o12 and 0xa have the same representation.Tcharacter literalUstring literalVinteger literalWfloating point literalXunboxed integer literalYunboxed word literalZunboxed float literal[unboxed double literal\unboxed character literal]unboxed string literal^<Class assertions. In Haskell 98, the argument would be a tyvarK, but this definition allows multiple parameters, and allows them to be typeRs. Also extended with support for implicit parameters and equality constraints._ordinary class assertion`constraint kind assertion, Dict :: cxt a => Dict cxta3class assertion where the class name is given infixbimplicit parameter assertionctype equality constraintdparenthesised class assertione A wildcardf A context is a set of assertionsgIA functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rniAn explicit kind annotation.j*, the kind of typesk-> , the kind of a type constructorl a kind surrounded by parenthesesm4a kind variable (as of yet unsupported by compilers)n k1 k2o (k1,k2,k3), kind of a promoted tuplep[k1], kind of a promoted listqIA type variable declaration, optionally with an explicit kind annotation.r%variable binding with kind annotationsordinary variable binding{MA type qualified with a context. An unqualified type has an empty context.|qualified type} function type~tuple type, possibly boxed)list syntax, e.g. [a], as opposed to [] a!parallel array syntax, e.g. [:a:]!application of a type constructor type variablenamed type or type constructortype surrounded by parenthesesinfix type constructor!type with explicit kind signature promoted data type (-XDataKinds)2type equality predicate enabled by ConstraintKindstemplate haskell splice typeStrict type marked with "!$" or type marked with UNPACK pragma. Type wildcardA guarded right hand side | stmts = exp, or | stmts -> exp for case alternatives. The guard is a series of statements when using pattern guards, otherwise it will be a single qualifier expression.UThe right hand side of a function binding, pattern binding, or a case alternative.unguarded right hand side (exp)guarded right hand side (gdrhs)]The type of a constructor argument or field, optionally including a strictness annotation.strict component, marked with "!"/unboxed component, marked with an UNPACK pragma,Declarations inside an instance declaration.ordinary declarationan associated type definition&an associated data type implementation4an associated data type implemented using GADT style(Declarations inside a class declaration.ordinary declaration&declaration of an associated data type)declaration of an associated type synonym-default choice for an associated type synonymdefault signatureAA single constructor declaration in a GADT data type declaration.,Declaration of an ordinary data constructor.ordinary data constructorinfix data constructorrecord constructoryA single constructor declaration within a data type declaration, which may have an existential quantification binding.Clauses of a function binding.#A binding of an implicit parameter.A binding group inside a let or where clause.An ordinary binding group'A binding group for implicit parametersFA flag stating whether a declaration is a data or newtype declaration.&A boolean formula for MINIMAL pragmas. A variable.And boolean formulas.Or boolean formulas.Parenthesized boolean formulas.$An annotation through an ANN pragma."An annotation for a declared name."An annotation for a declared type.&An annotation for the defining module.A type equation of the form  rhs = lhs used in closed type families.*A unidirectional pattern synonym with "<-"(A bidirectional pattern synonym with "=">A birectional pattern synonym with the construction specified.A top-level declaration.A type declarationA type family declaration A closed type family declarationA data OR newtype declaration)A data OR newtype declaration, GADT styleA data family declaration"A type family instance declaration"A data family instance declaration.A data family instance declaration, GADT styleA declaration of a type class'An declaration of a type class instance!A standalone deriving declaration A declaration of operator fixityA declaration of default types'A Template Haskell splicing declarationA type signature declarationPattern Synonym Signature!A set of function binding clausesA pattern bindingA foreign import declarationA foreign export declarationA RULES pragmaA DEPRECATED pragmaA WARNING pragmaAn INLINE pragmaAn INLINE CONLIKE pragmaA SPECIALISE pragmaA SPECIALISE INLINE pragmaA SPECIALISE instance pragma An ANN pragmaA MINIMAL pragmaA role annotationKA single derived instance, which may have arguments since it may be a MPTC.Associativity of an operator.(non-associative operator (declared with infix))left-associative operator (declared with infixl).*right-associative operator (declared with infixr)cAn import specification, representing a single explicit item imported (or hidden) from a module. variable.T3: the name of a class, datatype or type synonym.T(..)f: a class imported with all of its methods, or a datatype imported with all of its constructors.T(C_1,...,C_n)h: a class imported with some of its methods, or a datatype imported with some of its constructors.An import declaration.position of the import keyword.name of the module imported. imported  qualified?imported with {-# SOURCE #-}?Import safe?#imported with explicit package nameoptional alias name in an as clause.-optional list of import specifications. The  is  if the names are excluded by hiding.Namespaces for imports/exports.+An item in a module's export specification. variable.TC: a class or datatype exported abstractly, or a type synonym.T(..)f: a class exported with all of its methods, or a datatype exported with all of its constructors.T(C_1,...,C_n)h: a class exported with some of its methods, or a datatype exported with some of its constructors.module M: re-export a module.!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 method or field name of a data constructor Operators appearing in infix" declarations are never qualified. variable operator (varop) constructor operator (conop) $Possibly qualified infix operators (qop), appearing in expressions.variable operator (qvarop)constructor operator (qconop)An implicit parameter name.?ident, non-linear implicit parameter%ident, linear implicit parameter@This type is used to represent variables, and also constructors.varid or conid.varsym or consymWThis type is used to represent qualified variables, and also qualified constructors.!name qualified with a module nameunqualified local name(built-in constructor with special syntax{Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.unit type and data constructor ()list type constructor []function type constructor ->n)-ary tuple type and data constructors (,) etc, possibly boxed (#,#)list data constructor (:) $unboxed singleton tuple constructor (# #)!The name of a Haskell module.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL\]^_`ab      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLfgh^_`abcde{|}~ijklmnopqrstuvwxyz !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOSTUVWXYZ[\]PQR!"           \]^_`ab#$%&'()*+,-./0123456789:;<=>?@ABCDEGFHIJLKj     5 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS TUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL D(c) The GHC Team, 1997-2000, (c) Niklas Broberg 2004$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.se experimentalportableSafe1MdAn identifier with the given string as its name. The string should be a valid Haskell identifier.NOA symbol identifier. The string should be a valid Haskell symbol identifier.OA local variable as expression.P(Use the given identifier as an operator.Q#A qualified variable as expression.RA pattern variable.S,Application of expressions by juxtaposition.TApply an operator infix.U(Apply a function to a list of arguments.V.A constructor pattern, with argument patterns.WA tuple expression.XA tuple pattern.Y0A tuple expression consisting of variables only.Z-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.aA literal integer pattern.b\A do block formed by the given statements. The last statement in the list should be a  expression.cPLambda abstraction, given a list of argument patterns and an expression body.dA let ... in block.eA case expression.fAn unguarded alternative in a case expression.g(An alternative with a single guard in a case expression.E!An unguarded righthand side of a case alternative.F)An list of guarded righthand sides for a case alternative.G&A single guarded righthand side for a case alternative.hA list expression.iThe empty list expression.jThe empty list pattern.k%Put parentheses around an expression.l!Put parentheses around a pattern.m!A qualifier expression statement.nA generator statement: pat <- expoA let binding group as a statement.p/Hoist a set of declarations to a binding group.qAn empty binding group.rThe wildcard pattern: _sDGenerate k names by appending numbers 1 through k to a given string.tA function with a single clauseuXA function with a single clause, a single argument, no guards and no where declarationsvVA pattern bind where the pattern is a variable, and where there are no guards and no 'where' clause.w[A pattern bind where the pattern is a variable, and where there are no guards, but with a 'where' clause.x$Bind an identifier to an expression.y6Apply function of a given name to a list of arguments.zeApply a constructor of a given name to a list of pattern arguments, forming a constructor pattern.1MNOPQRSTUVWXYZ[\]^_`abcdefgEFGhijklmnopqrstuvwxyz.MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz.MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz1MNOPQRSTUVWXYZ[\]^_`abcdefgEFGhijklmnopqrstuvwxyz (c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe+{xAll AST elements that may include expressions which in turn may need fixity tweaking will be instances of this class.|Tweak any expressions in the element to account for the fixities given. Assumes that all operator expressions are fully left associative chains to begin with.}mOperator fixities are represented by their associativity (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 +++h 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.FThe same element, but with operator expressions updated, or a failure.}~HIJKLMNOPQRSTUVWXYZ[\]^_`abcdef {|}~ }~{|'{|}~HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefRNiklas Broberg (c) 2004-2009, Original (c) The GHC Team, 1997-2000/BSD-style (see the file libraries/base/LICENSE)$Niklas Broberg, d00nibro@chalmers.sestableportableSafegMonad for parsingQStatic parameters governing a parse. Note that the various parse functions in Language.Haskell.Exts.Parser> 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 parsingif W, the parser won't care about further extensions in LANGUAGE pragmas in source filesif V, the parser won't read line position information from LINE pragmas in source fileslist of fixities to be aware of0Checks whether functions have a consistent arityThe result of a parse.&The parse succeeded, yielding a value.JThe parse failed at the specified source location, with an error message.=Class providing function for parsing at many different types.cNote that for convenience of implementation, the default methods have definitions equivalent to h;. The minimal definition is all of the visible methods.!Parse a string with default mode. Parse a string with an explicit . Parse a string with an explicit /, returning all comments along with the AST.iDInternal parser, used to provide default definitions for the others.hRetrieve the result of a successful parse, throwing an 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't ignore LANGUAGE pragmas, do ignore LINE pragmas, and be aware of fixities from the Prelude.jHDiscard some input characters (these must not include tabs or newlines).k4Discard the next character, which must be a newline.l0Discard the next character, which must be a tab.m"lexWhile without the return value.n.Add an extension to the current configuration.o-Save the current configuration of extensions.p6Return to the previous saved extensions configuration.eqrsgtuvwxyz{|}~ijklmnopEqsg~ijklmnopDqrsgtuvwxyz{|}~ijklmnopI(c) The GHC Team, 1997-2000 (c) Niklas Broberg, 2004-2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe])VChecks whether the character would be legal in some position of a qvar. Means that '..' and AAA will pass the test.'lexWhiteSpace without the return value."Selects ASCII binary digits, i.e. '0'..'1'.      !"#$%&'()*+,      !"#$%&'()*+,-      !"#$%&'()*+,I(c) The GHC Team, 1997-2000 (c) Niklas Broberg, 2004-2012$BSD-style (see the file LICENSE.txt)*Niklas Broberg, niklas.broberg@chalmers.sestableportableSafe-7Lex a string into a list of Haskell 2010 source tokens..JLex a string into a list of Haskell source tokens, using an explicit mode.-.       !"#$%&'()*+,-.-.      !"#$%&'()*+ ,-.(c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.se experimentalportableSafe/Translate an annotated AST node representing a Haskell module, into a simpler version that retains (almost) only abstract information. In particular, XML and hybrid XML pages enabled by the XmlSyntax extension are translated into standard Haskell modules with a page function.0Translate an annotated AST node representing a Haskell declaration into a simpler version. Note that in the simpler version, all declaration nodes are still annotated by s.H/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvH/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvH/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvH/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvY(c) Niklas Broberg 2004-2009, (c) The GHC Team, Noel Winstanley 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafewKThings 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./Pretty-print something in a precedence context.;The document type produced by these pretty printers uses a x environment.Pretty printing monadxPretty-printing parameters.Note: the 2 must be positive and less than all other indents.z"indentation of a class or instance{indentation of a do -expression|indentation of the body of a case expression}$indentation of the body of a multi-if expression~&indentation of the declarations in a let expression&indentation of the declarations in a where clauseIindentation added for continuation lines that would otherwise be offsideblank lines between statements?Pretty-printing style to useadd GHC-style LINE pragmas to output?Varieties of layout we can use.classical layoutclassical layout made explicit(inline decls, with newlines between themeverything on a single lineMThe default mode: pretty-print using the offside rule and sensible defaults.0render the document with a given style and mode.}render the document with a given mode. renderWithMode :: PPHsMode -> Doc -> String renderWithMode = renderStyleMode P.stylerender the document with ?. render :: Doc -> String render = renderWithMode defaultMode)pretty-print with a given style and mode.5pretty-print with the default style and a given mode.(pretty-print with the default style and .(pretty-print with the default style and .5pretty-print with the default style and a given mode.7Indent without braces. Useful for deriving clauses etc.wxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~$ wxyz{|}~$w xyz{|}~wx yz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~<I(c) Niklas Broberg 2004-2009, (c) The GHC Team, 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe|Checks whether the parameter is a symbol, and gives a nice warning for "." if ExplicitForAll/TypeOperators are not enabled.-Add a strictness/unpack annotation on a type.Q                         xyz{|}~/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw                    Q                         (c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafexAll AST elements that may include expressions which in turn may need fixity tweaking will be instances of this class.Tweak any expressions in the element to account for the fixities given. Assumes that all operator expressions are fully left associative chains to begin with.!The fixities to account for.The element to tweak.FThe same element, but with operator expressions updated, or a failure.  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = }~ }~   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < =](c) Niklas Broberg 2004-2009, Original (c) Simon Marlow, Sven Panne 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableNone! *+-./0345679:;<=>@CDEGHIKLN > ? @ 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:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       > ? @ 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:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      @  A  C(c) Niklas Broberg 2004-2009 (c) Michael Sloan 2013$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableNone+-35ListOf a stores lists of the AST type a, along with a  , in order to provide  instances for lists. These instances are provided when the type is used as a list in the syntax, and the same delimiters are used in all of its usages. Some exceptions are made: Instances of  for  NonGreedy a& will only consume the input until a is fully parsed. This means that parse errors that come later in the input will be ignored. It's also more efficient, as it's fully lazy in the remainder of the input:aparse (unlines ("module A where" : "main =" : repeat "blah")) :: ParseResult PragmasAndModuleHead\ParseOk (NonGreedy {unNonGreedy = PragmasAndModuleHead [] (ModuleName "A",Nothing,Nothing)})&(this example uses the simplified AST)Type intended to be used with , with instances that implement a non-greedy parse of the module name, including top-level pragmas. This means that a parse error that comes after the module header won't be returned. If the  value is 5, then this means that there was no module header.IParse of a string, which should contain a complete Haskell module, using .JParse of a string containing a complete Haskell module, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.9Parse of a string containing a Haskell expression, using .EParse of a string containing a Haskell expression, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.6Parse of a string containing a Haskell pattern, using .BParse of a string containing a Haskell pattern, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.DParse of a string containing a Haskell top-level declaration, using .PParse of a string containing a Haskell top-level declaration, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.3Parse of a string containing a Haskell type, using .?Parse of a string containing a Haskell type, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.8Parse of a string containing a Haskell statement, using .?Parse of a string containing a Haskell type, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.8Parse of a string containing a Haskell statement, using .?Parse of a string containing a Haskell type, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.PNon-greedy parse of a string starting with a series of top-level option pragmas.2 &&, I(c) The GHC Team, 1997-2000 (c) Niklas Broberg, 2004-2012$BSD-style (see the file LICENSE.txt)*Niklas Broberg, niklas.broberg@chalmers.sestableportableNone+35Type intended to be used with n, with instances that implement a non-greedy parse of the module head, including top-level pragmas, module name, export list, and import list. This means that if a parse error that comes after the imports won't be returned. If no module head is found, then a default simple head like "module Main where" is assumed. This is the same behavior that  has.Note that the - particularly matters for this due to the  MagicHash6 changing the lexing of identifiers to include "#".Type intended to be used with C, with instances that implement a non-greedy parse of the module name, including top-level pragmas. This means that a parse error that comes after the module header won't be returned. If no module head is found, then a default simple head like "module Main where" is assumed. This is the same behavior that  has.Note that the - particularly matters for this due to the  MagicHash6 changing the lexing of identifiers to include "#".Type intended to be used with 8, with instances that implement a non-greedy parse of the module name, including top-level pragmas. This means that a parse error that comes after the module header won't be returned. If no module name is found (and no parse error occurs), then "Main" is returned. This is the same behavior that  has.IParse of a string, which should contain a complete Haskell module, using .JParse of a string containing a complete Haskell module, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.9Parse of a string containing a Haskell expression, using .EParse of a string containing a Haskell expression, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.6Parse of a string containing a Haskell pattern, using .BParse of a string containing a Haskell pattern, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.DParse of a string containing a Haskell top-level declaration, using PParse of a string containing a Haskell top-level declaration, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.3Parse of a string containing a Haskell type, using .?Parse of a string containing a Haskell type, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.3Parse of a string containing a Haskell type, using .?Parse of a string containing a Haskell type, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.AParse of a string containing a Haskell import declaration, using .?Parse of a string containing a Haskell type, using an explicit .JParse of a string containing a complete Haskell module, using an explicit , retaining comments.MPartial parse of a string starting with a series of top-level option pragmas.(!"#$%&'()*+,11%!"#$%&'()*+,(c) Niklas Broberg 2004-2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableNone:Parse a source file on disk, using the default parse mode.vParse 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.|Parse 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.VGather 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{|}~      !"#$%&'()*+,3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}~      !"#$%&'()*+-.wxyz{|}~  -./(c) Niklas Broberg 2004-2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableNone :Parse a source file on disk, using the default parse mode.vParse 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.SParse a source file on disk, supplying a custom parse mode, and retaining comments.pParse a source file on disk, supplying a custom parse mode, and retaining comments as well as unknown pragmas.?Parse a source file from a string using the default parse mode.|Parse 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.SParse a source file from a string using a custom parse mode and retaining comments.mParse a source file from a string using a custom parse mode retaining comments as well as unknown pragmas.VGather the extensions declared in LANGUAGE pragmas at the top of the file. Returns & if the parse of the pragmas fails.0]Converts a parse result with comments to a parse result with comments and unknown pragmas.1203Z \]^_`ab 3456:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-.wxyz{|}~ 12034 !"#$%&'(())*+,,-./0123456789:;<=>?@ABCDEFGHIJKKLMNOPQRSTUVWXYZ[\]^_`abcdeffghhijklmlnopqrstuvwxyz{|}~       !""#$%&&'()*+,-./0123456789:;<=>?@ABCDEEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrssttuvwxyz{|}~        !"#$%&'()*+,--../0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ( ( ) ) * + , , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f f g h h i  j k l m l n v w x y z { | } ~                                                                                                                                                                     " " # $ % 4 5 6 7 8 9 : ; < = > ? @ A B C D E 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 t t  v w x y z { | } ~                                                                                                                                              !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                    !"#$%&'()*+,-./0123456789:;<=>?@A)*+BCDEFGHIJKLMNOPPQQRSSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ L M N                                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~PPQQyzol      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     op      !"#$%&'()*+,-./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 { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 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{|}~                            haske_DZIEnGTTeZ2FBSHYHSA9eLLanguage.Haskell.Exts.Pretty&Language.Haskell.Exts.Annotated.Syntax%Language.Haskell.Exts.Annotated.BuildLanguage.Haskell.Exts.SrcLocLanguage.Haskell.Exts.Comments*Language.Haskell.Exts.Annotated.ExactPrint(Language.Haskell.Exts.Annotated.CommentsLanguage.Haskell.Exts.ExtensionLanguage.Haskell.Exts.SyntaxLanguage.Haskell.Exts.BuildLanguage.Haskell.Exts.FixityLanguage.Haskell.Exts.Parser&Language.Haskell.Exts.Annotated.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.InternalParserprett_7UQTOB05U7lIYPkFOVraeRText.PrettyPrint.HughesPJstyleribbonsPerLine lineLengthmodeStyle OneLineModeLeftMode ZigZagModePageModeMode AnnotatedannamapAlt FieldUpdateFieldPun FieldWildcardQualStmt ThenTransThenByGroupBy GroupUsing GroupByUsingStmt Generator QualifierLetStmtRecStmtPatField PFieldPat PFieldPunPFieldWildcardRPatRPOpRPEitherRPSeqRPGuardRPCAsRPAsRPParenRPPatRPatOpRPStarRPStarGRPPlusRPPlusGRPOptRPOptGPXAttrPatPVarPLitPNPlusK PInfixAppPAppPTuplePListPParenPRecPAsPat PWildCardPIrrPat PatTypeSigPViewPatPRPatPXTagPXETagPXPcdataPXPatTagPXRPats PQuasiQuotePBangPat WarningTextDeprTextWarnTextRuleVar TypedRuleVarRule Activation ActiveFrom ActiveUntilOverlap NoOverlap IncoherentToolGHCHUGSNHC98YHCHADDOCK UnknownTool ModulePragmaLanguagePragma OptionsPragmaAnnModulePragmaCallConvStdCallCCall CPlusPlusDotNetJvmJs JavaScriptCApiSafety PlayRiskyPlaySafePlayInterruptibleSpliceIdSplice ParenSpliceBracket ExpBracket PatBracket TypeBracket DeclBracketXAttrXNameXDomNameExpVarIPVarConLitInfixAppAppNegAppLambdaLetIfMultiIfCaseDoMDoTuple TupleSectionListParArrayParen LeftSection RightSection RecConstr RecUpdateEnumFrom EnumFromTo EnumFromThenEnumFromThenToParArrayFromToParArrayFromThenToListCompParComp ParArrayComp ExpTypeSigVarQuoteTypQuote BracketExp SpliceExp QuasiQuoteXTagXETagXPcdataXExpTag XChildTag CorePragma SCCPragma GenPragmaProc LeftArrApp RightArrAppLeftArrHighAppRightArrHighAppLCaseExprHoleSignSignlessNegativeLiteralCharStringIntFracPrimIntPrimWord PrimFloat PrimDoublePrimChar PrimStringAsstClassAAppAInfixAIParamEqualPParenA WildCardAContextCxSingleCxTupleCxEmptyFunDepKindKindStarKindFn KindParenKindVarKindApp KindTupleKindList TyVarBind KindedVar UnkindedVarBoxedUnboxedPromotedPromotedIntegerPromotedString PromotedCon PromotedList PromotedTuple PromotedUnitTypeTyForallTyFunTyTupleTyList TyParArrayTyAppTyVarTyConTyParenTyInfixTyKind TyPromotedTyEqualsTySpliceTyBang TyWildCard GuardedRhsRhs UnGuardedRhs GuardedRhssBangTypeBangedTy UnpackedTyInstDeclInsDeclInsTypeInsDataInsGData ClassDeclClsDecl ClsDataFamClsTyFamClsTyDef ClsDefSigGadtDecl FieldDeclConDecl InfixConDeclRecDecl QualConDeclMatch InfixMatchIPBindBindsBDeclsIPBindsDerivingInstHeadIHConIHInfixIHParenIHAppInstRuleIRuleIParenDeclHeadDHeadDHInfixDHParenDHApp DataOrNewDataTypeNewTypeRoleNominalRepresentationalPhantom RoleWildcardBooleanFormula VarFormula AndFormula OrFormula ParenFormula AnnotationAnnTypeAnn ModuleAnnTypeEqnPatternSynDirectionUnidirectionalImplicitBidirectionalExplicitBidirectionalDeclTypeDecl TypeFamDeclClosedTypeFamDeclDataDecl GDataDecl DataFamDecl TypeInsDecl DataInsDecl GDataInsDecl DerivDecl InfixDecl DefaultDecl SpliceDeclTypeSig PatSynSigFunBindPatBindPatSynForImpForExpRulePragmaDeclDeprPragmaDeclWarnPragmaDecl InlineSigInlineConlikeSigSpecSig SpecInlineSigInstSig AnnPragma MinimalPragma RoleAnnotDeclAssoc AssocNone AssocLeft AssocRight ImportSpecIVarIAbs IThingAll IThingWithImportSpecList ImportDecl importAnn importModuleimportQualified importSrc importSafe importPkgimportAs importSpecs Namespace NoNamespace TypeNamespacePatternNamespace ExportSpecEVarEAbs EThingAll EThingWithEModuleContentsExportSpecList ModuleHeadModuleXmlPage XmlHybridCNameVarNameConNameOpVarOpConOpQOpQVarOpQConOpIPNameIPDupIPLinNameIdentSymbolQNameQualUnQualSpecial SpecialConUnitConListConFunConTupleConConsUnboxedSingleCon 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_nameinterruptible_namethreadsafe_name stdcall_name ccall_namecplusplus_name dotnet_namejvm_namejs_namejavascript_name capi_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 combSpanMaybe<++><+?><**<^^>$fSrcInfoSrcSpanInfo$fSrcInfoSrcSpan$fSrcInfoSrcLoc$fShowSrcSpanInfo $fShowSrcSpan $fShowSrcLoc UnknownPragmaCommentExactP exactPrintassociateHaddockKnownExtensionOverlappingInstancesUndecidableInstancesIncoherentInstances InstanceSigsDoRec RecursiveDoParallelListCompMultiParamTypeClassesMonomorphismRestrictionFunctionalDependencies Rank2Types RankNTypesPolymorphicComponentsExistentialQuantificationScopedTypeVariablesPatternSignaturesImplicitParamsFlexibleContextsFlexibleInstancesEmptyDataDeclsCPPKindSignatures BangPatternsTypeSynonymInstancesTemplateHaskellForeignFunctionInterfaceArrowsGenericsImplicitPreludeNamedFieldPuns PatternGuardsGeneralizedNewtypeDerivingExtensibleRecordsRestrictedTypeSynonyms HereDocuments MagicHashBinaryLiterals TypeFamiliesStandaloneDeriving UnicodeSyntaxUnliftedFFITypesLiberalTypeSynonyms TypeOperatorsParallelArraysRecordWildCards RecordPunsDisambiguateRecordFieldsOverloadedStringsGADTs MonoPatBindsRelaxedPolyRecExtendedDefaultRules UnboxedTuplesDeriveDataTypeableConstrainedClassMethodsPackageImports LambdaCaseImpredicativeTypesNewQualifiedOperatorsPostfixOperators QuasiQuotesTransformListComp ViewPatterns XmlSyntaxRegularPatterns TupleSectionsGHCForeignImportPrimNPlusKPatternsDoAndIfThenElseRebindableSyntaxExplicitForAllDatatypeContextsMonoLocalBinds DeriveFunctor DeriveGenericDeriveTraversableDeriveFoldableNondecreasingIndentationInterruptibleFFICApiFFIExplicitNamespaces DataKinds PolyKinds MultiWayIf SafeImportsSafe TrustworthyDefaultSignaturesConstraintKindsRoleAnnotationsPatternSynonymsPartialTypeSignaturesNamedWildCards ExtensionEnableExtensionDisableExtensionUnknownExtensionLanguage Haskell98 Haskell2010HaskellAllDisabledUnknownLanguageknownLanguagesclassifyLanguageprettyLanguage impliesExts glasgowExts ghcDefaultknownExtensionsdeprecatedExtensionsclassifyExtensionparseExtensionprettyExtensiontoExtensionList AlwaysActive importLoc AppFixity applyFixitiesFixityprefixMinusFixitypreludeFixities baseFixitiesinfixr_infixl_infix_ ParseMode parseFilename baseLanguage extensionsignoreLanguagePragmasignoreLinePragmasfixitiesignoreFunctionArity ParseResultParseOk ParseFailed Parseableparse parseWithModeparseWithCommentsfromParseResultdefaultParseModeTokenVarIdQVarId IDupVarId ILinVarIdConIdQConIdDVarIdVarSymConSymQVarSymQConSymIntTokFloatTok Character StringTok IntTokHash WordTokHash FloatTokHash DoubleTokHash CharacterHash StringHash LeftParen RightParen LeftHashParenRightHashParen SemiColon LeftCurly RightCurly VRightCurly LeftSquare RightSquareParArrayLeftSquareParArrayRightSquareComma Underscore BackQuoteDotDotDotColon QuoteColon DoubleColonEquals BackslashBar LeftArrow RightArrowAtTilde DoubleArrowMinus ExclamationStar LeftArrowTailRightArrowTailLeftDblArrowTailRightDblArrowTail THExpQuote THPatQuote THDecQuote THTypQuote THCloseQuote THIdEscape THParenEscape THVarQuote THTyQuote THQuasiQuote RPGuardOpen RPGuardCloseRPCAt XCodeTagOpen XCodeTagClose XStdTagOpen XStdTagClose XCloseTagOpenXEmptyTagClose XChildTagOpenXPCDATA XRPatOpen XRPatClose PragmaEndRULESINLINEINLINE_CONLIKE SPECIALISESPECIALISE_INLINESOURCE DEPRECATEDWARNINGSCC GENERATEDCOREUNPACKOPTIONSLANGUAGEANNMINIMAL NO_OVERLAPOVERLAP INCOHERENTKW_AsKW_ByKW_CaseKW_ClassKW_Data KW_Default KW_DerivingKW_DoKW_MDoKW_Else KW_Family KW_ForallKW_Group KW_HidingKW_If KW_ImportKW_InKW_Infix KW_InfixL KW_InfixR KW_InstanceKW_Let KW_Module KW_NewTypeKW_OfKW_ProcKW_RecKW_RoleKW_ThenKW_TypeKW_UsingKW_Where KW_Qualified KW_Pattern KW_Foreign KW_ExportKW_Safe KW_Unsafe KW_ThreadsafeKW_Interruptible KW_StdCallKW_CCall KW_CPlusPlus KW_DotNetKW_JvmKW_Js KW_JavaScriptKW_CApiEOF showTokenlexTokenStreamlexTokenStreamWithModesModulesDeclsPatSynsTypeEqn sAnnotationsBooleanFormulasRole sModuleName sSpecialConsQNamesNamesIPNamesQOpsOpsCName sModuleHeadsExportSpecList sExportSpec sImportDeclsImportSpecList sNamespace sImportSpecsAssoc sDeclHead sInstRule sInstHead sDataOrNew sDerivingsBindssIPBindsMatch sQualConDeclsConDecl sFieldDecl sGadtDecl sClassDecl sRecFields sInstDecl sBangTypesRhs sGuardedRhssType sPromoted sTyVarBindsKindsFunDepsContextsAsstsLiteralsSignsExpsXNamesXAttrsBracketsSplicesSafety sCallConv sModulePragmasOverlap sActivationsRulesRuleVar sWarningTextsPatsPXAttrsRPatOpsRPat sPatFieldsStmt sQualStmt sFieldUpdatesAltPrettyPPHsMode classIndentdoIndent multiIfIndent caseIndent letIndent whereIndent onsideIndentspacinglayout linePragmasIndentPPLayout PPOffsideRule PPSemiColonPPInLine PPNoLayout defaultModeprettyPrintStyleModeprettyPrintWithMode prettyPrint prettyPrimprettyPrimWithModeListOf NonGreedy unNonGreedyModuleHeadAndImportsPragmasAndModuleHeadPragmasAndModuleName parseModuleparseModuleWithModeparseModuleWithCommentsparseExpparseExpWithModeparseExpWithCommentsparsePatparsePatWithModeparsePatWithComments parseDeclparseDeclWithModeparseDeclWithComments parseTypeparseTypeWithModeparseTypeWithComments parseStmtparseStmtWithModeparseStmtWithCommentsparseImportDeclparseImportDeclWithModeparseImportDeclWithComments getTopPragmasunListOf parseFileparseFileWithExtsparseFileWithModeparseFileWithCommentsparseFileContentsparseFileContentsWithExtsparseFileContentsWithModeparseFileContentsWithCommentsreadExtensionsparseFileWithCommentsAndPragmas'parseFileContentsWithCommentsAndPragmasbaseGHC.Basefmapghc-prim GHC.TypesFalseTrueMaybeNothing$fAnnotatedPromoted$fAnnotatedAlt$fAnnotatedFieldUpdate$fAnnotatedQualStmt$fAnnotatedStmt$fAnnotatedPatField$fAnnotatedRPat$fAnnotatedRPatOp$fAnnotatedPXAttr$fAnnotatedPat$fAnnotatedWarningText$fAnnotatedRuleVar$fAnnotatedRule$fAnnotatedActivation$fAnnotatedOverlap$fAnnotatedModulePragma$fAnnotatedCallConv$fAnnotatedSafety$fAnnotatedSplice$fAnnotatedBracket$fAnnotatedXAttr$fAnnotatedXName$fAnnotatedExp$fAnnotatedSign$fAnnotatedLiteral$fAnnotatedAsst$fAnnotatedContext$fAnnotatedFunDep$fAnnotatedKind$fAnnotatedTyVarBind$fAnnotatedType$fAnnotatedGuardedRhs$fAnnotatedRhs$fAnnotatedBangType$fAnnotatedInstDecl$fAnnotatedClassDecl$fAnnotatedGadtDecl$fAnnotatedFieldDecl$fAnnotatedConDecl$fAnnotatedQualConDecl$fAnnotatedMatch$fAnnotatedIPBind$fAnnotatedBinds$fAnnotatedInstHead$fAnnotatedInstRule$fAnnotatedDeclHead$fAnnotatedDataOrNew$fAnnotatedBooleanFormula$fAnnotatedAnnotation$fAnnotatedRole$fAnnotatedDecl$fAnnotatedTypeEqn$fAnnotatedDeriving$fAnnotatedAssoc$fAnnotatedImportSpec$fAnnotatedImportSpecList$fAnnotatedImportDecl$fAnnotatedNamespace$fAnnotatedExportSpec$fAnnotatedExportSpecList$fAnnotatedModuleHead$fAnnotatedModule$fAnnotatedCName $fAnnotatedOp$fAnnotatedQOp$fAnnotatedIPName$fAnnotatedName$fAnnotatedQName$fAnnotatedSpecialCon$fAnnotatedModuleNameTyPredAsPatWildCardIrrPatPostOpPreOpViewPatSeqRPGuardRPEitherRPCAsRPXRPatsBangPatPAsstPTypePContext ParseXAttr PFieldUpdatePExp p_unit_con p_tuple_conp_unboxed_singleton_con$fAnnotatedPAsst$fAnnotatedPType$fAnnotatedPContext$fAnnotatedParseXAttr$fAnnotatedPFieldUpdate$fAnnotatedPExpunGAltgAltsgAltBool GuardedAlt GuardedAltsexactPEPPosposrunEPgetPossetPos printString getComment dropCommentnewLinepadUntilmPrintComments printCommentprintWhitespace printStringAterrorEPexactPCprintSeq printStrs printPointsprintInterleavedprintInterleaved' printStreams interleavemaybeEP bracketListpListpList' parenList squareListsquareColonList curlyList parenHashList layoutListlListlList' printSemiisSymbolgetName specialNameepQName epInfixQNameepName epInfixNameprintWarndeprs sepFunBindssepClassFunBindssepInstFunBinds printContext internalError$fExactPIPBind$fExactPFieldDecl$fExactPActivation$fExactPOverlap$fExactPRuleVar $fExactPRule$fExactPSafety$fExactPCallConv $fExactPBinds $fExactPXName$fExactPPXAttr$fExactPRPatOp $fExactPRPat$fExactPPatField $fExactPPat$fExactPGuardedAlt$fExactPGuardedAlts$fAnnotatedGuardedAlt$fAnnotatedGuardedAlts$fExactPGuardedRhs $fExactPRhs $fExactPMatch $fExactPAlt $fExactPXAttr$fExactPBracket$fExactPQualStmt $fExactPStmt$fExactPFieldUpdate $fExactPExp$fExactPSplice$fExactPBangType$fExactPGadtDecl$fExactPConDecl$fExactPQualConDecl$fExactPFunDep$fExactPInstDecl$fExactPClassDecl$fExactPDeriving $fExactPAsst$fExactPContext$fExactPPromoted $fExactPType $fExactPKind$fExactPTyVarBind$fExactPInstHead$fExactPInstRule$fExactPDeclHead$fExactPBooleanFormula$fExactPAnnotation $fExactPRole $fExactPDecl$fExactPTypeEqn$fExactPDataOrNew $fExactPAssoc$fExactPWarningText$fExactPModulePragma$fExactPModuleHead$fExactPModule$fExactPImportDecl$fExactPImportSpec$fExactPImportSpecList$fExactPExportSpecList$fExactPExportSpec$fExactPNamespace $fExactPCName $fExactPOp $fExactPQOp$fExactPIPName $fExactPName $fExactPQName$fExactPSpecialCon$fExactPModuleName $fExactPSign$fExactPLiteral $fMonadEP$fApplicativeEP $fFunctorEPHaddockCommentPrePostNoneCommentAccumulatormergelastPost associate1newAccumulator getToMergematchPreviousSrcisBeforeisNonecommentsToHaddockcommentToHaddock hcCommentGHC.ListzipWithallLangDefaultclassifyKnownExtensionknownExtensionTablereadMayEnabled isEnabled MExtScheme ExtSchemeAnyAll$fEnabledMaybe$fEnabledExtScheme$fEnabledKnownExtension askFixity askFixityPaskFixfixity appFixDecls getFixitiesgetBindFixitiesleafFixleafFixP$fAppFixityXAttr$fAppFixitySplice$fAppFixityBracket$fAppFixityQualStmt$fAppFixityAlt$fAppFixityFieldUpdate$fAppFixityIPBind$fAppFixityBinds$fAppFixityStmt$fAppFixityPXAttr$fAppFixityRPat$fAppFixityPatField$fAppFixityGuardedRhs$fAppFixityRhs$fAppFixityMatch$fAppFixityInstDecl$fAppFixityClassDecl$fAppFixityAnnotation$fAppFixityDecl$fAppFixityModule$fAppFixityPat$fAppFixityExpPGHC.Err undefinedparserdiscard lexNewlinelexTab lexWhile_ addExtensionLsaveExtensionsLrestoreExtensionsLLexrunLrunPInternalParseMode IParseModeiParseFilename iExtensionsiIgnoreLinePragmasiIgnoreFunctionArity ParseStateCtxtFlag ExtContextCodeCtxtHarpCtxtTagCtxt ChildCtxt CloseTagCtxt CodeTagCtxt LexContextNoLayoutLayout ParseStatusOkFailedindentOfParseStatetoInternalParseModerunParserWithMode runParserrunParserWithModeCommentsatSrcLoc getSrcLoc getModuleNamepushCurrentContext currentIndent pushContext popContext getExtensions pushCtxtFlag pullDoStatusgetIgnoreFunctionAritygetInputnextTab tAB_LENGTHlexWhile alternativecheckBOLsetBOL startToken getOffside getSrcLocL setSrcLineL pushContextL popContextL pullCtxtFlagflagDo getExtContextpushExtContextLpopExtContextLgetExtensionsLignoreLinePragmasLsetLineFilenameL pushComment $fMonadLex$fApplicativeLex $fFunctorLex$fMonadP$fApplicativeP $fFunctorP$fMonoidParseResult$fMonadParseResult$fApplicativeParseResult$fFunctorParseResultisPossiblyQvarlexWhiteSpace_ isBinDigit reserved_opsspecial_varops reserved_idsspecial_varidspragmasisIdent isHSymbol isPragmaChar matchCharlexertopLexer lexWhiteSpaceisRecognisedPragma isLinePragma lexLinePragmalexNestedCommentlexBOLlexToken lexChildCtxt lexPCDATAlexCodeTagCtxtlexCloseTagCtxt lexTagCtxt lexHarpToken lexStdTokenlookupKnownPragmalexPragmaStart lexRawPragmalexDecimalOrFloatlexHashlexConIdOrQual lexCharacter lexString lexEscapelexOctal lexBinarylexHexadecimal lexDecimal parseIntegerflagKWpretty prettyPrecDocDocMrenderStyleModeppIndentPrettyDeclLikewantsBlanklinethenDocM then_DocMretDocMunDocMgetPPEnvemptynesttextcharintintegerfloatdoubleparensbracketsbraces doubleQuotesparensIfsemicommaspaceequals<><+>$$$+$hcathsepvcatfsep punctuateppModuleHeader ppWarnTxt condBlanklineppDeclsppWhereppSig ppWarnDepr ppRuleVarsppOptionsPragmappField ppDerivingppBTypeppAType prec_btype prec_atypeppForall ppOptKind ppFunDepsppLetExp ppBracket ppLetStmt ppQNameInfixppQName ppNameInfixppName isSymbolNamegetSpecialName ppContext colonFollowmaybePP hashParenList braceListbracketColonList flatBlock prettyBlock blanklinetopLevelppBody$$$mySepmyVcat myFsepSimplemyFsep layoutChoicemarkLine $fPrettyPType $fPrettyPAsst$fPrettyPContext$fPrettyParseXAttr$fPrettyPFieldUpdate $fPrettyPExp $fPrettyAsst$fPrettyContext $fPrettyCName$fPrettyDeclLikeIPBind$fPrettyIPBind$fPrettyIPName $fPrettyName $fPrettyOp $fPrettyQName $fPrettyQOp$fPrettyFieldUpdate$fPrettyQualStmt $fPrettyStmt $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$fPrettyInstRule$fPrettyDeclHead$fPrettyDeclLikeDecl $fPrettyDecl$fPrettyImportSpec$fPrettyImportSpecList$fPrettyImportDecl$fPrettyExportSpec$fPrettyExportSpecList$fPrettyModuleName$fPrettyWarningText$fPrettyModuleHead$fPrettyModule$fPrettySrcSpan$fPrettySrcLoc $fPrettyAsst0$fPrettySpecialCon$fPrettyCName0$fPrettyIPBind0$fPrettyDeclLikeIPBind0$fPrettyIPName0 $fPrettyName0 $fPrettyOp0$fPrettyQName0 $fPrettyQOp0$fPrettyFieldUpdate0$fPrettyQualStmt0 $fPrettyStmt0 $fPrettyAlt0$fPrettyRPatOp0 $fPrettyRPat0$fPrettyPatField0$fPrettyPXAttr0 $fPrettyPat0$fPrettySplice0$fPrettyBracket0$fPrettyXName0$fPrettyXAttr0 $fPrettyExp0$fPrettyLiteral0$fPrettyGuardedAlt$fPrettyGuardedAlts$fPrettyGuardedRhs0 $fPrettyRhs0$fPrettyFunDep0 $fPrettyKind0$fPrettyTyVarBind0$fPrettyPromoted $fPrettyType0$fPrettyBangType0$fPrettyConDecl0$fPrettyGadtDecl0$fPrettyQualConDecl0 $fPrettyTool$fPrettyModulePragma0$fPrettyRuleVar0$fPrettyOverlap$fPrettyActivation0 $fPrettyRule0$fPrettyCallConv0$fPrettySafety0$fPrettyInstDecl0$fPrettyDeclLikeInstDecl$fPrettyClassDecl0$fPrettyDeclLikeClassDecl$fPrettyMatch0$fPrettyAssoc0$fPrettyDataOrNew0 $fPrettyRole$fPrettyBooleanFormula$fPrettyAnnotation0 $fPrettyDecl0$fPrettyDeclLikeDecl0$fPrettyTypeEqn$fPrettyImportSpec0$fPrettyImportDecl0$fPrettyExportSpec0$fPrettyNamespace$fPrettyModuleName0$fPrettyModule0 $fMonadDocM$fApplicativeDocM $fFunctorDocMcheckAndWarnTypeOperatorsbangTypeSL splitTyConApp checkEnabledcheckEnabledOneOfcheckPatternGuards checkToplevel checkPContextcheckAssertion getSymbol checkSContext checkContext checkAsstcheckAsstParamcheckDataHeadercheckClassHeader checkSimple mkTyVarBindcheckInstHeader checkInstscheckInstsGuts checkDeriving checkPatterncheckPatisNegatableLiteral splitBang checkPatField checkPAttrpatFail checkRPattern checkRPatOprpOpFail fixRPOpPrec mkChildrenPat checkExpr checkAttrcheckDo check1Expr check2Exprs check3ExprscheckManyExprs mCheckExpr checkRuleExprreadTool checkField getGConName checkValDefisFunLhs checkSigVarcheckExplicitPatSyncheckClassBody checkInstBodycheckMethodDefcheckDefSigDef checkUnQualcheckQualOrUnQual checkEqNames checkPrecmkRecConstrOrUpdateupdateQNameLoccheckSingleDecl checkRevDeclscheckRevClsDeclscheckRevInstDeclscheckDataOrNewcheckDataOrNewGcheckSimpleType checkTypecheckT check1Type check2Types checkTypes checkTyVar checkKindcheckPageModulecheckHybridModulemkDVar mkTyForallmkRoleAnnotDecl getFixity HappyAddrHappyA#HappyStk Happy_IntList HappyConsHappyAny HappyAbsSyn 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 happyIn234 happyOut234 happyIn235 happyOut235 happyIn236 happyOut236 happyIn237 happyOut237 happyIn238 happyOut238 happyIn239 happyOut239 happyIn240 happyOut240 happyIn241 happyOut241 happyIn242 happyOut242 happyIn243 happyOut243 happyIn244 happyOut244 happyIn245 happyOut245 happyIn246 happyOut246 happyIn247 happyOut247 happyIn248 happyOut248 happyIn249 happyOut249 happyIn250 happyOut250 happyIn251 happyOut251 happyIn252 happyOut252 happyIn253 happyOut253 happyIn254 happyOut254 happyIn255 happyOut255 happyIn256 happyOut256 happyIn257 happyOut257 happyIn258 happyOut258 happyIn259 happyOut259 happyIn260 happyOut260 happyIn261 happyOut261 happyIn262 happyOut262 happyIn263 happyOut263 happyIn264 happyOut264 happyIn265 happyOut265 happyIn266 happyOut266 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nontermshappyReduce_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_629happyReduce_630happyReduction_630happyReduce_631happyReduction_631happyReduce_632happyReduction_632happyReduce_633happyReduction_633happyReduce_634happyReduction_634happyReduce_635happyReduction_635happyReduce_636happyReduction_636happyReduce_637happyReduction_637happyReduce_638happyReduction_638happyReduce_639happyReduction_639happyReduce_640happyReduction_640happyReduce_641happyReduction_641happyReduce_642happyReduction_642happyReduce_643happyReduction_643happyReduce_644happyReduction_644happyReduce_645happyReduction_645happyReduce_646happyReduction_646happyReduce_647happyReduction_647happyReduce_648happyReduction_648happyReduce_649happyReduction_649happyReduce_650happyReduction_650happyReduce_651happyReduction_651happyReduce_652happyReduction_652happyReduce_653happyReduction_653happyReduce_654happyReduction_654happyReduce_655happyReduction_655happyReduce_656happyReduction_656happyReduce_657happyReduction_657happyReduce_658happyReduction_658happyReduce_659happyReduction_659happyReduce_660happyReduction_660happyReduce_661happyReduction_661happyReduce_662happyReduction_662happyReduce_663happyReduction_663happyReduce_664happyReduction_664happyReduce_665happyReduction_665happyReduce_666happyReduction_666happyReduce_667happyReduction_667happyReduce_668happyReduction_668happyReduce_669happyReduction_669happyReduce_670happyReduction_670happyReduce_671happyReduction_671happyReduce_672happyReduction_672happyReduce_673happyReduction_673happyReduce_674happyReduction_674happyReduce_675happyReduction_675happyReduce_676happyReduction_676happyReduce_677happyReduction_677happyReduce_678happyReduction_678happyReduce_679happyReduction_679happyReduce_680happyReduction_680happyReduce_681happyReduction_681happyReduce_682happyReduction_682happyReduce_683happyReduction_683happyReduce_684happyReduction_684happyReduce_685happyReduction_685happyReduce_686happyReduction_686happyReduce_687happyReduction_687happyReduce_688happyReduction_688happyReduce_689happyReduction_689happyReduce_690happyReduction_690happyReduce_691happyReduction_691happyReduce_692happyReduction_692happyReduce_693happyReduction_693happyReduce_694happyReduction_694happyReduce_695happyReduction_695happyReduce_696happyReduction_696happyReduce_697happyReduction_697happyReduce_698happyReduction_698happyReduce_699happyReduction_699happyReduce_700happyReduction_700happyReduce_701happyReduction_701happyReduce_702happyReduction_702happyReduce_703happyReduction_703happyReduce_704happyReduction_704happyReduce_705happyReduction_705happyReduce_706happyReduction_706happyReduce_707happyReduction_707happyReduce_708happyReduction_708happyReduce_709happyReduction_709happyReduce_710happyReduction_710happyReduce_711happyReduction_711happyReduce_712happyReduction_712happyReduce_713happyReduction_713happyReduce_714happyReduction_714happyReduce_715happyReduction_715happyReduce_716happyReduction_716happyReduce_717happyReduction_717happyReduce_718happyReduction_718happyReduce_719happyReduction_719happyReduce_720happyReduction_720happyReduce_721happyReduction_721happyReduce_722happyReduction_722happyReduce_723happyReduction_723happyReduce_724happyReduction_724happyReduce_725happyReduction_725happyReduce_726happyReduction_726 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError' mparseModule mparseExp mparsePat mparseDeclAux mparseType mparseStmtmparseImportDeclngparseModulePragmasngparseModuleHeadAndImportsngparsePragmasAndModuleHeadngparsePragmasAndModuleNamehappySeq parseErrornISiS mparseDecl happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeq normalParsernormalParserNoFixitynglistParserNoFixitytoListOf$fFunctorNonGreedy$fParseableNonGreedy$fParseableNonGreedy0$fParseableNonGreedy1$fParseableNonGreedy2$fParseableImportDecl$fParseableType$fParseableStmt$fParseablePat$fParseableModule$fParseableExp$fParseableDeclparseWithSimplify ppContentsdelit readUTF8FileseparatePragmas