!;j      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~               ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                         (c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)*Niklas Broberg, niklas.broberg@chalmers.se transientportableSafe23n haskell-src-exts  GHC 7.6.3.4cAllow overlapping class instances, provided there is a unique most specific instance for each use. haskell-src-exts  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.haskell-src-exts  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.haskell-src-exts  GHC 7.6.3.5#Allow type signatures in instances.haskell-src-exts  GHC 7.3.82Deprecated in GHC. Allows recursive bindings in do blocks, using the rec keyword.haskell-src-exts  GHC 7.3.8.2 Allows recursive bindings using mdo, a variant of do, and rec.haskell-src-exts  GHC 7.3.9eProvide syntax for writing list comprehensions which iterate over several lists together, like the  family of functions.haskell-src-exts  GHC 7.6.1.1*Allow multiple parameters in a type class.haskell-src-exts  GHC 7.17,Enable the dreaded monomorphism restriction.haskell-src-exts  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.haskell-src-exts  GHC 7.8.5Like Z but does not allow a higher-rank type to itself appear on the left of a function arrow.haskell-src-exts  GHC 7.8.5NAllow a universally-quantified type to occur on the left of a function arrow.haskell-src-exts  GHC 7.8.5@Allow data constructors to have polymorphic arguments. Unlike ., does not allow this for ordinary functions.haskell-src-exts  GHC 7.4.41Allow existentially-quantified data constructors.haskell-src-exts  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.haskell-src-extsDeprecated, use  instead.haskell-src-exts  GHC 7.8.38Enable implicit function parameters with dynamic scope.haskell-src-exts  GHC 7.8.2HRelax some restrictions on the form of the context of a type signature.haskell-src-exts  GHC 7.6.3.2ORelax some restrictions on the form of the context of an instance declaration.haskell-src-exts  GHC 7.4.12Allow data type declarations with no constructors. haskell-src-exts  GHC 4.10.3.Run the C preprocessor on Haskell source code.!haskell-src-exts  GHC 7.8.4]Allow an explicit kind signature giving the kind of types over which a type variable ranges."haskell-src-exts  GHC 7.11bEnable a form of pattern which forces evaluation before an attempted match, and a form of strict let/where binding.#haskell-src-exts  GHC 7.6.3.1&Allow type synonyms in instance heads.$haskell-src-exts  GHC 7.9DEnable Template Haskell, a system for compile-time metaprogramming.%haskell-src-exts GHC 8Enable the Foreign Function Interface. In GHC, implements the standard Haskell 98 Foreign Function Interface Addendum, plus some GHC-specific extensions.&haskell-src-exts  GHC 7.10Enable arrow notation.'haskell-src-exts  GHC 7.16kEnable generic type classes, with default instances defined in terms of the algebraic structure of a type.(haskell-src-exts  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.)haskell-src-exts  GHC 7.3.15Enable syntax for implicitly binding local names corresponding to the field names of a record. Puns bind specific names, unlike 9.*haskell-src-exts  GHC 7.3.5DEnable a form of guard which matches a pattern and binds variables.+haskell-src-exts  GHC 7.5.4Allow a type declared with newtype to use deriving8 for any class with an instance for the underlying type.,haskell-src-exts  GHC 9.6.10/Allow use of any typeclass in deriving clauses.-haskell-src-exts  Hugs 7.1,Enable the "Trex" extensible records system..haskell-src-exts  Hugs 7.2Enable type synonyms which are transparent in some definitions and opaque elsewhere, as a way of implementing abstract datatypes./haskell-src-exts  Hugs 7.3HEnable an alternate syntax for string literals, with string templating.0haskell-src-exts  GHC 7.3.2Allow the character #X as a postfix modifier on identifiers. Also enables literal syntax for unboxed values.1haskell-src-extsBinary integer literals2haskell-src-exts  GHC 7.7cAllow data types and type synonyms which are indexed by types, i.e. ad-hoc polymorphism for types.3haskell-src-exts  GHC 7.5.2=Allow a standalone declaration which invokes the type class deriving mechanism.4haskell-src-exts  GHC 7.3.1pAllow certain Unicode characters to stand for certain ASCII character sequences, e.g. keywords and punctuation.5haskell-src-exts  GHC 8.1.1:Allow the use of unboxed types as foreign types, e.g. in foreign import and foreign export.6haskell-src-exts  GHC 7.4.3}Defer validity checking of types until after expanding type synonyms, relaxing the constraints on how synonyms may be used.7haskell-src-exts  GHC 7.4.2\Allow the name of a type constructor, type class, or type variable to be an infix operator.8haskell-src-exts  GHC 7.26.5*Parallel arrays for Data Parallel Haskell.9haskell-src-exts  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 ).:haskell-src-extsDeprecated, use ) instead.;haskell-src-exts  GHC 7.3.14QAllow a record field name to be disambiguated by the type of the record it's in.<haskell-src-exts  GHC 7.6.4VEnable overloading of string literals using a type class, much like integer literals.=haskell-src-exts  GHC 7.4.6Enable generalized algebraic data types, in which type variables may be instantiated on a per-constructor basis. Implies GADTSyntax.>haskell-src-exts  GHC 7.17.2"Make pattern bindings monomorphic.?haskell-src-exts  GHC 7.8.8DRelax the requirements on mutually-recursive polymorphic functions.@haskell-src-exts  GHC 2.4.5EAllow default instantiation of polymorphic types in more situations.Ahaskell-src-exts  GHC 7.2.2Enable unboxed tuples.Bhaskell-src-exts  GHC 7.5.3Enable deriving for classes Data.Typeable.Typeable and Data.Generics.Data.Chaskell-src-exts  GHC 7.6.1.3VAllow a class method's type to place additional constraints on a class type variable.Dhaskell-src-exts  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.SocketFhaskell-src-exts  GHC 7.3.20,Allow case expressions with no alternatives.Ghaskell-src-exts  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.Hhaskell-src-exts  GHC 7.3.31Change the syntax for qualified infix operators.Ihaskell-src-exts  GHC 7.3.12URelax the interpretation of left operator sections to allow unary postfix operators.Jhaskell-src-exts  GHC 7.9.5cEnable quasi-quotation, a mechanism for defining new concrete syntax for expressions and patterns.Khaskell-src-exts  GHC 7.3.10\Enable generalized list comprehensions, supporting operations such as sorting and grouping.Lhaskell-src-exts  GHC 7.3.6]Enable view patterns, which match a value by applying a function and matching on the result.Mhaskell-src-extsxAllow 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.Nhaskell-src-extsAllow regular pattern matching over lists, as discussed in the paper "Regular Expression Patterns" by Niklas Broberg, Andreas Farre and Josef Svenningsson, from ICFP '04.Ohaskell-src-exts(Enables the use of tuple sections, e.g. (, True) desugars into x -> (x, True).Phaskell-src-extsHAllows GHC primops, written in C--, to be imported into a Haskell file.Qhaskell-src-exts!Support for patterns of the form n + k, where k is an integer literal.Rhaskell-src-extsImprove the layout rule when if expressions are used in a do block.Shaskell-src-extsqMakes much of the Haskell sugar be desugared into calls to the function with a particular name that is in scope.Thaskell-src-extsMake forallN a keyword in types, which can be used to give the generalisation explicitly.Uhaskell-src-exts0Allow contexts to be put on datatypes, e.g. the Eq a in /data Eq a => Set a = NilSet | ConsSet a (Set a).Vhaskell-src-extsLocal (let and where) bindings are monomorphic.Whaskell-src-extsEnable deriving for the Data.Functor.Functor class.Xhaskell-src-exts  GHC 7.5.3Enable deriving for the Generic and Generic1 classes.Yhaskell-src-extsEnable deriving for the Data.Traversable.Traversable class.Zhaskell-src-extsEnable deriving for the Data.Foldable.Foldable class.[haskell-src-exts&Enable non-decreasing indentation for 'do' blocks.\haskell-src-exts  GHC 8.1.4Enable interruptible FFI.]haskell-src-exts  GHC 8.1.5 Enable the capi7 calling convention in the foreign function interface.^haskell-src-exts[GHCJS FFI extension with convenient import patterns, asynchronous FFI and a JSVal FFI type_haskell-src-exts  GHC 7.3.27,Enable explicit namespaces in import/export.bhaskell-src-exts  GHC 7.3.16hEnable the multi-way if-expressions extension to accept conditional expressions with multiple branches.chaskell-src-exts  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.Socketdhaskell-src-exts  GHC 7.20uCompile a module in the Safe, Safe Haskell mode -- a restricted form of the Haskell language to ensure type safety.ehaskell-src-exts  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.fhaskell-src-exts  GHC 7.6.1.4iAllow default signatures in class definitions. They apply to default methods implemented in this class.ghaskell-src-exts  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.hhaskell-src-exts  GHC 7.25.3Allow role annotations.ihaskell-src-exts  GHC 7.3.84Enable giving names to parametrized pattern schemesjhaskell-src-exts  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.khaskell-src-exts GHC 7.15.1.2This extension treats type variables which start with an underscore as wildcards. For example, `foo :: _x` is equivalent to `foo :: _`.ohaskell-src-extsAllow multiple deriving, clauses, each optionally qualified with a strategy.thaskell-src-extsQEnable deriving instances via types of the same runtime representation. Implies o.vhaskell-src-exts2This represents language extensions beyond a base z definition (such as {L) that are supported by some implementations, usually in some special mode.whaskell-src-extsEnable a known extensionxhaskell-src-extsDisable a known extensionyhaskell-src-exts4An unknown extension, identified by the name of its LANGUAGE pragma.{haskell-src-exts>The Haskell 98 language as defined by the Haskell 98 report. http://haskell.org/onlinereport/|haskell-src-extsBThe Haskell 2010 language as defined by the Haskell 2010 report. /http://www.haskell.org/onlinereport/haskell2010}haskell-src-extsThe minimal language resulting from disabling all recognized extensions - including ones that are part of all known language definitions e.g. MonomorphismRestriction.~haskell-src-exts,An unknown language, identified by its name.haskell-src-extsCertain 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.haskell-src-extsKThe list of extensions enabled by GHC's portmanteau -fglasgow-exts flag.haskell-src-exts;List of all known extensions, both "yes" and "no" versions.haskell-src-exts_Extensions that have been deprecated, possibly paired with another extension that replaces it.haskell-src-exts)A clever version of read that returns an y$ if the string is not recognised.haskell-src-exts1Parse an enabled or disabled extension; returns y if the parse fails.haskell-src-extsGPretty print an extension. Disabled extensions are prefixed with 'No'. BX'ZYW* !"#$%&()+,-./0123456789:;<=>?@ACDEFGHIJKLMNOPQRSTUV[\]^_`abcdefghijklmnopqrstuvwxyz{|}~z{|}~vwxy BX'ZYW* !"#$%&()+,-./0123456789:;<=>?@ACDEFGHIJKLMNOPQRSTUV[\]^_`abcdefghijklmnopqrstu (c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe9 (c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe27Vhaskell-src-exts>A class to work over all kinds of source location information.haskell-src-exts_A portion of the source, extended with information on the position of entities within the span.haskell-src-exts An entity located in the source.haskell-src-extsMA portion of the source, spanning one or more lines and zero or more columns.haskell-src-exts A single position in the source.haskell-src-extsReturns  and  in a pair.haskell-src-extsReturns  and  in a pair.haskell-src-exts5Combine two locations in the source to denote a span.haskell-src-extsMerge 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.haskell-src-exts:Test if a given span starts and ends at the same location.haskell-src-exts Generate a - with no positional information for entities.haskell-src-extsA bogus , the location is noLoc3. `noSrcSpan = noInfoSpan (mkSrcSpan noLoc noLoc)`haskell-src-exts Generate a 7 with the supplied positional information for entities.haskell-src-exts Combine two ms into one that spans the combined source area of the two arguments, leaving positional information blank.haskell-src-extsLike '( +?!)', but it also concatenates the .haskell-src-extsShort name for haskell-src-extskOptionally combine the first argument with the second, or return it unchanged if the second argument is .haskell-src-extsjOptionally combine the second argument with the first, or return it unchanged if the first argument is .haskell-src-exts7Add more positional information for entities of a span.haskell-src-exts Merge two s and lift them to a  SrcInfoSpan0 with no positional information for entities.,,54446I(c) Niklas Broberg 2004-2009, (c) The GHC Team, 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe24567mhaskell-src-extsOAST nodes are annotated, and this class allows manipulation of the annotations.haskell-src-exts'Retrieve the annotation of an AST node.haskell-src-extsChange 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 .haskell-src-extsAn alt alternative in a case expression.haskell-src-extsAn fbind0 in a labeled construction or update expression.haskell-src-extsordinary label-expresion pairhaskell-src-extsrecord field punhaskell-src-extsrecord field wildcardhaskell-src-exts A general  transqualp in a list comprehension, which could potentially be a transform of the kind enabled by TransformListComp.haskell-src-extsan ordinary statementhaskell-src-extsthen exphaskell-src-extsthen exp by exphaskell-src-extsthen group by exphaskell-src-extsthen group using exphaskell-src-extsthen group by exp using exphaskell-src-exts!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.haskell-src-exts a generator: pat <- exphaskell-src-extsan exp by itself: in a dox-expression, an action whose result is discarded; in a list comprehension and pattern guard, a guard expressionhaskell-src-extslocal bindingshaskell-src-exts$a recursive binding group for arrowshaskell-src-extsAn fpat in a labeled record pattern.haskell-src-extsordinary label-pattern pairhaskell-src-extsrecord field punhaskell-src-extsrecord field wildcardhaskell-src-extsAn entity in a regular pattern.haskell-src-extsoperator pattern, e.g. pat*haskell-src-extschoice pattern, e.g. (1 | 2)haskell-src-exts$sequence pattern, e.g. (| 1, 2, 3 |)haskell-src-exts%guarded pattern, e.g. (| p | p < 3 |)haskell-src-exts1non-linear variable binding, e.g. (foo@:(1 | 2))*haskell-src-exts)linear variable binding, e.g. foo@(1 | 2)haskell-src-exts parenthesised pattern, e.g. (2*)haskell-src-extsan ordinary patternhaskell-src-extsA regular pattern operator.haskell-src-exts* = 0 or morehaskell-src-exts*! = 0 or more, greedyhaskell-src-exts+ = 1 or morehaskell-src-exts+! = 1 or more, greedyhaskell-src-exts? = 0 or 1haskell-src-exts?! = 0 or 1, greedyhaskell-src-extsAn XML attribute in a pattern.haskell-src-exts)A pattern, to be matched against a value. haskell-src-extsvariable haskell-src-extsliteral constant haskell-src-exts n+k pattern haskell-src-exts&pattern with an infix data constructor haskell-src-exts&data constructor and argument patternshaskell-src-exts tuple patternhaskell-src-exts unboxed sumhaskell-src-exts list patternhaskell-src-extsparenthesized patternhaskell-src-extslabelled pattern, record stylehaskell-src-exts@-patternhaskell-src-extswildcard pattern: _haskell-src-extsirrefutable pattern: ~pathaskell-src-extspattern with type signaturehaskell-src-extsview patterns of the form (exp -> pat)haskell-src-extsregular list patternhaskell-src-extsXML element patternhaskell-src-extsXML singleton element patternhaskell-src-extsXML PCDATA patternhaskell-src-extsXML embedded patternhaskell-src-extsXML regular list patternhaskell-src-extstemplate haskell splice patternhaskell-src-extsquasi quote pattern: [$name| string |] haskell-src-extsstrict (bang) pattern:  f !x = ...!haskell-src-extsSWarning text to optionally use in the module header of e.g. a deprecated module.$haskell-src-extsAVariables used in a RULES pragma, optionally annotated with types'haskell-src-extsThe body of a RULES pragma.)haskell-src-exts$Activation clause of a RULES pragma.,haskell-src-exts(Recognised overlaps for overlap pragmas.-haskell-src-extsNO_OVERLAP pragma.haskell-src-extsOVERLAP pragma2haskell-src-extsINCOHERENT pragma3haskell-src-exts%Recognised tools for OPTIONS pragmas.:haskell-src-exts8A top level options pragma, preceding the module header.;haskell-src-extsLANGUAGE pragma<haskell-src-exts@OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC=haskell-src-extsANN pragma with module scope>haskell-src-exts2The calling convention of a foreign function call.Ghaskell-src-exts&The safety of a foreign function call.Hhaskell-src-extsunsafeIhaskell-src-extssafe () or threadsafe ()Jhaskell-src-exts interruptibleKhaskell-src-exts$A template haskell splice expressionLhaskell-src-extsvariable splice: $varMhaskell-src-extstyped variable splice: $$varNhaskell-src-exts!parenthesised expression splice: $(exp)Ohaskell-src-exts'parenthesised typed expression splice: $$(exp)Phaskell-src-exts&A template haskell bracket expression.Qhaskell-src-extsexpression bracket:  [| ... |]Rhaskell-src-extstyped expression bracket:  [|| ... ||]Shaskell-src-extspattern bracket:  [p| ... |]Thaskell-src-extstype bracket:  [t| ... |]Uhaskell-src-extsdeclaration bracket:  [d| ... |]Vhaskell-src-exts2An xml attribute, which is a name-expression pair.Xhaskell-src-extsPThe name of an xml element or attribute, possibly qualified with a namespace.[haskell-src-extsHaskell expressions.\haskell-src-extsvariable]haskell-src-extsOverloaded label #foo^haskell-src-extsimplicit parameter variable_haskell-src-extsdata constructor`haskell-src-extsliteral constantahaskell-src-extsinfix applicationbhaskell-src-extsordinary applicationchaskell-src-extsnegation expression -exp (unary minus)dhaskell-src-extslambda expressionehaskell-src-extslocal declarations with let ... in ...fhaskell-src-extsif exp then exp else expghaskell-src-extsif | stmts -> exp ...hhaskell-src-extscase exp of altsihaskell-src-extsdoJ-expression: the last statement in the list should be an expression.jhaskell-src-extsmdo -expressionkhaskell-src-extstuple expressionlhaskell-src-exts unboxed summhaskell-src-extstuple section expression, e.g. (,,3)nhaskell-src-extslist expressionohaskell-src-extsparallel array expressionphaskell-src-extsparenthesised expressionqhaskell-src-exts left section (exp qop)rhaskell-src-extsright section (qop exp)shaskell-src-extsrecord construction expressionthaskell-src-extsrecord update expressionuhaskell-src-exts5unbounded arithmetic sequence, incrementing by 1:  [from ..]vhaskell-src-exts2bounded arithmetic sequence, incrementing by 1  [from .. to]whaskell-src-exts@unbounded arithmetic sequence, with first two elements given [from, then ..]xhaskell-src-exts>bounded arithmetic sequence, with first two elements given [from, then .. to]yhaskell-src-extsAParallel array bounded arithmetic sequence, incrementing by 1 [:from .. to:]zhaskell-src-exts>bounded arithmetic sequence, with first two elements given [:from, then .. to:]{haskell-src-extsordinary list comprehension|haskell-src-extsparallel list comprehension}haskell-src-extsparallel array comprehension~haskell-src-exts'expression with explicit type signaturehaskell-src-exts'x- for template haskell reifying of expressionshaskell-src-exts''T' for template haskell reifying of typeshaskell-src-exts#template haskell bracket expressionhaskell-src-exts"template haskell splice expressionhaskell-src-extsquasi-quotaion: [$name| string |]haskell-src-extsVisible type applicationhaskell-src-exts)xml element, with attributes and childrenhaskell-src-exts"empty xml element, with attributeshaskell-src-extsPCDATA child elementhaskell-src-exts%escaped haskell expression inside xmlhaskell-src-extschildren of an xml elementhaskell-src-exts CORE pragmahaskell-src-exts SCC pragmahaskell-src-extsGENERATED pragmahaskell-src-exts arrows proc: proc pat -> exphaskell-src-extsarrow application (from left): exp -< exphaskell-src-exts arrow application (from right): exp >- exphaskell-src-exts,higher-order arrow application (from left): exp -<< exphaskell-src-exts-higher-order arrow application (from right): exp >>- exphaskell-src-extscase altshaskell-src-exts@An indication whether a literal pattern has been negated or not.haskell-src-extsliteral 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.haskell-src-extscharacter literalhaskell-src-extsstring literalhaskell-src-extsinteger literalhaskell-src-extsfloating point literalhaskell-src-extsunboxed integer literalhaskell-src-extsunboxed word literalhaskell-src-extsunboxed float literalhaskell-src-extsunboxed double literalhaskell-src-extsunboxed character literalhaskell-src-extsunboxed string literalhaskell-src-extsClass assertions.haskell-src-extstype assertionhaskell-src-extsimplicit parameter assertionhaskell-src-extsparenthesised class assertionhaskell-src-exts A context is a set of assertionshaskell-src-extsIA functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rnhaskell-src-extsAn explicit kind annotation.haskell-src-extsIA type variable declaration, optionally with an explicit kind annotation.haskell-src-exts%variable binding with kind annotationhaskell-src-extsordinary variable bindinghaskell-src-exts2Flag denoting whether a tuple is boxed or unboxed.haskell-src-extsUBools 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].haskell-src-extsparsed value and raw stringhaskell-src-extsparsed value and raw stringhaskell-src-extsMA type qualified with a context. An unqualified type has an empty context.haskell-src-extsqualified typehaskell-src-exts*, the type of typeshaskell-src-exts function typehaskell-src-extstuple type, possibly boxedhaskell-src-extsunboxed tuple typehaskell-src-exts)list syntax, e.g. [a], as opposed to [] ahaskell-src-exts!parallel array syntax, e.g. [:a:]haskell-src-exts!application of a type constructorhaskell-src-exts type variablehaskell-src-extsnamed type or type constructorhaskell-src-extstype surrounded by parentheseshaskell-src-extsinfix type constructorhaskell-src-exts!type with explicit kind signaturehaskell-src-exts'K%, a promoted data type (-XDataKinds).haskell-src-exts2type equality predicate enabled by ConstraintKindshaskell-src-extstemplate haskell splice typehaskell-src-extsStrict type marked with "!$" or type marked with UNPACK pragma.haskell-src-exts*Either an anonymous of named type wildcardhaskell-src-exts [$name| string |]haskell-src-extsA 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.haskell-src-extsUThe right hand side of a function binding, pattern binding, or a case alternative.haskell-src-extsunguarded right hand side (exp)haskell-src-extsguarded right hand side (gdrhs)haskell-src-exts"{-# UNPACK #-}"haskell-src-exts"{-# NOUNPACK #-}"haskell-src-extsNo unpack pragmahaskell-src-exts]The type of a constructor argument or field, optionally including a strictness annotation.haskell-src-extsstrict component, marked with "!"haskell-src-extslazy component, marked with "~"haskell-src-extsNo strictness informationhaskell-src-exts,Declarations inside an instance declaration.haskell-src-extsordinary declarationhaskell-src-extsan associated type definitionhaskell-src-exts&an associated data type implementationhaskell-src-exts4an associated data type implemented using GADT stylehaskell-src-exts(Declarations inside a class declaration.haskell-src-extsordinary declarationhaskell-src-exts&declaration of an associated data typehaskell-src-exts)declaration of an associated type synonymhaskell-src-exts-default choice for an associated type synonymhaskell-src-extsdefault signaturehaskell-src-extsAA 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.haskell-src-exts*Declaration of a (list of) named field(s).haskell-src-exts,Declaration of an ordinary data constructor.haskell-src-extsordinary data constructorhaskell-src-extsinfix data constructorhaskell-src-extsrecord constructorhaskell-src-extsyA single constructor declaration within a data type declaration, which may have an existential quantification binding.haskell-src-extsClauses of a function binding.haskell-src-extsA clause defined with prefix notation, i.e. the function name followed by its argument patterns, the right-hand side and an optional where clause.haskell-src-exts0A 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.haskell-src-exts#A binding of an implicit parameter.haskell-src-extsA binding group inside a let or where clause.haskell-src-extsAn ordinary binding grouphaskell-src-exts'A binding group for implicit parametershaskell-src-extsHWhich technique the user explicitly requested when deriving an instance.haskell-src-extsGHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., , ,  when -XDeriveFunctor is enabled, etc.)haskell-src-exts -XDeriveAnyClasshaskell-src-exts -XGeneralizedNewtypeDerivinghaskell-src-exts  -XDerivingViahaskell-src-exts4A deriving clause following a data type declaration.haskell-src-extsFThe 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")))))haskell-src-extstype or class namehaskell-src-exts<infix application of the type/class name to the left operandhaskell-src-extsparenthesized instance headhaskell-src-extsapplication to one more typehaskell-src-extsbThe 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") ]) ... haskell-src-extsqThe 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")) haskell-src-extstype or class name haskell-src-exts<infix application of the type/class name to the left operand haskell-src-extsparenthesized declaration head haskell-src-exts%application to one more type variablehaskell-src-exts,Injectivity info for injective type familieshaskell-src-extsFA flag stating whether a declaration is a data or newtype declaration.haskell-src-exts&A boolean formula for MINIMAL pragmas.haskell-src-exts A variable.haskell-src-extsAnd boolean formulas.haskell-src-extsOr boolean formulas.haskell-src-extsParenthesized boolean formulas. haskell-src-exts$An annotation through an ANN pragma.!haskell-src-exts"An annotation for a declared name."haskell-src-exts"An annotation for a declared type.#haskell-src-exts&An annotation for the defining module.$haskell-src-exts1A type equation as found in closed type families.'haskell-src-exts*A unidirectional pattern synonym with "<-"(haskell-src-exts(A bidirectional pattern synonym with "=")haskell-src-exts>A birectional pattern synonym with the construction specified.*haskell-src-extsA top-level declaration.+haskell-src-extsA type declaration,haskell-src-extsA type family declaration-haskell-src-exts A closed type family declaration.haskell-src-extsA data OR newtype declaration/haskell-src-exts)A data OR newtype declaration, GADT style0haskell-src-extsA data family declaration1haskell-src-exts"A type family instance declaration2haskell-src-exts"A data family instance declaration3haskell-src-exts.A data family instance declaration, GADT style4haskell-src-extsA declaration of a type class5haskell-src-exts'An declaration of a type class instance6haskell-src-exts!A standalone deriving declaration7haskell-src-exts A declaration of operator fixity8haskell-src-extsA declaration of default types9haskell-src-exts'A Template Haskell splicing declaration:haskell-src-exts-A typed Template Haskell splicing declaration;haskell-src-extsA type signature declaration<haskell-src-exts%A pattern synonym signature declation=haskell-src-exts!A set of function binding clauses>haskell-src-extsA pattern binding?haskell-src-extsA pattern synonym binding@haskell-src-extsA foreign import declarationAhaskell-src-extsA foreign export declarationBhaskell-src-extsA RULES pragmaChaskell-src-extsA DEPRECATED pragmaDhaskell-src-extsA WARNING pragmaEhaskell-src-extsAn INLINE pragmaFhaskell-src-extsAn INLINE CONLIKE pragmaGhaskell-src-extsA SPECIALISE pragmaHhaskell-src-extsA SPECIALISE INLINE pragmaIhaskell-src-extsA SPECIALISE instance pragmaJhaskell-src-exts An ANN pragmaKhaskell-src-extsA MINIMAL pragmaLhaskell-src-extsA role annotationMhaskell-src-extsA COMPLETE pragmaNhaskell-src-extsAssociativity of an operator.Ohaskell-src-exts(non-associative operator (declared with infix)Phaskell-src-exts)left-associative operator (declared with infixl).Qhaskell-src-exts*right-associative operator (declared with infixr)Rhaskell-src-extscAn import specification, representing a single explicit item imported (or hidden) from a module.Shaskell-src-extsvariableThaskell-src-extsT3: the name of a class, datatype or type synonym.Uhaskell-src-extsT(..)f: a class imported with all of its methods, or a datatype imported with all of its constructors.Vhaskell-src-extsT(C_1,...,C_n)h: a class imported with some of its methods, or a datatype imported with some of its constructors.Whaskell-src-exts&An explicit import specification list.Xhaskell-src-exts&A list of import specifications. The  is  if the names are excluded by hiding.Yhaskell-src-extsAn import declaration.[haskell-src-exts/annotation, used by parser for position of the import keyword.\haskell-src-extsname of the module imported.]haskell-src-exts imported  qualified?^haskell-src-extsimported with {-# SOURCE #-}?_haskell-src-extsImport safe?`haskell-src-exts#imported with explicit package nameahaskell-src-extsoptional alias name in an as clause.bhaskell-src-exts'optional list of import specifications.chaskell-src-extsNamespaces for imports/exports.ghaskell-src-exts8Indicates the position of the wildcard in an export listjhaskell-src-exts+An item in a module's export specification.khaskell-src-exts variable.lhaskell-src-extsTC: a class or datatype exported abstractly, or a type synonym.mhaskell-src-extsT(C_1,...,C_n)h: a class exported with some of its methods, or a datatype exported with some of its constructors.nhaskell-src-extsmodule M: re-export a module.ohaskell-src-exts!An explicit export specification.qhaskell-src-extsBThe head of a module, including the name and export specification.shaskell-src-exts!A complete Haskell source module.thaskell-src-extsan ordinary Haskell moduleuhaskell-src-extsa 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.vhaskell-src-extsAa hybrid module combining an XML document with an ordinary modulewhaskell-src-extsA name (cname/) of a component of a class or data type in an import or export specification.xhaskell-src-extsname of a method or fieldyhaskell-src-extsname of a data constructorzhaskell-src-extsOperators appearing in infix" declarations are never qualified.{haskell-src-extsvariable operator (varop)|haskell-src-extsconstructor operator (conop)}haskell-src-exts$Possibly qualified infix operators (qop), appearing in expressions.~haskell-src-extsvariable operator (qvarop)haskell-src-extsconstructor operator (qconop)haskell-src-extsAn implicit parameter name.haskell-src-exts?ident, non-linear implicit parameterhaskell-src-exts%ident, linear implicit parameterhaskell-src-exts@This type is used to represent variables, and also constructors.haskell-src-extsvarid or conid.haskell-src-extsvarsym or consymhaskell-src-extsUThis type is used to represent qualified variables, and also qualified constructors.haskell-src-exts!name qualified with a module namehaskell-src-extsunqualified local namehaskell-src-exts(built-in constructor with special syntaxhaskell-src-exts{Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.haskell-src-extsunit type and data constructor ()haskell-src-extslist type and data constructor []haskell-src-extsfunction type constructor ->haskell-src-extsn)-ary tuple type and data constructors (,) etc, possibly boxed (#,#)haskell-src-extslist data constructor (:)haskell-src-exts$unboxed singleton tuple constructor (# #)haskell-src-extsAn expression hole _haskell-src-extsThe name of a Haskell module.haskell-src-exts6Test if two AST elements are equal modulo annotations.      !"#$%&'()*+,1/02.-3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\f_bn]^`acdeghijklmopqrstuvwxyz{|}~      !"#$%&'()*?45+,-./01236789:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgihjklmnopqrstuvwxyz{|}~stuvqr!"#opjklmngihYZ[\]^_`abWXRSTUVNOPQcdef*?45+,-./01236789:;<=>@ABCDEFGHIJKLM     &'()$%[\f_bn]^`acdeghijklmopqrstuvwxyz{|}~VW      }~z{|wxyXYZPQRSTUKLMNOGHIJ>?@ABCDEF:;<=3456789,1/02.-'($%&)*+ !"# Safe4Ohaskell-src-exts*, the type of typeshaskell-src-exts function typehaskell-src-extstuple type, possibly boxedhaskell-src-exts unboxed sumhaskell-src-exts)list syntax, e.g. [a], as opposed to [] ahaskell-src-exts!parallel array syntax, e.g. [:a:]haskell-src-exts!application of a type constructorhaskell-src-exts type variablehaskell-src-extsnamed type or type constructorhaskell-src-extstype surrounded by parentheseshaskell-src-exts"assertion of an implicit parameterhaskell-src-extsinfix type constructorhaskell-src-exts!type with explicit kind signaturehaskell-src-extspromoted data typehaskell-src-extstype equality constrainthaskell-src-extstemplate haskell splice typehaskell-src-extsStrict type marked with "!$" or type marked with UNPACK pragma.haskell-src-exts Type wildcardhaskell-src-exts [qq| |]haskell-src-extsvariablehaskell-src-extsoverloaded label #foohaskell-src-extsimplicit parameter variablehaskell-src-extsdata constructorhaskell-src-extsliteral constanthaskell-src-extsinfix applicationhaskell-src-extsordinary applicationhaskell-src-extsnegation expression - exphaskell-src-extslambda expressionhaskell-src-extslocal declarations with lethaskell-src-extsif exp then exp else exphaskell-src-extsif | stmts -> exp ...haskell-src-extscase exp of altshaskell-src-extsdoJ-expression: the last statement in the list should be an expression.haskell-src-extsmdo -expressionhaskell-src-extstuple section expression, e.g. (,,3)haskell-src-exts Unboxed sumhaskell-src-extslist expressionhaskell-src-extsparallel array expressionhaskell-src-extsparenthesized expressionhaskell-src-extsrecord construction expressionhaskell-src-extsrecord update expressionhaskell-src-exts3unbounded arithmetic sequence, incrementing by 1haskell-src-exts1bounded arithmetic sequence, incrementing by 1haskell-src-exts?unbounded arithmetic sequence, with first two elements givenhaskell-src-exts=bounded arithmetic sequence, with first two elements givenhaskell-src-exts1bounded arithmetic sequence, incrementing by 1haskell-src-exts=bounded arithmetic sequence, with first two elements givenhaskell-src-extsparallel list comprehensionhaskell-src-extsparallel array comprehensionhaskell-src-extsexpression type signaturehaskell-src-exts patterns onlyhaskell-src-exts patterns onlyhaskell-src-exts patterns onlyhaskell-src-extspost-opshaskell-src-extspre-opshaskell-src-exts patterns onlyhaskell-src-extsregular patterns onlyhaskell-src-extsregular patterns onlyhaskell-src-extsregular patterns onlyhaskell-src-extsregular patterns onlyhaskell-src-exts'xhaskell-src-exts''Thaskell-src-exts $...|...haskell-src-exts Name... /Namehaskell-src-exts Name/haskell-src-extsPCDATAhaskell-src-exts %... %haskell-src-exts % ... /%haskell-src-exts [... ]haskell-src-exts{- CORE  -} pragmahaskell-src-exts{- SCC  -} pragmahaskell-src-exts{- GENERATED ...  -} pragmahaskell-src-exts f !a = ...haskell-src-exts proc p -> dohaskell-src-extse -< ehaskell-src-extse >- ehaskell-src-extse -<< ehaskell-src-extse >>- ehaskell-src-extscase altsf     Y(c) Niklas Broberg 2004-2009, (c) The GHC Team, Noel Winstanley 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe.zhaskell-src-extsKThings that can be pretty-printed, including all the syntactic objects in Language.Haskell.Exts.Syntax.haskell-src-exts$Pretty-print something in isolation.haskell-src-exts/Pretty-print something in a precedence context.haskell-src-exts;The document type produced by these pretty printers uses a { environment. haskell-src-extsPretty printing monad{haskell-src-extsPretty-printing parameters.Note: the 2 must be positive and less than all other indents.}haskell-src-exts"indentation of a class or instance~haskell-src-extsindentation of a do -expressionhaskell-src-extsindentation of the body of a case expressionhaskell-src-exts$indentation of the body of a multi-if expressionhaskell-src-exts&indentation of the declarations in a let expressionhaskell-src-exts&indentation of the declarations in a where clausehaskell-src-extsIindentation added for continuation lines that would otherwise be offsidehaskell-src-extsblank lines between statements?haskell-src-extsPretty-printing style to usehaskell-src-extsadd GHC-style LINE pragmas to output?haskell-src-extsVarieties of layout we can use.haskell-src-extsclassical layouthaskell-src-extsclassical layout made explicithaskell-src-exts(inline decls, with newlines between themhaskell-src-extseverything on a single linehaskell-src-extsMThe default mode: pretty-print using the offside rule and sensible defaults.!haskell-src-exts0render the document with a given style and mode.haskell-src-exts}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.haskell-src-exts5pretty-print with the default style and a given mode.haskell-src-exts(pretty-print with the default style and .haskell-src-exts(pretty-print with the default style and .haskell-src-exts5pretty-print with the default style and a given mode."haskell-src-exts7Indent without braces. Useful for deriving clauses etc.$ z{|}~$z {|}~#5(c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe2@haskell-src-extsxAll AST elements that may include expressions which in turn may need fixity tweaking will be instances of this class.haskell-src-extsTweak any expressions in the element to account for the fixities given. Assumes that all operator expressions are fully left associative chains to begin with.haskell-src-extsmOperator fixities are represented by their associativity (left, right or none) and their precedence (0-9).$haskell-src-exts Built-in fixity for prefix minushaskell-src-exts$All fixities defined in the Prelude.haskell-src-exts)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.haskell-src-extsThe fixities to account for.haskell-src-extsThe element to tweak.haskell-src-extsFThe same element, but with operator expressions updated, or a failure.  (c) JP Moresmau 2015$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.se experimentalportableSafe2U%haskell-src-extsRepresents a Haddock Comment&haskell-src-extsComment before declaration'haskell-src-extsComment after declaration(haskell-src-extsNon Haddock comment)haskell-src-extsThe comment accumulatorhaskell-src-extsAn unknown pragma.haskell-src-extsA Haskell comment. The  is $ if the comment is multi-line, i.e. {- -}.haskell-src-extsNAssociates an AST with Source Span Information with relevant Haddock comments*haskell-src-exts9Merge existing association with post comment associations+haskell-src-exts3Ensure that if file ends with comment we process it,haskell-src-extsrAccumulate comments mappings, either directly with the source or in another association list for later processing-haskell-src-extsCreate a new accumulator.haskell-src-extsGet comments to merge/haskell-src-exts6Get the biggest src that ends where the first one does0haskell-src-exts,Is a Haddock comment before a given location1haskell-src-extsIs a comment not haddock?2haskell-src-extsComments to Haddock Comments3haskell-src-extsComment to Haddock Comment.haskell-src-extsStop before srchaskell-src-extsAll remaining commentshaskell-src-extsComments to merge, left oversRNiklas Broberg (c) 2004-2009, Original (c) The GHC Team, 1997-2000/BSD-style (see the file libraries/base/LICENSE)$Niklas Broberg, d00nibro@chalmers.sestableportableSafes4haskell-src-extsMonad for parsinghaskell-src-extsQStatic 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 .haskell-src-exts&original name of the file being parsedhaskell-src-exts+base language (e.g. Haskell98, Haskell2010) haskell-src-exts&list of extensions enabled for parsing!haskell-src-extsif W, the parser won't care about further extensions in LANGUAGE pragmas in source files"haskell-src-extsif V, the parser won't read line position information from LINE pragmas in source files#haskell-src-extslist of fixities to be aware of$haskell-src-exts0Checks whether functions have a consistent arity%haskell-src-extsThe result of a parse.&haskell-src-exts&The parse succeeded, yielding a value.'haskell-src-extsJThe parse failed at the specified source location, with an error message.(haskell-src-exts=Class providing function for parsing at many different types.cNote that for convenience of implementation, the default methods have definitions equivalent to 5;. The minimal definition is all of the visible methods.)haskell-src-exts!Parse a string with default mode.*haskell-src-exts Parse a string with an explicit .+haskell-src-exts Parse a string with an explicit /, returning all comments along with the AST.6haskell-src-extsDInternal parser, used to provide default definitions for the others.,haskell-src-extshRetrieve the result of a successful parse, throwing an error if the parse is actually not successful.-haskell-src-extsDefault 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.7haskell-src-extsHDiscard some input characters (these must not include tabs or newlines).8haskell-src-extsJGet the last discarded character. This is only used for type application.9haskell-src-exts4Discard the next character, which must be a newline.:haskell-src-exts0Discard the next character, which must be a tab.;haskell-src-exts"lexWhile without the return value.<haskell-src-exts.Add an extension to the current configuration.=haskell-src-exts-Save the current configuration of extensions.>haskell-src-exts6Return to the previous saved extensions configuration.F?@4# !"$ABCDEFGHIJ%&'()*+6,-KLMNOPQRSTU789:V;WXYZ[\]^_`abcde<=>fghI(c) Niklas Broberg 2004-2009, (c) The GHC Team, 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafeQ:ihaskell-src-exts|Checks whether the parameter is a symbol, and gives a nice warning for "." if ExplicitForAll/TypeOperators are not enabled.jhaskell-src-exts-Add a strictness/unpack annotation on a type.khaskell-src-extsYTransform btype with strict_mark's into HsEqTy's (((~a) ~b) c) ~d ==> ((~a) ~ (b c)) ~ d    lmnopqrstuvwxyz{|}~jkI(c) The GHC Team, 1997-2000 (c) Niklas Broberg, 2004-2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe]ohaskell-src-exts]phaskell-src-exts|]yhaskell-src-exts)haskell-src-extsVChecks whether the character would be legal in some position of a qvar. Means that '..' and AAA will pass the test.haskell-src-exts'lexWhiteSpace without the return value.haskell-src-exts"Selects ASCII binary digits, i.e. '0'..'1'../0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~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^haskell-src-exts7Lex a string into a list of Haskell 2010 source tokens.haskell-src-extsJLex a string into a list of Haskell source tokens, using an explicit mode../0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Ӫ./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~](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=?Fh 9 9 6C(c) Niklas Broberg 2004-2009 (c) Michael Sloan 2013$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableNone24=?Ghaskell-src-extsListOf 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:haskell-src-exts 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)haskell-src-extsType 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.haskell-src-extsIParse of a string, which should contain a complete Haskell module, using -.haskell-src-extsJParse of a string containing a complete Haskell module, using an explicit .haskell-src-extsJParse of a string containing a complete Haskell module, using an explicit , retaining comments.haskell-src-exts9Parse of a string containing a Haskell expression, using -.haskell-src-extsEParse of a string containing a Haskell expression, using an explicit .haskell-src-extsJParse of a string containing a complete Haskell module, using an explicit , retaining comments.haskell-src-exts6Parse of a string containing a Haskell pattern, using -.haskell-src-extsBParse of a string containing a Haskell pattern, using an explicit .haskell-src-extsJParse of a string containing a complete Haskell module, using an explicit , retaining comments.haskell-src-extsDParse of a string containing a Haskell top-level declaration, using -.haskell-src-extsPParse of a string containing a Haskell top-level declaration, using an explicit .haskell-src-extsJParse of a string containing a complete Haskell module, using an explicit , retaining comments.haskell-src-exts3Parse of a string containing a Haskell type, using -.haskell-src-exts?Parse of a string containing a Haskell type, using an explicit .haskell-src-extsJParse of a string containing a complete Haskell module, using an explicit , retaining comments.haskell-src-exts8Parse of a string containing a Haskell statement, using -.haskell-src-exts?Parse of a string containing a Haskell type, using an explicit .haskell-src-extsJParse of a string containing a complete Haskell module, using an explicit , retaining comments.haskell-src-exts8Parse of a string containing a Haskell statement, using -.haskell-src-exts?Parse of a string containing a Haskell type, using an explicit .haskell-src-extsJParse of a string containing a complete Haskell module, using an explicit , retaining comments.haskell-src-extsPNon-greedy parse of a string starting with a series of top-level option pragmas.4# !"$%&'()*+,-4()*+# !"$-%&', (c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableSafe4hhaskell-src-extsNPrint an AST exactly as specified by the annotations on the nodes in the tree. D(c) The GHC Team, 1997-2000, (c) Niklas Broberg 2004$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.se experimentalportableSafe1ohaskell-src-extsdAn identifier with the given string as its name. The string should be a valid Haskell identifier.phaskell-src-extsOA symbol identifier. The string should be a valid Haskell symbol identifier.qhaskell-src-extsA local variable as expression.rhaskell-src-exts(Use the given identifier as an operator.shaskell-src-exts#A qualified variable as expression.thaskell-src-extsA pattern variable.uhaskell-src-exts,Application of expressions by juxtaposition.vhaskell-src-extsApply an operator infix.whaskell-src-exts(Apply a function to a list of arguments.xhaskell-src-exts.A constructor pattern, with argument patterns.yhaskell-src-extsA tuple expression.zhaskell-src-extsA tuple pattern.{haskell-src-exts0A tuple expression consisting of variables only.|haskell-src-exts-A tuple pattern consisting of variables only.}haskell-src-extsA function with a given name.~haskell-src-extsA literal string expression.haskell-src-extsA literal character expression.haskell-src-extsA literal integer expression.haskell-src-extsA literal string pattern.haskell-src-extsA literal character pattern.haskell-src-extsA literal integer pattern.haskell-src-exts\A do block formed by the given statements. The last statement in the list should be a  expression.haskell-src-extsPLambda abstraction, given a list of argument patterns and an expression body.haskell-src-extsA let ... in block.haskell-src-extsA case expression.haskell-src-extsAn unguarded alternative in a case expression.haskell-src-exts(An alternative with a single guard in a case expression.haskell-src-exts!An unguarded righthand side of a case alternative.haskell-src-exts)An list of guarded righthand sides for a case alternative.haskell-src-exts&A single guarded righthand side for a case alternative.haskell-src-extsA list expression.haskell-src-extsThe empty list expression.haskell-src-extsThe empty list pattern.haskell-src-exts%Put parentheses around an expression.haskell-src-exts!Put parentheses around a pattern.haskell-src-exts!A qualifier expression statement.haskell-src-extsA generator statement: pat <- exphaskell-src-extsA let binding group as a statement.haskell-src-exts/Hoist a set of declarations to a binding group.haskell-src-extsAn empty binding group.haskell-src-extsThe wildcard pattern: _haskell-src-extsDGenerate k names by appending numbers 1 through k to a given string.haskell-src-extsA function with a single clausehaskell-src-extsXA function with a single clause, a single argument, no guards and no where declarationshaskell-src-extsVA pattern bind where the pattern is a variable, and where there are no guards and no 'where' clause.haskell-src-exts[A pattern bind where the pattern is a variable, and where there are no guards, but with a 'where' clause.haskell-src-exts$Bind an identifier to an expression.haskell-src-exts6Apply function of a given name to a list of arguments.haskell-src-extseApply a constructor of a given name to a list of pattern arguments, forming a constructor pattern..opqrstuvwxyz{|}~.opqrstuvwxyz{|}~Safehaskell-src-exts takes a filename (for error reports), and transforms the given string, to eliminate the literate comments from the program text. (c) Niklas Broberg 2004-2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableNone)B haskell-src-exts:Parse a source file on disk, using the default parse mode.haskell-src-extsvParse a source file on disk, with an extra set of extensions to know about on top of what the file itself declares.haskell-src-exts;Parse a source file on disk, supplying a custom parse mode.haskell-src-extspParse a source file on disk, supplying a custom parse mode, and retaining comments as well as unknown pragmas.haskell-src-extsmParse a source file from a string using a custom parse mode retaining comments as well as unknown pragmas.haskell-src-exts?Parse a source file from a string using the default parse mode.haskell-src-exts|Parse a source file from a string, with an extra set of extensions to know about on top of what the file itself declares.haskell-src-exts<Parse a source file from a string using a custom parse mode.haskell-src-extsVGather the extensions declared in LANGUAGE pragmas at the top of the file. Returns & if the parse of the pragmas fails.haskell-src-exts]Converts a parse result with comments to a parse result with comments and unknown pragmas.  BX'ZYW* !"#$%&()+,-./0123456789:;<=>?@ACDEFGHIJKLMNOPQRSTUV[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,1/02.-3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\f_bn]^`acdeghijklmopqrstuvwxyz{|}~      !"#$%&'()*?45+,-./01236789:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgihjklmnopqrstuvwxyz{|}~z{|}~# !"$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~opqrstuvwxyz{|}~./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0012234567689:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^__``abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPPQQRSTUVWXYZ[\]^_^`abcdeeffgghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./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 { | } ~                                          c d e f g h i j k l m n o p q t s u v w z { | } ~                                               _                 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQQR S T UV W XY.haskell-src-exts-1.22.0-5tSwDhjCyZb5AQf9d2FsEoLanguage.Haskell.Exts.PrettyLanguage.Haskell.Exts.ExtensionLanguage.Haskell.Exts.SrcLocLanguage.Haskell.Exts.SyntaxLanguage.Haskell.Exts.FixityLanguage.Haskell.Exts.CommentsLanguage.Haskell.Exts.ParserLanguage.Haskell.Exts.Lexer Language.Haskell.Exts.ExactPrintLanguage.Haskell.Exts.BuildLanguage.Haskell.ExtsLanguage.Haskell.Exts.ExtScheme!Language.Haskell.Exts.ParseSyntax Language.Haskell.Exts.ParseMonad Language.Haskell.Exts.ParseUtils#Language.Haskell.Exts.InternalLexer$Language.Haskell.Exts.InternalParserLanguage.Preprocessor.Unlitpretty-1.1.3.6#Text.PrettyPrint.Annotated.HughesPJstyleribbonsPerLine lineLengthmodeStyle OneLineModeLeftMode ZigZagModePageModeModeKnownExtensionOverlappingInstancesUndecidableInstancesIncoherentInstances InstanceSigsDoRec RecursiveDoParallelListCompMultiParamTypeClassesMonomorphismRestrictionFunctionalDependencies Rank2Types RankNTypesPolymorphicComponentsExistentialQuantificationScopedTypeVariablesPatternSignaturesImplicitParamsFlexibleContextsFlexibleInstancesEmptyDataDeclsCPPKindSignatures BangPatternsTypeSynonymInstancesTemplateHaskellForeignFunctionInterfaceArrowsGenericsImplicitPreludeNamedFieldPuns PatternGuardsGeneralizedNewtypeDerivingDeriveAnyClassExtensibleRecordsRestrictedTypeSynonyms HereDocuments MagicHashBinaryLiterals TypeFamiliesStandaloneDeriving UnicodeSyntaxUnliftedFFITypesLiberalTypeSynonyms TypeOperatorsParallelArraysRecordWildCards RecordPunsDisambiguateRecordFieldsOverloadedStringsGADTs MonoPatBindsRelaxedPolyRecExtendedDefaultRules UnboxedTuplesDeriveDataTypeableConstrainedClassMethodsPackageImports LambdaCase EmptyCaseImpredicativeTypesNewQualifiedOperatorsPostfixOperators QuasiQuotesTransformListComp ViewPatterns XmlSyntaxRegularPatterns TupleSectionsGHCForeignImportPrimNPlusKPatternsDoAndIfThenElseRebindableSyntaxExplicitForAllDatatypeContextsMonoLocalBinds DeriveFunctor DeriveGenericDeriveTraversableDeriveFoldableNondecreasingIndentationInterruptibleFFICApiFFI JavaScriptFFIExplicitNamespaces DataKinds PolyKinds MultiWayIf SafeImportsSafe TrustworthyDefaultSignaturesConstraintKindsRoleAnnotationsPatternSynonymsPartialTypeSignaturesNamedWildCardsTypeApplicationsTypeFamilyDependenciesOverloadedLabelsDerivingStrategies UnboxedSums TypeInTypeStrict StrictData DerivingViaQuantifiedConstraints ExtensionEnableExtensionDisableExtensionUnknownExtensionLanguage Haskell98 Haskell2010HaskellAllDisabledUnknownLanguageknownLanguagesclassifyLanguageprettyLanguage impliesExts glasgowExts ghcDefaultknownExtensionsdeprecatedExtensionsclassifyExtensionparseExtensionprettyExtensiontoExtensionList$fShowLanguage$fReadLanguage $fEqLanguage $fOrdLanguage$fDataLanguage$fShowKnownExtension$fReadKnownExtension$fEqKnownExtension$fOrdKnownExtension$fEnumKnownExtension$fBoundedKnownExtension$fDataKnownExtension$fShowExtension$fReadExtension $fEqExtension$fOrdExtensionSrcInfo toSrcInfo fromSrcInfo getPointLocfileName startLine startColumn SrcSpanInfo srcInfoSpan srcInfoPointsLoclocunLocSrcSpansrcSpanFilenamesrcSpanStartLinesrcSpanStartColumnsrcSpanEndLinesrcSpanEndColumnSrcLoc srcFilenamesrcLine srcColumnnoLoc srcSpanStart srcSpanEnd mkSrcSpan mergeSrcSpan isNullSpanspanSize noInfoSpan noSrcSpaninfoSpan combSpanInfo combSpanMaybe<++><+?><**<^^> $fShowSrcLoc $fShowSrcSpan$fShowSrcSpanInfo$fSrcInfoSrcSpanInfo$fSrcInfoSrcSpan$fSrcInfoSrcLoc $fEqSrcLoc $fOrdSrcLoc $fDataSrcLoc$fGenericSrcLoc $fEqSrcSpan $fOrdSrcSpan $fDataSrcSpan$fGenericSrcSpan$fEqLoc$fOrdLoc $fShowLoc $fGenericLoc$fEqSrcSpanInfo$fOrdSrcSpanInfo$fDataSrcSpanInfo$fGenericSrcSpanInfo AnnotatedannamapAlt FieldUpdateFieldPun FieldWildcardQualStmt ThenTransThenByGroupBy GroupUsing GroupByUsingStmt Generator QualifierLetStmtRecStmtPatField PFieldPat PFieldPunPFieldWildcardRPatRPOpRPEitherRPSeqRPGuardRPCAsRPAsRPParenRPPatRPatOpRPStarRPStarGRPPlusRPPlusGRPOptRPOptGPXAttrPatPVarPLitPNPlusK PInfixAppPAppPTuple PUnboxedSumPListPParenPRecPAsPat PWildCardPIrrPat PatTypeSigPViewPatPRPatPXTagPXETagPXPcdataPXPatTagPXRPatsPSplice PQuasiQuotePBangPat WarningTextDeprTextWarnTextRuleVar TypedRuleVarRule Activation ActiveFrom ActiveUntilOverlap NoOverlap OverlappingOverlaps Overlappable IncoherentToolGHCHUGSNHC98YHCHADDOCK UnknownTool ModulePragmaLanguagePragma OptionsPragmaAnnModulePragmaCallConvStdCallCCall CPlusPlusDotNetJvmJs JavaScriptCApiSafety PlayRiskyPlaySafePlayInterruptibleSpliceIdSplice TIdSplice ParenSplice TParenSpliceBracket ExpBracket TExpBracket PatBracket TypeBracket DeclBracketXAttrXNameXDomNameExpVarOverloadedLabelIPVarConLitInfixAppAppNegAppLambdaLetIfMultiIfCaseDoMDoTuple UnboxedSum TupleSectionListParArrayParen LeftSection RightSection RecConstr RecUpdateEnumFrom EnumFromTo EnumFromThenEnumFromThenToParArrayFromToParArrayFromThenToListCompParComp ParArrayComp ExpTypeSigVarQuoteTypQuote BracketExp SpliceExp QuasiQuoteTypeAppXTagXETagXPcdataXExpTag XChildTag CorePragma SCCPragma GenPragmaProc LeftArrApp RightArrAppLeftArrHighAppRightArrHighAppLCaseSignSignlessNegativeLiteralCharStringIntFracPrimIntPrimWord PrimFloat PrimDoublePrimChar PrimStringAsstTypeAIParamParenAContextCxSingleCxTupleCxEmptyFunDepKind TyVarBind KindedVar UnkindedVarBoxedUnboxedPromotedPromotedIntegerPromotedString PromotedCon PromotedList PromotedTuple PromotedUnitMaybePromotedName PromotedNameUnpromotedNameTypeTyForallTyStarTyFunTyTuple TyUnboxedSumTyList TyParArrayTyAppTyVarTyConTyParenTyInfixTyKind TyPromotedTyEqualsTySpliceTyBang TyWildCard TyQuasiQuote GuardedRhsRhs UnGuardedRhs GuardedRhss UnpackednessUnpackNoUnpackNoUnpackPragmaBangTypeBangedTyLazyTy NoStrictAnnotInstDeclInsDeclInsTypeInsDataInsGData ClassDeclClsDecl ClsDataFamClsTyFamClsTyDef ClsDefSigGadtDecl FieldDeclConDecl InfixConDeclRecDecl QualConDeclMatch InfixMatchIPBindBindsBDeclsIPBinds DerivStrategy DerivStock DerivAnyclass DerivNewtypeDerivViaDerivingInstHeadIHConIHInfixIHParenIHAppInstRuleIRuleIParenDeclHeadDHeadDHInfixDHParenDHApp ResultSigKindSigTyVarSigInjectivityInfo DataOrNewDataTypeNewTypeRoleNominalRepresentationalPhantom RoleWildcardBooleanFormula VarFormula AndFormula OrFormula ParenFormula AnnotationAnnTypeAnn ModuleAnnTypeEqnPatternSynDirectionUnidirectionalImplicitBidirectionalExplicitBidirectionalDeclTypeDecl TypeFamDeclClosedTypeFamDeclDataDecl GDataDecl DataFamDecl TypeInsDecl DataInsDecl GDataInsDecl DerivDecl InfixDecl DefaultDecl SpliceDecl TSpliceDeclTypeSig PatSynSigFunBindPatBindPatSynForImpForExpRulePragmaDeclDeprPragmaDeclWarnPragmaDecl InlineSigInlineConlikeSigSpecSig SpecInlineSigInstSig AnnPragma MinimalPragma RoleAnnotDeclCompletePragmaAssoc AssocNone AssocLeft AssocRight ImportSpecIVarIAbs IThingAll IThingWithImportSpecList ImportDecl importAnn importModuleimportQualified importSrc importSafe importPkgimportAs importSpecs Namespace NoNamespace TypeNamespacePatternNamespace EWildcard NoWildcard ExportSpecEVarEAbs EThingWithEModuleContentsExportSpecList ModuleHeadModuleXmlPage XmlHybridCNameVarNameConNameOpVarOpConOpQOpQVarOpQConOpIPNameIPDupIPLinNameIdentSymbolQNameQualUnQualSpecial SpecialConUnitConListConFunConTupleConConsUnboxedSingleConExprHole ModuleName prelude_modmain_mod main_name unit_con_nametuple_con_name list_con_namelist_cons_nameunboxed_singleton_con_nameunit_con tuple_conunboxed_singleton_conas_namequalified_name hiding_name minus_name bang_namedot_name star_name hole_name export_name safe_name unsafe_nameinterruptible_namethreadsafe_name stdcall_name ccall_namecplusplus_name dotnet_namejvm_namejs_namejavascript_name capi_name forall_name family_name role_name stock_name anyclass_namevia_nameunit_tycon_namefun_tycon_namelist_tycon_nameunboxed_singleton_tycon_nametuple_tycon_name unit_tycon fun_tycon list_tyconunboxed_singleton_tycon tuple_tycon=~=$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$fAnnotatedTyVarBind$fAnnotatedMaybePromotedName$fAnnotatedType$fAnnotatedGuardedRhs$fAnnotatedRhs$fAnnotatedUnpackedness$fAnnotatedBangType$fAnnotatedInstDecl$fAnnotatedClassDecl$fAnnotatedGadtDecl$fAnnotatedFieldDecl$fAnnotatedConDecl$fAnnotatedQualConDecl$fAnnotatedMatch$fAnnotatedIPBind$fAnnotatedBinds$fAnnotatedInstHead$fAnnotatedInstRule$fAnnotatedDeclHead$fAnnotatedDataOrNew$fAnnotatedBooleanFormula$fAnnotatedAnnotation$fAnnotatedRole$fAnnotatedDecl$fAnnotatedResultSig$fAnnotatedInjectivityInfo$fAnnotatedTypeEqn$fAnnotatedDerivStrategy$fAnnotatedDeriving$fAnnotatedAssoc$fAnnotatedImportSpec$fAnnotatedImportSpecList$fAnnotatedImportDecl$fAnnotatedNamespace$fAnnotatedEWildcard$fAnnotatedExportSpec$fAnnotatedExportSpecList$fAnnotatedModuleHead$fAnnotatedModule$fAnnotatedCName $fAnnotatedOp$fAnnotatedQOp$fAnnotatedIPName$fAnnotatedName$fAnnotatedQName$fAnnotatedSpecialCon$fAnnotatedModuleName$fEqModuleName$fOrdModuleName$fShowModuleName$fDataModuleName$fFoldableModuleName$fTraversableModuleName$fFunctorModuleName$fGenericModuleName$fEqName $fOrdName $fShowName $fDataName$fFoldableName$fTraversableName $fFunctorName $fGenericName $fEqIPName $fOrdIPName $fShowIPName $fDataIPName$fFoldableIPName$fTraversableIPName$fFunctorIPName$fGenericIPName$fEqOp$fOrdOp$fShowOp$fDataOp $fFoldableOp$fTraversableOp $fFunctorOp $fGenericOp $fEqCName $fOrdCName $fShowCName $fDataCName$fFoldableCName$fTraversableCName$fFunctorCName$fGenericCName $fEqEWildcard$fOrdEWildcard$fShowEWildcard$fDataEWildcard$fFoldableEWildcard$fTraversableEWildcard$fFunctorEWildcard$fGenericEWildcard $fEqNamespace$fOrdNamespace$fShowNamespace$fDataNamespace$fFoldableNamespace$fTraversableNamespace$fFunctorNamespace$fGenericNamespace$fEqImportSpec$fOrdImportSpec$fShowImportSpec$fDataImportSpec$fFoldableImportSpec$fTraversableImportSpec$fFunctorImportSpec$fGenericImportSpec$fEqImportSpecList$fOrdImportSpecList$fShowImportSpecList$fDataImportSpecList$fFoldableImportSpecList$fTraversableImportSpecList$fFunctorImportSpecList$fGenericImportSpecList$fEqImportDecl$fOrdImportDecl$fShowImportDecl$fDataImportDecl$fFoldableImportDecl$fTraversableImportDecl$fFunctorImportDecl$fGenericImportDecl $fEqAssoc $fOrdAssoc $fShowAssoc $fDataAssoc$fFoldableAssoc$fTraversableAssoc$fFunctorAssoc$fGenericAssoc$fEqBooleanFormula$fOrdBooleanFormula$fShowBooleanFormula$fDataBooleanFormula$fFoldableBooleanFormula$fTraversableBooleanFormula$fFunctorBooleanFormula$fGenericBooleanFormula$fEqRole $fOrdRole $fShowRole $fDataRole$fFoldableRole$fTraversableRole $fFunctorRole $fGenericRole $fEqDataOrNew$fOrdDataOrNew$fShowDataOrNew$fDataDataOrNew$fFoldableDataOrNew$fTraversableDataOrNew$fFunctorDataOrNew$fGenericDataOrNew$fEqInjectivityInfo$fOrdInjectivityInfo$fShowInjectivityInfo$fDataInjectivityInfo$fFoldableInjectivityInfo$fTraversableInjectivityInfo$fFunctorInjectivityInfo$fGenericInjectivityInfo $fEqBangType $fOrdBangType$fShowBangType$fDataBangType$fFoldableBangType$fTraversableBangType$fFunctorBangType$fGenericBangType$fEqUnpackedness$fOrdUnpackedness$fShowUnpackedness$fDataUnpackedness$fFoldableUnpackedness$fTraversableUnpackedness$fFunctorUnpackedness$fGenericUnpackedness $fEqBoxed $fOrdBoxed $fShowBoxed $fDataBoxed$fGenericBoxed$fEqSpecialCon$fOrdSpecialCon$fShowSpecialCon$fDataSpecialCon$fFoldableSpecialCon$fTraversableSpecialCon$fFunctorSpecialCon$fGenericSpecialCon $fEqQName $fOrdQName $fShowQName $fDataQName$fFoldableQName$fTraversableQName$fFunctorQName$fGenericQName$fEqMaybePromotedName$fOrdMaybePromotedName$fShowMaybePromotedName$fDataMaybePromotedName$fFoldableMaybePromotedName$fTraversableMaybePromotedName$fFunctorMaybePromotedName$fGenericMaybePromotedName$fEqExportSpec$fOrdExportSpec$fShowExportSpec$fDataExportSpec$fFoldableExportSpec$fTraversableExportSpec$fFunctorExportSpec$fGenericExportSpec$fEqExportSpecList$fOrdExportSpecList$fShowExportSpecList$fDataExportSpecList$fFoldableExportSpecList$fTraversableExportSpecList$fFunctorExportSpecList$fGenericExportSpecList$fEqQOp$fOrdQOp $fShowQOp $fDataQOp $fFoldableQOp$fTraversableQOp $fFunctorQOp $fGenericQOp $fEqFunDep $fOrdFunDep $fShowFunDep $fDataFunDep$fFoldableFunDep$fTraversableFunDep$fFunctorFunDep$fGenericFunDep $fEqLiteral $fOrdLiteral $fShowLiteral $fDataLiteral$fFoldableLiteral$fTraversableLiteral$fFunctorLiteral$fGenericLiteral$fEqSign $fOrdSign $fShowSign $fDataSign$fFoldableSign$fTraversableSign $fFunctorSign $fGenericSign $fEqXName $fOrdXName $fShowXName $fDataXName$fFoldableXName$fTraversableXName$fFunctorXName$fGenericXName $fEqSafety $fOrdSafety $fShowSafety $fDataSafety$fFoldableSafety$fTraversableSafety$fFunctorSafety$fGenericSafety $fEqCallConv $fOrdCallConv$fShowCallConv$fDataCallConv$fFoldableCallConv$fTraversableCallConv$fFunctorCallConv$fGenericCallConv$fEqTool $fOrdTool $fShowTool $fDataTool $fGenericTool $fEqOverlap $fOrdOverlap $fShowOverlap $fDataOverlap$fFoldableOverlap$fTraversableOverlap$fFunctorOverlap$fGenericOverlap$fEqActivation$fOrdActivation$fShowActivation$fDataActivation$fFoldableActivation$fTraversableActivation$fFunctorActivation$fGenericActivation$fEqWarningText$fOrdWarningText$fShowWarningText$fDataWarningText$fFoldableWarningText$fTraversableWarningText$fFunctorWarningText$fGenericWarningText$fEqModuleHead$fOrdModuleHead$fShowModuleHead$fDataModuleHead$fFoldableModuleHead$fTraversableModuleHead$fFunctorModuleHead$fGenericModuleHead $fEqRPatOp $fOrdRPatOp $fShowRPatOp $fDataRPatOp$fFoldableRPatOp$fTraversableRPatOp$fFunctorRPatOp$fGenericRPatOp$fEqAlt$fOrdAlt $fShowAlt $fDataAlt $fFoldableAlt$fTraversableAlt $fFunctorAlt $fGenericAlt$fEqPat$fOrdPat $fShowPat $fDataPat $fFoldablePat$fTraversablePat $fFunctorPat $fGenericPat $fEqPatField $fOrdPatField$fShowPatField$fDataPatField$fFoldablePatField$fTraversablePatField$fFunctorPatField$fGenericPatField$fEqRPat $fOrdRPat $fShowRPat $fDataRPat$fFoldableRPat$fTraversableRPat $fFunctorRPat $fGenericRPat$fEqStmt $fOrdStmt $fShowStmt $fDataStmt$fFoldableStmt$fTraversableStmt $fFunctorStmt $fGenericStmt$fEqExp$fOrdExp $fShowExp $fDataExp $fFoldableExp$fTraversableExp $fFunctorExp $fGenericExp$fEqFieldUpdate$fOrdFieldUpdate$fShowFieldUpdate$fDataFieldUpdate$fFoldableFieldUpdate$fTraversableFieldUpdate$fFunctorFieldUpdate$fGenericFieldUpdate $fEqQualStmt $fOrdQualStmt$fShowQualStmt$fDataQualStmt$fFoldableQualStmt$fTraversableQualStmt$fFunctorQualStmt$fGenericQualStmt $fEqSplice $fOrdSplice $fShowSplice $fDataSplice$fFoldableSplice$fTraversableSplice$fFunctorSplice$fGenericSplice $fEqBracket $fOrdBracket $fShowBracket $fDataBracket$fFoldableBracket$fTraversableBracket$fFunctorBracket$fGenericBracket$fEqType $fOrdType $fShowType $fDataType$fFoldableType$fTraversableType $fFunctorType $fGenericType $fEqContext $fOrdContext $fShowContext $fDataContext$fFoldableContext$fTraversableContext$fFunctorContext$fGenericContext$fEqAsst $fOrdAsst $fShowAsst $fDataAsst$fFoldableAsst$fTraversableAsst $fFunctorAsst $fGenericAsst $fEqTyVarBind$fOrdTyVarBind$fShowTyVarBind$fDataTyVarBind$fFoldableTyVarBind$fTraversableTyVarBind$fFunctorTyVarBind$fGenericTyVarBind $fEqPromoted $fOrdPromoted$fShowPromoted$fDataPromoted$fFoldablePromoted$fTraversablePromoted$fFunctorPromoted$fGenericPromoted$fEqDecl $fOrdDecl $fShowDecl $fDataDecl$fFoldableDecl$fTraversableDecl $fFunctorDecl $fGenericDecl$fEqRule $fOrdRule $fShowRule $fDataRule$fFoldableRule$fTraversableRule $fFunctorRule $fGenericRule $fEqRuleVar $fOrdRuleVar $fShowRuleVar $fDataRuleVar$fFoldableRuleVar$fTraversableRuleVar$fFunctorRuleVar$fGenericRuleVar$fEqRhs$fOrdRhs $fShowRhs $fDataRhs $fFoldableRhs$fTraversableRhs $fFunctorRhs $fGenericRhs$fEqGuardedRhs$fOrdGuardedRhs$fShowGuardedRhs$fDataGuardedRhs$fFoldableGuardedRhs$fTraversableGuardedRhs$fFunctorGuardedRhs$fGenericGuardedRhs $fEqInstDecl $fOrdInstDecl$fShowInstDecl$fDataInstDecl$fFoldableInstDecl$fTraversableInstDecl$fFunctorInstDecl$fGenericInstDecl $fEqGadtDecl $fOrdGadtDecl$fShowGadtDecl$fDataGadtDecl$fFoldableGadtDecl$fTraversableGadtDecl$fFunctorGadtDecl$fGenericGadtDecl $fEqFieldDecl$fOrdFieldDecl$fShowFieldDecl$fDataFieldDecl$fFoldableFieldDecl$fTraversableFieldDecl$fFunctorFieldDecl$fGenericFieldDecl$fEqQualConDecl$fOrdQualConDecl$fShowQualConDecl$fDataQualConDecl$fFoldableQualConDecl$fTraversableQualConDecl$fFunctorQualConDecl$fGenericQualConDecl $fEqConDecl $fOrdConDecl $fShowConDecl $fDataConDecl$fFoldableConDecl$fTraversableConDecl$fFunctorConDecl$fGenericConDecl $fEqDeriving $fOrdDeriving$fShowDeriving$fDataDeriving$fFoldableDeriving$fTraversableDeriving$fFunctorDeriving$fGenericDeriving$fEqDerivStrategy$fOrdDerivStrategy$fShowDerivStrategy$fDataDerivStrategy$fFoldableDerivStrategy$fTraversableDerivStrategy$fFunctorDerivStrategy$fGenericDerivStrategy $fEqInstRule $fOrdInstRule$fShowInstRule$fDataInstRule$fFoldableInstRule$fTraversableInstRule$fFunctorInstRule$fGenericInstRule $fEqInstHead $fOrdInstHead$fShowInstHead$fDataInstHead$fFoldableInstHead$fTraversableInstHead$fFunctorInstHead$fGenericInstHead $fEqClassDecl$fOrdClassDecl$fShowClassDecl$fDataClassDecl$fFoldableClassDecl$fTraversableClassDecl$fFunctorClassDecl$fGenericClassDecl $fEqDeclHead $fOrdDeclHead$fShowDeclHead$fDataDeclHead$fFoldableDeclHead$fTraversableDeclHead$fFunctorDeclHead$fGenericDeclHead $fEqResultSig$fOrdResultSig$fShowResultSig$fDataResultSig$fFoldableResultSig$fTraversableResultSig$fFunctorResultSig$fGenericResultSig $fEqTypeEqn $fOrdTypeEqn $fShowTypeEqn $fDataTypeEqn$fFoldableTypeEqn$fTraversableTypeEqn$fFunctorTypeEqn$fGenericTypeEqn $fEqMatch $fOrdMatch $fShowMatch $fDataMatch$fFoldableMatch$fTraversableMatch$fFunctorMatch$fGenericMatch $fEqBinds $fOrdBinds $fShowBinds $fDataBinds$fFoldableBinds$fTraversableBinds$fFunctorBinds$fGenericBinds $fEqIPBind $fOrdIPBind $fShowIPBind $fDataIPBind$fFoldableIPBind$fTraversableIPBind$fFunctorIPBind$fGenericIPBind$fEqAnnotation$fOrdAnnotation$fShowAnnotation$fDataAnnotation$fFoldableAnnotation$fTraversableAnnotation$fFunctorAnnotation$fGenericAnnotation$fEqPatternSynDirection$fOrdPatternSynDirection$fShowPatternSynDirection$fDataPatternSynDirection$fFoldablePatternSynDirection $fTraversablePatternSynDirection$fFunctorPatternSynDirection$fGenericPatternSynDirection $fEqXAttr $fOrdXAttr $fShowXAttr $fDataXAttr$fFoldableXAttr$fTraversableXAttr$fFunctorXAttr$fGenericXAttr $fEqPXAttr $fOrdPXAttr $fShowPXAttr $fDataPXAttr$fFoldablePXAttr$fTraversablePXAttr$fFunctorPXAttr$fGenericPXAttr$fEqModulePragma$fOrdModulePragma$fShowModulePragma$fDataModulePragma$fFoldableModulePragma$fTraversableModulePragma$fFunctorModulePragma$fGenericModulePragma $fEqModule $fOrdModule $fShowModule $fDataModule$fFoldableModule$fTraversableModule$fFunctorModule$fGenericModulePrettyPPHsMode classIndentdoIndent multiIfIndent caseIndent letIndent whereIndent onsideIndentspacinglayout linePragmasIndentPPLayout PPOffsideRule PPSemiColonPPInLine PPNoLayout defaultModeprettyPrintStyleModeprettyPrintWithMode prettyPrint prettyPrimprettyPrimWithMode $fMonadDocM$fApplicativeDocM $fFunctorDocM $fPrettyPType $fPrettyPAsst$fPrettyPContext$fPrettyParseXAttr$fPrettyPFieldUpdate $fPrettyPExp$fPrettyModule$fPrettySrcSpan$fPrettySrcLoc $fPrettyAsst$fPrettyContext$fPrettySpecialCon $fPrettyCName$fPrettyIPBind$fPrettyIPName $fPrettyName $fPrettyOp $fPrettyQName $fPrettyQOp$fPrettyFieldUpdate$fPrettyQualStmt $fPrettyStmt$fPrettyRPatOp $fPrettyRPat$fPrettyPatField$fPrettyPXAttr $fPrettyPat$fPrettySplice$fPrettyBracket $fPrettyXName $fPrettyXAttr$fPrettyLiteral$fPrettyGuardedRhs $fPrettyRhs$fPrettyFunDep$fPrettyTyVarBind$fPrettyPromoted$fPrettyMaybePromotedName $fPrettyType$fPrettyDerivStrategy$fPrettyDeriving$fPrettyUnpackedness$fPrettyBangType$fPrettyFieldDecl$fPrettyConDecl$fPrettyGadtDecl$fPrettyQualConDecl $fPrettyTool$fPrettyModulePragma$fPrettyRuleVar$fPrettyOverlap$fPrettyActivation $fPrettyRule$fPrettyCallConv$fPrettySafety$fPrettyInstDecl$fPrettyDeclHead$fPrettyClassDecl $fPrettyMatch $fPrettyAssoc$fPrettyDataOrNew $fPrettyRole$fPrettyBooleanFormula$fPrettyAnnotation$fPrettyInstHead$fPrettyInstRule $fPrettyDecl$fPrettyResultSig$fPrettyInjectivityInfo$fPrettyTypeEqn$fPrettyImportSpec$fPrettyImportSpecList$fPrettyImportDecl$fPrettyExportSpec$fPrettyNamespace$fPrettyModuleName$fPrettyExportSpecList$fPrettyModuleHead$fPrettyDeclLikeIPBind$fPrettyDeclLikeInstDecl$fPrettyDeclLikeClassDecl$fPrettyDeclLikeDecl $fPrettyAlt $fPrettyExp$fPrettyGuardedAlt$fPrettyGuardedAlts $fEqPPLayout AppFixity applyFixitiesFixitypreludeFixities baseFixitiesinfixr_infixl_infix_$fAppFixityXAttr$fAppFixitySplice$fAppFixityBracket$fAppFixityQualStmt$fAppFixityAlt$fAppFixityFieldUpdate$fAppFixityIPBind$fAppFixityBinds$fAppFixityStmt$fAppFixityPXAttr$fAppFixityRPat$fAppFixityPatField$fAppFixityGuardedRhs$fAppFixityRhs$fAppFixityMatch$fAppFixityInstDecl$fAppFixityClassDecl$fAppFixityAnnotation$fAppFixityPatternSynDirection$fAppFixityDecl$fAppFixityModule$fAppFixityPat$fAppFixityExp $fEqFixity $fOrdFixity $fShowFixity $fDataFixity UnknownPragmaCommentassociateHaddock $fEqComment $fShowComment $fDataComment$fEqUnknownPragma$fShowUnknownPragma$fDataUnknownPragma ParseMode parseFilename baseLanguage extensionsignoreLanguagePragmasignoreLinePragmasfixitiesignoreFunctionArity ParseResultParseOk ParseFailed Parseableparse parseWithModeparseWithCommentsfromParseResultdefaultParseModeTokenVarId LabelVarIdQVarId 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 RightArrowAtTAppTilde DoubleArrowMinus ExclamationStar LeftArrowTailRightArrowTailLeftDblArrowTailRightDblArrowTail THExpQuote THTExpQuote THPatQuote THDecQuote THTypQuote THCloseQuote THTCloseQuote THIdEscape THParenEscape THTIdEscapeTHTParenEscape THVarQuote THTyQuote THQuasiQuote RPGuardOpen RPGuardCloseRPCAt XCodeTagOpen XCodeTagClose XStdTagOpen XStdTagClose XCloseTagOpenXEmptyTagClose XChildTagOpenXPCDATA XRPatOpen XRPatClose PragmaEndRULESINLINEINLINE_CONLIKE SPECIALISESPECIALISE_INLINESOURCE DEPRECATEDWARNINGSCC GENERATEDCOREUNPACKNOUNPACKOPTIONSLANGUAGEANNMINIMAL NO_OVERLAPOVERLAP OVERLAPPING OVERLAPPABLEOVERLAPS INCOHERENTCOMPLETEKW_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_PatternKW_Stock KW_AnyclassKW_Via KW_Foreign KW_ExportKW_Safe KW_Unsafe KW_ThreadsafeKW_Interruptible KW_StdCallKW_CCall KW_CPlusPlus KW_DotNetKW_JvmKW_Js KW_JavaScriptKW_CApiEOF showTokenlexTokenStreamlexTokenStreamWithModeListOf NonGreedy unNonGreedyModuleHeadAndImportsPragmasAndModuleHeadPragmasAndModuleName parseModuleparseModuleWithModeparseModuleWithCommentsparseExpparseExpWithModeparseExpWithCommentsparsePatparsePatWithModeparsePatWithComments parseDeclparseDeclWithModeparseDeclWithComments parseTypeparseTypeWithModeparseTypeWithComments parseStmtparseStmtWithModeparseStmtWithCommentsparseImportDeclparseImportDeclWithModeparseImportDeclWithComments getTopPragmasunListOf$fParseableImportDecl$fParseableType$fParseableStmt$fParseablePat$fParseableModule$fParseableExp$fParseableDecl$fFunctorNonGreedy$fParseableNonGreedy$fParseableNonGreedy0$fParseableNonGreedy1$fParseableNonGreedy2$fEqPragmasAndModuleName$fOrdPragmasAndModuleName$fShowPragmasAndModuleName$fDataPragmasAndModuleName$fEqPragmasAndModuleHead$fOrdPragmasAndModuleHead$fShowPragmasAndModuleHead$fDataPragmasAndModuleHead$fEqModuleHeadAndImports$fOrdModuleHeadAndImports$fShowModuleHeadAndImports$fDataModuleHeadAndImports $fEqNonGreedy$fOrdNonGreedy$fShowNonGreedy$fDataNonGreedy $fEqListOf $fOrdListOf $fShowListOf $fDataListOf$fFunctorListOfExactP exactPrint $fMonadFailEP $fMonadEP$fApplicativeEP $fFunctorEP$fExactPIPBind$fExactPFieldDecl$fExactPActivation$fExactPOverlap$fExactPRuleVar $fExactPRule$fExactPSafety$fExactPCallConv $fExactPBinds $fExactPXName$fExactPPXAttr$fExactPRPatOp $fExactPRPat$fExactPPatField $fExactPPat$fExactPGuardedRhs $fExactPRhs $fExactPMatch $fExactPXAttr$fExactPBracket$fExactPQualStmt $fExactPStmt$fExactPFieldUpdate$fExactPSplice$fExactPUnpackedness$fExactPBangType$fExactPGadtDecl$fExactPConDecl$fExactPQualConDecl$fExactPFunDep$fExactPInstDecl$fExactPClassDecl$fExactPDerivStrategy$fExactPDeriving $fExactPAsst$fExactPContext$fExactPPromoted$fExactPMaybePromotedName $fExactPType$fExactPTyVarBind$fExactPInstHead$fExactPInstRule$fExactPDeclHead$fExactPBooleanFormula$fExactPAnnotation $fExactPRole $fExactPDecl$fExactPResultSig$fExactPInjectivityInfo$fExactPTypeEqn$fExactPDataOrNew $fExactPAssoc$fExactPWarningText$fExactPModulePragma$fExactPModuleHead$fExactPModule$fExactPImportDecl$fExactPImportSpec$fExactPImportSpecList$fExactPExportSpecList$fExactPExportSpec$fExactPNamespace $fExactPCName $fExactPOp $fExactPQOp$fExactPIPName $fExactPName $fExactPQName$fExactPSpecialCon$fExactPModuleName $fExactPSign$fExactPLiteral$fAnnotatedGuardedAlts $fExactPAlt$fExactPGuardedAlt$fExactPGuardedAlts$fAnnotatedGuardedAlt $fExactPExp$fFunctorGuardedAlts$fShowGuardedAlts$fFunctorGuardedAlt$fShowGuardedAltnamesymvaropqvarpvarappinfixAppappFunpApptuplepTuplevarTuple pvarTuplefunctionstrEcharEintEstrPcharPintPdoElamEletEcaseEaltaltGWlistEeListpeListparenpParenqualStmtgenStmtletStmtbindsnoBindswildcardgenNamessfun simpleFunpatBind patBindWherenameBind metaFunction metaConPat parseFileparseFileWithExtsparseFileWithModeparseFileWithCommentsparseFileWithCommentsAndPragmasparseFileContentsparseFileContentsWithExtsparseFileContentsWithModeparseFileContentsWithCommentsreadExtensionsbaseGHC.ListzipWithEnabled isEnabled MExtScheme ExtSchemeAllAny GHC.MaybeNothingGHC.Basefmapghc-prim GHC.TypesFalseTrueMaybe GHC.ClassesEqGHC.ShowShowFunctorBoolTyPredAsPatWildCardIrrPatPostOpPreOpViewPatSeqRPGuardRPEitherRPCAsRPXRPatsBangPatPAsstPTypePContext ParseXAttr PFieldUpdatePExp p_unit_con p_tuple_conp_unboxed_singleton_conpretty prettyPrecDocDocMrenderStyleModeppIndent$$$prefixMinusFixityHaddockCommentPrePostNoneCommentAccumulatormergelastPost associate1newAccumulator getToMergematchPreviousSrcisBeforeisNonecommentsToHaddockcommentToHaddockPGHC.Err undefinedparserdiscard getLastChar lexNewlinelexTab lexWhile_ addExtensionLsaveExtensionsLrestoreExtensionsLLexrunL ExtContextCodeCtxtHarpCtxtTagCtxt ChildCtxt CloseTagCtxt CodeTagCtxt LexContextNoLayoutLayoutrunParserWithMode runParserrunParserWithModeCommentsatSrcLoc getSrcLoc getModuleNamepushCurrentContext popContext getExtensionsgetIgnoreFunctionAritygetInputlexWhile alternativecheckBOLsetBOL startToken getOffside getSrcLocL setSrcLineL pushContextL popContextL pullCtxtFlagflagDo getExtContextpushExtContextLpopExtContextLgetExtensionsLignoreLinePragmasLsetLineFilenameL pushCommentcheckAndWarnTypeOperatorsbangType splitTilde SumOrTupleSSumSTuple pexprToQName splitTyConApp checkEnabledcheckEnabledOneOfcheckPatternGuards checkToplevel checkPContextcheckAssertion checkContextcheckDataHeadercheckClassHeadercheckInstHeader checkDeriving checkPattern checkRPattern checkExpr checkRuleExprreadTool getGConName checkValDef checkSigVarcheckExplicitPatSyncheckClassBody checkInstBodycheckDefSigDef checkUnQualcheckQualOrUnQual checkEqNames checkPrecmkRecConstrOrUpdateupdateQNameLoccheckSingleDecl checkRevDeclscheckRevClsDeclscheckRevInstDeclscheckDataOrNewcheckDataOrNewGcheckSimpleType checkType checkTyVar checkKindcheckPageModulecheckHybridModulemkDVar mkTyForallmkRoleAnnotDecl mkAssocType mkEThingWith mkSumOrTupleisPossiblyQvarlexWhiteSpace_ isBinDigitlexertopLexer mparseModule mparseExp mparsePat mparseType mparseStmtmparseImportDeclngparseModulePragmasngparseModuleHeadAndImportsngparsePragmasAndModuleHeadngparsePragmasAndModuleName mparseDeclHappyStk<>unGAltgAltsgAltunlit'parseFileContentsWithCommentsAndPragmasseparatePragmas