aG3e      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !""""########$$$%%&&&&&&&&&&&&&& & & & & &&&&&''())*++++,--- -!-"-#-$-%-&-'-(-)-*-+-,---.-/-0-1-2-3-4-5-6-7-8-9-:.;.</=0>1?1@1A2B2C2D2E2F2G3H4I4J4K4L4M4N5O5P5Q5R5S5T6U7V8W9X:Y:Z:[:\:]:^:_:`:a:b:c:d:?; Safe-Inferred efghijklmnopqflmnopq efghijklmnopq Safe-InferredState for the parser monad*The most recently marked indentation level Safe-Inferred     Safe-Inferred+7 /Data type for simplified Javascript expressions VRaw Javascript (generated when parsing fails for an inline foreign import declaration) Continue statement Break statementLabelled statementInstanceOf testType-Of operatorThrow statementReturn statementIf-then-else statement ForIn loopFor loop While loopA variable assignment3A variable introduction and optional initialization A block of expressions in bracesConditional expressionVariableFunction application8A function introduction (optional name, arguments, body)&An object property accessor expressionAn object literal An array indexer expression!An array literal"A binary operator application#A unary operator application$A boolean literal%A string literal&A numeric literal'Built-in binary operators("Bitwise right shift with zero-fill)Bitwise right shift*Bitwise left shift+ Bitwise xor, Bitwise or- Bitwise and. Boolean or/ Boolean and0Numeric greater-than-or-equal1Numeric greater-than2Numeric less-than-or-equal3Numeric less-than4Generic inequality test5Generic equality test6 Remainder7Numeric division8Numeric multiplication9Numeric subtraction:Numeric addition;Built-in unary operators< Constructor=Numeric unary 'plus'>Bitwise negation?Boolean negation@Numeric negation:  !"#$%&'()*+,-./0123456789:;<=>?@ABC:  !"#$%&'()*+,-./0123456789:;<=>?@ABC:;@?>=<':9876543210/.-,+*)( &%$#"!  ABC &%$#"!  ':9876543210/.-,+*)(;@?>=<ABC Safe-Inferred DEFGHIJKL DEFGHIJKL DEFGHIJKL DEFGHIJKL Safe-InferredM@Collapse blocks which appear nested directly below another blockMNMNMNMN Safe-Inferred+MQ Source nameRStart of the spanTSource position informationV Line numberW Column number OPQRSTUVWXY OPQRSTUVW TUVWYOPQRSXOPQRSTUVWXY Safe-Inferred+ZFixity data for infix operators\!Associativity for infix operators`(A precedence level for an infix operatorZ[\]^_`aZ[\]^_``\_^]aZ[Z[\_^]`a Safe-InferredCbcdefghijklmnopqrstuvwxyz{|}~Cbcdefghijklmnopqrstuvwxyz{|}~Cbcdefghijklmnopqrstuvwxyz{|}~Cbcdefghijklmnopqrstuvwxyz{|}~  Safe-Inferred 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_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-InferredEliminate tail callsrr  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-Inferred+ Data type for binders)A binder with source position information/A binder which binds its input to an identifier;A binder which matches an array and binds its head and tail6A binder which matches an array and binds its elements8A binder which matches a record and binds its properties)A binder which matches a data constructor"A binder which binds an identifier(A binder which matches a numeric literal'A binder which matches a string literal(A binder which matches a boolean literalWildcard binder8Collect all names introduced in binders in an expression   Safe-Inferred31)A list of purescript reserved identifiers+The characters allowed for use in operators(A list of reserved identifiers for typesA list of reserved operators(Valid first characters for an identifierValid identifier characters&Valid first characters for an operatorValid operators characters"The PureScript language definition/A token parser based on the language definition Parse a tokenParse an identifier1Parse an identifier in a more permissive positionParse a reserved wordParse a reserved operatorParse an operatorParse a string literalParse whitespace SemicolonColonPeriodCommaBacktickPipe characterNatural numberParse a proper nameParse a module name0Parse a qualified name, i.e. M.name or just name(Parse an integer or floating point value-Parse an identifier or parenthesized operator$Parse a token inside square brackets Parse a token inside parenthesesParse a token inside braces#Parse a token inside angle brackets 8Parse zero or more values separated by a separator token 7Parse one or more values separated by a separator token 1Parse zero or more values separated by semicolons 0Parse one or more values separated by semicolons -Parse zero or more values separated by commas,Parse one or more values separated by commasnRun the first parser, then match the second if possible, applying the specified function on a successful matchnRun the first parser, then match the second zero or more times, applying the specified function for each matchPBuild a parser from a smaller parser and a list of parsers for postfix operators/Parse an identifier in backticks or an operator"Mark the current indentation level;Check that the current identation level matches a predicateACheck that the current indentation level is past the current markWCheck that the current indentation level is at the same indentation as the current mark'Run a parser which supports indentation1     1     1     1      Safe-InferredWrap a string in parentheses)Number of characters per identation level)Pretty print with a new indentation level!Get the current indentation levelPrint many lines .Prints an object key, escaping reserved names.     None+!The data type of kinds"Function kinds#5Kinds for labelled, unordered rows without duplicates$The kind of effects%The kind of types&!Unification variable of type Kind!"#$%&'(!"#$%&'(!&%$#"'(!&%$#"'(None) Parse a kindstu)))stu)None*4Generate a pretty-printed string representing a Kindvwx***vwx*None++The 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 printing0A type with a kind annotation1A non-empty row2 An empty row3A skolem constant4+A type with a set of type class constraints5Forall quantifier67A type synonym which is "saturated", i.e. fully applied7A type application8A type constructor9:A type wildcard, as would appear in a partial type synonym:A named type variable;#A unification variable of type Type<0An identifier for the scope of a skolem variable?4Convert a row to a list of pairs of labels and types@+Convert a list of labels and types to a rowA"Check whether a type is a monotypeBUniversally quantify a typeC?Replace a type variable, taking into account variable shadowingD'Replace named type variables with typesE.Collect all type variables appearing in a typeF3Collect all free type variables appearing in a typeGEUniversally quantify over all type variables appearing free in a typeH5Move all universal quantifiers to the front of a typeI"Check if a type contains wildcards$+,-./0123456789:;<=>?@ABCDEFGHIJKLMN$+,-./0123456789:;<=>?@ABCDEFGHIJKLMN$<=>+;:9876543210/.-,?@ABCDEFGHIJKLMN+;:9876543210/.-,<=>?@ABCDEFGHIJKLMNNone+ O#The type of a type class dictionaryPXA type class dictionary which is an alias for an imported dictionary from another moduleQA regular type class dictionaryR;Data representing a type class dictionary which is in scopeTCThe identifier with which the dictionary can be accessed at runtimeUDThe name of the type class to which this type class instance appliesV3The types to which this type class instance appliesWLType class dependencies which must be satisfied to construct this dictionaryXThe type of this dictionaryY(Is this instance exported by its module?ZMFind the original dictionary which a type class dictionary in scope refers to OPQRSTUVWXYZ OPQRSTUVWXYZ RSTUVWXYOQPZOQPRSTUVWXYZNone+'[ The type ('data' or  'newtype') of a data type declaration\A newtype constructor]A standard data constructor^The kinds of a type_A local type variable` Foreign dataa Type synonymb Data typecThe kind of a namedOA type class dictionary, generated during desugaring of type class declarationseA data constructorfSA local name introduced using a lambda abstraction, variable introduction or bindergA foreign importhfA type class dictionary member accessor import, generated during desugaring of type class declarationsi+A value introduced as a binding in a modulej!The visibility of a name in scopek_The name is defined in the another binding group, or has been made visible by a function binderlDThe name is defined in the current binding group, but is not visiblemThe type of a foreign importnEA foreign import which contains inline Javascript as a string literaloA regular foreign importpThe  Environment; defines all values and types which are currently in scope:rValue names currently in scopesType names currently in scopetXData constructors currently in scope, along with their associated data type constructorsu Type synonyms currently in scopev!Available type class dictionariesw Type classesxTThe initial environment with no values and only the default javascript types definedy)Construct a ProperName in the Prim modulez#Construct a type in the Prim module{Type constructor for functions|Type constructor for strings}Type constructor for numbers~Type constructor for booleansType constructor for arraysType constructor for objects$Smart constructor for function typesWThe primitive types in the external javascript environment with their associated kinds.)[\]^_`abcdefghijklmnopqrstuvwxyz{|}~([\]^_`abcdefghijklmnopqrstuvwxyz{|}~)pqrstuvwxmonjlkcihgfed^ba`_[]\yz{|}~[]\^ba`_cihgfedjlkmonpqrstuvwxyz{|}~None 4Convert an Ident into a valid Javascript identifier:,Alphanumeric characters are kept unmodified.2Reserved javascript identifiers are prefixed with $$.Symbols are prefixed with y2 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.Finds the value stored for a data constructor in the current environment. This is a partial function, but if an invalid type has reached this far then something has gone wrong in typechecking.Checks whether a data constructor is the only constructor for that type, used to simplify the check when generating code for binders.3Checks whether a data constructor is for a newtype.:Checks the number of arguments a data constructor accepts.AChecks whether a data constructor has no arguments, for example, z.    None{CInline 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{|{|None}}None@Apply a series of optimizer passes to simplified Javascript code~~None+MC"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 typecheckingA 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 introductionPartial record update&An record property accessor expressionAn object literalAn array literaljExplicit 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.,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 declarationFEFNone<NoneiOPQRSTUVWZ[\]^_`None)A list of modules with their dependencies:Sort a collection of modules based on module dependencies.6Reports an error if the module graph contains a cycle.NCalculate a list of used modules based on explicit imports and qualified namesFConvert a strongly connected component of the module graph to a moduleNoneZEliminate all declarations which are not a transitive dependency of the entry point moduleNone $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 case alternatives.Renames within binders.  None!"$ iGenerate code in the simplified Javascript intermediate representation for all declarations in a module.XGenerate code in the simplified Javascript intermediate representation for a declarationOGenerate key//value pairs for an object literal exporting values from a module.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.=  !"#$%&'()*+,-./0123456789:;<=>?@ABC!NoneEGenerate a pretty-printed string representing a Javascript expressionrGenerate a pretty-printed string representing a collection of Javascript expressions at the same indentation levelPGenerate an indented, pretty-printed string representing a Javascript expression"None5Parse a type as it appears in e.g. a data constructorParse a monotypeParse a polytype&Parse an atomic type with no wildcards#NoneE  Read source position informationParse a single declaration6Parse a module header and a collection of declarationsParse a collection of modulesParse a collection of modules Parse a valueParse a binder<Parse a binder as it would appear in a top level declaration Parse a guard88=NoneA     )$None3Generate a pretty-printed string representing a Row\Generate a pretty-printed string representing a Type, as it should appear inside parentheses4Generate a pretty-printed string representing a Type  %None;Generate a pretty-printed string representing an expression6Generate a pretty-printed string representing a Binder>None*&None3B A stack trace for an errorCompilation errors Error message"The value where the error occurred$Optional source position information(Type for sources of type checking errors#An error which originated at a Type#An error which originated at a Expr JRethrow an error with a more detailed error message in the case of failure1Rethrow an error with source position informationCollect errors in in parallel                    'None3HMDRemove explicit parentheses and reorder binary operator applications          (None Replace all DoNotationBind and DoNotationValueH constructors with applications of the Prelude.(>>=) function, and all  DoNotationLet# constructors with let expressions.)NoneIReplace all top level type declarations in a module with type annotations=Replace all top level type declarations with type annotations*None9Generate foreign imports for all declarations in a module?None>  !"#$%&'()*+,-./0123456789:;<=>?@ABC+NoneSReplace all sets of mutually-recursive declarations in a module with binding groupsBCollapse all binding groups in a module to individual declarationsGReplace all sets of mutually-recursive declarations with binding groups6Collapse all binding groups to individual declarationsoConvert a group of mutually-recursive dependencies into a BindingGroupDeclaration (or simple ValueDeclaration).,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 names ILocal 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 module%MThe 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.0mFilters the exports for a module to ensure only explicit exports are kept in the global exports environment.1|Finds the imports within a module, mapping the imported module name to an optional set of explicitly imported declarations.2,Constructs a local environment for a module.3TExtends the local environment for a module by resolving an import of another module.4 !5"#$%&'()*+,-./01234 !5"#$%&'()*+,-./0123-None2346BHMgThe 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 name%The current module&0Temporarily bind a collection of names to values'/Temporarily bind a collection of names to types(BTemporarily make a collection of type class dictionaries available);Get the currently available list of type class dictionaries*9Temporarily 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  Environment.0Lookup the visibility of a value by name in the  Environment/Assert that a name is visible0)Lookup the kind of a type by name in the  Environment1Get the current  Environment2 Update the  Environment3 Modify the  Environment4=Run a computation in the Check monad, starting with an empty  Environment5mRun a computation in the Check monad, failing with an error, or succeeding with a return value and the final  Environment.60Make an assertion, failing with an error message7'Generate new type class dictionary name8Lift a computation in the Check# monad into the substitution monad.9bRun a computation in the substitution monad, generating a return value and the final substitution. !"#$%&'()*+,-./0123456789 !"#$%&'()*+,-./0123456789&'()*+,-./0 !"#$%123456789 !"#$%&'()*+,-./0123456789.None:@Replace all top-level binders in a module with case expressions.;4Replace all top-level binders with case expressions. 6:7;89:;<:;;: 6:7;89:;</None<Add type synonym declarations for type class dictionary types, and value declarations for type class instance dictionary expressions. =><?@ABCDEF<< =><?@ABCDEF0None=,The desugaring pipeline proceeds as follows:3Introduce type synonyms for type class dictionaries'Rebracket user-defined binary operatorsDesugar do-notation using the  Prelude.Monad type classBDesugar top-level case declarations into explicit case expressionsPDesugar type declarations into value declarations with explicit type annotationsIGroup mutually recursive value and data declarations into binding groups.'Qualify any unqualified names and types=:;<===1None246>Infer the kind of a single type?tInfer the kind of a type constructor with a collection of arguments and a collection of associated data constructors@NSimultaneously infer the kinds of several mutually recursive type constructorsG^Solve the set of kind constraints associated with the data constructors for a type constructorH3Default all unknown kinds to the Star kind of typesIInfer a kind for a type >?J@GHIKLM>?@>?@ >?J@GHIKLM2None36N,Build a type substitution for a type synonymO:Replace all instances of a specific type synonym with the SaturatedTypeSynonym data constructorA#Replace all type synonyms with the SaturatedTypeSynonym data constructorB "Desaturate" SaturatedTypeSynonymsP-Replace fully applied type synonyms with the SaturatedTypeSynonymR data constructor, which helps generate better error messages during unification.D>Replace a type synonym and its arguments with the aliased type NOABPCDEFABCDEFABCFED NOABPCDEF3NoneG+Ensure rows do not contain duplicate labelsGGGG4NoneHGenerate a new skolem constantI5Introduce skolem scope at every occurence of a ForAllJGenerate a new skolem scopeKPSkolemize a type variable by replacing its instances with fresh skolem constantsLThis 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.M1Ensure skolem variables do not escape their scopeHIJKLMHIJKLMHIJKLMHIJKLM5None2346N2Unify two types, updating the current substitutionO1Unify 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.PCheck that two types unifyQ>Replace a single type variable with a new unification variableR$Replace type wildcards with unknownsSJReplace outermost unsolved unification variables with named type variablesNOPQRSQRNOPQRSNOPQRSNOPQRSQR6NoneSA simplified representation of expressions which are used to represent type class dictionaries at runtime, which can be compared for equalityTA subclass dictionaryU0A dictionary which depends on other dictionariesVCA dictionary which is brought into scope by an instance declarationW>A dictionary which is brought into scope by a local constraintTCheck that the current set of type class dictionaries entail the specified type class goal, and, if so, return a type class dictionary reference.XCheck 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.Y5Check all values in a list pairwise match a predicateSTUVWTXYTTSWVUTTXY7NoneU\Check whether one type subsumes another, rethrowing errors to provide a better error messageZ'Check whether one type subsumes anotherUZUUUZ8None36VInfer 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 value]PReplace type class dictionary placeholders with inferred type class dictionaries^9Check 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 messageaInfer a type for a valueb>Infer the type of a property inside a record with a given typec;Infer the types of variables brought into scope by a binderdLCheck the types of the return values in a set of binders in a case statementeNCheck the type of a value, rethrowing errors to provide a better error messagefCheck the type of a valueg5Check 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.h]Check the type of a function application, rethrowing errors to provide a better error messagei(Check the type of a function applicationjsCompute the meet of two types, i.e. the most general type which both types subsume. TODO: handle constrained typeskJEnsure a set of property names and value does not contain duplicate labelslmVnop[\]^_`aqbcdefrghijkVVlmVnop[\]^_`aqbcdefrghijk9None24s4Check that type synonyms are fully-applied in a typet'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 importsWType check an entire module and ensure all types and classes defined within the module that are required by exported members are also exported. uvwxyz{|}stW( !"#$%&'()*+,-./0123456789>?@ABCDEFVWW uvwxyz{|}stW:None( X#Determines when to rebuild a moduleYAlways rebuild this moduleZNever rebuild this module[SA type class which collects the IO actions we need to be able to run in "make" mode\Get a file timestamp]Read a file as a string^Write a text file_Report an error`Respond to a progress updateaCompile 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 Javascriptc[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.~SAdd an import declaration for a module if it does not already explicitly import it.XYZ[\]^_`abc~d  !"#$%&'()*+,-./0123456789:;<=>?@ABCOPQRSTUVWZ[\]^_`     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFVWXYZ[\]^_`abcd abXZY[\]^_`cd XZY[\]^_`abc~d@@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNNO<PQRSTUVWXYZ[\]^_`abcdefghijklmnoppqrstuvwxyz{|}~       !""""#### #!#"###$$%$&$'%(%)&*&+&*&,&-&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&=&>'?'@(A)B)C*D+E+F+G+H,I-J-J-K-L-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^-_-`-a-b-c-d.e.f/g0h1i1j1k2l2m2n2o2p2q3r4s4t4u4v4w4x5y5z5{5|5}5~6789:::::::::::::;;;;;;;;;;;;;             !!!!!!!!!!!!!!"""""""""""""###################################### # # # # ######$$$$$$$$%%%%%%%%%% %!%"%#%$%%'&'''(')'*'+','-'.'!'/'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,>,C.V.W.X.Y.Z.[.\/]/^/_/`/a/b/c/d//e1f1g1h1i1j1k1l2m2n2o5p5q6r6s6t6u6v6w6x7y8z8{8|8}8~8h8j888888888888888889999999L9K999::::::purescript-0.6.1.2 Language.PureScript.Parser.StateLanguage.PureScript.Traversals"Language.PureScript.CodeGen.JS.AST$Language.PureScript.Optimizer.Common$Language.PureScript.Optimizer.Blocks!Language.PureScript.AST.SourcePos!Language.PureScript.AST.OperatorsLanguage.PureScript.Constants$Language.PureScript.Optimizer.UnusedLanguage.PureScript.SupplyLanguage.PureScript.Options!Language.PureScript.Optimizer.TCOLanguage.PureScript.NamesLanguage.PureScript.AST.Binders!Language.PureScript.Parser.Common!Language.PureScript.Pretty.CommonLanguage.PureScript.Kinds Language.PureScript.Parser.Kinds Language.PureScript.Pretty.KindsLanguage.PureScript.Types)Language.PureScript.TypeClassDictionariesLanguage.PureScript.Environment"Language.PureScript.CodeGen.Common%Language.PureScript.Optimizer.MagicDo%Language.PureScript.Optimizer.InlinerLanguage.PureScript.Optimizer$Language.PureScript.AST.Declarations"Language.PureScript.AST.Traversals&Language.PureScript.ModuleDependencies'Language.PureScript.DeadCodeEliminationLanguage.PureScript.RenamerLanguage.PureScript.CodeGen.JSLanguage.PureScript.Pretty.JS Language.PureScript.Parser.Types'Language.PureScript.Parser.Declarations Language.PureScript.Pretty.Types!Language.PureScript.Pretty.ValuesLanguage.PureScript.Errors#Language.PureScript.Sugar.Operators$Language.PureScript.Sugar.DoNotation*Language.PureScript.Sugar.TypeDeclarations#Language.PureScript.CodeGen.Externs'Language.PureScript.Sugar.BindingGroupsLanguage.PureScript.Sugar.Names%Language.PureScript.TypeChecker.Monad*Language.PureScript.Sugar.CaseDeclarations%Language.PureScript.Sugar.TypeClassesLanguage.PureScript.Sugar%Language.PureScript.TypeChecker.Kinds(Language.PureScript.TypeChecker.Synonyms$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.CodeGen ParseStateindentationLevelfstMsndMthirdMpairMmaybeMeitherMdefSJSJSRaw JSContinueJSBreakJSLabel JSInstanceOfJSTypeOfJSThrowJSReturnJSIfElseJSForInJSForJSWhile JSAssignmentJSVariableIntroductionJSBlock JSConditionalJSVarJSApp JSFunction JSAccessorJSObjectLiteral JSIndexerJSArrayLiteralJSBinaryJSUnaryJSBooleanLiteralJSStringLiteralJSNumericLiteralBinaryOperatorZeroFillShiftRight ShiftRight ShiftLeft BitwiseXor BitwiseOr BitwiseAndOrAndGreaterThanOrEqualTo GreaterThanLessThanOrEqualToLessThan NotEqualToEqualToModulusDivideMultiplySubtractAdd UnaryOperatorJSNewPositive BitwiseNotNotNegateeverywhereOnJSeverywhereOnJSTopDowneverythingOnJSapplyAll replaceIdent replaceIdents isReassigned isReboundisUsedtargetVariable isUpdatedremoveFromBlockcollapseNestedBlockscollapseNestedIfs SourceSpanspanName spanStartspanEnd SourcePos sourcePosLinesourcePosColumn$fShowSourceSpan$fShowSourcePosFixity AssociativityInfixInfixrInfixl Precedence$fShowAssociativity$#<>++>>=+-*/%<><=>===/=.&..|..^.&&|| unsafeIndexnegateshlshrzshr complementnotreturnpure' returnEscapeduntilEwhileErunST runSTArray stRefValuenewSTRef readSTRef writeSTRef modifySTRef peekSTArray pokeSTArraymkFnrunFnunit undefinedmonadEffDictionaryapplicativeEffDictionarybindEffDictionary numNumber ordNumbereqNumbereqString eqBoolean bitsNumberboolLikeBooleansemigroupStringsemigroupoidArrmain __superclass___unusedprimprelude preludeUnsafeeffst dataFunctionremoveCodeAfterReturnStatementsremoveUnusedArgremoveUndefinedAppSupplySupplyT unSupplyT runSupplyT evalSupplyT runSupply evalSupplyfresh freshName$fMonadErroreSupplyTOptionsoptionsNoPrelude optionsNoTcooptionsNoMagicDo optionsMainoptionsNoOptimizationsoptionsVerboseErrorsoptionsAdditional ModeOptions MakeOptionsCompileOptionsModeMakeCompilebrowserNamespaceentryPointModulescodeGenModulesdefaultCompileOptionsdefaultMakeOptionstco Qualified ModuleName ProperName runProperNameIdentOprunIdent runModuleNamemoduleNameFromStringqualify$fShowQualified$fShowModuleName$fShowProperName $fShowIdentBinderPositionedBinder NamedBinder ConsBinder ArrayBinder ObjectBinderConstructorBinder VarBinder NumberBinder StringBinder BooleanBinder NullBinder binderNamesreservedPsNamesopCharsreservedTypeNamesreservedOpNames identStart identLetteropStartopLetterlangDef tokenParserlexeme identifieridentifierNamereserved reservedOpoperator stringLiteral whiteSpacesemicolondotcommatickpipenatural properName moduleNameparseQualifiedintegerOrFloat parseIdentsquaresparensbracesanglessepBysepBy1semiSepsemiSep1commaSep commaSep1augmentfoldbuildPostfixParserparseIdentInfixmarkcheckIndentationindentedsamerunIndentParser PrinterStateindent blockIndent withIndent currentIndentprettyPrintManyprettyPrintObjectKeyKindFunKindRowBangStarKUnknowneverywhereOnKindseverythingOnKinds parseKindprettyPrintKindTypePrettyPrintForAllPrettyPrintObjectPrettyPrintArrayPrettyPrintFunction KindedTypeRConsREmptySkolemConstrainedTypeForAllSaturatedTypeSynonymTypeAppTypeConstructor TypeWildcardTypeVarTUnknown SkolemScoperunSkolemScope rowToList rowFromList isMonoTypemkForAllreplaceTypeVarsreplaceAllTypeVarsusedTypeVariablesfreeTypeVariablesquantifymoveQuantifiersToFrontcontainsWildcardseverywhereOnTypeseverywhereOnTypesTopDowneverywhereOnTypesMeverywhereOnTypesTopDownMeverythingOnTypesTypeClassDictionaryTypeTCDAlias TCDRegularTypeClassDictionaryInScopetcdName tcdClassNametcdInstanceTypestcdDependenciestcdType tcdExportedcanonicalizeDictionary DataDeclTypeNewtypeDataTypeKindLocalTypeVariable ExternData TypeSynonymDataTypeNameKindTypeInstanceDictionaryValueDataConstructor LocalVariableExternTypeClassAccessorImportValueNameVisibilityDefined UndefinedForeignImportTypeInlineJavascript ForeignImport EnvironmentnamestypesdataConstructors typeSynonymstypeClassDictionaries typeClassesinitEnvironmentprimNameprimTy tyFunctiontyStringtyNumber tyBooleantyArraytyObjectfunction primTypes$fShowDataDeclType identToJsidentNeedsEscapingidentCharToStringnameIsJsReservedmoduleNameToJslookupConstructorisOnlyConstructorisNewtypeConstructorgetConstructorArityisNullaryConstructormagicDo etaConvertunThunk evaluateIifesinlineVariablesinlineOperatorinlineCommonOperatorsoptimizeDoNotationElementPositionedDoNotationElement DoNotationLetDoNotationBindDoNotationValueCaseAlternativecaseAlternativeBinderscaseAlternativeResultExprPositionedValueSuperClassDictionaryTypeClassDictionary!TypeClassDictionaryConstructorAppDoLet TypedValueCase Constructor IfThenElseVarAppAbs ObjectUpdateAccessor ObjectLiteral ArrayLiteralParensBinaryNoParens UnaryMinusBooleanLiteral StringLiteralNumericLiteralGuard DeclarationPositionedDeclarationTypeInstanceDeclarationTypeClassDeclarationImportDeclarationFixityDeclarationExternInstanceDeclarationExternDataDeclarationExternDeclarationBindingGroupDeclarationValueDeclarationTypeDeclarationTypeSynonymDeclarationDataBindingGroupDeclarationDataDeclarationImportDeclarationTypeHiding Qualifying UnqualifiedDeclarationRefPositionedDeclarationRefTypeInstanceRef TypeClassRefValueRefTypeRefModule isValueDecl isDataDecl isImportDeclisExternDataDeclisExternInstanceDecl isFixityDecl isExternDeclisTypeClassDeclaration$fEqDeclarationRefeverywhereOnValueseverywhereOnValuesTopDownMeverywhereOnValuesMeverythingOnValueseverythingWithContextOnValueseverywhereWithContextOnValuesM accumTypes ModuleGraph sortModuleseliminateDeadCoderenameInModules moduleToJsdeclToJs prettyPrintJS parseTypeAtom parseType parsePolyType noWildcardsparseDeclaration parseModuleparseModulesFromFiles parseModules parseValue parseBinderparseBinderNoParens parseGuardprettyPrintRowprettyPrintTypeAtomprettyPrintTypeprettyPrintValueprettyPrintBinder ErrorStackMultipleErrors runErrorStack CompileErrorcompileErrorMessagecompileErrorValuecompileErrorPosition ErrorSource TypeError ExprErrorprettyPrintErrorStackstringifyErrorStackisErrorNonEmpty showError mkErrorStack positionErrorrethrowrethrowWithPositionparU$fErrorErrorStack$fMonoidErrorStack rebracketremoveSignedLiteralsdesugarDoModuledesugarTypeDeclarationsModuledesugarTypeDeclarations moduleToPscreateBindingGroupsModulecollapseBindingGroupsModulecreateBindingGroupscollapseBindingGroupsdesugarImportsCheckunCheck CheckStatecheckEnv checkNextVarcheckNextDictNamecheckCurrentModule bindNames bindTypeswithTypeClassDictionariesgetTypeClassDictionariesbindLocalVariablesbindLocalTypeVariablesmakeBindingGroupVisiblelookupVariable getVisibilitycheckVisibilitylookupTypeVariablegetEnvputEnv modifyEnvrunCheck runCheck' guardWithfreshDictionaryName liftCheck liftUnifydesugarCasesModule desugarCasesdesugarTypeClassesdesugarkindOfkindsOf kindsOfAllsaturateAllTypeSynonymsdesaturateAllTypeSynonymsreplaceAllTypeSynonymsexpandTypeSynonym'expandTypeSynonymexpandAllTypeSynonymscheckDuplicateLabelsnewSkolemConstantintroduceSkolemScopenewSkolemScope skolemizeskolemizeTypesInValueskolemEscapeCheck unifyTypes unifyRows unifiesWithreplaceVarWithUnknownreplaceTypeWildcards varIfUnknownentailssubsumestypesOftypeCheckModule RebuildPolicy RebuildAlways RebuildNever MonadMake getTimestamp readTextFile writeTextFile liftErrorprogresscompilecompile'makecatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNametco' parseStar parseBang typeLiteralsmatchRowfunKindbaseGHC.Base Data.MaybeNothingmagicDo'inlineST shouldInlineuntilFixedPoint usedModulestoModule getModuleNameKeydeclarationsByModule dependencies RenameState rsBoundNames rsUsedNames runRenamenewScope updateScope lookupIdentfindDeclIdents renameInDecl renameInValuerenameInCaseAlternativerenameInBinderRename initState exportToJsvaraccessor valueToJs extendObjvarToJs qualifiedToJS bindersToJs binderToJs importToJsimportsaccessorStringprettyPrintJS1prettyPrintJS'literalsstring conditionalindexerlamapptypeOf instanceOfunarybinaryprettyStatements parseArray parseArrayOf parseFunction parseObjectparseTypeWildcardparseTypeVariableparseTypeConstructor parseForAllparseConstrainedType parseAnyTypeparseNameAndTypeparseRowEndingparseRowwithSourceSpan kindedIdentparseDataDeclarationparseTypeDeclarationparseTypeSynonymDeclarationparseValueDeclarationparseExternDeclarationparseAssociativity parseFixityparseFixityDeclarationparseImportDeclarationparseDeclarationRefparseTypeClassDeclarationparseTypeInstanceDeclaration positionedparseLocalDeclarationbooleanLiteralparseNumericLiteralparseStringLiteralparseBooleanLiteralparseArrayLiteralparseObjectLiteralparseIdentifierAndValueparseAbsparseVarparseConstructor parseCaseparseCaseAlternativeparseIfThenElseparseLetparseValueAtomparsePropertyUpdate parseAccessorparseDoparseDoNotationLetparseDoNotationBindparseDoNotationElementparseStringBinderparseBooleanBinderparseNumberBinderparseVarBinderparseNullaryConstructorBinderparseConstructorBinderparseObjectBinderparseArrayBinderparseNamedBinderparseNullBinderparseIdentifierAndBindertypeAppappliedFunctionkindedinsertPlaceholders matchTypeAtom matchTypeforall_prettyPrintDeclarationprettyPrintCaseAlternativeprettyPrintDoNotationElement ifThenElse objectUpdateprettyPrintValue'prettyPrintBinderAtomprettyPrintBinder'matchConsBinderprettyPrintObjectPropertyBinderprettyPrintObjectPropertyChainrebracketModule removeParenscollectFixitiesensureNoDuplicatescustomOperatorTablematchOperatorstoAssoctokenparseOp parseTicksmatchOp desugarDotoBindingGroupcreateBindingGroupsForValuecollapseBindingGroupsForValue usedIdentsusedImmediateIdentsusedProperNamesgetIdent getProperNametoDataBindingGroup isTypeSynonym fromValueDeclImportEnvironment importedTypesimportedDataConstructorsimportedTypeClassesimportedValuesExports exportedTypesexportedTypeClassesexportedValuesExportEnvironmentupdateExportedModuleaddEmptyModuleaddType addTypeClassaddValue addExportelaborateExportselaborateImportsrenameInModule findExports filterExports findImportsresolveImports resolveImportisLeft desugarAbs inSameGrouptoDecls isVarBindertoTuplemakeCaseDeclarationDesugar MemberMap desugarModule desugarDeclmemberToNameAndTypetypeClassDictionaryDeclaration#typeClassMemberToDictionaryAccessormkSuperclassDictionaryName!typeInstanceDictionaryDeclaration solveTypes starIfUnknowninfer freshKindVarinfer'$fUnifiableCheckKind $fPartialKindbuildTypeSubstitutionsaturateTypeSynonymreplaceAllTypeSynonyms'$fUnifiableCheckType $fPartialTypeDictionaryValueSubclassDictionaryValueDependentDictionaryValueGlobalDictionaryValueLocalDictionaryValuetypeHeadsAreEqualpairwise subsumes'isTyped overTypesreplaceTypeClassDictionaries checkTypeKindinstantiatePolyTypeWithUnknowns inferProperty inferBinder checkBinderscheckcheck'checkPropertiescheckFunctionApplicationcheckFunctionApplication'meetensureNoDuplicateProperties UntypedDataTypeDatatypeDictionaryForBindingGroupcheckTypedBindingGroupElementtypeForBindingGroupElementinferLetBindingcontainsTypeSynonymscheckTypeSynonyms typeCheckAll addDataTypeaddDataConstructoraddTypeSynonymvalueIsNotDefinedaddTypeClassDictionariescheckDuplicateTypeArgumentscheckTypeClassInstanceaddDefaultImport generateMaintraverseEitherreverseDependencies importPrim importPrelude