s      !"#$%&'()*+,-./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({)|)})~)))))))))))*++++,,,,,,,,,-.../0001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 1 1 1 1 1111111111111112233 4!5"5#5$5%5&5'5(5)5*5+6,6-7.7/707172737475767778797:7;7<7=7>7?7@7A7B7C7D7E7F7G7H7I7J7K7L7M7N7O8P8Q8R8S9T9U9V9W9X9Y:Z;[;\;];^<_<`=a=b=c>d?e@f@gAhBiCjDkDlDmEnEoFpGqHrHsHtHuHvHwIxIyIzI{I|I}J~KLMNNNNNNNNNNNNNNNNNNOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR R R R R RRRRRRRRRRRRRRRRRRR R!R"R#R$R%R&R'R(R)R*R+R,R-R.R/S0S1T2T3T4T5T6T7T8T9T:T;T<U=U>U?U@UAVBWCWDWEWFWGWHWIWJWKWLWMWNWOWPWQWRWSWTWUWVWWWXWYWZW[W\W]W^W_W`WaWbWcWdWeXfXgXhXiXjXkXlXmXnXoXpXqXrX` Safe-Inferred     None GGlob relative to the current directory, and produce relative pathnames. )Glob pattern for PureScript source files. -Glob pattern for PureScript dependency files.     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 capabilities3A class for errors which support unification errors State required for type checking#The next fresh unification variableThe current substitutionMA substitution maintains a mapping from unification variables to their values*Identifies types which support unification .A type which can contain unification variables%Untyped unification variables& An empty  UnifyState'Run 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 variable)SReplace 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 variable,8Generate a fresh unification variable at a specific type !"#$%&'()*+,-./ !"#$%&'()*+,% !"#$/&.-'()*+, !"#$%&'()*+,-./ Safe-Inferred+-0UData type for literal values. Parameterised so it can be used for Exprs and Binders.1An object literal2An array literal3A boolean literal4A character literal5A string literal6A numeric literal0123456012345606543210654321 Safe-InferredQ789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Q789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Q789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Q789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred None+M Source nameStart of the spanSource position information Line number Column number  None+Fixity data for infix operators!Associativity for infix operators(A precedence level for an infix operator  Y Safe-Inferred stuvwxyz{|}~tz{|}~ stuvwxyz{|}~ None3EFM>A module is just a list of elements of the types listed above.<There are four types of module element we are interested in:R1) Require statements 2) Member declarations 3) Export lists 4) Everything else|Each is labelled with the original AST node which generated it, so that we can dump it back into the output during codegen.An export is either a "regular export", which exports a name from the regular module we are in, or a reexport of a declaration in the corresponding foreign module.WRegular exports are labelled, since they might re-export an operator with another name.yA piece of code is identified by its module and its name. These keys are used to label vertices in the dependency graph.7A module is identified by its module name and its type.VModules are either "regular modules" (i.e. those generated by psc) or foreign modules.The type of error messages. We separate generation and rendering of errors using a data type, in case we need to match on error types later.3Prepare an error message for consumption by humans.FUnpack the node inside a JSNode. This is useful when pattern matching.FCalculate the ModuleIdentifier which a require(...) statement imports.OCompute the dependencies of all elements in a module, and add them to the tree.YMembers and exports can have dependencies. A dependency is of one of the following forms: 1) module.name or member["name"]where module was imported usingvar module = require( Module.Name);2) nameAwhere name is the name of a member defined in the current module.1Attempt to create a Module from a Javascript AST.xEach type of module element is matched using pattern guards, and everything else is bundled into the Other constructor.=Eliminate unused code based on the specified entry point set.zTopologically sort the module dependency graph, so that when we generate code, modules can be defined in the right order.A module is empty if it contains no exported members (in other words, if the only things left after dead code elimination are module imports and "other" foreign code).<If a module is empty, we don't want to generate code for it.?Generate code for a set of modules, including a call to main().8Modules get defined on the global PS object, as follows:>var PS = { }; (function(exports) { ... })(PS[ Module.Name] = PS[ Module.Name ] || {});LIn particular, a module and its foreign imports share the same namespace inside PS. This saves us from having to generate unique names for a module and its foreign imports, and is safe since a module shares a namespace with its foreign imports in PureScript as well (so there is no way to have overlaps in code generated by psc).The bundling function. This function performs dead code elimination, filters empty modules and generates and prints the final Javascript bundle.! main module namespace input modulesCThe input modules. Each module should be javascript rendered from OZ or psc.WEntry points. These module identifiers are used as the roots for dead-code eliminationAn optional main module.The namespace (e.g. PS). NoneB None6 Safe-Inferred !The data type of compiler optionsDisable 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)The path to prepend to require statementsDefault make options None!"+-: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 unqualifiedNone4Convert 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.None+-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 binderNone+-"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 NoneNone+Data constructor metadata7The constructor is for a type with multiple construcors6The constructor is for a type with a single construcorMetadata annotations/The contained reference is for a foreign member9The contained value is a typeclass dictionary constructor  The contained value is a newtype )The contained value is a data constructor        None+ The data type of kinds Function kinds 5Kinds for labelled, unordered rows without duplicatesThe kind of effectsThe kind of types!Unification variable of type Kind               None+BA typeclass constraintThe type of types%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 quantifier 7A type synonym which is "saturated", i.e. fully applied!A type application"A type constructor#: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 row+"Check whether a type is a monotype,Universally 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 type03Collect all free type variables appearing in a type1EUniversally quantify over all type variables appearing free in a type25Move all universal quantifiers to the front of a type3"Check if a type contains wildcards% !"#$%&'()*+,-./0123456789$ !"#$%&'()*+,-./012345678&&'(%$#"! 99)*+,-./012345678%$#"! &'()*+,-./0123456789None+:A simplified representation of expressions which are used to represent type class dictionaries at runtime, which can be compared for equality;A subclass dictionary<0A dictionary which depends on other dictionaries=CA dictionary which is brought into scope by an instance declaration>>A dictionary which is brought into scope by a local constraint?#The type of a type class dictionary@XA type class dictionary which is an alias for an imported dictionary from another moduleAA regular type class dictionaryB;Data representing a type class dictionary which is in scopeDCThe identifier with which the dictionary can be accessed at runtimeEDThe name of the type class to which this type class instance appliesF3The types to which this type class instance appliesGLType class dependencies which must be satisfied to construct this dictionaryHThe type of this dictionaryI(Is this instance exported by its module?JMFind the original dictionary which a type class dictionary in scope refers to:;<=>?@ABCDEFGHIJ:;<=>?@ABCDEFGHIJBCDEFGHI?A@:>=<;J:>=<;?A@BCDEFGHIJNone+)K The type ('data' or  'newtype') of a data type declarationLA newtype constructorMA standard data constructorNThe kinds of a typeOA scoped type variablePA local type variableQ Foreign dataR Type synonymS Data typeTA flag for whether a name is for an private or public value - only public values will be included in a generated externs file.U.A name for member introduced by foreign importV@A public value for a module member or foreing import declarationWmA private value introduced as an artifact of code generation (class instances, class member accessors, etc.)X!The visibility of a name in scopeY_The name is defined in the another binding group, or has been made visible by a function binderZDThe name is defined in the current binding group, but is not visible[The  Environment; defines all values and types which are currently in scope:]Value names currently in scope^Type names currently in scope_XData constructors currently in scope, along with their associated data type constructors` Type synonyms currently in scopea!Available type class dictionariesb Type classescTThe initial environment with no values and only the default javascript types definedd)Construct a ProperName in the Prim modulee#Construct a type in the Prim modulefType constructor for functionsgType constructor for stringshType constructor for stringsiType constructor for numbersjType constructor for integerskType constructor for booleanslType constructor for arraysmType constructor for objectsn!Check whether a type is an objecto"Check whether a type is a functionq$Smart constructor for function typesrWThe primitive types in the external javascript environment with their associated kinds.sGFinds information about data constructors from the current environment.t3Checks whether a data constructor is for a newtype.u<Finds information about values from the current environment..KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx+KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu.[\]^_`abcXZYTWVUNSRQPOKMLxwvdefghijklmnopqrstuKMLNSRQPOTWVUXZY[\]^_`abcdefghijklmnopqrstuvwx Safe-Inferred+yz{yz{y{zy{zNone+ |Data type for binders})A binder with source position information~/A binder which binds its input to an identifier6A 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 character literal'A binder which matches a string literal(A binder which matches a boolean literalWildcard binder8Collect all names introduced in binders in an expression |}~ |}~ |~}| ~}None+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 character 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))A foreign import declaration (name, 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 declarationDAn import with a list of references to hide: `import M hiding (foo)`IAn import with an explicit list of references to import: `import M (foo)`+An import with no explicit list: `import M`0An item in a list of explicit imports or exports8A declaration reference with source position informationA module, in its entirety]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 comments about the module, 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 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 instance declaration1Test if a declaration is a type class declarationCRecursively flatten data binding groups in the list of declarationsPOPNoneNoneReturn a list of all declarations which are exported from a module. This function descends into data declarations to filter out unexported data constructors, and also filters out type instance declarations if they refer to classes or types which are not themselves exported.]Note that this function assumes that the module has already had its imports desugared using B[. It will produce incorrect results if this is not the case - for example, type class instances will be incorrectly removed in some cases.Filter out all data constructors from a declaration which are not exported. If the supplied declaration is not a data declaration, this function returns it unchanged.Filter out all the type instances from a list of declarations which reference a type or type class which is both local and not exported.Note that this function assumes that the module has already had its imports desugared using "Language.PureScript.Sugar.Names.desugarImports". It will produce incorrect results if this is not the case - for example, type class instances will be incorrectly removed in some cases.LGet all type and type class names referenced by a type instance declaration.Test if a declaration is exported, given a module's export list. Note that this function does not account for type instance declarations of non-exported types, or non-exported data constructors. Therefore, you should prefer " to this function, where possible._Test if a data constructor for a given type is exported, given a module's export list. Prefer " to this function, where possible. Safe-Inferred+8/Data type for simplified Javascript expressionsCommented JavascriptVRaw Javascript (generated when parsing fails for an inline foreign import declaration)Continue statementBreak 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 literalAn array indexer expressionAn array literalA binary operator applicationA unary operator applicationA boolean literalA string literalA numeric literalBuilt-in binary operators"Bitwise right shift with zero-fillBitwise right shiftBitwise left shift Bitwise xor Bitwise or Bitwise and Boolean or Boolean and Numeric greater-than-or-equal Numeric greater-than Numeric less-than-or-equal Numeric less-than Generic inequality testGeneric equality test RemainderNumeric divisionNumeric multiplicationNumeric subtractionNumeric additionBuilt-in unary operators ConstructorNumeric unary 'plus'Bitwise negationBoolean negationNumeric negation<     <     <           Safe-Inferred  !"#$%&  !"#$%&  !"#$%&  !"#$%&  Safe-Inferred'Eliminate tail calls''''!NoneCInline 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)*+,-./0)*+,-./0,-./0)*+)*+,-./0# Safe-Inferred123123123123$ Safe-Inferred4@Collapse blocks which appear nested directly below another block45454545%None36@Apply a series of optimizer passes to simplified Javascript code6666&None7 Type alias for basic annotations8#Initial annotation with no metadata9&Remove the comments from an annotation789789789789'None :;<=>?@AB :;<=>?@AB ;<=>?@AB::;<=>?@AB( Safe-InferredECWe use Text.Parsec.Token to implement the string and number lexemes/A token parser based on the language definitiong1Parse zero or more values separated by semicolonsh0Parse one or more values separated by semicolonsi-Parse zero or more values separated by commasj,Parse one or more values separated by commasx)A list of purescript reserved identifiersz+The characters allowed for use in operators^CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz8CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz8DEFGHICJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklnpomqrwstuvxyz>CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz)None3 }Parse a module name~0Parse a qualified name, i.e. M.name or just name-Parse an identifier or parenthesized operatornRun 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"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?Read the comments from the the next token, without consuming it Run a parser{|}~{|}~{|}~{|}~*None Parse a kind+None5Parse a type as it appears in e.g. a data constructorParse a monotypeParse a polytype&Parse an atomic type with no wildcards, 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.   -None4Generate a pretty-printed string representing a Kind.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  /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\Nonex|}~0None;Generate a pretty-printed string representing an expression6Generate a pretty-printed string representing a Binder        ]None1None36BHow critical the issue isLA map from rigid type variable name/unknown variable pairs to new variables.QThe various types of things which might need to be relabelled in errors messages.A stack trace for an errorWrapper of simpler errorsA type of error messages.Get the error code for a particular error type5Check whether a collection of errors is empty or not. 6Create an error set from a single simple error message /Create an error set from a single error message ?Lift a function on ErrorMessage to a function on MultipleErrors 1Extract nested error messages from wrapper errors5Pretty print a single error, simplifying if necessaryPretty print multiple errorsPretty print multiple warningsPInterpret multiple errors and warnings in a monad supporting errors and warningsJRethrow an error with a more detailed error message in the case of failure1Rethrow an error with source position informationCollect errors in in parallel}     y     }     I     2None3)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 module  3None3M RQualifies a propername from a given qualified propername and a default module nameGiven an environment and a datatype or newtype name, this function returns the associated data constructors if it is the case of a datatype where: - ProperName is the name of the constructor (for example, NothingN in Maybe) - [Type] is the list of arguments, if it has (for example, Just has [TypeVar "a"])Replicates a wildcard binderBApplies a function over two lists of tuples that may lack elementsFind the uncovered set between two binders: the first binder is the case we are trying to cover, the second one is the matching binderReturns the uncovered set of binders the first argument is the list of uncovered binders at step i the second argument is the (i+1)th clause of a pattern matching definitionZThe idea of the algorithm is as follows: it processes each binder of the two lists (say, x and yU) one by one at each step two cases arises: - there are no missing cases between x and y: this is very straightforward, it continues with the remaining cases but keeps the uncovered binder in its position. - there are missing cases, let us call it the set U5: on the one hand, we mix each new uncovered case in U with the current tail of uncovered set. On the other hand, it continues with the remaining cases: here we can use x. (but it will generate overlapping cases), or y,, which will generate non-overlapping cases.As an example, consider:wdata N = Z | S N f Z Z = Z --> {[S _, _], [Z, S _]} which are the right non-overlapping cases (GHC uses this). if we use x instead of y (in this case, y stands for Z and x for `_`i) we obtain: f Z Z = Z --> {[S _, _], [_, S _]} you can see that both cases overlaps each other. Up to now, we've decided to use x~ just because we expect to generate uncovered cases which might be redundant or not, but uncovered at least. If we use y instead, we'll need to have a redundancy checker (which ought to be available soon), or increase the complexity of the algorithm.Guard handling+We say a guard is exhaustive iff it has an  (or truep) expression. Example: f x | x < 0 = 0 | otherwise = 1 is exhaustive, whereas `f x | x < 0` is not5The function below say whether or not a guard has an # expression It is considered that  is defined in Prelude.Returns the uncovered set of case alternativeseMain exhaustivity checking function Starting with the set `uncovered = { _ }` (nothing covered, one `_` for each function argument), it partitions that set with the new uncovered cases, until it consumes the whole set of clauses. Then, returns the uncovered set of case alternatives.1Exhaustivity checking over a list of declarations*Exhaustivity checking over a single module  4None3BM TLint the PureScript AST. | | Right now, this pass only performs a shadowing check.    5None3EM  Read source position information"Parse a single declaration$6Parse a module header and a collection of declarations%Parse a collection of modules&Parse a collection of modules/Parse an expression in backticks or an operator' Parse a value(Parse a binder)<Parse a binder as it would appear in a top level declaration* Parse a guard@ !"#$%!&'()"#$%&*+,-./0123456789:;<=>?@A'BCDEFGHIJKLMNO()* !"#$%&'()* "$&%'*()!#@ !"#$%!&'()"#$%&*+,-./0123456789:;<=>?@A'BCDEFGHIJKLMNO()*6None3+,P+,+,+,P^NoneZCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,7None !"2346BHM-gThe type checking monad, which provides the state of the type checker, and error reporting capabilities0!State required for type checking:2 The current  Environment3(The next fresh unification variable name4#The next type class dictionary name5The current module60Temporarily bind a collection of names to values7/Temporarily bind a collection of names to types8/Temporarily bind a collection of names to types9BTemporarily make a collection of type class dictionaries available::Get the currently available map of type class dictionaries;+Lookup type class dictionaries in a module.<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?QUpdate the visibility of all names to Defined in the scope of the provided action@6Perform an action while preserving the names from the  Environment.A*Lookup the type of a value by name in the  EnvironmentB0Lookup the visibility of a value by name in the  EnvironmentCAssert that a name is visibleD)Lookup the kind of a type by name in the  EnvironmentEGet the current  EnvironmentF Update the  EnvironmentG Modify the  EnvironmentH=Run a computation in the Check monad, starting with an empty  EnvironmentImRun a computation in the Check monad, failing with an error, or succeeding with a return value and the final  Environment.J0Make an assertion, failing with an error messageK'Generate new type class dictionary nameLLift a computation in the Check# monad into the substitution monad.MbRun a computation in the substitution monad, generating a return value and the final substitution.N|Run a computation in the substitution monad, generating a return value, the final substitution and updating warnings values."-./0123456789:;<=>?@ABCDEFGHIJKLMN"-./0123456789:;<=>?@ABCDEFGHIJKLMN"6789:;<=>?@ABCD012345-./EFGHIJKLMN-./0123456789:;<=>?@ABCDEFGHIJKLMN8None246EOInfer the kind of a single typePQInfer the kind of a single type, returning the kinds of any scoped type variablesQtInfer the kind of a type constructor with a collection of arguments and a collection of associated data constructorsRNSimultaneously infer the kinds of several mutually recursive type constructorsQ^Solve the set of kind constraints associated with the data constructors for a type constructorR3Default all unknown kinds to the Star kind of typesSInfer a kind for a type OPQTRQRSUVWOPQROPQR OPQTRQRSUVW9None!"36X,Build a type substitution for a type synonymS#Replace all type synonyms with the SaturatedTypeSynonym data constructorT "Desaturate" SaturatedTypeSynonymsY-Replace fully applied type synonyms with the SaturatedTypeSynonymR data constructor, which helps generate better error messages during unification.V>Replace a type synonym and its arguments with the aliased typeXSTYUVWXSTUVWXSTUXWVXSTYUVWX:NoneY9Generate foreign imports for all declarations in a moduleYYYY;None3ZSReplace all sets of mutually-recursive declarations in a module with binding groups[BCollapse all binding groups in a module to individual declarations]6Collapse all binding groups to individual declarationsZoConvert a group of mutually-recursive dependencies into a BindingGroupDeclaration (or simple ValueDeclaration).Z[\][\]^_`ZabcZ[\]\Z][Z[\][\]^_`Zabc<None3M^@Replace all top-level binders in a module with case expressions._4Replace all top-level binders with case expressions.d^e_fghi^__^d^e_fghi=None3`Add type synonym declarations for type class dictionary types, and value declarations for type class instance dictionary expressions. jk`lmnopqrab`ab`ab jk`lmnopqrab>Nonec4Desugars a module from AST to CoreFn representation.sFind 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).t?Desugars import declarations from AST to CoreFn representation.u@Desugars foreign declarations from AST to CoreFn representation.vDesugars 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.wMakes 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.x"Converts a ProperName to an Ident.cstuvwxcccstuvwx_None80123456  789:;<=>?@ABc?None3My$The state object used in this modulezDA 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 output|CRuns 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.d,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.yz{|}~dddyz{|}~d@None !"3MeiGenerate code in the simplified Javascript intermediate representation for all declarations in a module.efD     efefef`NoneE     YefANone3Mg Replace all DoNotationBind and DoNotationValueG constructors with applications of the Prelude.bind function, and all  DoNotationLet# constructors with let expressions.ggggBNone3FM]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 module%The modules 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.hFReplaces 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.hhhhCNone3MiiiiDNone3HMjDRemove explicit parentheses and reorder binary operator applicationsjkljkljkljklENone3mIReplace all top level type declarations in a module with type annotationsn=Replace all top level type declarations with type annotationsmnmnnmmnFNone3o,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.oZ[\]^_`abghijklmnoooGNonep+Ensure rows do not contain duplicate labelsppppHNoneqGenerate a new skolem constantr5Introduce skolem scope at every occurence of a ForAllsGenerate a new skolem scopetPSkolemize a type variable by replacing its instances with fresh skolem constantsuThis 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.v1Ensure skolem variables do not escape their scopeqrstuvqrstuvqrstuvqrstuvINone2346w2Unify two types, updating the current substitutionx1Unify 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.yCheck that two types unifyz>Replace a single type variable with a new unification variable{$Replace type wildcards with unknowns|JReplace outermost unsolved unification variables with named type variableswxyz{|wxyz{|wxyz{|wxyz{|JNoneB}Check 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 predicate}}}}KNone~\Check whether one type subsumes another, rethrowing errors to provide a better error message'Check whether one type subsumes another~~~~LNone36Infer 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 statementNCheck the type of a value, rethrowing errors to provide a better error messageCheck the type of a value5Check 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 applicationsCompute the meet of two types, i.e. the most general type which both types subsume. TODO: handle constrained typesJEnsure a set of property names and value does not contain duplicate labelsMNone244Check 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. .-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX NNone (3BEHM A monad for running make actions#Determines when to rebuild a moduleAlways rebuild this moduleNever rebuild this module'A value to be used in the Supply monad.#Generated code for an externs file.AActions that require implementations when running in "make" mode.Get the timestamp for the input file(s) for a module. If there are multiple files (.purs and foreign files, for example) the timestamp should be for the most recently modified file.Get the timestamp for the output files for a module. This should be the timestamp for the oldest modified file, or Nothing if any of the required output files are missing.]Read the externs file for a module as a string and also return the actual path for the file.JRun the code generator for the module and write any required output files.Respond to a progress update.[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. Execute a P monad, returning either errors, or the result of the compile plus any warnings.KA set of make actions that read and write modules from the given directory.the output directoryQa map between module names and paths to the file containing the PureScript moduleWa map between module name and the file containing the foreign javascript for the moduleGenerate a prefix comment? ONone(3M'    !"#$%&'()*+,-./012345678KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuyz{|}~CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXZ[\]^_`abdghijklmnoPNoneBA type representing a highly simplified version of PureScript code, intended for use in output formats like plain text or HTML.This type is isomorphic to  G. It makes code a bit easier to read, as the meaning is more explicit.A single element in a rendered code fragment. The intention is to support multiple output formats. For example, plain text, or highlighted HTML. Convert a   to a !, using the obvious isomorphism. Convert a  to a  !, using the obvious isomorphism. A version of  fromMaybe for  values.%This function allows conversion of a  value into a value of some other type (for example, plain text, or HTML). The first argument is a function specifying how each individual  should be rendered.A  fragment representing a space.$QNoneRender code representing a RowRender code representing a KindGRender code representing a Type, as it should appear inside parenthesesRender code representing a Type  aNone(RNoneEHM `Minimum allowable version for generating data with the current parser, and actual version used.A type class member, with its type. Note that the type does not include the type class constraint; this may be added manually if desired. For example,  from  Applicative would be `forall a. a -> f a`.,A data constructor, with its type arguments.@A type instance declaration, with its dependencies and its type.A value of this type contains information that is specific to a particular kind of declaration (as opposed to information which exists in all kinds of declarations, which goes into the  type directly).Many of the constructors are very similar to their equivalents in the real PureScript AST, except that they have their name elided, since this is already available via the rdTitle field of .yA type class, with its type arguments and its superclasses. Instances and members are represented as child declarations.5A type synonym, with its type arguments and its type.*A data type foreign import, with its kind.A data/newtype declaration, with the kind of declaration (data or newtype) and its type arguments. Constructors are represented as child declarations.#A value declaration, with its type.The version of the PureScript compiler which was used to generate this data. We store this in order to reject packages which are too old. Given a function for turning association list keys into JSON object keys, and a function for turning association list values to JSON string values, turns an association list into a JSON object.For example: *assocListToJSON T.pack T.pack [("a", "b")] will give  {"a": "b"}.s      !"#$%&'()*+,-.s      s.-, +    *)('&%$#" !B       !"#$%&'()*+,-.SNone EESome data which will be used to augment a Declaration in the output.oThe AugmentChild constructor allows us to move all children under their respective parents. It is only necessary for type instance declarations, since they appear at the top level in the AST, and since they might need to appear as children in two places (for example, if a data type defined in a module is an instance of a type class also defined in that module).qThe AugmentFixity constructor allows us to augment operator definitions with their associativity and precedence.OThe data type for an intermediate stage which we go through during converting.In the first pass, we take all top level declarations in the module, and collect other information which will later be used to augment the top level declarations. These two situation correspond to the Right and Left constructors, respectively.In the second pass, we go over all of the Left values and augment the relevant declarations, leaving only the augmented Right values.uNote that in the Left case, we provide a [String] as well as augment information. The [String] value should be a list of titles of declarations that the augmentation should apply to. For example, for a type instance declaration, that would be any types or type classes mentioned in the instance. For a fixity declaration, it would be just the relevant operator's name./Convert a single Module.Augment top-level declarations; the second pass. See the comments under the type synonym IntermediateDeclaration for more information.`Add the default operator fixity for operators which do not have associated fixity declarations.UTODO: This may no longer be necessary after issue 806 is resolved, hopefully in 0.8.!Create a basic Declaration value.0Go through a PureScript module and extract a list of Bookmarks; references to data types or values, to be used as a kind of index. These are used for generating links in the HTML documentation, for example./0/0/0 /0TNone 123456789:; 123456789:; 123456789:; 123456789:;UNoneE<Specifies whether a PureScript source file is considered as: 1) with the d constructor, a target source file, i.e., we want to see its modules in the output 2) with the  constructor, a dependencies source file, i.e. we do not want its modules in the output; it is there to enable desugaring, and to ensure that links between modules are constructed correctly.@Given:A list of local source filesZA list of source files from external dependencies, together with their package namesGA callback, taking a list of bookmarks, and a list of desugared modules!This function does the following:2Parse all of the input and dependency source files.Partially desugar all of the resulting modules>Collect a list of bookmarks from the whole set of source files]Collect a list of desugared modules from just the input source files (not dependencies)?Call the callback with the bookmarks and desugared module list.<=>?@     <=>?@@<?>=<?>=@     bNone      /0123456789:;<=>?@VNoneAcTake a list of modules and render them all in order, returning a single Markdown-formatted String.A !AAA !WNoneH6An error that probably indicates a bug in this module.N*An error that should be fixed by the user.]RAn error which meant that it was not possible to retrieve metadata for a package.2"#$%&BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab'()*+,c-./d0#BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd#]`_^Y\[ZNXWVUTSRQPOHIBDCJMLKEGFabdc"#$%&BDCEGFHIJMLKN XWVUTSRQPOY\[Z]`_^ab'()*+,c-./d0XNoneBE 1QResolved to a version. The String argument is the resolution tag (eg, "v0.1.0").2Resolved, but to something other than a version. The String argument is the resolution type. The values it can take that I'm aware of are "commit" and "branch".3In the output of `bower list --json --offline`, there was no _resolution key. This can be caused by adding the dependency using `bower link`, or simply copying it into bower_components instead of installing it normally.4(Listed in bower.json, but not installed.hWHow to obtain the version tag and version that the data being generated will refer to.j~Attempt to retrieve package metadata from the current directory. Calls exitFailure if no package metadata could be retrieved.5RExtracts all dependencies and their versions from `bower list --json --offline`6`Extracts only the top level dependency names from the output of `bower list --json --offline`7`Returns whether it looks like there is a purescript package checked out in the given directory.+812349:;e<=fghijk>?@ABlmnopqCDrE56FGHI7JKLMefghijklmnopqrjlekfghinopqmr!843219;:e<=fghijk>?@ABlmnopqCDrE56FGHI7JKLMNcdecdfghijklmnopqrsttuvvwxyzz{|}}~                                         !"#$%&&''(()*+*,-./0123456789:;<=>?@ABBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzz{|}~<=>?ABBCDIJKQLMNOPE     UV !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ \!]"^"_"`"a"b"c"d"e#f#g#h$i$j%k&l&m&n'o'''p''q'r's't(u(v(v(w(x(y(z({(|(}(~((((((((((((((((((((((((((((((((((((((((((((()))))))))))j)))*++++,,,,,,,,,-.../00011111111111 1111111111111111 111111111111111111111111111111111111111 1 1 1 1 1111111111111111111 1!1"1#1$1%1&1'1(1)1*1+1,1-1.1/101112131415161718191:1;1<1=1>1?1@1A1B1C1D2E2F3G3H4I5J5K5L5M5N5O5P5Q5R5S6T6U7V7V7W7X7X7Y7Z7[7\7]7^7_7`7a7b7c7d7e7f7g7h7i7j7k7l7m7n7o7p7q7r7s7t7u8v8w8x8y9z9{9|9}9~9:;;;;<<===>?@@AB[CDDDEEFGHHHHHHIIIIIIJKLMNZNZNNNNNNNNNNNNNNNNOPPPPPPPP_PP*PPPPPPPPPPPPPPPPPPPPPQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR R R R R RRRRRRRRRRRRRRRRRRR R!R"R#R$R%R&R'R(R)R*R+R,R-R.R/R0R1R2R3R4R5R6R7R8R9R:R;R<R=R>R?R@SASBTCTDTETFTGTHTITJTKTLTMUNUOUPUQURVSWTWUWVWWWXWYWZW[W\W]W^W_W`WaWbWcWdWeWfWgWhWiWjWkWlWmWnWWTWZW`WoWpWqWrXsXtXtXuXvXwXxXyXzX{X|X}X~XYYYYYYYYYYYYY          F          !!""""""""""""""""""""%%((((((((((((((((((((((((((((((((((((((***+++++++++++++---..L......////////////////00000000000223333333333 5 5 5 5 55555!555555555555555 5!5"5#5$5%5&5'5(5)5*5+5,5-5.5/505152535455565758595:5;5<5=5>6?8@8A8B8C8D8E8F9G9H;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?g?uAvBwBxByBzB{B|B}B~BBBBBBBBBBBBBBBBBBBwB|DDDDDDDDD}DPDDDIIJJJJKLLLLLLBLDLLLLLLLLLLLLLLLLLMMMMMMMMMMMNNNNNPPPPPQQQQQLQQQQQQQQQQSSSSSSSSSSSSUUUFUUUUUUUUUUVVVVVVVVVVVVVmVVVWWWWWWWWWWWWWWWXX X X X/X X XXXXXsXXXXXXXXXXXXXXX X!X"#purescript-0.7.2.1(Language.PureScript.Publish.BoxesHelpers!Language.PureScript.Publish.Utils+Language.PureScript.Docs.Utils.MonoidExtras Language.PureScript.Parser.StateControl.Monad.Unify#Language.PureScript.CoreFn.LiteralsLanguage.PureScript.ConstantsLanguage.PureScript.Traversals!Language.PureScript.AST.SourcePos!Language.PureScript.AST.OperatorsLanguage.PureScript.BundleControl.Monad.SupplyControl.Monad.Supply.ClassLanguage.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.AST.Declarations"Language.PureScript.AST.Traversals Language.PureScript.AST.Exported"Language.PureScript.CodeGen.JS.AST/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.OptimizerLanguage.PureScript.CoreFn.Ann!Language.PureScript.CoreFn.Module 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.Pretty.ValuesLanguage.PureScript.Errors&Language.PureScript.ModuleDependencies%Language.PureScript.Linter.ExhaustiveLanguage.PureScript.Linter'Language.PureScript.Parser.DeclarationsLanguage.PureScript.Parser.JS%Language.PureScript.TypeChecker.Monad%Language.PureScript.TypeChecker.Kinds(Language.PureScript.TypeChecker.Synonyms#Language.PureScript.CodeGen.Externs'Language.PureScript.Sugar.BindingGroups*Language.PureScript.Sugar.CaseDeclarations%Language.PureScript.Sugar.TypeClasses"Language.PureScript.CoreFn.DesugarLanguage.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.PureScript.MakeLanguage.PureScript+Language.PureScript.Docs.RenderedCode.Types,Language.PureScript.Docs.RenderedCode.RenderLanguage.PureScript.Docs.Types Language.PureScript.Docs.ConvertLanguage.PureScript.Docs.Render(Language.PureScript.Docs.ParseAndDesugar#Language.PureScript.Docs.AsMarkdown*Language.PureScript.Publish.ErrorsWarningsLanguage.PureScript.PublishPaths_purescriptMakedesugarImportsLanguage.PureScript.ASTLanguage.PureScript.PrettyLanguage.PureScript.ParserLanguage.PureScript.CoreFnLanguage.PureScript.CodeGen%Language.PureScript.Docs.RenderedCodeLanguage.PureScript.Docs boxes-0.1.4Text.PrettyPrint.BoxesnullBoxBoxwidth indentWidthparaindentedsuccessivelyIndentedvcatspacer bulletedList printToStderr globRelativepurescriptSourceFilespurescriptDepsFiles mintersperse ParseStateindentationLevelUnifyTunUnifyUnificationErroroccursCheckFailed UnifyState unifyNextVarunifyCurrentSubstitution SubstitutionrunSubstitution Unifiable=?=Partialunknown isUnknownunknowns$?UnknowndefaultUnifyStaterunUnify substituteOne=:= occursCheckfresh'fresh$fMonadErroreUnifyT$fMonadStatesUnifyT$fMonoidSubstitutionLiteral ObjectLiteral ArrayLiteralBooleanLiteral CharLiteral StringLiteralNumericLiteral$#<>++>>=+-*/%<><=>===/=&&||bind unsafeIndex.|..&..^.<<<negatenotconjdisjmodshlshrzshr complementzeroonebottomtopreturnpure' returnEscapeduntilEwhileErunST stRefValuenewSTRef readSTRef writeSTRef modifySTRefmkFnrunFnunit undefinedmonadEffDictionaryapplicativeEffDictionarybindEffDictionarysemiringNumber semiringInt ringNumberringIntmoduloSemiringNumbermoduloSemiringInt ordNumberordInteqNumbereqInteqString eqBooleanboundedBooleanbooleanAlgebraBooleansemigroupStringsemigroupoidArrmain __superclass___unusedprimpreludedataArrayUnsafeeffst dataFunction dataIntBitsfstMsndMthirdMpairMmaybeMeitherMdefS SourceSpanspanName spanStartspanEnd SourcePos sourcePosLinesourcePosColumndisplaySourcePosdisplayStartEndPosdisplaySourceSpan$fToJSONSourceSpan$fToJSONSourcePosFixity AssociativityInfixInfixrInfixl Precedence$fToJSONFixity$fToJSONAssociativity$fShowAssociativityModuleIdentifier ModuleTypeForeignRegular ErrorMessage ErrorInModuleUnsupportedExportUnableToParseModuleInvalidTopLevelUnsupportedModulePath moduleNameprintErrorMessagebundleSupplySupplyT unSupplyT runSupplyT evalSupplyT runSupply evalSupply MonadSupply freshName$fMonadSupplyStateT$fMonadSupplySupplyTOptions optionsNoTcooptionsNoMagicDo optionsMainoptionsNoOptimizationsoptionsVerboseErrorsoptionsNoCommentsoptionsRequirePathdefaultOptions Qualified ModuleName ProperName runProperNameIdentOprunIdent runModuleNamemoduleNameFromStringqualify$fFromJSONQualified$fToJSONQualified$fShowQualified$fShowModuleName$fShowProperName $fShowIdent identToJsidentNeedsEscapingidentCharToStringnameIsJsReservedmoduleNameToJsproperNameIsJsReservedBinder NamedBinderConstructorBinder VarBinder LiteralBinder NullBinderCaseAlternativecaseAlternativeBinderscaseAlternativeResultGuardBindRecNonRecExprLetCaseVarAppAbs ObjectUpdateAccessor Constructor extractAnn modifyAnn$fFunctorCaseAlternativeeverywhereOnValueseverythingOnValuesConstructorTypeSumType ProductTypeMeta IsForeignIsTypeClassConstructor IsNewtype IsConstructorKindFunKindRowBangStarKUnknowneverywhereOnKindseverywhereOnKindsMeverythingOnKinds $fToJSONKind ConstraintTypePrettyPrintForAllPrettyPrintObjectPrettyPrintFunction KindedTypeRConsREmptySkolemConstrainedTypeForAllSaturatedTypeSynonymTypeAppTypeConstructor TypeWildcardTypeVarTUnknown SkolemScoperunSkolemScope rowToList rowFromList isMonoTypemkForAllreplaceTypeVarsreplaceAllTypeVarsusedTypeVariablesfreeTypeVariablesquantifymoveQuantifiersToFrontcontainsWildcardseverywhereOnTypeseverywhereOnTypesTopDowneverywhereOnTypesMeverywhereOnTypesTopDownMeverythingOnTypes $fToJSONTypeDictionaryValueSubclassDictionaryValueDependentDictionaryValueGlobalDictionaryValueLocalDictionaryValueTypeClassDictionaryTypeTCDAlias TCDRegularTypeClassDictionaryInScopetcdName tcdClassNametcdInstanceTypestcdDependenciestcdType tcdExportedcanonicalizeDictionary DataDeclTypeNewtypeDataTypeKind ScopedTypeVarLocalTypeVariable ExternData TypeSynonymDataTypeNameKindExternalPublicPrivateNameVisibilityDefined Undefined EnvironmentnamestypesdataConstructors typeSynonymstypeClassDictionaries typeClassesinitEnvironmentprimNameprimTy tyFunctiontyStringtyChartyNumbertyInt tyBooleantyArraytyObjectisObject isFunctionisTypeOrAppliedfunction primTypeslookupConstructorisNewtypeConstructor lookupValue$fFromJSONDataDeclType$fToJSONDataDeclType$fShowDataDeclTypeComment BlockComment LineCommentPositionedBinder ArrayBinder ObjectBinder NumberBinder CharBinder StringBinder BooleanBinder binderNamesDoNotationElementPositionedDoNotationElement DoNotationLetDoNotationBindDoNotationValuePositionedValueSuperClassDictionaryTypeClassDictionaryAccessorTypeClassDictionary!TypeClassDictionaryConstructorAppDo TypedValue IfThenElse ObjectUpdater ObjectGetterObjectConstructorOperatorSectionParensBinaryNoParens UnaryMinus DeclarationPositionedDeclarationTypeInstanceDeclarationTypeClassDeclarationImportDeclarationFixityDeclarationExternInstanceDeclarationExternDataDeclarationExternDeclarationBindingGroupDeclarationValueDeclarationTypeDeclarationTypeSynonymDeclarationDataBindingGroupDeclarationDataDeclarationImportDeclarationTypeHidingExplicitImplicitDeclarationRefPositionedDeclarationRef ModuleRefTypeInstanceRef TypeClassRefValueRefTypeRefModule getModuleName isValueDecl isDataDecl isImportDeclisExternDataDeclisExternInstanceDecl isFixityDecl isExternDeclisTypeClassInstanceDeclarationisTypeClassDeclaration flattenDecls$fEqDeclarationRefeverywhereOnValuesTopDownMeverywhereOnValuesMeverythingWithContextOnValueseverywhereWithContextOnValuesM accumTypesexportedDeclarations isExportedJS JSCommentJSRaw JSContinueJSBreakJSLabel JSInstanceOfJSTypeOfJSThrowJSReturnJSIfElseJSForInJSForJSWhile JSAssignmentJSVariableIntroductionJSBlock JSConditionalJSVarJSApp JSFunction JSAccessorJSObjectLiteral JSIndexerJSArrayLiteralJSBinaryJSUnaryJSBooleanLiteralJSStringLiteralJSNumericLiteralBinaryOperatorZeroFillShiftRight ShiftRight ShiftLeft BitwiseXor BitwiseOr BitwiseAndOrAndGreaterThanOrEqualTo GreaterThanLessThanOrEqualToLessThan NotEqualToEqualToModulusDivideMultiplySubtractAdd UnaryOperatorJSNewPositive BitwiseNotNotNegateeverywhereOnJSeverywhereOnJSTopDowneverywhereOnJSTopDownMeverythingOnJSapplyAll replaceIdent replaceIdents isReassigned isReboundisUsedtargetVariable isUpdatedremoveFromBlocktcomagicDo etaConvertunThunk evaluateIifesinlineVariables inlineValuesinlineOperatorinlineCommonOperatorsinlineArrCompositionremoveCodeAfterReturnStatementsremoveUnusedArgremoveUndefinedAppcollapseNestedBlockscollapseNestedIfsoptimizeAnnnullAnnremoveComments ForeignDeclmoduleComments moduleImports moduleExports moduleForeign moduleDecls TokenParserPositionedToken ptSourcePosptToken ptCommentsTokenlexanyTokentokenmatchlparenrparenparenslbracerbracebraceslsquarersquaresquaresindentindentAtlarrowrarrow lfatArrow rfatArrowcolon doubleColonequalspipetickdotcommasemiat underscoresemiSepsemiSep1commaSep commaSep1lname qualifierreservedunamemnameuname'symbolsymbol' charLiteral stringLiteralnumbernatural identifierreservedPsNamesreservedTypeNamesopCharsfeatureWasRemoved properNameparseQualified parseIdentaugmentfoldbuildPostfixParsermarkcheckIndentationsame readCommentsrunTokenParser parseKind parseTypeAtom parseType parsePolyType noWildcards PrinterState blockIndent withIndent currentIndentprettyPrintManyprettyPrintObjectKeyprettyPrintKindprettyPrintRowprettyPrintTypeAtomprettyPrintType prettyPrintJSprettyPrintValueprettyPrintBinderAtomprettyPrintBinderLevelWarningError UnknownMap LabelType SkolemLabel TypeLabelMultipleErrorsrunMultipleErrorsSimpleErrorWrapperPositionedErrorErrorInForeignImportErrorInValueDeclarationErrorInTypeSynonymErrorInDataBindingGroupErrorInBindingGroupErrorInTypeConstructorErrorInDataConstructorErrorInApplicationErrorInferringTypeErrorCheckingKindErrorCheckingTypeErrorInSubsumptionErrorInInstanceErrorInExpressionErrorUnifyingTypes NotYetDefinedSimpleErrorMessage ClassOperatorOverlappingPatternNotExhaustivePatternWildcardInferredType ShadowedNameTransitiveExportErrorInvalidInstanceHeadInvalidNewtypeTypeSynonymInstanceCannotApplyFunctionPropertyIsMissingExprDoesNotHaveTypeSubsumptionCheckFailedIncorrectConstructorArity ExpectedTypeExtraneousClassMemberMissingClassMemberOverlappingArgNamesArgListLengthsDifferDuplicateValueDeclarationDuplicateLabelNoInstanceFoundOverlappingInstancesConstrainedTypeUnifiedKindsDoNotUnifyTypesDoNotUnifyUnspecifiedSkolemScope EscapedSkolemPartiallyAppliedSynonymUndefinedTypeVariableNameNotInScopeNameIsUndefinedCycleInModulesCycleInTypeSynonymCycleInDeclaration InvalidDoLet InvalidDoBindDuplicateTypeArgumentDuplicateValueExportDuplicateClassExportClassConflictsWithCtorClassConflictsWithTypeCtorConflictsWithClassTypeConflictsWithClassConflictingCtorDeclsConflictingTypeDeclsConflictingImportsConflictingImportUnknownTypeConstructorUnknownDataConstructor UnknownValueUnknownTypeClass UnknownType UnknownModuleOverlappingNamesInLetRedefinedIdentRedefinedModuleOrphanFixityDeclarationOrphanTypeDeclarationMultipleFixitiesCannotReorderOperators InfiniteKind InfiniteTypeCannotWriteFileCannotReadFileCannotGetFileInfoInvalidExternsFileUnnecessaryFFIModuleMultipleFFIModulesMissingFFIModuleErrorParsingModuleErrorParsingFFIModuleErrorParsingExterns errorCodenonEmpty errorMessage singleErroronErrorMessagesunwrapErrorMessagereplaceUnknownsonTypesInErrorMessageMprettyPrintSingleErrorprettyPrintMultipleErrorsprettyPrintMultipleWarningsprettyPrintMultipleErrorsWith renderBox"interpretMultipleErrorsAndWarningsrethrowrethrowWithPositionparU$$fUnificationErrorKindMultipleErrors$$fUnificationErrorTypeMultipleErrors"$fUnificationErrorKindErrorMessage"$fUnificationErrorTypeErrorMessage ModuleGraph sortModulescheckExhaustivecheckExhaustiveModulelintparseImportDeclaration'parseDeclarationparseLocalDeclaration parseModuleparseModulesFromFiles parseModules parseValue parseBinderparseBinderNoParens parseGuard ForeignJSparseForeignModulesFromFilesCheckunCheck CheckStatecheckEnv checkNextVarcheckNextDictNamecheckCurrentModule bindNames bindTypeswithScopedTypeVarswithTypeClassDictionariesgetTypeClassDictionarieslookupTypeClassDictionariesbindLocalVariablesbindLocalTypeVariablesmakeBindingGroupVisiblewithBindingGroupVisiblepreservingNameslookupVariable getVisibilitycheckVisibilitylookupTypeVariablegetEnvputEnv modifyEnvrunCheck runCheck' guardWithfreshDictionaryName liftCheck liftUnifyliftUnifyWarningskindOfkindOfWithScopedVarskindsOf kindsOfAllsaturateAllTypeSynonymsdesaturateAllTypeSynonymsreplaceAllTypeSynonymsexpandTypeSynonym'expandTypeSynonymexpandAllTypeSynonyms moduleToPscreateBindingGroupsModulecollapseBindingGroupsModulecreateBindingGroupscollapseBindingGroupsdesugarCasesModule desugarCasesdesugarTypeClassestypeClassMemberNamesuperClassDictionaryNamesmoduleToCoreFnrenameInModules moduleToJsmainCalldesugarDoModuledesugarObjectConstructors rebracketremoveSignedLiteralsdesugarOperatorSectionsdesugarTypeDeclarationsModuledesugarTypeDeclarationsdesugarcheckDuplicateLabelsnewSkolemConstantintroduceSkolemScopenewSkolemScope skolemizeskolemizeTypesInValueskolemEscapeCheck unifyTypes unifyRows unifiesWithreplaceVarWithUnknownreplaceTypeWildcards varIfUnknownentailssubsumestypesOftypeCheckModuleunMake RebuildPolicy RebuildAlways RebuildNever SupplyVarExterns MakeActionsgetInputTimestampgetOutputTimestamp readExternscodegenprogressmakerunMakebuildMakeActionsversion RenderedCodeContainingModule OtherModule ThisModuleRenderedCodeElementSpaceKeywordCtorSyntaxasRenderedCodeElementasContainingModulemaybeToContainingModulecontainingModuleToMaybefromContainingModuleasRenderedCode outputWithspsyntaxidentctorkindkeyword keywordForall keywordDatakeywordNewtype keywordType keywordClasskeywordInstance keywordWhereRenderTypeOptionsprettyPrintObjects renderRow renderKindrenderTypeAtom renderTypedefaultRenderTypeOptionsrenderTypeWithOptions InPackageFromDepLocalBookmark PackageErrorInvalidDataDeclType InvalidKind InvalidFixityInvalidChildDeclarationTypeInvalidDeclarationTypeInvalidVersionErrorInPackageMetaCompilerTooOld GithubRepo runGithubRepo GithubUser runGithubUserChildDeclarationInfoChildTypeClassMemberChildDataConstructor ChildInstanceChildDeclaration cdeclTitle cdeclCommentscdeclSourceSpan cdeclInfoDeclarationInfo declTitle declCommentsdeclSourceSpan declChildren declFixitydeclInfomodName modCommentsmodDeclarationsVerifiedPackageUploadedPackage NotYetKnownPackagepkgMeta pkgVersion pkgVersionTag pkgModules pkgBookmarkspkgResolvedDependencies pkgGithub pkgUploaderpkgCompilerVersion verifyPackage packageNamedeclInfoToStringchildDeclInfoToString takeLocal takeLocals ignorePackageparseUploadedPackageparseVerifiedPackage asPackageasUploadedPackage asNotYetKnownasVerifiedPackagedisplayPackageError asGithubUser asVersion parseVersion'asModule asDeclarationasFixityparseAssociativityasAssociativityasDeclarationInfoasTypeArgumentsasKindasTypeasDataDeclTypeasChildDeclarationasChildDeclarationInfo asSourcePos asConstraintasQualifiedProperName asBookmarks asBookmarkasResolvedDependenciesasGithub asSourceSpanassocListToJSON$fToJSONInPackage$fToJSONGithubRepo$fToJSONGithubUser$fToJSONChildDeclarationInfo$fToJSONDeclarationInfo$fToJSONChildDeclaration$fToJSONDeclaration$fToJSONModule$fToJSONNotYetKnown$fToJSONPackage$fFromJSONGithubUser$fFromJSONPackage$fFromJSONNotYetKnown$fFunctorInPackage convertModulecollectBookmarksrenderDeclarationrenderDeclarationWithOptionsrenderChildDeclaration!renderChildDeclarationWithOptionsrenderConstraintrenderConstraintWithOptionsrenderConstraintsrenderConstraintsWithOptions notQualifiedtypeApp toTypeVarParseDesugarError DesugarErrorSortModulesError ParseErrorparseAndDesugarrenderModulesAsMarkdown OtherErrorIOExceptionThrown ProcessFailed JSONSource FromBowerListFromFile InternalError JSONErrorRepositoryFieldError NotOnGithubBadRepositoryTypeRepositoryFieldMissing UserErrorDirtyWorkingTreeParseAndDesugarErrorMissingDependenciesBadRepositoryFieldAmbiguousVersionsTagMustBeCheckedOutBowerJSONNameMissingCouldntParseBowerJSONBowerExecutableNotFoundBowerJSONNotFoundPackageWarningUnacceptableVersionUndeclaredDependencyNoResolvedVersion printError renderErrorrenderWarnings printWarningsPrepareMPublishOptionspublishGetVersiondefaultPublishOptionspreparePackage runPrepareMpreparePackage'getModulesAndBookmarksgetGitWorkingTreeStatusrequireCleanWorkingTreegetVersionFromGitTag getBowerInfogetResolvedDependenciescatchIObindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName ModuleElement ExportTypeKeynodecheckImportPathwithDepstoModulecompile isModuleEmptycodeGenOther ExportsListMemberRequireForeignReexport RegularExportbaseGHC.BasefilterDataConstructorsfilterInstancestypeInstanceConstituentsisDctorExportedtco'magicDo'inlineST shouldInlineisDictisFn isPreludeFn optimize'untilFixedPointlangDef tokenParserNumberSymbol QualifierUNameLName UnderscoreAtSemiCommaDotTickPipeEquals DoubleColonColon RFatArrow LFatArrowRArrowLArrowIndentRSquareLSquareRBraceLBraceRParenLParenprettyPrintToken parseTokens whitespace parseCommentparsePositionedToken parseTokenvalidModuleName$fShowPositionedToken parseStar parseBang parseArray parseArrayOf parseFunction parseObjectparseTypeWildcardparseTypeVariableparseTypeConstructor parseForAllparseConstrainedType parseAnyTypeparseNameAndTypeparseRowEndingparseRow typeLiteralsmatchRowfunKindappliedFunctionkindedinsertPlaceholders matchTypeAtom matchTypeforall_prettyPrintJS1prettyPrintJS'literalsstring conditionalaccessorindexerlamapptypeOf instanceOfunary'unarynegateOperatorbinaryprettyStatementsprettyPrintDeclarationprettyPrintCaseAlternativeprettyPrintDoNotationElementprettyPrintObject' ifThenElse objectUpdateprettyPrintValue' usedModules qualifyNamegetConstructors initialize genericMergemissingCasesSinglemissingCasesMultipleisExhaustiveGuard otherwise missingCasescheckExhaustiveDeclsmissingAlternativewithSourceSpanparseInfixExpr kindedIdentparseDataDeclarationparseTypeDeclarationparseTypeSynonymDeclarationparseValueDeclarationparseExternDeclaration parseFixityparseFixityDeclarationparseImportDeclarationparseDeclarationRefparseTypeClassDeclarationparseTypeInstanceDeclaration positionedbooleanLiteralparseNumericLiteralparseCharLiteralparseStringLiteralparseBooleanLiteralparseArrayLiteralparseObjectLiteralparseIdentifierAndValueparseAbsparseVarparseConstructor parseCaseparseCaseAlternativeparseIfThenElseparseLetparseValueAtomparseOperatorSectionparsePropertyUpdate parseAccessorparseDoparseDoNotationLetparseDoNotationBindparseDoNotationElementparseObjectGetterparseUpdaterBodyparseObjectUpdaterWildcardparseStringBinderparseCharBinderparseBooleanBinderparseNumberBinderparseVarBinderparseNullaryConstructorBinderparseConstructorBinderparseObjectBinderparseArrayBinderparseNamedBinderparseNullBinderparseIdentifierAndBinderfindModuleName solveTypes starIfUnknowninfer freshKindVarinfer'$fUnifiableCheckKind $fPartialKindbuildTypeSubstitutionreplaceAllTypeSynonyms'toBindingGroupcollapseBindingGroupsForValue usedIdentsusedImmediateIdentsusedProperNamesgetIdent getProperNametoDataBindingGroup isTypeSynonym fromValueDeclisLeft desugarAbs inSameGrouptoDeclstoTuplemakeCaseDeclarationDesugar MemberMap desugarModule desugarDeclmemberToNameAndTypetypeClassDictionaryDeclaration#typeClassMemberToDictionaryAccessor!typeInstanceDictionaryDeclarationfindQualModulesimportToCoreFnexternToCoreFnexportToCoreFnmkTypeClassConstructor properToIdent RenameState rsBoundNames rsUsedNames runRenamenewScope updateScope lookupIdentfindDeclIdents renameInDecl renameInValuerenameInLiteralrenameInCaseAlternativerenameInBinderRename initState desugarDoImportEnvironment importedTypesimportedDataConstructorsimportedTypeClassesimportedValuesExports exportedTypesexportedTypeClassesexportedValuesexportedModulesExportEnvironmentupdateExportedModuleaddEmptyModuleaddType addTypeClassaddValue addExportelaborateExportselaborateImportsrenameInModule findExports filterExports findImportsresolveImports resolveImportthrowConflictErrorChainrebracketModule removeParenscollectFixitiesensureNoDuplicatescustomOperatorTablematchOperatorstoAssocparseOp parseTicksmatchOpGHC.Num$fUnifiableCheckType $fPartialTypetypeHeadsAreEqualpairwiseWork subsumes'isTyped overTypesreplaceTypeClassDictionaries checkTypeKindinstantiatePolyTypeWithUnknowns inferProperty inferBinder checkBinderscheckcheck'checkPropertiescheckFunctionApplicationcheckFunctionApplication'meetensureNoDuplicateProperties UntypedDataTypeDatatypeDictionaryForBindingGroupcheckTypedBindingGroupElementtypeForBindingGroupElementinferLetBindingcontainsTypeSynonymscheckTypeSynonyms typeCheckAll addDataTypeaddDataConstructoraddTypeSynonymvalueIsNotDefinedaddTypeClassDictionariescheckDuplicateTypeArgumentscheckTypeClassInstanceaddDefaultImportreverseDependencies importPrimmakeIOtraverseEither Data.MaybeMaybeRCunRC$fToJSONRenderedCode$fToJSONContainingModule$fToJSONRenderedCodeElement renderHead renderLabel renderTaildePrimconvertconvertForAllspreprocessTypeControl.ApplicativepureDeclarationAugmentIntermediateDeclarationaugmentDeclarationsaddDefaultFixity mkDeclaration AugmentFixity AugmentChildgetDeclarationTitlebasicDeclarationconvertDeclarationconvertCommentscollectBookmarks'FileInfo parseFilesdesugarWithBookmarks throwLeftfileInfoToString parseFileparseAsgetDepsModuleNames addPackageDocsFirstNotFirstmodulesAsMarkdownmoduleAsMarkdowndeclAsMarkdown codeToStringfixityAsMarkdown childToStringrunDocstell' headerLevel fencedBlockticksCollectedWarningsnoResolvedVersionsundeclaredDependenciesunacceptableVersionsdisplayUserErrordisplayRepositoryErrordisplayInternalErrordisplayJSONSourcedisplayOtherErrorcollectWarningswarnNoResolvedVersionswarnUndeclaredDependencieswarnUnacceptableVersions$fMonoidCollectedWarningsResolvedVersion ResolvedOther NoResolutionMissingasToplevelDependencies isPureScriptDependencyStatus TreeStatusDirtyClean unPrepareMwarn userError internalError otherError catchLeft extractGithub readProcess'findBowerExecutableasDependencyStatuswarnUndeclared handleDepstryExtractVersiongetInputAndDepsFileswithPackageNamegetPackageName$fMonadIOPrepareM