y>      !"#$%&'()*+,-./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-{-|-}-~---------..............................//////0111122223344456789:;<<<==>?@@@@@@AAAAAABCDEFFFFFFFFFFFFLG Safe-Inferred   Safe-InferredState for the parser monad*The most recently marked indentation levelNone +23468BgThe type checking monad, which provides the state of the type checker, and error reporting capabilities State required for type checking#The next fresh unification variable The current substitution MA substitution maintains a mapping from unification variables to their values *Identifies types which support unification.A type which can contain unification variablesUntyped unification variables An empty  UnifyStateRun a computation in the Unify monad, failing with an error, or succeeding with a return value and the new next unification variable(Substitute a single unification variableSReplace a unification variable with the specified value in the current substitution[Perform the occurs check, to make sure a unification variable does not occur inside a value-Generate a fresh untyped unification variable8Generate a fresh unification variable at a specific type        Safe-Inferred+-UData type for literal values. Parameterised so it can be used for Exprs and Binders. An object literal!An array literal"A boolean literal#A string literal$A numeric literal !"#$ !"#$$#"! $#"!  Safe-Inferred%&'()*+%&'()*+%&'()*+%&'()*+ Safe-Inferred+M. Source name/Start of the span1Source position information3 Line number4 Column number ,-./0123456 ,-./01234 12346,-./05,-./0123456 Safe-Inferred+7Fixity data for infix operators9!Associativity for infix operators=(A precedence level for an infix operator789:;<=>789:;<==9<;:>78789<;:=> Safe-InferredE?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~E?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~E?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~E?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None246B   Safe-Inferred!"(* !The data type of compiler options)Disable inclusion of the built in PreludeDisable tail-call elimination>Disable inlining of calls to return and bind for the Eff monad#When specified, checks the type of mainN in the module, and generate a call to run main after the module definitions.Skip all optimizationsVerbose error message)Remove the comments from the generated js_Specify the namespace that PureScript modules will be exported to when running in the browser.Per-mode optionsVIndicates the mode of the compiler. Lifted using DataKinds to refine the Options type.Default compiler optionsDefault make options   Safe-Inferred+-:A qualified name, i.e. a name with an optional module name Module namesTProper names, i.e. capitalized names for e.g. module names, type//data constructors.Names for value identifiers%A symbolic name for an infix operatorAn alphanumeric identifier7Provide a default module name, if a name is unqualified   Safe-Inferred4Convert an Ident into a valid Javascript identifier:,Alphanumeric characters are kept unmodified.2Reserved javascript identifiers are prefixed with $$.Symbols are prefixed with 2 followed by a symbol name or their ordinal value.;Test if a string is a valid JS identifier without escaping.kAttempts to find a human-readable name for a symbol, if none has been specified returns the ordinal value.<Checks whether an identifier name is reserved in Javascript.7Checks whether a proper name is reserved in Javascript.  Safe-Inferred+-Data type for binders/A binder which binds its input to an identifierPA binder which matches a data constructor (type name, constructor name, binders)"A binder which binds an identifier&A binder which matches a literal valueWildcard binder  Safe-Inferred+-"An alternative in a case statement6A collection of binders with which to match the inputs9The result expression or a collect of guarded expressionsSA guard is just a boolean-valued expression that appears alongside a set of bindersA let or module binding.3Mutually recursive binding group for several values(Non-recursive binding for a single value#Data type for expressions and terms A let bindingA case expressionVariableFunction applicationFunction introductionPartial record updateA record property accessor=A data constructor (type name, constructor name, field names)A literal value"Extract the annotation from a termModify the annotation on a term  Safe-Inferred Safe-Inferred+Data constructor metadata7The constructor is for a type with multiple construcors6The constructor is for a type with a single construcorMetadata annotations9The contained value is a typeclass dictionary constructor The contained value is a newtype)The contained value is a data constructorNone+The data type of kindsFunction kinds5Kinds for labelled, unordered rows without duplicatesThe kind of effectsThe kind of types!Unification variable of type KindNone+A typeclass constraintThe type of types%A placeholder used in pretty printing%A placeholder used in pretty printing%A placeholder used in pretty printing%A placeholder used in pretty printingA type with a kind annotationA non-empty row An empty rowA skolem constant+A type with a set of type class constraintsForall quantifier7A type synonym which is "saturated", i.e. fully appliedA type applicationA type constructor:A type wildcard, as would appear in a partial type synonymA named type variable#A unification variable of type Type0An identifier for the scope of a skolem variable4Convert a row to a list of pairs of labels and types+Convert a list of labels and types to a row"Check whether a type is a monotypeUniversally quantify a type?Replace a type variable, taking into account variable shadowing'Replace named type variables with types.Collect all type variables appearing in a type3Collect all free type variables appearing in a typeEUniversally quantify over all type variables appearing free in a type5Move all universal quantifiers to the front of a type"Check if a type contains wildcards%    %    %        None+  #The type of a type class dictionaryXA type class dictionary which is an alias for an imported dictionary from another moduleA regular type class dictionary;Data representing a type class dictionary which is in scopeCThe identifier with which the dictionary can be accessed at runtimeDThe name of the type class to which this type class instance applies3The types to which this type class instance appliesLType class dependencies which must be satisfied to construct this dictionaryThe type of this dictionary(Is this instance exported by its module?MFind the original dictionary which a type class dictionary in scope refers to       None+* The type ('data' or  'newtype') of a data type declarationA newtype constructorA standard data constructorThe kinds of a typeA scoped type variableA local type variable Foreign data  Type synonym! Data type"The kind of a name#OA type class dictionary, generated during desugaring of type class declarations$A data constructor%SA local name introduced using a lambda abstraction, variable introduction or binder&A foreign import'fA type class dictionary member accessor import, generated during desugaring of type class declarations(+A value introduced as a binding in a module)!The visibility of a name in scope*_The name is defined in the another binding group, or has been made visible by a function binder+DThe name is defined in the current binding group, but is not visible,The type of a foreign import-EA foreign import which contains inline Javascript as a string literal.A regular foreign import/The  Environment; defines all values and types which are currently in scope:1Value names currently in scope2Type names currently in scope3XData constructors currently in scope, along with their associated data type constructors4 Type synonyms currently in scope5!Available type class dictionaries6 Type classes7TThe initial environment with no values and only the default javascript types defined8)Construct a ProperName in the Prim module9#Construct a type in the Prim module:Type constructor for functions;Type constructor for strings<Type constructor for numbers=Type constructor for booleans>Type constructor for arrays?Type constructor for objects@$Smart constructor for function typesAWThe primitive types in the external javascript environment with their associated kinds.BGFinds information about data constructors from the current environment.C3Checks whether a data constructor is for a newtype., !"#$%&'()*+,-./0123456789:;<=>?@ABCD+ !"#$%&'()*+,-./0123456789:;<=>?@ABC,/01234567,.-)+*"('&%$#! D89:;<=>?@ABC! "('&%$#)+*,.-/0123456789:;<=>?@ABCD Safe-Inferred+EFGEFGEGFEGF Safe-Inferred+ HData type for bindersI)A binder with source position informationJ/A binder which binds its input to an identifierK;A binder which matches an array and binds its head and tailL6A binder which matches an array and binds its elementsM8A binder which matches a record and binds its propertiesN)A binder which matches a data constructorO"A binder which binds an identifierP(A binder which matches a numeric literalQ'A binder which matches a string literalR(A binder which matches a boolean literalSWildcard binderT8Collect all names introduced in binders in an expression HIJKLMNOPQRST HIJKLMNOPQRST HSRQPONMLKJITH SRQPONMLKJIT Safe-Inferred+8U/Data type for simplified Javascript expressionsVCommented JavascriptWVRaw Javascript (generated when parsing fails for an inline foreign import declaration)XContinue statementYBreak statementZLabelled statement[InstanceOf test\Type-Of operator]Throw statement^Return statement_If-then-else statement` ForIn loopaFor loopb While loopcA variable assignmentd3A variable introduction and optional initializatione A block of expressions in bracesfConditional expressiongVariablehFunction applicationi8A function introduction (optional name, arguments, body)j&An object property accessor expressionkAn object literallAn array indexer expressionmAn array literalnA binary operator applicationoA unary operator applicationpA boolean literalqA string literalrA numeric literalsBuilt-in binary operatorst"Bitwise right shift with zero-filluBitwise right shiftvBitwise left shiftw Bitwise xorx Bitwise ory Bitwise andz Boolean or{ Boolean and|Numeric greater-than-or-equal}Numeric greater-than~Numeric less-than-or-equalNumeric less-thanGeneric inequality testGeneric equality test RemainderNumeric divisionNumeric multiplicationNumeric subtractionNumeric additionBuilt-in unary operators ConstructorNumeric unary 'plus'Bitwise negationBoolean negationNumeric negation;UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~;UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~;s~}|{zyxwvutUrqponmlkjihgfedcba`_^]\[ZYXWVUrqponmlkjihgfedcba`_^]\[ZYXWVs~}|{zyxwvutNone+MM"A statement in a do-notation block6A do notation element with source position information0A let statement, i.e. a pure value with a binderA monadic value with a binder A monadic value without a binder"An alternative in a case statement6A collection of binders with which to match the inputs9The result expression or a collect of guarded expressions#Data type for expressions and terms(A value with source position informationeA placeholder for a superclass dictionary to be turned into a TypeClassDictionary during typechecking`A typeclass dictionary accessor, the implementation is left unspecified until CoreFn desugaring.A placeholder for a type class dictionary to be inserted later. At the end of type checking, these placeholders will be replaced with actual expressions representing type classes dictionaries which can be evaluated at runtime. The constructor arguments represent (in order): whether or not to look at superclass implementations when searching for a dictionary, the type class name and instance type, and the type class dictionaries in scope.\An application of a typeclass dictionary constructor. The value should be an ObjectLiteral.A do-notation block A let bindingA value with a type annotationA case expression. During the case expansion phase of desugaring, top-level binders will get desugared into case expressions, hence the need for guards and multiple binders per branch here.A data constructor%Conditional (if-then-else expression)VariableFunction applicationFunction introductionyPartial record updater. This will be removed during desugaring and expanded into a lambda that returns an object update.Partial record update&An record property accessor expression An object property getter (e.g. `_.x`k). This will be removed during desugaring and expanded into a lambda that reads a property from an object.An object constructor (object literal with underscores). This will be removed during desugaring and expanded into a lambda that returns an object literal.An object literalAn array literalOperator section. This will be removed during desugaring and replaced with a partially applied operator or lambda to flip the arguments.jExplicit parentheses. During the rebracketing phase of desugaring, this data constructor will be removed.qBinary operator application. During the rebracketing phase of desugaring, this data constructor will be removed.A prefix -, will be desugaredA boolean literalA string literalA numeric literalSA guard is just a boolean-valued expression that appears alongside a set of bindersThe data type of declarations.A declaration with source position informationbA type instance declaration (name, dependencies, class name, instance types, member declarations)GA type class declaration (name, argument, implies, member declarations)'A module import (module name, qualified unqualified%hiding, optional "qualified as" name)1A fixity declaration (fixity data, operator name)$A type class instance foreign import'A data type foreign import (name, kind)KA foreign import declaration (type, name, optional inline Javascript, type)6A minimal mutually recursive set of value declarationsDA value declaration (name, top-level binders, optional guard, value))A type declaration for a value (name, ty)2A type synonym declaration (name, arguments, type):A minimal mutually recursive set of data type declarationsMA data type declaration (data or newtype, name, arguments, data constructors)8The data type which specifies type of import declaration;Import with hiding clause with a list of references to hide4Qualified import with a list of references to importUnqualified import0An item in a list of explicit imports or exports8A declaration reference with source position information]A type class instance, created during typeclass desugaring (name, class name, instance types) A type classA value)A type constructor with data constructorsA module declaration, consisting of a module name, a list of declarations, and a list of the declarations that are explicitly exported. If the export list is Nothing, everything is exported.Return a module's name.@Test if a declaration is exported, given a module's export list.VTest if a data constructor for a given type is exported, given a module's export list.7Return the exported data constructors for a given type.,Test if a declaration is a value declaration@Test if a declaration is a data type or type synonym declaration(Test if a declaration is a module import3Test if a declaration is a data type foreign import=Test if a declaration is a type class instance foreign import-Test if a declaration is a fixity declaration)Test if a declaration is a foreign import=Test if a declaration is a type class or instance declarationCRecursively flatten data binding groups in the list of declarationsQPQNone Safe-Inferred     Safe-InferredEliminate tail calls Safe-InferredCInline type class dictionaries for >>= and return for the Eff monadE.g.;Prelude[">>="](dict)(m1)(function(x) { return ...; })becomes-function __do { var x = m1(); ... }!Inline functions in the ST module Safe-Inferred   Safe-Inferred Safe-Inferred@Collapse blocks which appear nested directly below another block Safe-Inferred3@Apply a series of optimizer passes to simplified Javascript code None!None Type alias for basic annotations #Initial annotation with no metadata &Remove the comments from an annotation        " Safe-InferredECWe use Text.Parsec.Token to implement the string and number lexemes/A token parser based on the language definition/1Parse zero or more values separated by semicolons00Parse one or more values separated by semicolons1-Parse zero or more values separated by commas2,Parse one or more values separated by commas?)A list of purescript reserved identifiersA+The characters allowed for use in operators\         !"#$%&'()*+,-./0123456789:;<=>?@A7    !"#$%&'()*+,-./0123456789:;<=>?@A7    !"#$%&'()*+,-./0123468759:>;<=?@A=         !"#$%&'()*+,-./0123456789:;<=>?@A# Safe-Inferred3 CParse a module nameD0Parse a qualified name, i.e. M.name or just nameE-Parse an identifier or parenthesized operatorFnRun the first parser, then match the second if possible, applying the specified function on a successful matchGnRun the first parser, then match the second zero or more times, applying the specified function for each matchHPBuild a parser from a smaller parser and a list of parsers for postfix operatorsI"Mark the current indentation levelJ;Check that the current identation level matches a predicateKACheck that the current indentation level is past the current markLWCheck that the current indentation level is at the same indentation as the current markM?Read the comments from the the next token, without consuming itN Run a parser BCDEFGHIJKLMN BCDEFGHIJKLMN BCDEFGHIJKLMN BCDEFGHIJKLMN$NoneO Parse a kind OOO O%NoneP5Parse a type as it appears in e.g. a data constructorQParse a monotypeRParse a polytypeS&Parse an atomic type with no wildcards!"#$%&'(P)*QRS+,-PQRSQRSP!"#$%&'(P)*QRS+,-& Safe-InferredWWrap a string in parenthesesX)Number of characters per identation levelY)Pretty print with a new indentation levelZ!Get the current indentation level[Print many lines\.Prints an object key, escaping reserved names. TUVWXYZ[\ TUVWXYZ[\ WTUVXYZ[\TUVWXYZ[\'None]4Generate a pretty-printed string representing a Kind./0]]]./0](None^3Generate a pretty-printed string representing a Row_\Generate a pretty-printed string representing a Type, as it should appear inside parentheses`4Generate a pretty-printed string representing a Type 1^2345678_`^_``_^ 1^2345678_`)None9EGenerate a pretty-printed string representing a Javascript expressionarGenerate a pretty-printed string representing a collection of Javascript expressions at the same indentation level:PGenerate an indented, pretty-printed string representing a Javascript expression;<=>?@ABCDEFGH9a:aa;<=>?@ABCDEFGH9a:HNonet,-./01234789:;<=HIJKLMNOPQRST*None3b)A list of modules with their dependenciesc:Sort a collection of modules based on module dependencies.6Reports an error if the module graph contains a cycle.INCalculate a list of used modules based on explicit imports and qualified namesJFConvert a strongly connected component of the module graph to a modulebcIJbccbbcIJ+NoneE K Read source position informationdParse a single declaratione6Parse a module header and a collection of declarationsfParse a collection of modulesgParse a collection of modulesL/Parse an expression in backticks or an operatorh Parse a valueiParse a binderj<Parse a binder as it would appear in a top level declarationk Parse a guard=KMNOPQRSTUVWXYZd[efg\]^_`abcdefghijLklmnopqrhstuvwxyz{|}~ijkdefghijkdegfhkij=KMNOPQRSTUVWXYZd[efg\]^_`abcdefghijLklmnopqrhstuvwxyz{|}~ijkINoneT    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSdefghijk,Nonel;Generate a pretty-printed string representing an expressionm6Generate a pretty-printed string representing a BinderlmlmlmlmJNone]^_`alm-None3B nA stack trace for an errorrCompilation errorst Error messageu"The value where the error occurredv$Optional source position informationw(Type for sources of type checking errorsx#An error which originated at a Typey#An error which originated at a Exprz"Create an ErrorStack from a stringJRethrow an error with a more detailed error message in the case of failure1Rethrow an error with source position informationCollect errors in in parallel\Add an extra error string onto the top of each error stack in a list of possibly many errorsnopqrstuvwxyz{|}~nopqrstuvwxyz{|}~wyxrstuvnpoqz{|}~npoqrstuvwyxz{|}~.None !"2346BHMgThe type checking monad, which provides the state of the type checker, and error reporting capabilities!State required for type checking: The current  Environment(The next fresh unification variable name#The next type class dictionary nameThe current module0Temporarily bind a collection of names to values/Temporarily bind a collection of names to types/Temporarily bind a collection of names to typesBTemporarily make a collection of type class dictionaries available;Get the currently available list of type class dictionaries9Temporarily bind a collection of names to local variables>Temporarily bind a collection of names to local type variables-Update the visibility of all names to Defined*Lookup the type of a value by name in the  Environment0Lookup the visibility of a value by name in the  EnvironmentAssert that a name is visible)Lookup the kind of a type by name in the  EnvironmentGet the current  Environment Update the  Environment Modify the  Environment=Run a computation in the Check monad, starting with an empty  EnvironmentmRun a computation in the Check monad, failing with an error, or succeeding with a return value and the final  Environment.0Make an assertion, failing with an error message'Generate new type class dictionary nameLift a computation in the Check# monad into the substitution monad.bRun a computation in the substitution monad, generating a return value and the final substitution./None!"36,Build a type substitution for a type synonym:Replace all instances of a specific type synonym with the SaturatedTypeSynonym data constructor#Replace all type synonyms with the SaturatedTypeSynonym data constructor "Desaturate" SaturatedTypeSynonyms-Replace fully applied type synonyms with the SaturatedTypeSynonymR data constructor, which helps generate better error messages during unification.>Replace a type synonym and its arguments with the aliased type  0None9Generate foreign imports for all declarations in a module1None246EInfer the kind of a single typeQInfer the kind of a single type, returning the kinds of any scoped type variablestInfer the kind of a type constructor with a collection of arguments and a collection of associated data constructorsNSimultaneously infer the kinds of several mutually recursive type constructors^Solve the set of kind constraints associated with the data constructors for a type constructor3Default all unknown kinds to the Star kind of typesInfer a kind for a type  2NoneSReplace all sets of mutually-recursive declarations in a module with binding groupsBCollapse all binding groups in a module to individual declarations6Collapse all binding groups to individual declarationsoConvert a group of mutually-recursive dependencies into a BindingGroupDeclaration (or simple ValueDeclaration).3None@Replace all top-level binders in a module with case expressions.4Replace all top-level binders with case expressions.  4NoneAdd type synonym declarations for type class dictionary types, and value declarations for type class instance dictionary expressions.  5None4Desugars a module from AST to CoreFn representation.Find module names from qualified references to values. This is used to ensure instances are imported from any module that is referenced by the current module, not just from those that are imported explicitly (#667).?Desugars import declarations from AST to CoreFn representation.@Desugars foreign declarations from AST to CoreFn representation.Desugars export declarations references from AST to CoreFn representation. CoreFn modules only export values, so all data constructors, class constructor, instances and values are flattened into one list.Makes a typeclass dictionary constructor function. The returned expression is a function that accepts the superclass instances and member implementations and returns a record for the instance dictionary."Converts a ProperName to an Ident.KNone5 !"#$  6NoneKey type to use in graphZEliminate all declarations which are not a transitive dependency of the entry point module.Extract declaration names for a binding group.,Extract the ident for a foreign declaration..Find dependencies for each member in a module.2Find all referenced values within a binding group.&Check whether a binding group is used.*Check whether a named declaration is used.7None$The state object used in this moduleDA map from names bound (in the input) to their names (in the output)DThe set of names which have been used and are in scope in the outputCRuns renaming starting with a list of idents for the initial scope.bCreates a new renaming scope using the current as a basis. Used to backtrack when leaving an Abs.qAdds a new scope entry for an ident. If the ident is already present, a new unique name is generated and stored.'Finds the new name to use for an ident.(Finds idents introduced by declarations.,Renames within each declaration in a module.PRenames within a declaration. isTopLevel is used to determine whether the declaration is a module member or appearing within a Let. At the top level declarations are not renamed or added to the scope (they should already have been added), whereas in a Let declarations are renamed if their name shadows another in the current scope.Renames within a value.Renames within literals.!Renames within case alternatives.Renames within binders.8None !"3 iGenerate code in the simplified Javascript intermediate representation for all declarations in a module..Generates Javascript code for a module import.XGenerate code in the simplified Javascript intermediate representation for a declarationoGenerate code in the simplified Javascript intermediate representation for a single non-recursive declaration.LThe main purpose of this function is to handle code generation for comments.xGenerate code in the simplified Javascript intermediate representation for a variable based on a PureScript identifier.Generate code in the simplified Javascript intermediate representation for an accessor based on a PureScript identifier. If the name is not valid in Javascript (symbol based, reserved name) an indexer is returned.aGenerate code in the simplified Javascript intermediate representation for a value or expression.Shallow copy an object.fGenerate code in the simplified Javascript intermediate representation for a reference to a variable.Generate code in the simplified Javascript intermediate representation for a reference to a variable that may have a qualified name.mGenerate code in the simplified Javascript intermediate representation for pattern match binders and guards.cGenerate code in the simplified Javascript intermediate representation for a pattern match binder.BUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~LNoneCUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~9None Replace all DoNotationBind and DoNotationValueH constructors with applications of the Prelude.(>>=) function, and all  DoNotationLet# constructors with let expressions.:None]An imported environment for a particular module. This also contains the module's own members.HLocal names for types within a module mapped to to their qualified namesTLocal names for data constructors within a module mapped to to their qualified namesJLocal names for classes within a module mapped to to their qualified namesILocal names for values within a module mapped to to their qualified names(The exported declarations from a module.#The types exported from each module%The classes exported from each module$The values exported from each moduleMThe global export environment - every declaration exported from every module.Updates the exports for a module from the global environment. If the module was not previously present in the global environment, it is created.-Adds an empty module to an ExportEnvironment.<Adds a type belonging to a module to the export environment.'Adds a class to the export environment.'Adds a class to the export environment.eAdds an entry to a list of exports unless it is already present, in which case an error is returned.FReplaces all local names with qualified names within a set of modules.Make all exports for a module explicit. This may still effect modules that have an exports list, as it will also make all data constructor exports explicit.Add `import X ()` for any modules where there are only fully qualified references to members. This ensures transitive instances are included when using a member from a module.vReplaces all local names with qualified names within a module and checks that all existing qualified names are valid.4Finds all exported declarations in a set of modules.mFilters the exports for a module to ensure only explicit exports are kept in the global exports environment.|Finds the imports within a module, mapping the imported module name to an optional set of explicitly imported declarations.,Constructs a local environment for a module.TExtends the local environment for a module by resolving an import of another module.IRaises an error for when there is more than one definition for something.Raises an error for when there is a conflicting definition for something, for example, a type class and data constructor of the same name.;None<None3HMDRemove explicit parentheses and reorder binary operator applications    =NoneIReplace all top level type declarations in a module with type annotations=Replace all top level type declarations with type annotations>None,The desugaring pipeline proceeds as follows: $Remove signed literals in favour of   applications3Desugar object literals with wildcards into lambdasDesugar operator sectionsDesugar do-notation using the  Prelude.Monad type classBDesugar top-level case declarations into explicit case expressionsPDesugar type declarations into value declarations with explicit type annotations'Qualify any unqualified names and types'Rebracket user-defined binary operators3Introduce type synonyms for type class dictionariesIGroup mutually recursive value and data declarations into binding groups.?None+Ensure rows do not contain duplicate labels@NoneGenerate a new skolem constant5Introduce skolem scope at every occurence of a ForAllGenerate a new skolem scopePSkolemize a type variable by replacing its instances with fresh skolem constantsThis function has one purpose - to skolemize type variables appearing in a SuperClassDictionary placeholder. These type variables are somewhat unique since they are the only example of scoped type variables.1Ensure skolem variables do not escape their scopeANone23462Unify two types, updating the current substitution1Unify two rows, updating the current substitutionCommon labels are first identified, and unified. Remaining labels and types are unified with a trailing row unification variable, if appropriate, otherwise leftover labels result in a unification error.Check that two types unify>Replace a single type variable with a new unification variable$Replace type wildcards with unknownsJReplace outermost unsolved unification variables with named type variables    BNoneA simplified representation of expressions which are used to represent type class dictionaries at runtime, which can be compared for equalityA subclass dictionary0A dictionary which depends on other dictionariesCA dictionary which is brought into scope by an instance declaration>A dictionary which is brought into scope by a local constraintCheck that the current set of type class dictionaries entail the specified type class goal, and, if so, return a type class dictionary reference.Check whether the type heads of two types are equal (for the purposes of type class dictionary lookup), and return a substitution from type variables to types which makes the type heads unify.5Check all values in a list pairwise match a predicateCNone\Check whether one type subsumes another, rethrowing errors to provide a better error message'Check whether one type subsumes anotherDNone36Infer the types of multiple mutually-recursive values, and return elaborated values including type class dictionaries and type annotations.+Check if a value contains a type annotation=Map a function over type annotations appearing inside a valuePReplace type class dictionary placeholders with inferred type class dictionaries9Check the kind of a type, failing if it is not of kind *.yRemove any ForAlls and ConstrainedType constructors in a type by introducing new unknowns or TypeClassDictionary values.iThis is necessary during type checking to avoid unifying a polymorphic type with a unification variable.UInfer a type for a value, rethrowing any error to provide a more useful error messageInfer a type for a value>Infer the type of a property inside a record with a given type;Infer the types of variables brought into scope by a binderLCheck the types of the return values in a set of binders in a case statement NCheck the type of a value, rethrowing errors to provide a better error message!Check the type of a value"5Check the type of a collection of named record fieldsThe laxt parameter controls whether or not every record member has to be provided. For object updates, this is not the case.#]Check the type of a function application, rethrowing errors to provide a better error message$(Check the type of a function application%sCompute the meet of two types, i.e. the most general type which both types subsume. TODO: handle constrained types&JEnsure a set of property names and value does not contain duplicate labels'()*+, !-"#$%&'()*+, !-"#$%&ENone24.4Check that type synonyms are fully-applied in a type/'Type check all declarations in a moduleWAt this point, many declarations will have been desugared, but it is still necessary to)Kind-check all types and add them to the  Environment*Type-check all values and add them to the  Environment%Bring type class instances into scopeProcess module importsType check an entire module and ensure all types and classes defined within the module that are required by exported members are also exported. 012345678./* 012345678./FNone(3 #Determines when to rebuild a moduleAlways rebuild this moduleNever rebuild this moduleSA type class which collects the IO actions we need to be able to run in "make" modeGet a file timestampRead a file as a stringWrite a text fileRespond to a progress updateCompile a collection of modules-The compilation pipeline proceeds as follows:PSort the modules based on module dependencies, checking for cyclic dependencies.#Perform a set of desugaring passes.YType check, and elaborate values to include type annotations and type class dictionaries.URegroup values to take into account new value dependencies introduced by elaboration.Eliminate dead code.5Generate Javascript, and perform optimization passes.%Pretty-print the generated Javascript[Compiles in "make" mode, compiling each module separately to a js files and an externs fileIf timestamps have not changed, the externs file can be used to provide the module's types without having to typecheck the module again.9SAdd an import declaration for a module if it does not already explicitly import it.:;<9=>,-./01234789:;<=     !"#$%&'()*+,-./0123456789:;<=>?@ABCEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS]^_`abcdefghijklmnopqrstuvwxyz{|}~  :;<9=>?MMNOOPQQRSTTUVWXYZ[\]^_`abcdefghijklmnopqrstuuvwxyyz{|}~~d                                         h    !"#$%&'()*+,-./01234567789:;<=>?@ABCDEFGHIJKLLMNOPQRSTUVWXYZ[\]^_`abcdefghijjklmnopqrstuvwxyz{|}~     ijklm          ! " # $!%!&!'"(")")"*"+","-"."/"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&o&;&4&p&q&r&s&t'u(v(w(x)y*z*{+|+}+~+++++,,-------------------------..............................//////0111122223344456789:;<<<==>?@@@@@@AAAAAABCDEFFFFFFFFFFFFGGGGGGGGGGGGG    " """l""""""""""""""""" "!"""#"$"%"&"'"(")"*"+","-"."/"0$1$2$k%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+{+|+}+~++++++++++++++++++,L,,,,,,O,,R,Q,,,,,,///111111122222222223333333444444444555555666666 6777777777777777788888O888888888889::::::::::::::::::::::::::::<<<<< < < < <0<< <<AABBBBBBBCDDDDDDDD D!D"D#D$D%D&D'D(D)D*D+D,D-D.D/D0E1E2E3E4E5E6EEE7E8E9F:F;F<F=F>F?@purescript-0.6.8 Language.PureScript.Parser.StateControl.Monad.Unify#Language.PureScript.CoreFn.LiteralsLanguage.PureScript.Traversals!Language.PureScript.AST.SourcePos!Language.PureScript.AST.OperatorsLanguage.PureScript.ConstantsLanguage.PureScript.SupplyLanguage.PureScript.OptionsLanguage.PureScript.Names%Language.PureScript.CodeGen.JS.Common"Language.PureScript.CoreFn.BindersLanguage.PureScript.CoreFn.Expr%Language.PureScript.CoreFn.TraversalsLanguage.PureScript.CoreFn.MetaLanguage.PureScript.KindsLanguage.PureScript.Types)Language.PureScript.TypeClassDictionariesLanguage.PureScript.EnvironmentLanguage.PureScript.CommentsLanguage.PureScript.AST.Binders"Language.PureScript.CodeGen.JS.AST$Language.PureScript.AST.Declarations"Language.PureScript.AST.Traversals/Language.PureScript.CodeGen.JS.Optimizer.Common,Language.PureScript.CodeGen.JS.Optimizer.TCO0Language.PureScript.CodeGen.JS.Optimizer.MagicDo0Language.PureScript.CodeGen.JS.Optimizer.Inliner/Language.PureScript.CodeGen.JS.Optimizer.Unused/Language.PureScript.CodeGen.JS.Optimizer.Blocks(Language.PureScript.CodeGen.JS.Optimizer!Language.PureScript.CoreFn.ModuleLanguage.PureScript.CoreFn.Ann Language.PureScript.Parser.Lexer!Language.PureScript.Parser.Common Language.PureScript.Parser.Kinds Language.PureScript.Parser.Types!Language.PureScript.Pretty.Common Language.PureScript.Pretty.Kinds Language.PureScript.Pretty.TypesLanguage.PureScript.Pretty.JS&Language.PureScript.ModuleDependencies'Language.PureScript.Parser.Declarations!Language.PureScript.Pretty.ValuesLanguage.PureScript.Errors%Language.PureScript.TypeChecker.Monad(Language.PureScript.TypeChecker.Synonyms#Language.PureScript.CodeGen.Externs%Language.PureScript.TypeChecker.Kinds'Language.PureScript.Sugar.BindingGroups*Language.PureScript.Sugar.CaseDeclarations%Language.PureScript.Sugar.TypeClasses"Language.PureScript.CoreFn.Desugar'Language.PureScript.DeadCodeEliminationLanguage.PureScript.RenamerLanguage.PureScript.CodeGen.JS$Language.PureScript.Sugar.DoNotationLanguage.PureScript.Sugar.Names)Language.PureScript.Sugar.ObjectWildcards#Language.PureScript.Sugar.Operators*Language.PureScript.Sugar.TypeDeclarationsLanguage.PureScript.Sugar$Language.PureScript.TypeChecker.Rows'Language.PureScript.TypeChecker.Skolems%Language.PureScript.TypeChecker.Unify*Language.PureScript.TypeChecker.Entailment+Language.PureScript.TypeChecker.Subsumption%Language.PureScript.TypeChecker.TypesLanguage.PureScript.TypeCheckerLanguage.PureScriptPaths_purescriptLanguage.PureScript.ASTLanguage.PureScript.ParserLanguage.PureScript.PrettyLanguage.PureScript.CoreFnLanguage.PureScript.CodeGen ParseStateindentationLevelUnifyTunUnify UnifyState unifyNextVarunifyCurrentSubstitution SubstitutionrunSubstitution Unifiable=?=Partialunknown isUnknownunknowns$?UnknowndefaultUnifyStaterunUnify substituteOne=:= occursCheckfresh'fresh$fMonadErroreUnifyT$fMonadStatesUnifyT$fMonoidSubstitutionLiteral ObjectLiteral ArrayLiteralBooleanLiteral StringLiteralNumericLiteralfstMsndMthirdMpairMmaybeMeitherMdefS SourceSpanspanName spanStartspanEnd SourcePos sourcePosLinesourcePosColumn$fShowSourceSpan$fShowSourcePosFixity AssociativityInfixInfixrInfixl Precedence$fShowAssociativity$#<>++>>=+-*/%<><=>===/=.&..|..^.&&|| unsafeIndexnegateshlshrzshr complementnotzeroonereturnpure' returnEscapeduntilEwhileErunST stRefValuenewSTRef readSTRef writeSTRef modifySTRefmkFnrunFnunit undefinedmonadEffDictionaryapplicativeEffDictionarybindEffDictionarysemiringNumber ringNumbermoduloSemiringNumber numNumber ordNumbereqNumbereqString eqBoolean bitsNumberboolLikeBooleansemigroupStringsemigroupoidArrmain __superclass___unusedprimprelude preludeUnsafeeffst dataFunctionSupplySupplyT unSupplyT runSupplyT evalSupplyT runSupply evalSupply freshName$fMonadErroreSupplyTOptionsoptionsNoPrelude optionsNoTcooptionsNoMagicDo optionsMainoptionsNoOptimizationsoptionsVerboseErrorsoptionsNoCommentsoptionsAdditional ModeOptions MakeOptionsCompileOptionsModeMakeCompilebrowserNamespaceentryPointModulescodeGenModulesdefaultCompileOptionsdefaultMakeOptions Qualified ModuleName ProperName runProperNameIdentOprunIdent runModuleNamemoduleNameFromStringqualify$fShowQualified$fShowModuleName$fShowProperName $fShowIdent identToJsidentNeedsEscapingidentCharToStringnameIsJsReservedmoduleNameToJsproperNameIsJsReservedBinder NamedBinderConstructorBinder VarBinder LiteralBinder NullBinderCaseAlternativecaseAlternativeBinderscaseAlternativeResultGuardBindRecNonRecExprLetCaseVarAppAbs ObjectUpdateAccessor Constructor extractAnn modifyAnn$fFunctorCaseAlternativeeverywhereOnValueseverythingOnValuesConstructorTypeSumType ProductTypeMetaIsTypeClassConstructor IsNewtype IsConstructorKindFunKindRowBangStarKUnknowneverywhereOnKindseverythingOnKinds ConstraintTypePrettyPrintForAllPrettyPrintObjectPrettyPrintArrayPrettyPrintFunction KindedTypeRConsREmptySkolemConstrainedTypeForAllSaturatedTypeSynonymTypeAppTypeConstructor TypeWildcardTypeVarTUnknown SkolemScoperunSkolemScope rowToList rowFromList isMonoTypemkForAllreplaceTypeVarsreplaceAllTypeVarsusedTypeVariablesfreeTypeVariablesquantifymoveQuantifiersToFrontcontainsWildcardseverywhereOnTypeseverywhereOnTypesTopDowneverywhereOnTypesMeverywhereOnTypesTopDownMeverythingOnTypesTypeClassDictionaryTypeTCDAlias TCDRegularTypeClassDictionaryInScopetcdName tcdClassNametcdInstanceTypestcdDependenciestcdType tcdExportedcanonicalizeDictionary DataDeclTypeNewtypeDataTypeKind ScopedTypeVarLocalTypeVariable ExternData TypeSynonymDataTypeNameKindTypeInstanceDictionaryValueDataConstructor LocalVariableExternTypeClassAccessorImportValueNameVisibilityDefined UndefinedForeignImportTypeInlineJavascript ForeignImport EnvironmentnamestypesdataConstructors typeSynonymstypeClassDictionaries typeClassesinitEnvironmentprimNameprimTy tyFunctiontyStringtyNumber tyBooleantyArraytyObjectfunction primTypeslookupConstructorisNewtypeConstructor$fShowDataDeclTypeComment BlockComment LineCommentPositionedBinder ConsBinder ArrayBinder ObjectBinder NumberBinder StringBinder BooleanBinder binderNamesJS JSCommentJSRaw JSContinueJSBreakJSLabel JSInstanceOfJSTypeOfJSThrowJSReturnJSIfElseJSForInJSForJSWhile JSAssignmentJSVariableIntroductionJSBlock JSConditionalJSVarJSApp JSFunction JSAccessorJSObjectLiteral JSIndexerJSArrayLiteralJSBinaryJSUnaryJSBooleanLiteralJSStringLiteralJSNumericLiteralBinaryOperatorZeroFillShiftRight ShiftRight ShiftLeft BitwiseXor BitwiseOr BitwiseAndOrAndGreaterThanOrEqualTo GreaterThanLessThanOrEqualToLessThan NotEqualToEqualToModulusDivideMultiplySubtractAdd UnaryOperatorJSNewPositive BitwiseNotNotNegateeverywhereOnJSeverywhereOnJSTopDowneverythingOnJSDoNotationElementPositionedDoNotationElement DoNotationLetDoNotationBindDoNotationValuePositionedValueSuperClassDictionaryTypeClassDictionaryAccessorTypeClassDictionary!TypeClassDictionaryConstructorAppDo TypedValue IfThenElse ObjectUpdater ObjectGetterObjectConstructorOperatorSectionParensBinaryNoParens UnaryMinus DeclarationPositionedDeclarationTypeInstanceDeclarationTypeClassDeclarationImportDeclarationFixityDeclarationExternInstanceDeclarationExternDataDeclarationExternDeclarationBindingGroupDeclarationValueDeclarationTypeDeclarationTypeSynonymDeclarationDataBindingGroupDeclarationDataDeclarationImportDeclarationTypeHiding Qualifying UnqualifiedDeclarationRefPositionedDeclarationRefTypeInstanceRef TypeClassRefValueRefTypeRefModule getModuleName isExportedexportedDeclarationsisDctorExportedexportedDctors isValueDecl isDataDecl isImportDeclisExternDataDeclisExternInstanceDecl isFixityDecl isExternDeclisTypeClassDeclaration flattenDecls$fEqDeclarationRefeverywhereOnValuesTopDownMeverywhereOnValuesMeverythingWithContextOnValueseverywhereWithContextOnValuesM accumTypesapplyAll replaceIdent replaceIdents isReassigned isReboundisUsedtargetVariable isUpdatedremoveFromBlocktcomagicDo etaConvertunThunk evaluateIifesinlineVariables inlineValuesinlineOperatorinlineCommonOperatorsremoveCodeAfterReturnStatementsremoveUnusedArgremoveUndefinedAppcollapseNestedBlockscollapseNestedIfsoptimize ForeignDecl moduleName moduleImports moduleExports moduleForeign moduleDeclsAnnnullAnnremoveComments TokenParserPositionedToken ptSourcePosptToken ptCommentsTokenlexanyTokentokenmatchlparenrparenparenslbracerbracebraceslsquarersquaresquaresindentindentAtlarrowrarrow lfatArrow rfatArrowcolon doubleColonequalspipetickdotcommasemiat underscoresemiSepsemiSep1commaSep commaSep1lname qualifierreservedunamemnameuname'symbolsymbol' stringLiteralnumbernatural identifierreservedPsNamesreservedTypeNamesopChars properNameparseQualified parseIdentaugmentfoldbuildPostfixParsermarkcheckIndentationindentedsame readCommentsrunTokenParser parseKind parseTypeAtom parseType parsePolyType noWildcards PrinterState blockIndent withIndent currentIndentprettyPrintManyprettyPrintObjectKeyprettyPrintKindprettyPrintRowprettyPrintTypeAtomprettyPrintType prettyPrintJS ModuleGraph sortModulesparseDeclaration parseModuleparseModulesFromFiles parseModules parseValue parseBinderparseBinderNoParens parseGuardprettyPrintValueprettyPrintBinder ErrorStackMultipleErrors runErrorStack CompileErrorcompileErrorMessagecompileErrorValuecompileErrorPosition ErrorSource TypeError ExprErrorstrMsgprettyPrintErrorStackstringifyErrorStackisErrorNonEmpty showError mkErrorStackmkCompileError positionErrorrethrowrethrowWithPositionparU combineErrors$fIsStringErrorStackCheckunCheck CheckStatecheckEnv checkNextVarcheckNextDictNamecheckCurrentModule bindNames bindTypeswithScopedTypeVarswithTypeClassDictionariesgetTypeClassDictionariesbindLocalVariablesbindLocalTypeVariablesmakeBindingGroupVisiblelookupVariable getVisibilitycheckVisibilitylookupTypeVariablegetEnvputEnv modifyEnvrunCheck runCheck' guardWithfreshDictionaryName liftCheck liftUnifysaturateAllTypeSynonymsdesaturateAllTypeSynonymsreplaceAllTypeSynonymsexpandTypeSynonym'expandTypeSynonymexpandAllTypeSynonyms moduleToPskindOfkindOfWithScopedVarskindsOf kindsOfAllcreateBindingGroupsModulecollapseBindingGroupsModulecreateBindingGroupscollapseBindingGroupsdesugarCasesModule desugarCasesdesugarTypeClassestypeClassMemberNamesuperClassDictionaryNamesmoduleToCoreFneliminateDeadCoderenameInModules moduleToJsdesugarDoModuledesugarImportsdesugarObjectConstructors rebracketremoveSignedLiteralsdesugarOperatorSectionsdesugarTypeDeclarationsModuledesugarTypeDeclarationsdesugarcheckDuplicateLabelsnewSkolemConstantintroduceSkolemScopenewSkolemScope skolemizeskolemizeTypesInValueskolemEscapeCheck unifyTypes unifyRows unifiesWithreplaceVarWithUnknownreplaceTypeWildcards varIfUnknownentailssubsumestypesOftypeCheckModule RebuildPolicy RebuildAlways RebuildNever MonadMake getTimestamp readTextFile writeTextFileprogresscompilecompile'makecatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNamebaseGHC.Basetco'magicDo'inlineST shouldInline isPreludeDict isPreludeFn optimize'untilFixedPointlangDef tokenParserNumberSymbol QualifierUNameLName UnderscoreAtSemiCommaDotTickPipeEquals DoubleColonColon RFatArrow LFatArrowRArrowLArrowIndentRSquareLSquareRBraceLBraceRParenLParenprettyPrintToken parseTokens whitespace parseCommentparsePositionedToken parseTokenvalidModuleName$fShowPositionedToken parseStar parseBang parseArray parseArrayOf parseFunction parseObjectparseTypeWildcardparseTypeVariableparseTypeConstructor parseForAllparseConstrainedType parseAnyTypeparseNameAndTypeparseRowEndingparseRow typeLiteralsmatchRowfunKindtypeAppappliedFunctionkindedinsertPlaceholders matchTypeAtom matchTypeforall_prettyPrintJS1prettyPrintJS'literalsstring conditionalaccessorindexerlamapptypeOf instanceOfunary'unarynegateOperatorbinaryprettyStatements usedModulestoModulewithSourceSpanparseInfixExpr kindedIdentparseDataDeclarationparseTypeDeclarationparseTypeSynonymDeclarationparseValueDeclarationparseExternDeclarationparseAssociativity parseFixityparseFixityDeclarationparseImportDeclarationparseDeclarationRefparseTypeClassDeclarationparseTypeInstanceDeclaration positionedparseLocalDeclarationbooleanLiteralparseNumericLiteralparseStringLiteralparseBooleanLiteralparseArrayLiteralparseObjectLiteralparseIdentifierAndValueparseAbsparseVarparseConstructor parseCaseparseCaseAlternativeparseIfThenElseparseLetparseValueAtomparseOperatorSectionparsePropertyUpdate parseAccessorparseDoparseDoNotationLetparseDoNotationBindparseDoNotationElementparseObjectGetterparseUpdaterBodyparseObjectUpdaterWildcardparseStringBinderparseBooleanBinderparseNumberBinderparseVarBinderparseNullaryConstructorBinderparseConstructorBinderparseObjectBinderparseArrayBinderparseNamedBinderparseNullBinderparseIdentifierAndBinderprettyPrintDeclarationprettyPrintCaseAlternativeprettyPrintDoNotationElementprettyPrintObject' ifThenElse objectUpdateprettyPrintValue'prettyPrintBinderAtomprettyPrintBinder'matchConsBinderprettyPrintObjectPropertyBinderprettyPrintObjectPropertybuildTypeSubstitutionsaturateTypeSynonymreplaceAllTypeSynonyms' solveTypes starIfUnknowninfer freshKindVarinfer'$fUnifiableCheckKind $fPartialKindtoBindingGroupcollapseBindingGroupsForValue usedIdentsusedImmediateIdentsusedProperNamesgetIdent getProperNametoDataBindingGroup isTypeSynonym fromValueDeclisLeft desugarAbs inSameGrouptoDecls isVarBindertoTuplemakeCaseDeclarationDesugar MemberMap desugarModule desugarDeclmemberToNameAndTypetypeClassDictionaryDeclaration#typeClassMemberToDictionaryAccessor!typeInstanceDictionaryDeclarationfindQualModulesimportToCoreFnexternToCoreFnexportToCoreFnmkTypeClassConstructor properToIdentKey bindIdents foreignIdentdeclarationsByModule dependenciesisUsed' RenameState rsBoundNames rsUsedNames runRenamenewScope updateScope lookupIdentfindDeclIdents renameInDecl renameInValuerenameInLiteralrenameInCaseAlternativerenameInBinderRename initState importToJsbindToJs nonRecToJSvar valueToJs extendObjvarToJs qualifiedToJS bindersToJs binderToJsaccessorStringiifeliteralToValueJSliteralToBinderJSisCons desugarDoImportEnvironment importedTypesimportedDataConstructorsimportedTypeClassesimportedValuesExports exportedTypesexportedTypeClassesexportedValuesExportEnvironmentupdateExportedModuleaddEmptyModuleaddType addTypeClassaddValue addExportelaborateExportselaborateImportsrenameInModule findExports filterExports findImportsresolveImports resolveImportthrowMultipleDefErrorthrowConflictingDefErrorChainrebracketModule removeParenscollectFixitiesensureNoDuplicatescustomOperatorTablematchOperatorstoAssocparseOp parseTicksmatchOpGHC.Num$fUnifiableCheckType $fPartialTypeDictionaryValueSubclassDictionaryValueDependentDictionaryValueGlobalDictionaryValueLocalDictionaryValuetypeHeadsAreEqualpairwise subsumes'isTyped overTypesreplaceTypeClassDictionaries checkTypeKindinstantiatePolyTypeWithUnknowns inferProperty inferBinder checkBinderscheckcheck'checkPropertiescheckFunctionApplicationcheckFunctionApplication'meetensureNoDuplicateProperties UntypedDataTypeDatatypeDictionaryForBindingGroupcheckTypedBindingGroupElementtypeForBindingGroupElementinferLetBindingcontainsTypeSynonymscheckTypeSynonyms typeCheckAll addDataTypeaddDataConstructoraddTypeSynonymvalueIsNotDefinedaddTypeClassDictionariescheckDuplicateTypeArgumentscheckTypeClassInstanceaddDefaultImport generateMaintraverseEitherreverseDependencies importPrim importPrelude