a6       !"#$%&'()*+,-./0123456789:;<=>?@ABCD E F G H I J K L M N O P Q R S T UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                !!!""""""""""###############$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H%I%J%K%L%M%N%O%P%Q%R%S%T%U%V%W%X%Y%Z%[%\%]%^%_%`%a%b%c%d%e%f%g%h%i%j%k%l%m%n%o%p%q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % %%%%%%%%%%%%%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J%K%L%M%N%O%P%Q%R%S%T%U%V%W%X%Y%Z%[%\%]%^%_%`%a%b%c%d%e%f%g%h%i%j%k%l%m%n%o%p%q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&'''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())***********+++++++++,-.../000 0 0 0 0 0000000000000000000 0!0"0#0$0%0&0'0(0)0*0+0,0-0.0/000102030405060708090:0;0<0=0>0?0@0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O1P2Q2R2S2T2U2V2W2X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f2g2h2i2j2k2l2m2n2o2p2q3r3s4t5u6v6w6x6y6z6{6|6}7~89:::::;;;;;;;;;;<<<<<<<<<<===>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>?@@AAAAAAAAAAAAABCCCCDDDDDDDDDDD D D D D DDDDDDDDDDDDDDDDDDD D!D"D#D$D%D&D'D(D)D*D+D,D-D.D/D0D1D2D3D4D5D6D7E8E9F:F;F<F=G>G?H@IAJBJCJDJEJFJGJHJIJJJKJLJMJNJOJPJQJRJSJTJUJVJWJXJYJZJ[J\J]J^J_J`JaJbJcJdJeJfJgJhJiJjJkJlJmJnJoJpJqJrJsJtJuJvJwJxJyJzJ{J|J}J~JJJJJJJJJJJJJJKKLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNOOOOOOPPPQQQQQQQQQQRSSSTUUVVVWXYZ[[[[[[[[[[[\]]]]]]]^^___`aaaaaaaaaa a b b b bbbbbbbbbbbbbbbbbbb b!b"b#b$b%b&b'b(b)b*b+b,b-b.b/b0b1c2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd d d d d ddddddddddddddeeeff g!g"g#g$h%i&j'j(j)j*j+j,j-j.j/j0j1j2j3k4k5k6k7k8k9k:k;k<k=k>k?k@kAkBkCkDkEkFkGkHkIkJkKlLlMlNlOlPlQlRlSmTmUmVmWmXmYmZm[m\m]m^m_m`mambmcmdmemfmgmhmimjmkmlmmmnmompmqmrmsmtmumvmwmxmymzm{m|m}n~nnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o !o "o #o $o %o &o 'o (o )o *o +o ,o -o .o /o 0o 1o 2o 3o 4o 5o 6o 7o 8o 9o :o ;o <o =o >o ?o @o Ao Bo Co Do Eo Fo Go Ho Io Jo Ko Lo Mo No Oo Po Qo Ro So To Uo Vo Wo Xo Yo Zo [o \o ]o ^o _o `o ao bo co do eo fo go ho io jo ko lo mo no oo po qo ro so to uo vo wo xo yo zo {o |o }o ~o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o p p p p p p p p p p q q r r r r r r r r r r r r r r r r r r r r r s s s s t u u v v v v v v v v v v v v v w w w w w w w w w x x x x x y y y y y y y y y y y y y y y z z z z z z z z z z z z z { { { { { | | | | | | | | | | | | | !| "| #} $} %} &} '} (} )~ *~ +~ ,~ -~ .~ /~ 0~ 1~ 2~ 3~ 4~ 5~ 6~ 7~ 8~ 9~ :~ ;~ <~ =~ >~ ?~ @~ A~ B~ C~ D~ E~ F~ G~ H~ I~ J~ K~ L~ M~ N~ O~ P~ Q~ R~ S~ T~ U~ V~ W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                           None!"$*,2:<=DLOT[blUnfortunately ByteString's readFile does not convert line endings on Windows, so we have to do it ourselvesSafe!"$*,2:<=DLOT[b ! " # $ % & ' ( ) * + , ! ' ( ) * + , ! " # $ % & ' ( ) * + ,Safe!"$*,2:<=DLOT[b    None!"$*,2:<=DLOT[bGGlob relative to the current directory, and produce relative pathnames.)Glob pattern for PureScript source files.Safe!"$*,2:<=DLOT[b    Safe!"$*,2:<=DLOT[bState for the parser monad*The most recently marked indentation levelNone!"$*,25:<=DILOT[bStrings in PureScript are sequences of UTF-16 code units, which do not necessarily represent UTF-16 encoded text. For example, it is permissible for a string to contain *lone surrogates,* i.e. characters in the range U+D800 to U+DFFF which do not appear as a part of a surrogate pair.The Show instance for PSString produces a string literal which would represent the same data were it inserted into a PureScript source file.Because JSON parsers vary wildly in terms of how they deal with lone surrogates in JSON strings, the ToJSON instance for PSString produces JSON strings where that would be safe (i.e. when there are no lone surrogates), and arrays of UTF-16 code units (integers) otherwise. -Decode a PSString to a String, representing any lone surrogates as the reserved code point with that index. Warning: if there are any lone surrogates, converting the result to Text via Data.Text.pack will result in loss of information as those lone surrogates will be replaced with U+FFFD REPLACEMENT CHARACTER. Because this function requires care to use correctly, we do not export it.!eDecode a PSString as UTF-16 text. Lone surrogates will be replaced with U+FFFD REPLACEMENT CHARACTER"Decode a PSString as UTF-16. Lone surrogates in the input are represented in the output with the Left constructor; characters which were successfully decoded are represented with the Right constructor.#Pretty print a PSString, using Haskell/PureScript escape sequences. This is identical to the Show instance except that we get a Text out instead of a String.$zAttempt to decode a PSString as UTF-16 text. This will fail (returning Nothing) if the argument contains lone surrogates.%dPretty print a PSString, using JavaScript escape sequences. Intended for use in compiled JS output. . -!"#$% / 0 1 2 3 4&'()*+ !"#$%&  $"!#%& . -!"#$% / 0 1 2 3 4&'()*+Safe!"$*,2:<=DLOT[b0!The data type of compiler options2Verbose error message3)Remove the comments from the generated js4Generate source maps5 Dump CoreFn0123456012345601234560123456None!"$*,25:<=DILOT[b8Labels are used as record keys and row entry names. Labels newtype PSString because records are indexable by PureScript strings at runtime.89:;89:89:89:; Safe!"$*,2:<=DLOT[bD0Locates the node executable. Checks for either nodejs or node.E/Grabs the filename where the history is stored. 5 6DEDEDE 5 6DE Safe!"$*,2:<=DLOT[bFFFF None!"$*,2:<=DLOT[bGAn embedded copy of normalize.css as a UTF-8 encoded ByteString; this should be included before pursuit.css in any HTML page using pursuit.css.HLike G , but as a  7.IDCSS for use with generated HTML docs, as a UTF-8 encoded ByteString.JLike I , but as a  7.GHIJGHIJGHIJGHIJ Safe!"$*,2:<=DLOT[bK A compatibility wrapper for the GHC.Stack.HasCallStack constraint.L3Exit with an error message and a crash report link.KLKLKLKL None!"$*,2:<=DLOT[bMNOSMNOMNOSSMNOSNone!"$*,2:<=DLOT[bXStart position of this tokenY5End position of this token (not including whitespace)Z"End position of the previous token_Lexes the given file, and on encountering a parse error, returns the progress made up to that point, instead of returning an error 8CWe use Text.Parsec.Token to implement the string and number lexemes 9/A token parser based on the language definition}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 commas)A list of purescript reserved identifiers+The characters allowed for use in operators :<The characters allowed in the head of an unquoted record key ;<The characters allowed in the tail of an unquoted record key3Strings allowed to be left unquoted in a record keyoU <VWXYZ[\] = > ? @ 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 8 9`abcdefghijklmnopqrstuvwxyz{|}~ b c d : ;AUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~AVWXYZ[\]U^_`abcdefghijklmnopqrstuvwxyz{|}~LU <VWXYZ[\] = > ? @ 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 8 9`abcdefghijklmnopqrstuvwxyz{|}~ b c d : ;None!"$*,2:<=DLOT[b e>A module is just a list of elements of the types listed above. f<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. gAn 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. hyA 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.kModules are either "regular modules" (i.e. those generated by the PureScript compiler) 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.XGiven a filename, assuming it is in the correct place on disk, infer a ModuleIdentifier.3Prepare an error message for consumption by humans. iFCalculate the ModuleIdentifier which a require(...) statement imports. jOCompute 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. k1Attempt 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. l=Eliminate unused code based on the specified entry point set. mzTopologically sort the module dependency graph, so that when we generate code, modules can be defined in the right order. nA 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. o?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 ] || {});UIn 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 the compiler).The bundling function. This function performs dead code elimination, filters empty modules and generates and prints the final JavaScript bundle.The bundling function. This function performs dead code elimination, filters empty modules and generates and prints the final JavaScript bundle./ e p f q r s t u g v w h x i j y z { | k } ~  l m n o main module namespace input modulesoutput filenamePThe input modules. Each module should be javascript rendered from the compiler.WEntry points. These module identifiers are used as the roots for dead-code eliminationAn optional main module.The namespace (e.g. PS).JThe output file name (if there is one - in which case generate source map)PThe input modules. Each module should be javascript rendered from the compiler.WEntry points. These module identifiers are used as the roots for dead-code eliminationAn optional main module.The namespace (e.g. PS). e p f q r s t u g v w h x i j y z { | k } ~  l m n oNone!"$*,25:<=DLOT[b Source nameStart of the spanEnd of the spanSource position information Line number Column number6Source annotation - position information and comments. None!"$*,25:<=DLOT[bFixity data for infix operators!Associativity for infix operators(A precedence level for an infix operator  None!"$*,2:<=DLOT[bUData type for literal values. Parameterised so it can be used for Exprs and Binders.A numeric literalA string literalA character literalA boolean literalAn array literalAn object literalNone!"$*,2:<=DILOT[bNone!"$*,26:<=DLORT[b                      None!"$*,25:<=DLOT[b:A qualified name, i.e. a name with an optional module name Module names$The closed set of proper name types.TProper names, i.e. capitalized names for e.g. module names, type//data constructors.'The closed set of operator alias types.Operator alias names."Names for value identifiers#An alphanumeric identifier$"A generated name for an identifier%EA sum of the possible name types, useful for error and lint messages.;Coerces a ProperName from one ProperNameType to another. This should be used with care, and is primarily used to convert ClassNames into TypeNames after classes have been desugared.@7Provide a default module name, if a name is unqualifiedA4Makes a qualified value from a name and module name.B,Remove the module name from a qualified nameCZRemove the qualification from a value when it is qualified with a particular module name.DNChecks whether a qualified value is actually qualified with a module referenceERChecks whether a qualified value is not actually qualified with a module referenceFFChecks whether a qualified value is qualified with a particular moduleE !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPjln8 !"#$%,&'()*+-./0123456789:;<=>?@ABCDEFH%&'()*+,-P./012345"#$O6789 !NML:KJI;H<=G>?@ABCDEFjjllnn. !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPjlnNone!"$*,2:<=DLOT[bq Convert an "$ 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.s<Test if a string is a valid AST identifier without escaping.tkAttempts to find a human-readable name for a symbol, if none has been specified returns the ordinal value.u<Checks whether an identifier name is reserved in JavaScript.v=Checks whether a name matches a built-in value in JavaScript.pqrstuvwxyz{|}pqrstuvwxyz{|}pqrstuvwxyz{|}pqrstuvwxyz{|}None!"$*,2:<=DLOT[b~     ~     ~     ~     None!"$*,2:<=DLOT[bData type for bindersWildcard binder&A binder which matches a literal value"A binder which binds an identifier)A binder which matches a data constructor/A binder which binds its input to an identifierNone!"$*,2:<=DLOT[b"An alternative in a case statement 6A collection of binders with which to match the inputs!9The result expression or a collect of guarded expressions"SA guard is just a boolean-valued expression that appears alongside a set of binders#A let or module binding.$(Non-recursive binding for a single value%3Mutually recursive binding group for several values&#Data type for expressions and terms'A literal value(=A data constructor (type name, constructor name, field names))A record property accessor*Partial record update+Function introduction,Function application-Variable.A case expression/ A let binding0"Extract the annotation from a term1Modify the annotation on a term !"#$%&'()*+,-./012 !"#$%&'-()*+,./01&'()*+,-./#$%" !201 !"#$%& '()*+,-./012None!"$*,2:<=DLOT[b89898989None!"$*,2:<=DLOT[b:Data constructor metadata;6The constructor is for a type with a single construcor<7The constructor is for a type with multiple construcors=Metadata annotations>)The contained value is a data constructor? The contained value is a newtype@9The contained value is a typeclass dictionary constructorA/The contained reference is for a foreign member:;<=>?@A:;<=>?@A=>?@A:;<:;<=>?@ANone!"$*,25:<=DLOT[bHThe data type of kindsI!Unification variable of type KindJ5Kinds for labelled, unordered rows without duplicatesKFunction kindsL A named kind HIJKLMNOPQRS HJIKLMNOP HIJKLSRMQNOPHIJKLMNOPQRSNone!"$*,2:<=DLOT[bXParse a general proper name.YParse a proper name for a type.ZParse a proper name for a kind.[+Parse a proper name for a data constructor.\Parse a module name]0Parse a qualified name, i.e. M.name or just name^Parse an identifier._<Parse a label, which may look like an identifier or a string`Parse an operator.anRun the first parser, then match the second if possible, applying the specified function on a successful matchbnRun the first parser, then match the second zero or more times, applying the specified function for each matchcPBuild a parser from a smaller parser and a list of parsers for postfix operatorsd"Mark the current indentation levele;Check that the current identation level matches a predicatefACheck that the current indentation level is past the current markgWCheck that the current indentation level is at the same indentation as the current markh?Read the comments from the the next token, without consuming iti Run a parserjConvert from Parsec sourceposk-Read source position information and commentsXYZ[\]^_`abcdefghijklmXYZ[\]^_`abcdefghijklmXYZ[\]^_`abcdefghijklmXYZ[\]^_`abcdefghijklmNone!"$*,2:<=DLOT[bn Parse a kind nnn nNone!"$*,25:<=DILOT[b'oA typeclass constraintqconstraint class namertype argumentss+additional data relevant to this constraintt2Additional data relevant to type class constraintsuData to accompany a Partial constraint generated by the exhaustivity checker. It contains (rendered) binder information for those binders which were not matched, and a flag indicating whether the list was truncated or not. Note: we use  7 here because using Binder: would introduce a cyclic dependency in the module graph.vThe type of typesw#A unification variable of type TypexA named type variableyA type-level stringz:A type wildcard, as would appear in a partial type synonym{A type constructor|lA type operator. This will be desugared into a type constructor during the "operators" phase of desugaring.}A type application~Forall quantifier+A type with a set of type class constraintsA skolem constant An empty rowA non-empty rowA type with a kind annotation%A placeholder used in pretty printing%A placeholder used in pretty printing%A placeholder used in pretty printingqBinary operator application. During the rebracketing phase of desugaring, this data constructor will be removed.jExplicit parentheses. During the rebracketing phase of desugaring, this data constructor will be removed.zNote: although it seems this constructor is not used, it _is_ useful, since it prevents certain traversals from matching.0An identifier for the scope of a skolem variable4Convert a row to a list of pairs of labels and typesKConvert a row to a list of pairs of labels and types, sorted by the labels.+Convert a list of labels and types to a row"Check whether a type is a monotypeUniversally quantify a type?Replace a type variable, taking into account variable shadowing'Replace named type variables with types.Collect all type variables appearing in a type3Collect all free type variables appearing in a typeEUniversally quantify over all type variables appearing free in a type5Move all universal quantifiers to the front of a type"Check if a type contains wildcardsCheck if a type contains forall9opqrstuvwxyz{|}~2opqrstuvwxyz{|}~<vwxyz{|}~tuopqrs opqrstuvwxyz{|}~ None!"$*,2:<=DLOT[b Data type for bindersWildcard binder A binder which matches a literal"A binder which binds an identifier)A binder which matches a data constructormA operator alias binder. 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.jExplicit parentheses. During the rebracketing phase of desugaring, this data constructor will be removed.zNote: although it seems this constructor is not used, it _is_ useful, since it prevents certain traversals from matching./A binder which binds its input to an identifier)A binder with source position informationA binder with a type annotation8Collect all names introduced in binders in an expression    !None!"$*,2:<=DLOT[b Type alias for basic annotations9An annotation empty of metadata aside from a source span.&Remove the comments from an annotation"None!"$*,2:<=DLOT[b The CoreFn module representation   #None!"$*,2345:<=DLOT[b;Data representing a type class dictionary which is in scope>The value with which the dictionary can be accessed at runtime8How to obtain this instance via superclass relationshipsDThe name of the type class to which this type class instance applies3The types to which this type class instance appliesLType class dependencies which must be satisfied to construct this dictionaryPGenerate a name for a superclass reference which can be used in generated code.   $None!"$*,25:<=DLOT[b8 The type ('data' or  'newtype') of a data type declarationA standard data constructorA newtype constructorThe kinds of a type Data type Type synonym Foreign dataA local type variableA scoped type variableA flag for whether a name is for an private or public value - only public values will be included in a generated externs file.mA private value introduced as an artifact of code generation (class instances, class member accessors, etc.)@A public value for a module member or foreing import declaration.A name for member introduced by foreign import!The visibility of a name in scopeDThe name is defined in the current binding group, but is not visible_The name is defined in the another binding group, or has been made visible by a function binderlA functional dependency indicates a relationship between two sets of type arguments in a class declaration.@the type arguments which determine the determined type argumentsthe determined type argumentsInformation about a type classVA list of type argument names, and their kinds, where kind annotations were provided.oA list of type class members and their types. Type arguments listed above are considered bound in these types.A list of superclasses of this type class. Type arguments listed above are considered bound in the types appearing in these constraints.GA list of functional dependencies for the type arguments of this class.A set of indexes of type argument that are fully determined by other arguments via functional dependencies. This can be computed from both typeClassArguments and typeClassDependencies.BA sets of arguments that can be used to infer all other arguments.The  Environment; defines all values and types which are currently in scope:Values currently in scopeType names currently in scope yData constructors currently in scope, along with their associated type constructor name, argument types and return type.  Type synonyms currently in scope !Available type class dictionaries  Type classes Kinds in scopeTThe initial environment with no values and only the default javascript types definedgA constructor for TypeClassData that computes which type class arguments are fully determined and argument covering sets. Fully determined means that this argument cannot be used when selecting a type class instance. A covering set is a minimal collection of arguments that can be used to find an instance and therefore determine all other type arguments.An example of the difference between determined and fully determined would be with the class: ```class C a b c | a -> b, b -> a, b -> c``` In this case, a must differ when bB differs, and vice versa - each is determined by the other. Both a and b: can be used in selecting a type class instance. However, c% cannot - it is fully determined by a and b."Define a graph of type class arguments with edges being fundep determiners to determined. Each argument also has a self looping edge. An argument is fully determined if doesn't appear at the start of a path of strongly connected components. An argument is not fully determined otherwise.1The way we compute this is by saying: an argument X is fully determined if there are arguments that determine X that X does not determine. This is the same thing: everything X determines includes everything in its SCC, and everything determining X is either before it in an SCC path, or in the same SCC.)Construct a ProperName in the Prim moduleKind of ground types#Construct a type in the Prim moduleType constructor for functionsType constructor for stringsType constructor for stringsType constructor for numbersType constructor for integersType constructor for booleansType constructor for arraysType constructor for records Check whether a type is a record"Check whether a type is a function!$Smart constructor for function types"The primitive kinds#oThe primitive types in the external javascript environment with their associated kinds. There are also pseudo Fail, Warn, and Partial; types that correspond to the classes with the same names.$0The primitive class map. This just contains the Fail, Warn, and Partial classes. Partial? is used as a kind of magic constraint for partial functions. Fail' is used for user-defined type errors. Warn for user-defined warnings.%GFinds information about data constructors from the current environment.&3Checks whether a data constructor is for a newtype.'<Finds information about values from the current environment.L      !"#$%&'()*+,-./01234?      !"#$%&'L     43210/.-,+*)( !"#$%&'.      !"#$%&'()*+,-./01234%None!"$*,23457:<=DLOT[beP"A statement in a do-notation blockQ A monadic value without a binderRA monadic value with a binderS0A let statement, i.e. a pure value with a binderT6A do notation element with source position informationU"An alternative in a case statementW6A collection of binders with which to match the inputsX9The result expression or a collect of guarded expressionsY#Data type for expressions and termsZA literal value[A prefix -, will be desugared\qBinary operator application. During the rebracketing phase of desugaring, this data constructor will be removed.]jExplicit parentheses. During the rebracketing phase of desugaring, this data constructor will be removed.zNote: although it seems this constructor is not used, it _is_ useful, since it prevents certain traversals from matching.^-An record property accessor expression (e.g. `obj.x` or `_.x`z). Anonymous arguments will be removed during desugaring and expanded into a lambda that reads a property from a record._Partial record update`_Object updates with nested support: `x { foo { bar = e } }` Replaced during desugaring into a i and nested _saFunction introductionbFunction applicationcVariabled`An operator. This will be desugared into a function during the "operators" phase of desugaring.e%Conditional (if-then-else expression)fA data constructorgA 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.hA value with a type annotationi A let bindingjA do-notation blockk\An application of a typeclass dictionary constructor. The value should be an ObjectLiteral.lA 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.m`A typeclass dictionary accessor, the implementation is left unspecified until CoreFn desugaring.neA placeholder for a superclass dictionary to be turned into a TypeClassDictionary during typecheckingo0A placeholder for an anonymous function argumentpEA typed hole that will be turned into a hint/error duing typecheckingq(A value with source position informationrLThe right hand side of a binder in value declarations and case expressions.tSA guard is just a boolean-valued expression that appears alongside a set of bindersw0The members of a type class instance declarationxThis is a derived instancey*This is an instance derived from a newtypeznThis is an instance derived from a newtype, desugared to include a dictionary for the type under the newtype.{%This is a regular (explicit) instanceThe data type of declarationsMA data type declaration (data or newtype, name, arguments, data constructors):A minimal mutually recursive set of data type declarations2A type synonym declaration (name, arguments, type))A type declaration for a value (name, ty)DA value declaration (name, top-level binders, optional guard, value)_A declaration paired with pattern matching in let-in expression (binder, optional guard, value)6A minimal mutually recursive set of value declarations)A foreign import declaration (name, type)'A data type foreign import (name, kind)A foreign kind import (name)A fixity declaration'A module import (module name, qualified unqualified%hiding, optional "qualified as" name)GA type class declaration (name, argument, implies, member declarations)bA type instance declaration (name, dependencies, class name, instance types, member declarations)mA value declaration assigns a name and potential binders, to an expression (or multiple guarded expressions). double x = x + xIn this example double is the identifier, x is a binder and x + x is the expression.The declared value's name-Whether or not this value is exported/visible7A type declaration assigns a type to an identifier, eg: identity :: forall a. a -> aIn this example identity is the identifier and forall a. a -> a the type.8The data type which specifies type of import declaration,An import with no explicit list: `import M`.IAn import with an explicit list of references to import: `import M (foo)`DAn import with a list of references to hide: `import M hiding (foo)`0An item in a list of explicit imports or exports)A type constructor with data constructorsA type operatorA valueA value-level operator A type class]A type class instance, created during typeclass desugaring (name, class name, instance types)A module, in its entirety A named kindgA value re-exported from another module. These will be inserted during elaboration in name desugaring.A 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.Categories of hintsGError message hints, providing more detailed information about failure.A type of error messages2Iinstance name, type class, expected argument count, actual argument count3:a user-defined warning raised by using the Warn type class4Ba declaration couldn't be used because it contained free variables5CHolds the data necessary to do type directed search for typed holes6EAn Environment captured for later consumption by type directed search7PResults of applying type directed search to the previously captured Environment88The identifiers that fully satisfy the subsumption check9IRecord fields that are available on the first argument to the typed hole:&A map of locally-bound names in scope.AReturn a module's name.BReturn a module's source span.CSAdd an import declaration for a module if it does not already explicitly import it.fWill not import an unqualified module if that module has already been imported qualified. (See #2197)DmAdds import declarations to a module for an implicit Prim import and Prim | qualified as Prim, as necessary.W A traversal for TypeInstanceBody[,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 import^3Test if a declaration is a data type foreign import_.Test if a declaration is a foreign kind import`-Test if a declaration is a fixity declarationb)Test if a declaration is a foreign importc:Test if a declaration is a type class instance declarationd1Test if a declaration is a type class declarationeCRecursively flatten data binding groups in the list of declarations"HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefHIJKLMNOPQRSTUVWXYZcfd^_abgi[\]`ehjklmnopqrstuvwyxz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde$:56789?@      !"#$%&'()*+,-./01234ABCDfEFGHIJKLMNOPQRSTU>~|}=<wxyz{VWXYZ[\]^_`abcdetuvrs;YZ[\]^_`abcdefghijklmnopqUVWXPQRSTNOKLMHIJFHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ i      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef&None!"$*,2:<=DLOT[bReturn 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 K. It will produce incorrect results if this is not the case - for example, type class instances will be incorrectly removed in some cases.The returned declarations are in the same order as they appear in the export list, unless there is no export list, in which case they appear in the same order as they do in the source file. 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. NReorder declarations based on the order they appear in the given export list.    'None!"$*,2:<=DLOT[b=Map a function over type annotations appearing inside a value    None!"$*,2:<=DLOT[bYHIJKLMNOPQRSTUVWXYZcfd^_abgi[\]`ehjklmnopqrstuvwyxz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde(None!"$*,2:<=DLOT[b/Data type for simplified JavaScript expressionsA numeric literalA string literalA boolean literalA unary operator applicationA binary operator applicationAn array literalAn array indexer expressionAn object literal8A function introduction (optional name, arguments, body)Function applicationVariable A block of expressions in braces3A variable introduction and optional initializationA variable assignment While loopFor loop ForIn loopIf-then-else statementReturn statement%Return statement with no return valueThrow statementinstanceof checkCommented JavaScriptBuilt-in binary operatorsBuilt-in unary operators888 )None!"$*,2:<=DLOT[b@Collapse blocks which appear nested directly below another block*None!"$*,2:<=DLOT[b    +None!"$*,2:<=DLOT[b.   .  ,None!"$*,2:<=DLOT[bCInline 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!"$*,2:<=DLOT[bEliminate tail calls.None!"$*,2:<=DLOT[b/None!"$*,2:<=DLOT[b@Apply a series of optimizer passes to simplified JavaScript code  None!"$*,2:<=DLOT[bT0None!"$*,25:<=DILOT[b A type representing a highly simplified version of PureScript code, intended for use in output formats like plain text or HTML.A single element in a rendered code fragment. The intention is to support multiple output formats. For example, plain text, or highlighted HTML. Any symbol which you might or might not want to link to, in any namespace (value, type, or kind). Note that this is not related to the kind called Symbol for type-level strings.This type is isomorphic to   G. It makes code a bit easier to read, as the meaning is more explicit. bGiven a list of actions, attempt them all, returning the first success. If all the actions fail,   returns the first argument. pTry the given parsers in sequence. If all fail, fail with the given message, and include the JSON in the error. 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. $Wrap a RenderedCode value in parens. oConverts a FixityAlias into a different representation which is more useful to other functions in this module.@         !"#$%&'()*+,-./01234 56789:;<=/      !"#$%&'()*+,-./01234/      !"#$%&'()*+,-./012343         !"#$%&'()*+,-./01234 56789:;<=1None!"$*,2:<=DLOT[bO/Generate RenderedCode value representing a Kind OOO O2None!"$*,2:<=DILOT[b U)String with length and source-map entries\Wrap a string in parentheses_+Generalize intercalate slightly for monoidse)Number of characters per identation levelf)Pretty print with a new indentation levelg!Get the current indentation levelhPrint many linesjRPlace a box before another, vertically when the first box takes up multiple lines.l*Place a Box on the bottom right of anotheroMake a monoid where append consists of concatenating the string part, adding the lengths appropriately and advancing source mappings on the right hand side to account for the length of the left. PQRSTUVWXYZ[\]^_`abcdefghijklmnoPQRSTUVWXYZ[\]^_`abcdefghijkl \]^_YZ[WXUVonST`mabcPQRdefghijklPQRSTUVWXYZ[\]^_`abcdefghijklmno3None!"$*,2:<=DLOT[bqrGenerate a pretty-printed string representing a collection of JavaScript expressions at the same indentation level PGenerate an indented, pretty-printed string representing a JavaScript expression qr qrrq qr 4None!"$*,2:<=DLOT[bs4Generate a pretty-printed string representing a Kind sss s5None!"$*,2:<=DLOT[btReplace every BoundValueDeclaration in Let expressions with Case expressions. Desugar a single let expressiont ttt 6None!"$*,2:<=DLOT[buvwxyz{|uvwxyz{|uvwxyz{|uvwxyz{|7None!"$*,2:<=DLOT[b}}}}8None!"$*,2:<=DLOT[b~~~~9None!"$*,2:<=DLOT[b:None!"$*,2:<=DLOT[bParse an atomic type with no forall5Parse a type as it appears in e.g. a data constructorParse a monotypeParse a polytype&Parse an atomic type with no wildcards      ;None!"$*,2:<=DLOT[b 3Generate a pretty-printed string representing a Row\Generate a pretty-printed string representing a Type, as it should appear inside parentheses0Generate a pretty-printed string representing a v0Generate a pretty-printed string representing a v( using unicode symbols where applicable:Generate a pretty-printed string representing a suggested v           <None!"$*,2:<=DLOT[bRender code representing a RowRender code representing a TypeGRender code representing a Type, as it should appear inside parentheses      None!"$*,2:<=DLOT[b:      !"#$%&'()*+,-./01234O=None!"$*,2:<=DLOT[b 5Render an aligned list of items separated with commasPretty-print an expression CPretty-print an atomic expression, adding parentheses if necessary.6Generate a pretty-printed string representing a Binder                  None!"$*,2:<=DLOT[b#s>None!"#$*,2:<=DILOT[b& Options$Color code with this color... or not"Should write a full error message?)Should this report an error or a warning?/Should show a link to error message's doc page?)FilePath to which the errors are relativeHow critical the issue isLA map from rigid type variable name/unknown variable pairs to new variables.Ga map from skolems to their new names, including source and naming info3a map from unification variables to their new namesunknowns and skolems share a source of names during renaming, to avoid overlaps in error messages. This is the next label for either case.A stack trace for an error Get the source span for an error Get the module name for an error3Remove the module name and span hints from an error.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 messageLCreate an error set from a single simple error message and source annotation/Create an error set from a single error message?Lift a function on ErrorMessage to a function on MultipleErrorsAdd a hint to an error messageAdd hints to an error message1Extract nested error messages from wrapper errors)Default color intesity and color for codeDefault options for PPEOptions5Pretty print a single error, simplifying if necessaryPretty print multiple errorsPretty print multiple warningsPretty print warnings as a BoxPretty print errors as a Box)Pretty print a Parsec ParseError as a Box Pretty print  ParseError detail messages. Adapted from . See  Hhttps://github.com/aslatter/parsec/blob/v3.1.9/Text/Parsec/Error.hs#L173./Indent to the right, and pad on top and bottom.JRethrow an error with a more detailed error message in the case of failure1Rethrow an error with source position informationuRuns a computation listening for warnings and then escalating any warnings that match the predicate to error status.Collect errors in in parallelIHIJKLMNOPQRSTUVWXYZcfd^_abgi[\]`ehjklmnopqrstuvwyxz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeI:?None!"$*,2:<=DLOT[b 8There are two modes of failure for the redundancy check: WExhaustivity was incomplete due to too many cases, so we couldn't determine redundancy.OWe didn't attempt to determine redundancy for a binder, e.g. an integer binder.+We want to warn the user in the first case. RQualifies a propername from a given qualified propername and a default module name Given 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 binder BApplies a function over two lists of tuples that may lack elements Find the uncovered set between two binders: the first binder is the case we are trying to cover, the second one is the matching binder Returns 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 not;or in case of a pattern guard if the pattern is exhaustive.5The 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 alternatives eMain 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.Exhaustivity checking                         @None!"$*,2:<=DLOT[b4A list of modules with their transitive dependencies:Sort a collection of modules based on module dependencies.6Reports an error if the module graph contains a cycle. OCalculate a list of used modules based on explicit imports and qualified names. FConvert a strongly connected component of the module graph to a module    ANone!"$*,2:<=DLOT[b Parse a single declaration6Parse a module declaration and its export declarations6Parse a module header and a collection of declarations)Parse a collection of modules in parallel@Parses a single module with FilePath for eventual parsing errors Converts a  ParseError into a  /Parse an expression in backticks or an operator 1Expressions including indexers and record updatesParse an expressionParse a binder<Parse a binder as it would appear in a top level declaration Parse a guardD  ! " # $ % & ' ( ) * + , - . / 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  D  ! " # $ % & ' ( ) * + , - . / 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 SNone!"$*,2:<=DLOT[bmUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~XYZ[\]^_`abcdefghijklmnBNone!"$*,2:<=DLOT[b;Warns about duplicate values in a list of declaration refs.CNone!"$*,2:<=DLOT[bSReplace all sets of mutually-recursive declarations in a module with binding groupsBCollapse all binding groups in a module to individual declarations6Collapse all binding groups to individual declarations ToConvert a group of mutually-recursive dependencies into a BindingGroupDeclaration (or simple ValueDeclaration). U V W X Y T Z [ \ ] U V W X Y T Z [ \ ]DNone!"$*,2:<=DLOT[b&When updating the  the behaviour is slightly different depending on whether we are exporting values defined within the module or elaborating re-exported values. This type is used to indicate which behaviour should be used.9The imports and exports for a collection of modules. The  is used to store the source location of the module with a given name, used to provide useful information when there is a duplicate module definition.(The exported declarations from a module.CThe exported types along with the module they originally came from.MThe exported type operators along with the module they originally came from.EThe exported classes along with the module they originally came from.DThe exported values along with the module they originally came from.NThe exported value operators along with the module they originally came from. CThe exported kinds along with the module they originally came from. KThe imported declarations for a module, including the module's own members. ELocal names for types within a module mapped to their qualified names NLocal names for type operators within a module mapped to their qualified namesQLocal names for data constructors within a module mapped to their qualified namesGLocal names for classes within a module mapped to their qualified namesFLocal names for values within a module mapped to their qualified namesOLocal names for value operators within a module mapped to their qualified nameszThe name of modules that have been imported into the current scope that can be re-exported. If a module is imported with as qualification, the as0 name appears here, otherwise the original name.<The "as" names of modules that have been imported qualified.ELocal names for kinds within a module mapped to their qualified namesUsed to track how an import was introduced into scope. This allows us to handle the one-open-import special case that allows a name conflict to become a warning rather than being an unresolvable situation.JThe details for an import: the name of the thing that is being imported ( if importing from Az), the module that the thing was originally defined in (for re-export resolution), and the import provenance (see below).  An empty  value.! Extracts the  from an  value." Extracts the   from an  value.# Extracts the  from an  value. ^The exported types from the Prim module$0Environment which only contains the Prim module.%gSafely adds a type and its data constructors to some exports, returning an error if a conflict occurs.&VSafely adds a type operator to some exports, returning an error if a conflict occurs.'MSafely adds a class to some exports, returning an error if a conflict occurs.(MSafely adds a value to some exports, returning an error if a conflict occurs.)WSafely adds a value operator to some exports, returning an error if a conflict occurs.*LSafely adds a kind to some exports, returning an error if a conflict occurs. _eAdds an entry to a list of exports unless it is already present, in which case an error is returned. `IRaises an error for when there is more than one definition for something. aDRaises an error for when there are conflicting names in the exports.+MGets the exports for a module, or raise an error if the module doesn't exist.,SWhen reading a value from the imports, check that there are no conflicts in scope.4      b !"# ^$%&'()* _ ` a+,/      !"#$%&'()*+,/      $!"#%&'()*+,      b !"# ^$%&'()* _ ` a+,ENone!"$*,2:<=DLOT[b7LFinds all exportable members of a module, disregarding any explicit exports.8Resolves the exports for a module, filtering out members that have not been exported and elaborating re-exports of other modules. c~Filters the full list of exportable values, types, and classes for a module based on a list of export declaration references.78 c787878 cFNone!"$*,2:<=DLOT[b:|Finds the imports within a module, mapping the imported module name to an optional set of explicitly imported declarations.;)Constructs a set of imports for a module.<7Constructs a set of imports for a single module import. dTExtends the local environment for a module by resolving an import of another module.9:;< d9:;<9;<:9:;< dGNone!"$*,2:<=DLOT[b=TMap of module name to list of imported names from that module which have been used.>Find and warn on:3Unused import statements (qualified or unqualified),Unused references in an explicit import listImplicit imports of modulesoImplicit imports into a virtual module (unless the virtual module only has members from one module imported)Imports using hiding- (this is another form of implicit importing)=> e f g h i %,&'()*+-=> >%&'()*+,-==> e f g h iHNone!"$*,2:<=DLOT[b?TLint the PureScript AST. | | Right now, this pass only performs a shadowing check.? %,&'()*+-=>???INone!"$*,2:<=DLOT[b@IReplace all top level type declarations in a module with type annotations@@@@JNone!"$*,2:<=DLOT[b!A8A type or value declaration appearing in an externs fileBA type declarationCA type synonymDA data construtorEA value declarationFA type class declarationGAn instance declarationHA kind declaration`,A type fixity declaration in an externs fileb!The associativity of the operatorc$The precedence level of the operatordThe operator symbole&The value the operator is an alias forf'A fixity declaration in an externs fileh!The associativity of the operatori$The precedence level of the operatorjThe operator symbolk&The value the operator is an alias forl"A module import in an externs filenThe imported moduleo-The import type: regular, qualified or hidingp+The imported-as name, for qualified importsq4The data which will be serialized to an externs filesThe externs versiont Module nameuList of module exportsvList of module importsw$List of operators and their fixitiesx)List of type operators and their fixitiesy"List of type and value declarationzSource span for error reporting{*Convert an externs file back into a module|9Generate an externs file for all declarations in a moduleAABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|<ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|<qrstuvwxyzlmnopfghijk`abcdeABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_|{ ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq rstuvwxyz{|KNone!"$*,2:<=DLOT[bReplaces all local names with qualified names within a list of modules. The modules should be topologically sorted beforehand. jMake all exports for a module explicit. This may still affect modules that have an exports list, as it will also make all data constructor exports explicit.The exports will appear in the same order as they do in the existing exports list, or if there is no export list, declarations are order based on their order of appearance in the module. kGiven a list of declarations, an original exports list, and an elaborated exports list, reorder the elaborated list so that it matches the original order. If there is no original exports list, reorder declarations based on their order in the source file. lvReplaces all local names with qualified names within a module and checks that all existing qualified names are valid. j k l             j k lLNone!"$*,2:<=DLOT[b mAn operator associated with its declaration position, fixity, and the name of the function or data constructor it is an alias for.ARemoves unary negation operators and replaces them with calls to  n.ERemove explicit parentheses and reorder binary operator applications.LThis pass requires name desugaring and export elaboration to have run first. A version of . which allows you to choose which declarations should be affected. This is used in docs generation, where we want to desugar type operators in instance declarations to ensure that instances are paired up with their types correctly, but we don't want to desugar type operators in value declarations.Checks all the fixity exports within a module to ensure that members aliased by the operators are also exported from the module.LThis pass requires name desugaring and export elaboration to have run first. o p m q r s t u v w x o p m q r s t u v w xMNone!"$%&*,29:;<=DLOT[b'Unification variables State required for type checking The current  Environment"The next type unification variable"The next kind unification variableThe next skolem variableThe next skolem scope constantThe current moduleThe current substitutionOThe current error message hint stack. This goes into state, rather than using R, since this way, we can provide good error messages during instance resolution.:A substitution of unification variables for types or kindsType substitutionKind substitutionAn empty substitutionCreate an empty  CheckState0Temporarily bind a collection of names to values/Temporarily bind a collection of names to types/Temporarily bind a collection of names to typesThese hints are added at the front, so the most nested hint occurs at the front, but the simplifier assumes the reverse order.BTemporarily 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 DefinedQUpdate the visibility of all names to Defined in the scope of the provided action6Perform an action while preserving the names from the  Environment.*Lookup the type of a value by name in the  Environment0Lookup the visibility of a value by name in the  EnvironmentAssert that a name is visible)Lookup the kind of a type by name in the  EnvironmentGet the current  Environment?Get locally-bound names in context, to create an error message. Update the  Environment Modify the  EnvironmentDRun a computation in the typechecking monad, starting with an empty  EnvironmenttRun a computation in the typechecking monad, failing with an error, or succeeding with a return value and the final  Environment.0Make an assertion, failing with an error messagebRun a computation in the substitution monad, generating a return value and the final substitution.///# NNone!"$*,29:;<=DLOT[b yGenerate a fresh kind variable z2Update the substitution to solve a kind constraint {Apply a substitution to a kind |2Make sure that an unknown does not occur in a kind }Unify two kindsInfer the kind of a single typeQInfer the kind of a single type, returning the kinds of any scoped type variablestInfer the kind of a type constructor with a collection of arguments and a collection of associated data constructorsNSimultaneously infer the kinds of several mutually recursive type constructors ~^Solve the set of kind constraints associated with the data constructors for a type constructor 7Default all unknown kinds to the kindType kind of types Infer a kind for a type y z { | }  ~   y z { | }  ~  ONone!"$*,2:<=DLOT[bGenerate a new skolem constant5Introduce skolem scope at every occurence of a ForAllGenerate a new skolem scopePSkolemize a type variable by replacing its instances with fresh skolem constantsMThis function skolemizes type variables appearing in any type signatures or no placeholders. These type variables are the only places where scoped type variables can appear in expressions.1Ensure skolem variables do not escape their scope(Every skolem variable is created when a ~c type is skolemized. This determines the scope of that skolem variable, which is copied from the  field of the ~ constructor.<This function traverses the tree top-down, and collects any s introduced by ~s. If a  is encountered whose L is not in the current list, then we have found an escaped skolem variable.PNone!"$%&*,2:<=DLOT[bNType synonym information (arguments with kinds, aliased type), indexed by name#Replace fully applied type synonyms>Replace fully applied type synonyms by explicitly providing a .  QNone!"$*,29:;<=DLOT[b Generate a fresh type variable2Update the substitution to solve a type constraintApply a substitution to a type 2Make sure that an unknown does not occur in a type2Compute a list of all unknowns appearing in a type2Unify two types, updating the current substitution9Align two rows of types, splitting them into three parts:%Those types which appear in both rows#Those which appear only on the left$Those which appear only on the rightINote: importantly, we preserve the order of the types with a given label.1Unify two rows, updating the current substitutionCommon labels are identified and unified. Remaining labels and types are unified with a trailing row unification variable, if appropriate.>Replace a single type variable with a new unification variable$Replace type wildcards with unknownsJReplace outermost unsolved unification variables with named type variables      RNone!"$%&*,2:<=DLORT[b 5This type family tracks what evidence we return from  for each mode. %Value-level proxies for the two modes %Subsumption can operate in two modes:CElaboration mode, in which we try to insert type class dictionaries;No-elaboration mode, in which we do not insert dictionariesVSome subsumption rules apply in both modes, and others are specific to certain modes.The subsumption algorithm follows the structure of the types in question, and we can switch into no-elaboration mode when we move under a type constructor where we can no longer insert dictionaries, e.g. into the fields of a record. #The default coercion for each mode.YCheck that one type subsumes another, rethrowing errors to provide a better error message $Check that one type subsumes another      SNone!"$*,2:<=DLOT[b@Replace all top-level binders in a module with case expressions. ]Desugar case with pattern guards and pattern clauses to a series of nested case expressions. 2Validates that case head and binder lengths match.4Replace all top-level binders with case expressions.      TNone!"$*,2:<=DLOT[b Replace all DoNotationBind and DoNotationValueH constructors with applications of the bind function in scope, and all  DoNotationLet$ constructors with let expressions. Desugar a single do statement  UNone!"$*,2:<=DLOT[bVNone!"$*,2:<=DLOT[bAdd type synonym declarations for type class dictionary types, and value declarations for type class instance dictionary expressions.    WNone!"$*,2:<=DLOT[b4Desugars a module from AST to CoreFn representation. Find module names from qualified references to values. This is used to ensure instances are imported from any module that is referenced by the current module, not just from those that are imported explicitly (#667). ?Desugars import declarations from AST to CoreFn representation. @Desugars foreign declarations from AST to CoreFn representation. Desugars export declarations references from AST to CoreFn representation. CoreFn modules only export values, so all data constructors, class constructor, instances and values are flattened into one list. Makes a typeclass dictionary constructor function. The returned expression is a function that accepts the superclass instances and member implementations and returns a record for the instance dictionary. "Converts a ProperName to an Ident.  None!"$*,2:<=DLOT[b9 !"#$%&'-()*+,./0189:;<=>?@AXNone!"$*,2:<=DLOT[biGenerate code in the simplified JavaScript intermediate representation for all declarations in a module.pqrstuvwxyz{|}None!"$*,2:<=DLOT[bpqrstuvwxyz{|}YNone!"$*,2:<=DLOT[b    ZNone!"$*,2:<=DLOT[b $The state object used in this module DA 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.,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.     [None!"#$*,2:<=DLOT[b!Options for the constraint solverEShould the solver be allowed to generalize over unsolved constraints?EShould the solver be allowed to defer errors by skipping constraints? QThree options for how we can handle a constraint, depending on the mode we're in. We solved this constraint CWe couldn't solve this constraint right now, it will be generalized DWe couldn't solve this constraint right now, so it has been deferred GA type substitution which makes an instance head match a list of types.Note: we store many types per type variable name. For any name, all types should unify if we are going to commit to an instance.The 1 tracks those constraints which can be satisfied. =Description of a type class dictionary with instance evidence FDescribes what sort of dictionary to generate for type class instances An existing named instance 3Warn type class with a user-defined warning message 2The IsSymbol type class for a given Symbol literal *Extract the identifier of a named instancePReplace type class dictionary placeholders with inferred type class dictionariesCheck that the current set of type class dictionaries entail the specified type class goal, and, if so, return a type class dictionary reference.iAdd a dictionary for the constraint to the scope, and dictionaries for all implied superclass instances. 5Check all pairs of values in a list match a predicate 4Check any pair of values in a list match a predicate  Solver optionsThe constraint to solve-The contexts in which to solve the constraint3Error message hints to apply to any instance errors        \None!"$*,2:<=DLOT[b )Additional constraints we need to satisfyGThe Environment which contains the relevant definitions and typeclassesThe typechecker stateThe user supplied type$The type supplied by the environment K(all accessors we found, all accessors we found that match the result type))Additional constraints we need to satisfyGThe Environment which contains the relevant definitions and typeclassesThe typechecker stateThe type we are looking for ]None!"#$*,2:<=DLOT[b eA binding group contains multiple value definitions, some of which are typed and some which are not.HThis structure breaks down a binding group into typed and untyped parts. The untyped expressions 8The typed expressions, along with their type annotations A map containing all expressions and their assigned types (which might be fresh unification variables). These will be added to the ? after the binding group is checked, so the value type of the Map. is chosen to be compatible with the type of .Infer the types of multiple mutually-recursive values, and return elaborated values including type class dictionaries and type annotations.  This function breaks a binding group down into two sets of declarations: those which contain type annotations, and those which don't. This function also generates fresh unification variables for the types of declarations without type annotations, returned in the  UntypedData structure. >Check the type annotation of a typed value in a binding group. FInfer a type for a value in a binding group which lacks an annotation. 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 message Infer a type for a value ;Infer the types of variables brought into scope by a binder Returns true if a binder requires its argument type to be a monotype. | If this is the case, we need to instantiate any polymorphic types before checking binders. 9Instantiate polytypes only when necessitated by a binder. LCheck the types of the return values in a set of binders in a case statement NCheck the type of a value, rethrowing errors to provide a better error message Check the type of a value 5Check the type of a collection of named record fieldsThe laxt parameter controls whether or not every record member has to be provided. For object updates, this is not the case. ^Check the type of a function application, rethrowing errors to provide a better error message.!This judgment takes three inputs:.The expression of the function we are applyingThe type of that function$The expression we are applying it toand synthesizes two outputs:The return typewThe elaborated expression for the function application (since we might need to insert type class dictionaries, etc.) (Check the type of a function application JEnsure a set of property names and value does not contain duplicate labels  YThe identifier we are trying to define, along with the expression and its type annotation.Names brought into scope in this binding group The identifier we are trying to define, along with the expression and its assigned type (at this point, this should be a unification variable).Names brought into scope in this binding group The function expressionThe type of the functionThe argument expression(The result type, and the elaborated term    ^None!"$*,29:;<=DLOT[b 4Check that type synonyms are fully-applied in a type 'Type check all declarations in a moduleWAt this point, many declarations will have been desugared, but it is still necessary to)Kind-check all types and add them to the  Environment*Type-check all values and add them to the  Environment%Bring type class instances into scopeProcess module importsType check an entire module and ensure all types and classes defined within the module that are required by exported members are also exported. index of type class argument = 7 _None!"$*,2:<=DLOT[b When deriving an instance for a newtype, we must ensure that all superclass instances were derived in the same way. This data structure is used to ensure this property. ~A list of superclass constraints for each type class. Since type classes have not been desugared here, we need to track this. >A list of newtype instances which were derived in this module. cExtract the name of the newtype appearing in the last type argument of a derived newtype instance.Note: since newtypes in newtype instances can only be applied to type arguments (no flexible instances allowed), we don't need to bother with unification when looking for matching superclass instances, which saves us a lot of work. Instead, we just match the newtype name.=Elaborates deriving instance declarations by code generation. Takes a declaration, and if the declaration is a deriving TypeInstanceDeclaration, elaborates that into an instance declaration via code generation.%                           "                            `None!"$*,2:<=DLOT[b,The desugaring pipeline proceeds as follows: $Remove signed literals in favour of negate applications3Desugar object literals with wildcards into lambdasDesugar operator sectionsDesugar do-notationBDesugar 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.5t     @aSafe!"$*,29:;<=DLORT[b;A replacement for WriterT IO which uses mutable references.5Run a Logger computation, starting with an empty log.      bNone!"$*,2:<=DILORT[b  A monad for running make actions #Determines when to rebuild a moduleNever rebuild this moduleAlways rebuild this module#Generated code for an externs file.AActions that require implementations when running in "make" mode.-This type exists to make two things abstract:;The particular backend being used (JavaScript, C++11, etc.).The details of how files are read/written etc.TGet 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.tGet the timestamp for the output files for a module. This should be the timestamp for the oldest modified file, or  !2 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.'Progress messages from the make process,Compilation started for the specified moduleRender a progress messageRebuild a single module.QThis function is used for fast-rebuild workflows (PSCi and psc-ide are examples).?Compiles in "make" mode, compiling each module separately to a .js file and an  externs.json file.If timestamps have not changed, the externs file can be used to provide the module's types without having to typecheck the module again. Execute a  P monad, returning either errors, or the result of the compile plus any warnings.Run an  " action in the  ; monad, by specifying how IO errors should be rendered as  values.Read a text file in the  ( monad, capturing any errors using the  # instance. ZInfer the module name for a module by looking for the same filename with a .js extension.!KA set of make actions that read and write modules from the given directory. $oCheck that the declarations in a given PureScript module match with those in its corresponding foreign module.     !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? $"#     !    !      ! $"#cNone!"$*,2:<=DLOT[b1 7#0123456KLMNOUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%,&'()*+-./0123456789:;<=>?@ABCDEFHJIKLMNOPXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'HIJKLMNOPQRSTUVWXYZcfd^_abgi[\]`ehjklmnopqrstuvwyxz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdest     =>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|     !111dNone!"$*,25:<=DLOT[b3+A link to a declaration in the same module.4A link to a declaration in a different module, but still in the current package; we need to store the current module and the other declaration's module.5A link to a declaration in a different package. We store: current module name, name of the other package, version of the other package, and name of the module in the other package that the declaration is in.6A link to a declaration that is built in to the compiler, e.g. the Prim module. In this case we only need to store the module that the builtin comes from (at the time of writing, this will only ever be Prim).H`Minimum allowable version for generating data with the current parser, and actual version used.X@A type instance declaration, with its dependencies and its type.Y,A data constructor, with its type arguments.ZA 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  & would be `forall a. a -> f a`.aA 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 i 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 i.b#A value declaration, with its type.cA data/newtype declaration, with the kind of declaration (data or newtype) and its type arguments. Constructors are represented as child declarations.d*A data type foreign import, with its kind.e5A type synonym, with its type arguments and its type.fA type class, with its type arguments, its superclasses and functional dependencies. Instances and members are represented as child declarations.g[An operator alias declaration, with the member the alias is for and the operator's fixity.hA kind declarationThe version of the PureScript compiler which was used to generate this data. We store this in order to reject packages which are too old.The time format used for serializing package tag times in the JSON format. This is the ISO 8601 date format which includes a time and a timezone.RConvenience function for formatting a time in the format expected by this module.OConvenience function for parsing a time in the format expected by this module.>Discard any children which do not satisfy the given predicate.Given a links context, the current module name, the namespace of a thing to link to, its title, and its containing module, attempt to create a DocLink.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"}.23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcedhfgijmklnopqrstuvwxyz{|}~Ʊ{|}~yzxwvpqrstuijklmnoabcdefgh[\]^_`WXYZTUVQRSGHIJKLMNOPDEF<=>?@ABC789:;23456m23456789:;<=>?@ABCDEFG HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{ |}~eNone!"$*,2:<=DLOT[b 'An intermediate data type, used for either moving type class members under their parent type classes, or promoting them to normal Declaration values if their parent type class has not been re-exported. (Type class members which have not yet been dealt with. The Text is the name of the type class they belong to, and the constraint is used to make sure that they have the correct type if they get promoted. )A list of normal value declarations. Type class members will be added to this list if their parent type class is not available. *rA list of type class declarations. Type class members will be added to their parents in this list, if they exist.Given:The Imports/Exports Env<An order to traverse the modules (which must be topological)iA map of modules, indexed by their names, which are assumed to not have their re-exports listed yet.This function adds all the missing re-exports. +@Collect all of the re-exported declarations for a single module.We require that modules have already been sorted (P.sortModules) in order to ensure that by the time we convert a particular module, all its dependencies have already been converted. ,Assemble a list of declarations re-exported from a particular module, based on the Imports and Exports value for that module, and by extracting the declarations from the current state.This function works by searching through the lists of exported declarations in the Exports, and looking them up in the associated Imports value to find the module they were imported from. Additionally:Attempts to move re-exported type class members under their parent type classes, if possible, or otherwise, "promote" them from ChildDeclarations to proper Declarations.]Filters data declarations to ensure that only re-exported data constructors are listed.dFilters type class declarations to ensure that only re-exported type class members are listed. -Given a list of imported declarations (of a particular kind, ie. type, data, class, value, etc), and the name of an exported declaration of the same kind, together with the module it was originally defined in, return a tuple of:the module that exported declaration was imported from (note that this can be different from the module it was originally defined in, if it is a re-export),that same declaration's name.XThis function uses a type variable for names because we want to be able to instantiate name as both " and . .Extract a particular type declaration. For data declarations, constructors are only included in the output if they are listed in the arguments. /{Get the full list of declarations for a particular module out of the state, or raise an internal error if it is not there. 0Take a TypeClassEnv and handle all of the type class members in it, either adding them to their parent classes, or promoting them to normal Declaration values.*Returns a tuple of (values, type classes). 1Given a list of exported constructor names, remove any data constructor names in the provided Map of declarations which are not in the list. 2Given a list of exported type class member names, remove any data type class member names in the provided Map of declarations which are not in the list. 3If the provided Declaration is a TypeClassDeclaration, construct an appropriate Constraint for use with the types of its members. ' 4 ( ) * + , - 5 6 . 7 8 9 / : ; < 0 = 1 2 > ? @ A B 3 ' 4 ( ) * + , - 5 6 . 7 8 9 / : ; < 0 = 1 2 > ? @ A B 3fNone!"$*,2:<=DLOT[b CESome 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). DOThe 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.qNote that in the Left case, we provide a [Text] as well as augment information. The [Text] 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. E%Different declarations we can augment F&Augment documentation for a type class G,Augment documentation for a type constructoroConvert a single Module, but ignore re-exports; any re-exported types or values will not appear in the result. HAugment top-level declarations; the second pass. See the comments under the type synonym IntermediateDeclaration for more information. I!Create a basic Declaration value. C J D E F G H K I L M C J D E F G H K I L MgNone!"$*,2:<=DLOT[b Like convertModules, except that it takes a list of modules, together with their dependency status, and discards dependency modules in the resulting documentation."bConvert a group of modules to the intermediate format, designed for producing documentation from.Note that the whole module dependency graph must be included in the list; if some modules import things from other modules, then those modules must also be included.For value declarations, if explicit type signatures are omitted, or a wildcard type is used, then we typecheck the modules and use the inferred types. NwConvert a sorted list of modules, returning both the list of converted modules and the Env produced during desugaring. OIf any exported value declarations have either wildcard type signatures, or none at all, then typecheck in order to fill them in with the inferred types. P<Typechecks all the modules together. Also returns the final _, which is useful for adding in inferred types where explicit declarations were not provided. QtUpdates all the types of the ValueDeclarations inside the module based on their types inside the given Environment. RcPartially desugar modules so that they are suitable for extracting documentation information from.  !"# N O P Q S R !"#"# !  !"# N O P Q S RhNone!"$*,2:<=DLOT[b T<Specifies whether a PureScript source file is considered as: 1) with the Ed constructor, a target source file, i.e., we want to see its modules in the output 2) with the F 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 names!This function does the following:2Parse all of the input and dependency source filesmAssociate each dependency module with its package name, thereby distinguishing these from local modulesReturn the parsed modules and a Map mapping module names to package names for modules which come from dependencies. If a module does not exist in the map, it can safely be assumed to be local. T$ U V W$$ T$ U V WiNone!"$*,2:<=DLOT[b XlLookup the TypeClassData of a Prim class. This function is specifically not exported because it is partial.% Y Z [ \ X ] ^ _ ` a b c d e f g h i j k l m n%%% Y Z [ \ X ] ^ _ ` a b c d e f g h i j k l m njNone!"$*,2:<=DLOT[b &'()*+,-./012 &'()*+,-./012 &'()*+,-./012 &'()*+,-./012None!"$*,2:<=DLOT[bGHIJ      !"#$%&'()*+,-./01234O23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcedhfgijmklnopqrstuvwxyz{|}~ !"#$%&'()*+,-./012kNone!"$*,2:<=DLOT[bBAAn HtmlRenderContext for when you don't want to render any links.FQRender Markdown to HTML. Safe for untrusted input. Relative links are | removed.3456789:;<=>?@ABCD o p q rE s t uF v w x y3456789:;<=>?@ABCDEF=>?@9:;<345678BACDEF3456789:;<=>?@ABCD o p q rE s t uF v w x ylNone!"$*,2:<=DLOT[bLaTake a list of modules and render them all in order, returning a single Markdown-formatted Text.K z { |LM } ~N O KLMNOLKOMNK z { |LM } ~N O mNone!"$*,2:<=DLOT[bSTUVWXYZ[\]^_`abcdefghisuwyz{STVUWX^Y]Z[_\`abcdefghiyz!defghi`abcWXYZ[\]^_STUVssuuww{{yz STUVWXYZ[\]^_`abcdefghisuwyz{nNone!"$*,2:<=DLOT[b}~}~}~ }~oNone!"$*,2457:<=DLOT[b :A name tagged with a namespace <DDenotes the different namespaces a name in PureScript can reside in. A\A Pursuit Response for a module. Consists of the modules name and the package it belongs to BlA Pursuit Response for a declaration. Consist of the declaration's module, name, package, type summary text P+A completion as it gets sent to the editors [IdeVolatileState is derived from the  IdeFileState@ and needs to be invalidated and refreshed carefully. It holds AstData, which is the data we extract from the parsed ASTs, as well as the IdeDeclarations, which contain lots of denormalized data, so they need to fully rebuilt whenever  IdeFileState changes. The vsCachedRebuild field can hold a rebuild result with open imports which is used to provide completions for module private declarations ` IdeFileStateV holds data that corresponds 1-to-1 to an entity on the filesystem. Externs correspond to the ExternsFiles the compiler emits into the output folder, and modules are parsed ASTs from source files. This means, that we can update single modules or ExternsFiles inside this state whenever the corresponding entity changes on the file system. zgSourceSpans for the definition sites of values and types as well as type annotations found in a module                           ! " # $ % & ' ( ) * + 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 { | } ~                             ! " # $ % & ' ( ) * + 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 x t u v w y z { | } ~                           + * ) ( ' # $ % &    ! " 9 8 7 6 ~ }  | { y z s t u v w x m n o p q r i j k l h d e f g ` a b c [ \ ] ^ _ Y Z P Q R S T U V W X H I J K L M N O F G C D E @ A B < = > ? : ;W                           ! " # $ % & ' ( ) * + 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 { | } ~  pNone!"$*,2:<=DLOT[b     qNone!"$*,2:<=DLOST[b    rNone!"$*,2:<=DILOT[b    sNone!"$*,2:<=DLOST[b    tNone!"$*,2:<=DLOT[b    uNone!"$*,2:<=DLOT[b    vNone!"$*,2:<=DLOT[b   wNone!"$*,2:<=DILOT[b .Only keeps Identifiers in the given Namespaces Only keeps the given Modules 7Only keeps Identifiers that start with the given prefix :Only keeps Identifiers that are equal to the search string 5Only keeps Identifiers in the given type declarations     xNone!"$*,29:;<=DILOT[b =Matches any occurence of the search string with intersectionsThe scoring measures how far the matches span the string where closer is better. Examples: flMa matches flexMatcher. Score: 14.28 sons matches sortCompletions. Score: 6.25    yNone!"$*,2:<=DLOT[b Applies the CompletionFilters and the Matcher to the given Modules and sorts the found Completions according to the Matching Score   zNone!"$*,25:<=DLOT[b BContains the module with resolved reexports, and possible failures TUses the passed formatter to format the resolved module, and adds possible failures %Whether any Refs couldn't be resolved qResolves Reexports for the given Modules, by looking up the reexported values from the passed in DeclarationRefs     !Formatter for the resolved resultThe Result to be pretty printed  the references to resolve1Modules to search for the reexported declarations                         {None!"$*,2:<=DLOT[b -Extracts AST information from a parsed module ;Extracts type annotations for functions from a given Module uGiven a surrounding Sourcespan and a Declaration from the PS AST, extracts definition sites inside that Declaration.     %The declaration to extract spans from'Declarations and their source locations               |None!"#$*,2:<=DLOST[b Resets all State inside psc-ide Gets the loaded Modulenames Gets all loaded ExternFiles (Insert a Module into Stage1 of the State STM version of insertModule \Retrieves the FileState from the State. This includes loaded Externfiles and parsed Modules STM version of getFileState hRetrieves VolatileState from the State. This includes the denormalized Declarations and cached rebuilds STM version of getVolatileState )Sets the VolatileState inside Ide's state Checks if the given ModuleName matches the last rebuild cache and if it does returns all loaded definitions + the definitions inside the rebuild cache Adds an ExternsFile into psc-ide's FileState. This does not populate the VolatileState, which needs to be done after all the necessary Externs and SourceFiles have been loaded. STM version of insertExterns +Sets rebuild cache to the given ExternsFile Retrieves the rebuild cache OResolves reexports and populates VolatileState with data to be used in queries. $STM version of populateVolatileState !RLooks up the types and kinds for operators and assigns them to their declarations             ! "             ! "             ! "             ! "}None!"$*,2:<=DLOT[b '/Constructs Patterns to insert into a sourcefile # $ % & ' Current lineBegin of the splitEnd of the split%Whether to explicitly type the splitsConstructors to split (  # $ % & ' ( # $ % ' ( & # $ % & ' ( ~None!"$*,2:<=DLOT[b, ) * + , - . / 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) ) + * , - . / 0 1 4 : > 5 ? 7 9 6 ; 2 3 8 < = P @ A B C D E F G H I J K L M N O Q, 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 - . / 0 T ) * + , S R ) * + , - . / 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 TNone!"$*,2:<=DLOT[b  ImportParseD holds the data we extract out of a partial parse of the sourcefile the module name we parse dthe beginning of the import section. If `import Prelude` was the first import, this would point at i the end of the import section !the extracted import declarations YReads a file and returns the parsed modulename as well as the parsed imports, while ignoring eventual parse errors that aren't relevant to the import section bReads a file and returns the (lines before the imports, the imports, the lines after the imports) [Adds an implicit import like import Prelude to a Sourcefile. ]Adds a qualified import like import Data.Map as Map to a source file. Adds an explicit import like import Prelude (unit){ to a Sourcefile. If an explicit import already exists for the given module, it adds the identifier to that imports list.So &addExplicitImport "/File.purs" "bind" Prelude with an already existing import Prelude (bind) in the file File.purs returns  ["import Prelude (bind, unit)"] `>Looks up the given identifier in the currently loaded modules.2Throws an error if the identifier cannot be found.KIf exactly one match is found, adds an explicit import to the importsectionaIf more than one possible imports are found, reports the possibilities as a list of completions. cWrites a list of lines to  Just filepath and responds with a  TextResult, or returns the lines as a MultilineTextResult if Nothing" was given as the first argument. dTest and ghci helper W X Y Z [The source file read fromThe module to import \ ]The sourcefile read fromThe module to import#The qualifier under which to import ^ _ `The Sourcefile to read fromThe identifier to import,The optional qualifier under which to import5Filters to apply before searching for the identifier a b c d W X Y Z [ \ ] ^ _ ` a b c d [ ] ` c Y d b \ ^ _ Z a W X  W X Y Z [ \ ] ^ _ ` a b c dNone!"$*,2:<=DLOST[b ,Parameters we can access while building our  MakeActions g.Given a filepath performs the following steps:7Reads and parses a PureScript module from the filepath.VBuilds a dependency graph for the parsed module from the already loaded ExternsFiles.Attempts to find an FFI definition file for the module by looking for a file with the same filepath except for a .js extension.$Passes all the created artifacts to  rebuildModule.&If the rebuilding succeeds, returns a RebuildSuccessB with the generated warnings, and if rebuilding fails, returns a  RebuildError with the generated errors. dRebuilds a module but opens up its export list first and stores the result inside the rebuild cache Builds the default  MakeActions from a MakeActionsEnv -Shuts the compiler up about progress messages ZStops any kind of codegen (also silences errors about missing or unused FFI files though) Returns a topologically sorted list of dependent ExternsFiles for the given module. Throws an error if there is a cyclic dependency within the ExternsFiles Removes a modules export list. gThe file to rebuild6The file to use as the location for parsing and errors/A runner for the second build with open exports h i  g h i i h g  g h i None!"$*,2:<=DLOST[b jeAccepts a Commmand and runs it against psc-ide's State. This is the main entry point for the server. dFinds all the externs.json files inside the output folder and returns the corresponding Modulenames <Finds all matches for the globs specified at the commandline Looks up the ExternsFiles for the given Modulenames and loads them into the server state. Then proceeds to parse all the specified sourcefiles and inserts their ASTs into the state. Finally kicks off an async worker, which populates the VolatileState. j  j j j None!"$*,2:<=DLOST[b kReloads an ExternsFile from Disc. If the Event indicates the ExternsFile was deleted we don't do anything. k`Installs filewatchers for the given directory and reloads ExternsFiles when they change on disc k k k kNone!"$*,2:<=DLOT[b m"Pretty print a module's signatures l m l m l m l mNone!"$*,2:<=DLOT[b |Valid Meta-commands for PSCI }A purescript expression ~&Show the help (ie, list of directives) "Import a module from a loaded file Browse a module  Exit PSCI +Reload all the imported modules of the REPL Clear the state of the REPL 7Add some declarations to the current evaluation context Find the type of an expression Find the kind of an expression 5Shows information about the current state of the REPL Paste multiple lines -Return auto-completion output as if pressing tab OAll of the data that is contained by an ImportDeclaration in the AST. That is:=A module name, the name of the module which is being importedpAn ImportDeclarationType which specifies whether there is an explicit import list, a hiding list, or neither.gIf the module is imported qualified, its qualified name in the importing module. Otherwise, Nothing. The PSCI state.Holds a list of imported modules, loaded files, and partial let bindings. The let bindings are partial, because it makes more sense to apply the binding to the final evaluated expression. The PSCI configuration.:These configuration values do not change during execution. 1Updates the imported modules in the state record. 5Updates the loaded externs files in the state record. -Updates the let bindings in the state record. A list of all ReplQuery values.0 n o p q r s t u v w x y z { | } ~  0 n u t v x p o q r s w y z { |  } ~ 0 | } ~  y z { n o p q r s t u v w x n o p q r s t u v w x y z { | } ~    None!"$*,2:<=DLOT[b !List of all avaliable directives. RA mapping of directives to the different strings that can be used to invoke them. 0Like directiveStrings, but the other way around. List of all directive strings. ;Returns all possible string representations of a directive. 9Returns the default string representation of a directive. ~Returns the list of directives which could be expanded from the string argument, together with the string alias that matched. ?True if the given directive takes an argument, false otherwise. The help menu. None!"$*,2:<=DLOT[b -Loads module, function, and file completions. Callback for Haskeline's  Z. Expects: * Line contents to the left of the word, reversed * Word to be completed IConvert Haskeline completion result to results as they would be displayed Decide what kind of completion we need based on input. This function expects a list of complete words (to the left of the cursor) as the first argument, and the current word as the second argument. Given a module and a declaration in that module, return all possible ways it could have been referenced given the current PSCiState - including fully qualified, qualified using an alias, and unqualified. SReturns all the ImportedModule values referring to imports of a particular module.     None!"$*,2:<=DLOT[b  The guide URL The help message. The welcome prologue. The quit message.    None!"$*,2:<=DLOT[b #The name of the PSCI support module 'Checks if the Console module is defined "Loads a file for use with imports. Load all modules. :Makes a volatile module to execute the current expression. iMakes a volatile module to hold a non-qualified type synonym for a fully-qualified data type declaration. 7Makes a volatile module to execute the current imports. None!"$*,2:<=DLOT[b <Parses PSCI metacommands or expressions input from the user.,Parses expressions entered at the PSCI repl.eImports must be handled separately from other declarations, so that :show import works, for example.[Any declaration that we don't need a 'special case' parser for (like import declarations).To show error message when 'let'7 is used for declaration in PSCI, which is deprecated.             None!"$*,2:<=DLOT[bPretty-print errors &This is different than the runMake in cD in that it specifies the options and ignores the warning messages.ARebuild a module, using the cached externs data for dependencies. NBuild the collection of modules from scratch. This is usually done on startup. Performs a PSCi commandReload the application stateClear the application stateATakes a value expression and evaluates it with the current state.Takes a list of declarations and updates the environment, then run a make. If the declaration fails, restore the original environment.#Show actual loaded modules in psci."Show the imported modules in psci.:Imports a module, preserving the initial state on failure.!Takes a value and prints its type Takes a type and prints its kind*Browse a module and displays its signaturePReturn output as would be returned by tab completion, for tools integration etc.   evaluate JSreloadprint into consoleNDE l m n u t v x p o q r s w y z { |  } ~    None!"$*,2:<=DLOT[b 6An error that probably indicates a bug in this module. *An error that should be fixed by the user. RAn error which meant that it was not possible to retrieve metadata for a package.< !"#$ %&'()*+ ,-./0 ( (  !"#$       %&'()*+ ,-./0 None!"$*,2:<=DILOT[b 1.Listed in package manifest, but not installed.26In the resolutions file, there was no _resolution key.3Resolved, but to something other than a version. The Text argument is the resolution type. The values it can take that I'm aware of are "commit" and "branch".4OResolved to a version. The Text argument is the resolution tag (eg, "v0.1.0"). WHow to obtain the version tag and version that the data being generated will refer to. )What to do when the working tree is dirty ~Attempt to retrieve package metadata from the current directory. Calls exitFailure if no package metadata could be retrieved. cAttempt to retrieve package metadata from the current directory. Returns a PackageError on failure5-Given a git tag, get the time it was created.65Check if a string is a valid SPDX license expression.7Extracts all dependencies and their versions from a "resolutions" file, which is based on the output of `bower list --json --offline`8EExtracts only the top level dependency names from a resolutions file.-91234:;< =>         ?    5 @6AB 78CDEFG                             !91234:;< =>          ?    5 @6AB 78CDEFG H           !"#$%&'()*+,-./01234556789:;<=>?@ABCDEFGHIJKLMNOPQRSSTUVWWXYZ[\]^_`abcdefghijklmmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~%A      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE      F G H  I J K L  M N!O!P!Q"R"S"S"T"A"U"V"W"X"R#Y#Z#Z#[#\#]#^#_#`#a#b#c#d#e#f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$w$x$y$z$z${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % %S%S%9%9%%%%%%%%%%%>%%%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%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%{%|%}%~%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%R%%M%%%%%&&'''''''''''''(((((((( (( ((( ( ( (((((((((((((((((((( (!("(#($(%(&('((()(*(+(,(-(.(/((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/V0W0X0Y0Z0[0\0]00^0_0`0a0b0a0c0d0e0f0g0h0i0j0k0l0m0n00o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~0000000000000000000000000000001222222222222222222222222222222222334566666666789:::::;;;;;;;;;;<<<<<<<<<<===>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> > > > > >>>>>>>>>>>>>>>>>>>> >!>">#>$>%>&>'>(>)?*@+@,A-A.A/A0A1A2A3A4A5AA6A7A8B9C:C;C<C=D>D?D@DADBDBDCDDDEDFDGDHDIDIDJDKDLDMDNDODPDQDRDSDTDUDVDDWDWDXDYDZD[D\D]D^D_D`DaDbDcDdDeDfDgDhDiDjDkDlDmDnDoDpDqDrEsEtFuFvFwFxGyGzH{I|J}J~JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNOOOOOOPPPQQQQQQQ Q Q Q R SSSTUUVVVWXYZ[[[[[[[ [!["[#[$\%]&]'](])]*]+],^-^._/_0_1`2a3a3a4a5a6a7a8a9a:a;a<bbb=b>b?b@bAbBbBbCbDbEbFbGbHbIbJbKbLbMbNbObPbQbRbSbTbUbVbWbXbYbZb[b\b]b^b_b`cadbdcdddedfdgdgdhdidjdkdkdldmdndodpdqdrdVdsdtdudvdwdxdydzd{d|d}d~d~ddddddddddddddddddddddddddddddSdSddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd d d d d dddddddddddddddddddd d!d"dRd#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5e6e7e8f9f:g;g<g=g>h?i@jAjBjCjDjEjFjGjHjIjJjKjLjMkNkNkOkPkQkRkSkSkTkUkVkVkWkXkYkZk[k\k]k^k_k`kakblcldlelflglhliljmkmkmlmmmnmnmompmmqmrmAmsmmmtmumvmvmwmxmymzm{m|m}m~mmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o !o "o #o $o %o %o &o 'o (o )o *o +o ,o -o .o /o 0o 1o 2o 3o 4o 5o 6o 7o 8o 9o :o ;o ;o <o =o >o ?o @o Ao Bo Coo Do Eo Eo Fo Go Ho Io Jo Ko Lo Mo No No Oo Po Qo Ro So To Uo Vo Vo Wo Wo Xo Yo Zo [o [o \o ]o ^o ^o _o `o ao bo bo co do eo eo fo go ho io jo ko lo mo no oo po po qo ro so to uo vo wo xo yo zo {o |o }o ~o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o p p p p,p p p p p p q q rrr r r rr r r r r rr r r r r r rrrs4s s s t u u v v v v v v v v v v v v v w w w w w w w w w x x x x x y y y y y y y y y y y y y y y z z z z z z z z z z z z z {2{3{ { { | | | | | | | | | | | | | | | } } } } } } ~ ~ ~I~ ~ ~ ~ ~ ~ ~ ~ ~~ ~ ~ ~ ~ ~ !~ "~ #~ $~ %~ &~%~ '~ (~ )~ *~ +~ ,~ -~ .~ /~ 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 i j k l m m n o p q r s t u v w x y z { | } ~   ML N       n                       t       a                                      ! " # $ %] & ' ( ) * + , - . / 0 1 2S 3 4 5 6 7 8 9, : ;S < = > ? @ A B C D E F G H I J K L M N O P Q& R& S& T& U& V+ W+j+k+l+m+p+q+w+x+y+z+{+r+s+t+u+v++|+~++ X+ Y+ Z+ [+ \+ ]+ ^+ _+ `+ a+ b+ c+ d+ e+ f+ g, h/ i L M j0 k0 l0 m0 n0 o0 p0 q0 r1 s1 t1 u3 v3 w3 x3 y3 z3 {3 |3 }3 ~3 3 3 4 s4 t4 u5 : : : : : : : : : : : : : ; ; ; ; ; ; ; ;L; ; ; ; ; ; ; ; ; ;; ; ; < s<E<G< < < <L< < < < < < < < < < < = = = P= = = = = = = = ? ? ? ? ? ? ? ? L M ? ? ? ?? @ @ 8A A A A A A A A A A A AA A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A C C C C C C C C C C D D D D D E F G G G G G K K K L  L ML L L L L L L L L L N N N N N N N !N "N #N $P %Q R &R 'R (R )R *R +R ,R -R .S /S 0S 1S 2S 3S 4S 5S 6T 7V 8V 9V :VV ;V <V =VdV >V ?W @W AW BW CW DW EY FY GY HY IY JY KY LY MY NY OZ PZ QZ RZ SZ TZ UZ VZ WZ XZ YZ ZZ [Z \Z ]Z PZ ^[ _[ `[ 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] {] |] }] ~] ] ] ] "] $] ] ] ] ] ] ] ] ] ] ] y] ] ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ _ _ _ _ _ _ _ _ _ _ _ _ ___ _ _ _ _ _ _ _ _ _ _ z_ _ _ _ _ _ _ _ _ _ L M   b L M L M e e e e e e e e e e e Re e e e e e e e e e e e e e e ee f f f f f f f f f f f g g g g g g h h h h i i ii i i iiii i i)i i i i ii i i i i i k k k k k k k k k k k l l l l l l l ll l l p p q q q q q q q q q q q u u v !wSw w "w #w $w %w &x x 'x (x )x *x +x ,x -x .y /y /ySy 0y 1z 2{ 3| 4| 5| 6| 7| 8| 9| :| ;| <| =| >| ?| @} }} A} B} C} D} E} F} G} H} I J K L M N O P J Q R S T UQ V W X Y T Z [ \ ] ^ _ ` a b  c d e f g  h i j b k l m n o p q r s t u v w x y z { | } ~              &purescript-0.11.7-LYkkdaNPe76o3Ss2KvZX(Language.PureScript.Publish.BoxesHelpersSystem.IO.UTF8Language.PureScript.Traversals!Language.PureScript.Publish.Utils Language.PureScript.Parser.StateLanguage.PureScript.PSStringLanguage.PureScript.OptionsLanguage.PureScript.Label"Language.PureScript.Interactive.IO+Language.PureScript.Docs.Utils.MonoidExtrasLanguage.PureScript.Docs.CssLanguage.PureScript.CrashLanguage.PureScript.Comments Language.PureScript.Parser.LexerLanguage.PureScript.Bundle!Language.PureScript.AST.SourcePos!Language.PureScript.AST.Operators Language.PureScript.AST.LiteralsControl.Monad.SupplyControl.Monad.Supply.ClassLanguage.PureScript.Names%Language.PureScript.CodeGen.JS.CommonLanguage.PureScript.Constants"Language.PureScript.CoreFn.BindersLanguage.PureScript.CoreFn.Expr%Language.PureScript.CoreFn.TraversalsLanguage.PureScript.CoreFn.MetaLanguage.PureScript.Kinds!Language.PureScript.Parser.Common Language.PureScript.Parser.KindsLanguage.PureScript.TypesLanguage.PureScript.AST.BindersLanguage.PureScript.CoreFn.Ann!Language.PureScript.CoreFn.Module)Language.PureScript.TypeClassDictionariesLanguage.PureScript.Environment$Language.PureScript.AST.Declarations Language.PureScript.AST.Exported"Language.PureScript.AST.TraversalsLanguage.PureScript.CoreImp.AST,Language.PureScript.CoreImp.Optimizer.Blocks,Language.PureScript.CoreImp.Optimizer.Common-Language.PureScript.CoreImp.Optimizer.Inliner-Language.PureScript.CoreImp.Optimizer.MagicDo)Language.PureScript.CoreImp.Optimizer.TCO,Language.PureScript.CoreImp.Optimizer.Unused%Language.PureScript.CoreImp.Optimizer+Language.PureScript.Docs.RenderedCode.Types0Language.PureScript.Docs.RenderedCode.RenderKind!Language.PureScript.Pretty.Common&Language.PureScript.CodeGen.JS.Printer Language.PureScript.Pretty.Kinds$Language.PureScript.Sugar.LetPattern*Language.PureScript.Sugar.Operators.Common+Language.PureScript.Sugar.Operators.Binders(Language.PureScript.Sugar.Operators.Expr)Language.PureScript.Sugar.Operators.Types Language.PureScript.Parser.Types Language.PureScript.Pretty.Types0Language.PureScript.Docs.RenderedCode.RenderType!Language.PureScript.Pretty.ValuesLanguage.PureScript.Errors%Language.PureScript.Linter.Exhaustive&Language.PureScript.ModuleDependencies'Language.PureScript.Parser.Declarations&Language.PureScript.Sugar.Names.Common'Language.PureScript.Sugar.BindingGroups#Language.PureScript.Sugar.Names.Env'Language.PureScript.Sugar.Names.Exports'Language.PureScript.Sugar.Names.Imports"Language.PureScript.Linter.ImportsLanguage.PureScript.Linter*Language.PureScript.Sugar.TypeDeclarationsLanguage.PureScript.ExternsLanguage.PureScript.Sugar.Names#Language.PureScript.Sugar.Operators%Language.PureScript.TypeChecker.Monad%Language.PureScript.TypeChecker.Kinds'Language.PureScript.TypeChecker.Skolems(Language.PureScript.TypeChecker.Synonyms%Language.PureScript.TypeChecker.Unify+Language.PureScript.TypeChecker.Subsumption*Language.PureScript.Sugar.CaseDeclarations$Language.PureScript.Sugar.DoNotation)Language.PureScript.Sugar.ObjectWildcards%Language.PureScript.Sugar.TypeClasses"Language.PureScript.CoreFn.DesugarLanguage.PureScript.CodeGen.JS!Language.PureScript.CoreFn.ToJSONLanguage.PureScript.Renamer*Language.PureScript.TypeChecker.Entailment*Language.PureScript.TypeChecker.TypeSearch%Language.PureScript.TypeChecker.TypesLanguage.PureScript.TypeChecker.Language.PureScript.Sugar.TypeClasses.DerivingLanguage.PureScript.SugarControl.Monad.LoggerLanguage.PureScript.MakeLanguage.PureScriptLanguage.PureScript.Docs.Types*Language.PureScript.Docs.Convert.ReExports'Language.PureScript.Docs.Convert.Single Language.PureScript.Docs.Convert'Language.PureScript.Docs.ParseInPackageLanguage.PureScript.Docs.PrimLanguage.PureScript.Docs.RenderLanguage.PureScript.Docs.AsHtml#Language.PureScript.Docs.AsMarkdownLanguage.PureScript.Errors.JSONLanguage.PureScript.HierarchyLanguage.PureScript.Ide.TypesLanguage.PureScript.Ide.ErrorLanguage.PureScript.Ide.Externs*Language.PureScript.Ide.Filter.DeclarationLanguage.PureScript.Ide.LoggingLanguage.PureScript.Ide.PrimLanguage.PureScript.Ide.PursuitLanguage.PureScript.Ide.UtilLanguage.PureScript.Ide.FilterLanguage.PureScript.Ide.Matcher"Language.PureScript.Ide.Completion!Language.PureScript.Ide.Reexports"Language.PureScript.Ide.SourceFileLanguage.PureScript.Ide.State!Language.PureScript.Ide.CaseSplitLanguage.PureScript.Ide.CommandLanguage.PureScript.Ide.ImportsLanguage.PureScript.Ide.RebuildLanguage.PureScript.IdeLanguage.PureScript.Ide.Watcher'Language.PureScript.Interactive.Printer%Language.PureScript.Interactive.Types)Language.PureScript.Interactive.Directive*Language.PureScript.Interactive.Completion'Language.PureScript.Interactive.Message&Language.PureScript.Interactive.Module&Language.PureScript.Interactive.ParserLanguage.PureScript.Interactive*Language.PureScript.Publish.ErrorsWarningsLanguage.PureScript.PublishPaths_purescriptdesugarImportsLanguage.PureScript.ASTLanguage.PureScript.CoreImp%Language.PureScript.Docs.RenderedCodeLanguage.PureScript.PrettyText.Parsec.ErrorshowErrorMessagesLanguage.PureScript.ParserAxLanguage.PureScript.CoreFnLanguage.PureScript.CodeGenLanguage.PureScript.DocsMake"boxes-0.1.4-8r7hgbHhiwZ9TYlQbo7ovBText.PrettyPrint.BoxesnullBoxBoxfixCRLF readUTF8FileTwriteUTF8FileT readUTF8File writeUTF8FilefstMsndMthirdMpairMmaybeMeitherMdefS globRelativepurescriptSourceFileswidth indentWidthparaindentedsuccessivelyIndentedvcatspacer bulletedList bulletedListT printToStderr printToStdout ParseStateindentationLevel$fShowParseStatePSStringtoUTF16CodeUnitsdecodeStringWithReplacementdecodeStringEitherprettyPrintString decodeStringprettyPrintStringJSmkString$fFromJSONPSString$fToJSONPSString$fIsStringPSString$fShowPSString$fNFDataPSString $fEqPSString $fOrdPSString$fMonoidPSString$fGenericPSStringOptionsoptionsVerboseErrorsoptionsNoCommentsoptionsSourceMapsoptionsDumpCoreFndefaultOptions $fShowOptionsLabelrunLabel $fNFDataLabel $fShowLabel $fEqLabel $fOrdLabel$fIsStringLabel $fMonoidLabel $fToJSONLabel$fFromJSONLabel$fGenericLabelfindNodeProcessgetHistoryFilename mintersperse normalizeCss normalizeCssT pursuitCss pursuitCssT HasCallStack internalErrorComment LineComment BlockComment $fShowComment $fEqComment $fOrdComment$fFromJSONComment$fToJSONComment TokenParserPositionedToken ptSourcePosptEndPos ptPrevEndPosptToken ptCommentsTokenlex lexLenientanyTokentokenmatchlparenrparenparenslbracerbracebraceslsquarersquaresquaresindentindentAtlarrowrarrow lfatArrow rfatArrowcolon doubleColonequalspipetickdotcommasemiat underscoreholeLitsemiSepsemiSep1commaSep commaSep1lnamelname' qualifierreservedunameuname'tynamekiname dconsnamemnamesymbolsymbol' charLiteral stringLiteralnumbernatural identifierreservedPsNamesreservedTypeNames isSymbolChar isUnquotedKey$fShowPositionedToken $fShowToken $fEqToken $fOrdToken$fEqPositionedTokenModuleIdentifier ModuleTypeRegularForeign ErrorMessageUnsupportedModulePathInvalidTopLevelUnableToParseModuleUnsupportedExport ErrorInModuleMissingEntryPointMissingMainModule moduleNameguessModuleIdentifierprintErrorMessagegetExportedIdentifiersbundleSMbundle$fShowModuleType$fEqModuleType$fOrdModuleType$fShowModuleIdentifier$fEqModuleIdentifier$fOrdModuleIdentifier$fShowErrorMessage$fShowExportType$fEqExportType$fOrdExportType$fShowModuleElement $fShowModule SourceSpanspanName spanStartspanEnd SourcePos sourcePosLinesourcePosColumn SourceAnndisplaySourcePosdisplayStartEndPosdisplaySourceSpaninternalModuleSourceSpan$fFromJSONSourceSpan$fToJSONSourceSpan$fNFDataSourceSpan$fFromJSONSourcePos$fToJSONSourcePos$fNFDataSourcePos$fShowSourcePos $fEqSourcePos$fOrdSourcePos$fGenericSourcePos$fShowSourceSpan$fEqSourceSpan$fOrdSourceSpan$fGenericSourceSpanFixity AssociativityInfixlInfixrInfix Precedence showAssoc readAssoc$fToJSONFixity$fNFDataFixity$fFromJSONAssociativity$fToJSONAssociativity$fNFDataAssociativity$fShowAssociativity$fEqAssociativity$fOrdAssociativity$fGenericAssociativity $fShowFixity $fEqFixity $fOrdFixity$fGenericFixityLiteralNumericLiteral StringLiteral CharLiteralBooleanLiteral ArrayLiteral ObjectLiteral $fEqLiteral $fOrdLiteral $fShowLiteral$fFunctorLiteralSupplySupplyT unSupplyT runSupplyT evalSupplyT runSupply evalSupply$fFunctorSupplyT$fApplicativeSupplyT$fMonadSupplyT$fMonadTransSupplyT$fMonadErrorSupplyT$fMonadWriterSupplyT$fMonadReaderSupplyT$fAlternativeSupplyT$fMonadPlusSupplyT MonadSupplyfreshpeek freshName$fMonadSupplyWriterT$fMonadSupplyStateT$fMonadSupplySupplyT Qualified ModuleNameProperNameTypeTypeNameConstructorName ClassNameKindName Namespace ProperName runProperName OpNameType ValueOpName TypeOpNameOpName runOpNameIdentGenIdentName IdentName ValOpNameTyNameTyOpName DctorName TyClassNameModNameKiName getIdentName getValOpName getTypeName getKindName getTypeOpName getDctorName getClassName getModNamerunIdent showIdent freshIdent freshIdent'showOpcoerceProperName runModuleNamemoduleNameFromString showQualifiedgetQualqualify mkQualified disqualify disqualifyFor isQualified isUnqualifiedisQualifiedWith$fNFDataQualified$fNFDataModuleName$fFromJSONProperName$fToJSONProperName$fNFDataProperName$fFromJSONOpName$fToJSONOpName$fNFDataOpName $fNFDataIdent $fNFDataName $fShowIdent $fEqIdent $fOrdIdent$fGenericIdent $fShowOpName $fEqOpName $fOrdOpName$fGenericOpName$fShowProperName$fEqProperName$fOrdProperName$fGenericProperName$fShowModuleName$fEqModuleName$fOrdModuleName$fGenericModuleName$fEqName $fOrdName $fShowName $fGenericName$fShowQualified $fEqQualified$fOrdQualified$fFunctorQualified$fGenericQualified$fFromJSONQualified$fToJSONQualified$fFromJSONIdent $fToJSONIdent$fFromJSONModuleName$fToJSONModuleNamemoduleNameToJs identToJs properToJsidentNeedsEscapingidentCharToTextnameIsJsReservednameIsJsBuiltIn jsAnyReserved jsKeywordsjsSometimesReservedjsFutureReservedjsFutureReservedStrict jsOldReserved jsLiterals ControlBindRowConsUnionWarnFailPartialPrim RowListCons RowListNil RowToListTypeRow AppendSymbol CompareSymbolTypeDataSymbolIsSymbol DataSymbolDiscard$apply# applyFlipped<>++append>>=binddiscard+add-sub*mul/div%mod<lessThan> greaterThan<= lessThanOrEq>=greaterThanOrEq==eq/=notEqcompare&&conj||disj unsafeIndexorandxor<<<compose>>>composeFlippedmapnegatenotshlshrzshr complementzeroonebottomtopreturnpure' returnEscapeduntilEwhileErunST stRefValuenewSTRef readSTRef writeSTRef modifySTRefmkFnrunFnunit undefinedmonadEffDictionaryapplicativeEffDictionarybindEffDictionarydiscardUnitDictionarysemiringNumber semiringInt ringNumberringIntmoduloSemiringNumbermoduloSemiringInteuclideanRingNumbereuclideanRingInt ordBoolean ordNumberordInt ordStringordChareqNumbereqInteqStringeqChar eqBooleanboundedBooleanbooleanAlgebraBooleanheytingAlgebraBooleansemigroupStringsemigroupoidFngenerictoSpine fromSpine toSignaturetypeDataOrdering orderingLT orderingEQ orderingGTmainpartialtyp__unusedprimprelude dataArrayeffstcontrolApplicativecontrolSemigroupoid controlBind dataBounded dataSemigroupdataHeytingAlgebradataEqdataOrd dataSemiringdataRingdataEuclideanRing dataFunctiondataFunctionUncurried dataIntBits partialUnsafe unsafePartial unsafeCoerceunsafeCoerceFnBinder NullBinder LiteralBinder VarBinderConstructorBinder NamedBinderextractBinderAnn $fShowBinder$fFunctorBinderCaseAlternativecaseAlternativeBinderscaseAlternativeResultGuardBindNonRecRecExpr ConstructorAccessor ObjectUpdateAbsAppVarCaseLet extractAnn modifyAnn$fFunctorCaseAlternative$fShowCaseAlternative $fShowExpr $fFunctorExpr $fShowBind $fFunctorBindeverywhereOnValueseverythingOnValuesConstructorType ProductTypeSumTypeMeta IsConstructor IsNewtypeIsTypeClassConstructor IsForeign$fShowConstructorType$fEqConstructorType$fOrdConstructorType $fShowMeta$fEqMeta $fOrdMetaKindKUnknownRowFunKind NamedKind kindFromJSONeverywhereOnKindseverywhereOnKindsMeverythingOnKinds$fFromJSONKind $fToJSONKind $fNFDataKind $fShowKind$fEqKind $fOrdKind $fGenericKind properNametypeNamekindNamedataConstructorNameparseQualified parseIdent parseLabel parseOperatoraugmentfoldbuildPostfixParsermarkcheckIndentationsame readCommentsrunTokenParser toSourcePoswithSourceSpanwithSourceAnnFwithSourceSpan' parseKind ConstraintconstraintClassconstraintArgsconstraintDataConstraintDataPartialConstraintDataTypeTUnknownTypeVarTypeLevelString TypeWildcardTypeConstructorTypeOpTypeAppForAllConstrainedTypeSkolemREmptyRCons KindedTypePrettyPrintFunctionPrettyPrintObjectPrettyPrintForAllBinaryNoParensType ParensInType SkolemScoperunSkolemScopemapConstraintArgsoverConstraintArgs$fNFDataConstraint$fNFDataConstraintData $fNFDataType$fNFDataSkolemScope$fShowSkolemScope$fEqSkolemScope$fOrdSkolemScope$fToJSONSkolemScope$fFromJSONSkolemScope$fGenericSkolemScope$fShowConstraintData$fEqConstraintData$fOrdConstraintData$fGenericConstraintData$fShowConstraint$fEqConstraint$fOrdConstraint$fGenericConstraint $fShowType$fEqType $fOrdType $fGenericType$fFromJSONType $fToJSONType$fFromJSONConstraint$fToJSONConstraint rowToListrowToSortedList rowFromList isMonoTypemkForAllreplaceTypeVarsreplaceAllTypeVarsusedTypeVariablesfreeTypeVariablesquantifymoveQuantifiersToFrontcontainsWildcardscontainsForAlleverywhereOnTypeseverywhereOnTypesTopDowneverywhereOnTypesMeverywhereOnTypesTopDownMeverythingOnTypeseverythingWithContextOnTypes$fFromJSONConstraintData$fToJSONConstraintDataOpBinderBinaryNoParensBinderParensInBinderPositionedBinder TypedBinder binderNames isIrrefutable $fEqBinder $fOrdBinderAnnssAnnremoveComments ForeignDeclModulemoduleComments moduleImports moduleExports moduleForeign moduleDecls NamedDictTypeClassDictionaryInScopetcdValuetcdPath tcdClassNametcdInstanceTypestcdDependenciessuperclassName"$fNFDataTypeClassDictionaryInScope $fShowTypeClassDictionaryInScope#$fFunctorTypeClassDictionaryInScope$$fFoldableTypeClassDictionaryInScope'$fTraversableTypeClassDictionaryInScope#$fGenericTypeClassDictionaryInScope DataDeclTypeDataNewtypeTypeKindDataType TypeSynonym ExternDataLocalTypeVariable ScopedTypeVarNameKindPrivatePublicExternalNameVisibility UndefinedDefinedFunctionalDependency fdDeterminers fdDetermined TypeClassDatatypeClassArgumentstypeClassMemberstypeClassSuperclassestypeClassDependenciestypeClassDeterminedArgumentstypeClassCoveringSets EnvironmentnamestypesdataConstructors typeSynonymstypeClassDictionaries typeClasseskindsinitEnvironmentmakeTypeClassDatashowDataDeclTypeprimNameprimKindkindType kindSymbolprimTy tyFunctiontyStringtyChartyNumbertyInt tyBooleantyArraytyRecordisObject isFunctionisTypeOrAppliedfunction primKinds primTypes primClasseslookupConstructorisNewtypeConstructor lookupValue$fFromJSONDataDeclType$fToJSONDataDeclType$fNFDataDataDeclType$fFromJSONTypeKind$fToJSONTypeKind$fNFDataTypeKind$fNFDataNameKind$fNFDataNameVisibility$fToJSONFunctionalDependency$fFromJSONFunctionalDependency$fNFDataFunctionalDependency$fNFDataTypeClassData$fNFDataEnvironment$fShowFunctionalDependency$fGenericFunctionalDependency$fShowTypeClassData$fGenericTypeClassData$fShowNameVisibility$fEqNameVisibility$fGenericNameVisibility$fShowNameKind $fEqNameKind$fGenericNameKind$fShowTypeKind $fEqTypeKind$fGenericTypeKind$fShowDataDeclType$fEqDataDeclType$fOrdDataDeclType$fGenericDataDeclType$fShowEnvironment$fGenericEnvironment AssocList runAssocListPathNodeLeafBranchPathTreeDoNotationElementDoNotationValueDoNotationBind DoNotationLetPositionedDoNotationElement UnaryMinusBinaryNoParensParensObjectUpdateNestedOp IfThenElse TypedValueDo!TypeClassDictionaryConstructorAppTypeClassDictionaryTypeClassDictionaryAccessorDeferredDictionaryAnonymousArgumentHolePositionedValue GuardedExprConditionGuard PatternGuardTypeInstanceBodyDerivedInstanceNewtypeInstanceNewtypeInstanceWithDictionaryExplicitInstance TypeFixity ValueFixity DeclarationDataDeclarationDataBindingGroupDeclarationTypeSynonymDeclarationTypeDeclarationValueDeclarationBoundValueDeclarationBindingGroupDeclarationExternDeclarationExternDataDeclarationExternKindDeclarationFixityDeclarationImportDeclarationTypeClassDeclarationTypeInstanceDeclarationValueDeclarationDatavaldeclSourceAnn valdeclIdent valdeclNamevaldeclBindersvaldeclExpressionTypeDeclarationDatatydeclSourceAnn tydeclIdent tydeclTypeImportDeclarationTypeImplicitExplicitHidingDeclarationRefTypeRef TypeOpRefValueRef ValueOpRef TypeClassRefTypeInstanceRef ModuleRefKindRef ReExportRef HintCategoryExprHintKindHint CheckHint PositionHint SolverHint OtherHintErrorMessageHintErrorUnifyingTypesErrorInExpressionErrorInInstanceErrorInSubsumptionErrorCheckingAccessorErrorCheckingTypeErrorCheckingKindErrorCheckingGuardErrorInferringTypeErrorInApplicationErrorInDataConstructorErrorInTypeConstructorErrorInBindingGroupErrorInDataBindingGroupErrorInTypeSynonymErrorInValueDeclarationErrorInTypeDeclarationErrorInTypeClassDeclarationErrorInForeignImportErrorSolvingConstraintPositionedErrorSimpleErrorMessageModuleNotFoundErrorParsingFFIModuleErrorParsingModuleMissingFFIModuleMultipleFFIModulesUnnecessaryFFIModuleMissingFFIImplementationsUnusedFFIImplementationsInvalidFFIIdentifierCannotGetFileInfoCannotReadFileCannotWriteFile InfiniteType InfiniteKindMultipleValueOpFixitiesMultipleTypeOpFixitiesOrphanTypeDeclarationRedefinedIdentOverlappingNamesInLet UnknownName UnknownImportUnknownImportDataConstructor UnknownExportUnknownExportDataConstructor ScopeConflictScopeShadowing DeclConflictExportConflictDuplicateModuleDuplicateTypeClassDuplicateInstanceDuplicateTypeArgument InvalidDoBind InvalidDoLetCycleInDeclarationCycleInTypeSynonymCycleInModulesNameIsUndefinedUndefinedTypeVariablePartiallyAppliedSynonym EscapedSkolemTypesDoNotUnifyKindsDoNotUnifyConstrainedTypeUnifiedOverlappingInstancesNoInstanceFoundAmbiguousTypeVariables UnknownClassPossiblyInfiniteInstance CannotDeriveInvalidDerivedInstanceExpectedTypeConstructorInvalidNewtypeInstance MissingNewtypeSuperclassInstanceUnverifiableSuperclassInstanceCannotFindDerivingTypeDuplicateLabelDuplicateValueDeclarationArgListLengthsDifferOverlappingArgNamesMissingClassMemberExtraneousClassMember ExpectedTypeIncorrectConstructorArityExprDoesNotHaveTypePropertyIsMissingAdditionalPropertyTypeSynonymInstanceOrphanInstanceInvalidNewtypeInvalidInstanceHeadTransitiveExportErrorTransitiveDctorExportError ShadowedNameShadowedTypeVar UnusedTypeVarWildcardInferredTypeHoleInferredTypeMissingTypeDeclarationOverlappingPatternIncompleteExhaustivityCheckMisleadingEmptyTypeImportImportHidingModule UnusedImportUnusedExplicitImportUnusedDctorImportUnusedDctorExplicitImportDuplicateSelectiveImportDuplicateImportDuplicateImportRefDuplicateExportRef IntOutOfRangeImplicitQualifiedImportImplicitImport HidingImportCaseBinderLengthDiffersIncorrectAnonymousArgumentInvalidOperatorInBinder!CannotGeneralizeRecursiveFunctionCannotDeriveNewtypeForDataExpectedWildcardCannotUseBindWithDoClassInstanceArityMismatchUserDefinedWarningUnusableDeclaration TypeSearchTSBeforeTSAftertsAfterIdentifierstsAfterRecordFieldsContext MkUnguardedTypeFixityDeclarationValueFixityDeclaration ValueDeclonTypeSearchTypesonTypeSearchTypesM getModuleNamegetModuleSourceSpanaddDefaultImport importPrim compDecRefdeclRefSourceSpan declRefName getTypeRef getTypeOpRef getValueRef getValueOpRefgetTypeClassRef getKindRef isModuleRef isImplicit isExplicitoverTypeDeclarationgetTypeDeclarationunwrapTypeDeclarationoverValueDeclarationgetValueDeclarationmapTypeInstanceBodytraverseTypeInstanceBody declSourceAnndeclSourceSpandeclName isValueDecl isDataDecl isImportDeclisExternDataDeclisExternKindDecl isFixityDecl getFixityDecl isExternDeclisTypeClassInstanceDeclarationisTypeClassDeclaration flattenDecls$fEqDeclarationRef$fShowTypeSearch$fShowHintCategory$fEqHintCategory$fShowDeclarationRef$fGenericDeclarationRef$fNFDataDeclarationRef$fEqImportDeclarationType$fShowImportDeclarationType$fShowTypeDeclarationData$fEqTypeDeclarationData$fShowValueDeclarationData$fFunctorValueDeclarationData$fFoldableValueDeclarationData!$fTraversableValueDeclarationData$fEqValueFixity$fOrdValueFixity$fShowValueFixity$fEqTypeFixity$fOrdTypeFixity$fShowTypeFixity$fShowAssocList $fEqAssocList$fOrdAssocList$fFoldableAssocList$fFunctorAssocList$fTraversableAssocList$fShowPathTree $fEqPathTree $fOrdPathTree$fFunctorPathTree$fFoldablePathTree$fTraversablePathTree$fShowPathNode $fEqPathNode $fOrdPathNode$fFunctorPathNode$fFoldablePathNode$fTraversablePathNode$fShowDoNotationElement$fShowDeclaration$fShowGuardedExpr $fShowGuard$fShowTypeInstanceBody$fShowErrorMessageHint$fShowSimpleErrorMessage$fFromJSONDeclarationRef$fToJSONDeclarationRef isTrueExpr$fFromJSONImportDeclarationType$fToJSONImportDeclarationTypeexportedDeclarations isExported guardedExprMmapGuardedExprlitMeverywhereOnValuesTopDownMeverywhereOnValuesMeverythingWithContextOnValueseverywhereWithContextOnValuesMeverythingWithScope accumTypes accumKinds overTypesASTUnaryBinaryIndexerFunctionBlockVariableIntroduction AssignmentWhileForForInIfElseReturnReturnNoResultThrow InstanceOfBinaryOperatorAddSubtractMultiplyDivideModulusEqualTo NotEqualToLessThanLessThanOrEqualTo GreaterThanGreaterThanOrEqualToAndOr BitwiseAnd BitwiseOr BitwiseXor ShiftLeft ShiftRightZeroFillShiftRight UnaryOperatorNegateNot BitwiseNotPositiveNew getSourceSpan everywhereeverywhereTopDowneverywhereTopDownM everything$fShowUnaryOperator$fEqUnaryOperator$fShowBinaryOperator$fEqBinaryOperator $fShowAST$fEqASTcollapseNestedBlockscollapseNestedIfsapplyAll replaceIdent replaceIdents isReassigned isReboundisUsedtargetVariable isUpdatedremoveFromBlockisDictisDict' etaConvertunThunk evaluateIifesinlineVariablesinlineCommonValuesinlineCommonOperatorsinlineFnCompositioninlineUnsafeCoerceinlineUnsafePartialmagicDotcoremoveCodeAfterReturnStatementsremoveUnusedArgremoveUndefinedAppoptimize FixityAlias RenderedCodeRenderedCodeElementSyntaxKeywordSpaceSymbol ValueLevel TypeLevel KindLevelLinkNoLinkContainingModule ThisModule OtherModuleasContainingModulemaybeToContainingModulecontainingModuleToMaybefromContainingModule fromQualifiedasRenderedCodeElementasRenderedCode outputWithspsyntaxkeyword keywordForall keywordDatakeywordNewtype keywordType keywordClasskeywordInstance keywordWhere keywordFixity keywordKind keywordAsidentdataCtortypeCtortypeOptypeVarkindalias aliasName$fToJSONRenderedCode$fToJSONRenderedCodeElement$fFromJSONNamespace$fToJSONNamespace$fNFDataNamespace$fFromJSONLink $fToJSONLink$fFromJSONContainingModule$fToJSONContainingModule$fShowContainingModule$fEqContainingModule$fOrdContainingModule $fShowLink$fEqLink $fOrdLink$fShowNamespace $fEqNamespace$fOrdNamespace$fGenericNamespace$fShowRenderedCodeElement$fEqRenderedCodeElement$fOrdRenderedCodeElement$fShowRenderedCode$fEqRenderedCode$fOrdRenderedCode$fMonoidRenderedCode renderKind PrinterState PlainStringStrPosSMapEmitemit addMappingparensT parensPos intercalaterunPlainString addMapping'bumpPosaddPosemptyPrinterState blockIndent withIndent currentIndentprettyPrintManyobjectKeyRequiresQuotingbeforebeforeWithSpaceendWith$fEmitPlainString $fEmitStrPos$fMonoidStrPos$fMonoidPlainStringprettyPrintJSWithSourceMaps prettyPrintJSprettyPrintKinddesugarLetPatternModuleChaintoAssoc parseValueparseOpmatchOpopTablematchOperatorsmatchBinderOperatorsmatchExprOperatorsmatchTypeOperatorsnoForAll parseTypeAtom parseType parsePolyType noWildcardsprettyPrintRow typeAtomAsBoxprettyPrintTypeAtom typeAsBoxsuggestedTypeAsBoxprettyPrintTypeprettyPrintTypeWithUnicodeprettyPrintSuggestedTypeprettyPrintLabelprettyPrintObjectKeyRenderTypeOptionsprettyPrintObjects currentModule renderRow renderTyperenderTypeAtomdefaultRenderTypeOptionsrenderTypeWithOptionsrenderTypeAtomWithOptionsprettyPrintValueprettyPrintBinderAtomprettyPrintBinder PPEOptions ppeCodeColorppeFullppeLevel ppeShowDocsppeRelativeDirectoryLevelErrorWarningTypeMap umSkolemMap umUnknownMap umNextIndexMultipleErrorsrunMultipleErrorsErrorSuggestion errorSpan errorModulefindHintstripModuleAndSpan errorCodenonEmpty errorMessage errorMessage' singleErroronErrorMessagesaddHintaddHintsdefaultUnknownMapunwrapErrorMessagereplaceUnknownsonTypesInErrorMessageonTypesInErrorMessageM errorDocUrierrorSuggestionsuggestionSpanshowSuggestion ansiColoransiColorReset colorCode colorCodeBoxdefaultCodeColordefaultPPEOptionsprettyPrintSingleErrorprettyPrintExportprettyPrintImportprettyPrintRefprettyPrintMultipleErrorsprettyPrintMultipleWarningsprettyPrintMultipleWarningsBoxprettyPrintMultipleErrorsBoxprettyPrintMultipleErrorsWithprettyPrintParseErrorprettyPrintParseErrorMessageslinelineS renderBoxtoTypelevelStringrethrow reifyErrors reflectErrorswarnAndRethrowrethrowWithPositionwarnWithPositionwarnAndRethrowWithPosition withPositionescalateWarningWhenparU$fShowMultipleErrors$fMonoidMultipleErrors $fShowTypeMap $fShowLevelcheckExhaustiveExpr ModuleGraph sortModulesparseImportDeclaration'parseDeclarationRefparseDeclarationparseLocalDeclarationparseModuleDeclaration parseModuleparseModulesFromFilesparseModuleFromFiletoPositionedError parseBinderparseBinderNoParens parseGuardwarnDuplicateRefscreateBindingGroupsModulecollapseBindingGroupsModulecreateBindingGroupscollapseBindingGroups ExportModeInternalReExportEnvExports exportedTypesexportedTypeOpsexportedTypeClassesexportedValuesexportedValueOps exportedKindsImports importedTypesimportedTypeOpsimportedDataConstructorsimportedTypeClassesimportedValuesimportedValueOpsimportedModulesimportedQualModules importedKindsImportProvenance FromImplicit FromExplicitLocal ImportRecord importNameimportSourceModuleimportProvenance nullImports nullExportsenvModuleSourceSpanenvModuleImportsenvModuleExportsprimEnv exportType exportTypeOpexportTypeClass exportValue exportValueOp exportKind getExportscheckImportConflicts$fEqImportProvenance$fOrdImportProvenance$fShowImportProvenance$fEqImportRecord$fOrdImportRecord$fShowImportRecord $fShowImports $fShowExports$fEqExportMode$fShowExportModefindExportableresolveExports ImportDef findImportsresolveImportsresolveModuleImport UsedImports lintImportslintdesugarTypeDeclarationsModuleExternsDeclarationEDType EDTypeSynonymEDDataConstructorEDValueEDClass EDInstanceEDKind edTypeName edTypeKindedTypeDeclarationKindedTypeSynonymNameedTypeSynonymArgumentsedTypeSynonymTypeedDataCtorNameedDataCtorOriginedDataCtorTypeCtoredDataCtorTypeedDataCtorFields edValueName edValueType edClassNameedClassTypeArgumentsedClassMembersedClassConstraintsedFunctionalDependenciesedInstanceClassNameedInstanceNameedInstanceTypesedInstanceConstraints edKindNameExternsTypeFixityefTypeAssociativityefTypePrecedenceefTypeOperator efTypeAlias ExternsFixityefAssociativity efPrecedence efOperatorefAlias ExternsImporteiModule eiImportType eiImportedAs ExternsFile efVersion efModuleName efExports efImports efFixitiesefTypeFixitiesefDeclarations efSourceSpanapplyExternsFileToEnvironmentmoduleToExternsFile$fShowExternsImport$fShowExternsFixity$fShowExternsTypeFixity$fShowExternsDeclaration$fShowExternsFile$fFromJSONExternsImport$fToJSONExternsImport$fFromJSONExternsFixity$fToJSONExternsFixity$fFromJSONExternsTypeFixity$fToJSONExternsTypeFixity$fFromJSONExternsDeclaration$fToJSONExternsDeclaration$fFromJSONExternsFile$fToJSONExternsFiledesugarImportsWithEnvdesugarSignedLiterals rebracketrebracketFilteredcheckFixityExportsUnknown CheckStatecheckEnv checkNextType checkNextKindcheckNextSkolemcheckNextSkolemScopecheckCurrentModulecheckSubstitution checkHints Substitution substType substKindemptySubstitutionemptyCheckState bindNames bindTypeswithScopedTypeVarswithErrorMessageHintgetHintsrethrowWithPositionTCwarnAndRethrowWithPositionTCwithTypeClassDictionariesgetTypeClassDictionarieslookupTypeClassDictionariesbindLocalVariablesbindLocalTypeVariablesmakeBindingGroupVisiblewithBindingGroupVisiblepreservingNameslookupVariable getVisibilitycheckVisibilitylookupTypeVariablegetEnvgetLocalContextputEnv modifyEnvrunCheck runCheck' guardWithcaptureSubstitutioncapturingSubstitutionwithFreshSubstitutionwithoutWarningskindOfkindOfWithScopedVarskindsOf kindsOfAllnewSkolemConstantintroduceSkolemScopenewSkolemScope skolemizeskolemizeTypesInValueskolemEscapeCheck SynonymMapreplaceAllTypeSynonymsreplaceAllTypeSynonymsM freshType solveTypesubstituteTypeunknownsInType unifyTypes alignRowsWith unifyRowsreplaceVarWithUnknownreplaceTypeWildcards varIfUnknownsubsumesdesugarCasesModuledesugarCaseGuards desugarCasesdesugarDoModuledesugarObjectConstructors desugarDecldesugarTypeClassestypeClassMemberNamesuperClassDictionaryNamesmoduleToCoreFn moduleToJs moduleToJSONrenameInModules SolverOptionssolverShouldGeneralizesolverDeferErrorsInstanceContextreplaceTypeClassDictionariesentailsnewDictionaries$fShowEvidence $fEqEvidence$fShowEntailsResult typeSearchBindingGroupTypeRecursiveBindingGroupNonRecursiveBindingGrouptypesOf$fShowBindingGroupType$fEqBindingGroupType$fOrdBindingGroupType checkNewtypetypeCheckModulederiveInstances$fMonoidNewtypeDerivedInstances$fShowNewtypeDerivedInstancesdesugarLogger runLogger runLogger'$fMonadBaseControlIOLogger$fMonadBaseIOLogger$fMonadWriterwLogger$fMonadIOLogger $fMonadLogger$fApplicativeLogger$fFunctorLoggerunMake RebuildPolicy RebuildNever RebuildAlwaysExterns MakeActionsgetInputTimestampgetOutputTimestamp readExternscodegenprogressProgressMessageCompilingModulerenderProgressMessage rebuildModulemakerunMakemakeIO readTextFileinferForeignModulesbuildMakeActions$fMonadBaseControlIOMake$fMonadBaseIOMake$fShowProgressMessage$fEqProgressMessage$fOrdProgressMessage$fShowRebuildPolicy$fEqRebuildPolicy$fOrdRebuildPolicy $fFunctorMake$fApplicativeMake $fMonadMake $fMonadIOMake$fMonadErrorMake$fMonadWriterMake$fMonadReaderMakeversion LinkLocation SameModule LocalModule DepsModule BuiltinModuleDocLink linkLocation linkTitle linkNamespace LinksContext ctxGithub ctxModuleMapctxResolvedDependenciesctxPackageName ctxVersion ctxVersionTag InPackageFromDep PackageErrorCompilerTooOldErrorInPackageMetaInvalidVersionInvalidDeclarationTypeInvalidChildDeclarationType InvalidFixity InvalidKindInvalidDataDeclType InvalidTime GithubRepo runGithubRepo GithubUser runGithubUserChildDeclarationInfo ChildInstanceChildDataConstructorChildTypeClassMemberChildDeclaration cdeclTitle cdeclCommentscdeclSourceSpan cdeclInfoDeclarationInfoAliasDeclaration declTitle declComments declChildrendeclInfomodName modCommentsmodDeclarations modReExports ManifestErrorVerifiedPackageUploadedPackage NotYetKnownPackagepkgMeta pkgVersion pkgVersionTag pkgTagTime pkgModules pkgModuleMappkgResolvedDependencies pkgGithub pkgUploaderpkgCompilerVersion verifyPackage packageNamejsonTimeFormat formatTime parseTimeconvertFundepsToStringsdeclInfoToStringdeclInfoNamespace isTypeClassisValueisType isValueAlias isTypeAliasisKindfilterChildrenchildDeclInfoToStringchildDeclInfoNamespaceisTypeClassMemberisDataConstructor takeLocal takeLocals ignorePackagegetLinkgetLinksContextparseUploadedPackageparseVerifiedPackage asPackageparseTimeEitherasUploadedPackage asNotYetKnownasVerifiedPackagedisplayPackageError asGithubUser asVersion parseVersion'asModule asDeclaration asReExportpOr asInPackageasFixity asFixityAliasparseAssociativityasAssociativityasDeclarationInfoasTypeArgumentsasKindasType asFunDepsasDataDeclTypeasChildDeclarationasChildDeclarationInfo asSourcePos asConstraintasQualifiedProperNameasQualifiedIdent asModuleMapbookmarksAsModuleMapasResolvedDependenciesparsePackageName'mapLeftasGithub asSourceSpanassocListToJSON$fToJSONInPackage$fToJSONGithubRepo$fToJSONGithubUser$fToJSONChildDeclarationInfo$fToJSONDeclarationInfo$fToJSONChildDeclaration$fToJSONDeclaration$fToJSONModule$fToJSONNotYetKnown$fToJSONPackage$fFromJSONGithubUser$fFromJSONPackage$fFromJSONNotYetKnown$fNFDataLinkLocation$fNFDataDocLink$fNFDataLinksContext$fFunctorInPackage$fNFDataInPackage$fNFDataPackageError$fNFDataGithubRepo$fNFDataGithubUser$fNFDataChildDeclarationInfo$fNFDataChildDeclaration$fNFDataDeclarationInfo$fNFDataDeclaration$fNFDataModule$fNFDataNotYetKnown$fNFDataPackage$fShowNotYetKnown$fEqNotYetKnown$fOrdNotYetKnown$fGenericNotYetKnown$fShowDeclarationInfo$fEqDeclarationInfo$fOrdDeclarationInfo$fGenericDeclarationInfo$fShowChildDeclarationInfo$fEqChildDeclarationInfo$fOrdChildDeclarationInfo$fGenericChildDeclarationInfo$fShowChildDeclaration$fEqChildDeclaration$fOrdChildDeclaration$fGenericChildDeclaration$fEqDeclaration$fOrdDeclaration$fGenericDeclaration$fShowGithubUser$fEqGithubUser$fOrdGithubUser$fGenericGithubUser$fShowGithubRepo$fEqGithubRepo$fOrdGithubRepo$fGenericGithubRepo$fShowPackageError$fEqPackageError$fOrdPackageError$fGenericPackageError$fShowInPackage $fEqInPackage$fOrdInPackage$fGenericInPackage $fEqModule $fOrdModule$fGenericModule $fShowPackage $fEqPackage $fOrdPackage$fGenericPackage$fShowLinksContext$fEqLinksContext$fOrdLinksContext$fGenericLinksContext$fShowLinkLocation$fEqLinkLocation$fOrdLinkLocation$fGenericLinkLocation $fShowDocLink $fEqDocLink $fOrdDocLink$fGenericDocLinkupdateReExports$fMonoidTypeClassEnv$fShowTypeClassEnvconvertSingleModuleconvertCommentsconvertModulesInPackageconvertModulesInPackageWithEnvconvertModulesconvertModulesWithEnvparseFilesInPackagesprimDocsModulerenderDeclarationrenderDeclarationWithOptionsrenderChildDeclaration!renderChildDeclarationWithOptionsrenderConstraintrenderConstraintWithOptionsrenderConstraintsrenderConstraintsWithOptions notQualifiedident' dataCtor'typeApp toTypeVarHtmlRenderContextcurrentModuleName buildDocLink renderDocLinkrenderSourceLinkHtmlOutputModulehtmlOutputModuleLocalshtmlOutputModuleReExports HtmlOutput htmlIndex htmlModules declNamespacenullRenderContext packageAsHtml moduleAsHtml makeFragmentrenderMarkdown$fShowHtmlOutputModule$fFunctorHtmlOutputModule$fShowHtmlOutput$fFunctorHtmlOutputDocsrenderModulesAsMarkdownmodulesAsMarkdown codeToStringrunDocs $fShowFirst $fEqFirst $fOrdFirst JSONResultwarningserrors JSONErrorpositionmessage errorLinkfilename suggestion replacement replaceRange ErrorPosition startLine startColumnendLine endColumn$fShowErrorPosition$fEqErrorPosition$fOrdErrorPosition$fShowErrorSuggestion$fEqErrorSuggestion$fShowJSONError $fEqJSONError$fShowJSONResult$fEqJSONResult$fFromJSONErrorPosition$fToJSONErrorPosition$fFromJSONJSONError$fToJSONJSONError$fFromJSONJSONResult$fToJSONJSONResult toJSONErrors toJSONError$fFromJSONErrorSuggestion$fToJSONErrorSuggestionDigraph _unDigraph GraphName _unGraphNameGraph graphNamedigraphSuperMap _unSuperMap prettyPrinttypeClassGraphtypeClassPrologue typeClassBodytypeClassEpilogue superClasses $fOrdSuperMap $fEqSuperMap $fEqGraphName$fShowGraphName $fEqDigraph $fShowDigraph $fEqGraph $fShowGraphIdeTypeOperator_ideTypeOpName_ideTypeOpAlias_ideTypeOpPrecedence_ideTypeOpAssociativity_ideTypeOpKindIdeValueOperator_ideValueOpName_ideValueOpAlias_ideValueOpPrecedence_ideValueOpAssociativity_ideValueOpType IdeInstance_ideInstanceModule_ideInstanceName_ideInstanceTypes_ideInstanceConstraints IdeTypeClass _ideTCName _ideTCKind_ideTCInstancesIdeDataConstructor _ideDtorName_ideDtorTypeName _ideDtorTypeIdeTypeSynonym_ideSynonymName_ideSynonymType_ideSynonymKindIdeType _ideTypeName _ideTypeKind _ideTypeDtorsIdeValue_ideValueIdent _ideValueTypeIdeDeclaration IdeDeclValue IdeDeclTypeIdeDeclTypeSynonymIdeDeclDataConstructorIdeDeclTypeClassIdeDeclValueOperatorIdeDeclTypeOperator IdeDeclKind ModuleMap ModuleIdent$fShowIdeValue $fEqIdeValue $fOrdIdeValue$fGenericIdeValue$fNFDataIdeValue $fShowIdeType $fEqIdeType $fOrdIdeType$fGenericIdeType$fNFDataIdeType$fShowIdeTypeSynonym$fEqIdeTypeSynonym$fOrdIdeTypeSynonym$fGenericIdeTypeSynonym$fNFDataIdeTypeSynonym$fShowIdeDataConstructor$fEqIdeDataConstructor$fOrdIdeDataConstructor$fGenericIdeDataConstructor$fNFDataIdeDataConstructor$fShowIdeInstance$fEqIdeInstance$fOrdIdeInstance$fGenericIdeInstance$fNFDataIdeInstance$fShowIdeTypeClass$fEqIdeTypeClass$fOrdIdeTypeClass$fGenericIdeTypeClass$fNFDataIdeTypeClass$fShowIdeValueOperator$fEqIdeValueOperator$fOrdIdeValueOperator$fGenericIdeValueOperator$fNFDataIdeValueOperator$fShowIdeTypeOperator$fEqIdeTypeOperator$fOrdIdeTypeOperator$fGenericIdeTypeOperator$fNFDataIdeTypeOperator$fShowIdeDeclaration$fEqIdeDeclaration$fOrdIdeDeclaration$fGenericIdeDeclaration$fNFDataIdeDeclaration _IdeDeclValue _IdeDeclType_IdeDeclTypeSynonym_IdeDeclDataConstructor_IdeDeclTypeClass_IdeDeclValueOperator_IdeDeclTypeOperator _IdeDeclKind ideValueIdent ideValueType ideTypeDtors ideTypeKind ideTypeNameideSynonymKindideSynonymNameideSynonymType ideDtorName ideDtorTypeideDtorTypeNameideTCInstances ideTCKind ideTCNameideInstanceConstraintsideInstanceModuleideInstanceNameideInstanceTypesideValueOpAliasideValueOpAssociativityideValueOpNameideValueOpPrecedenceideValueOpType Annotation _annLocation_annExportedFrom_annTypeAnnotation_annDocumentationIdeDeclarationAnn_idaAnnotation_idaDeclarationideTypeOpAliasideTypeOpAssociativity ideTypeOpKind ideTypeOpNameideTypeOpPrecedence$fShowAnnotation$fEqAnnotation$fOrdAnnotation$fGenericAnnotation$fNFDataAnnotation$fShowIdeDeclarationAnn$fEqIdeDeclarationAnn$fOrdIdeDeclarationAnn$fGenericIdeDeclarationAnn$fNFDataIdeDeclarationAnnannDocumentationannExportedFrom annLocationannTypeAnnotation IdeNamespaced IdeNamespace IdeNSValue IdeNSType IdeNSKindPursuitResponseModuleResponseDeclarationResponsePursuitSearchType Identifier PursuitQuerySuccessCompletionResult TextResultMultilineTextResult PursuitResult ImportList ModuleListRebuildSuccess Completion complModulecomplIdentifier complTypecomplExpandedType complLocationcomplDocumentationcomplExportedFromMatchIdeVolatileState vsAstDatavsDeclarationsvsCachedRebuild IdeFileState fsExterns fsModulesIdeState ideFileStateideVolatileStateIdeIdeEnvironment ideStateVarideConfigurationIdeConfigurationconfOutputPath confLogLevel confGlobsconfEditorMode IdeLogLevelLogDebugLogPerfLogAll LogDefaultLogNoneAstDataTypeAnnotationsDefinitionSites idaAnnotationidaDeclarationemptyAnn emptyIdeStateemptyFileStateemptyVolatileStateidentifierFromDeclarationRef encodeSuccess encodeImport$fFromJSONIdeNamespace$fToJSONPursuitResponse$fFromJSONPursuitResponse$fFromJSONPursuitQuery$fFromJSONPursuitSearchType$fToJSONSuccess$fToJSONCompletion$fShowIdeLogLevel$fEqIdeLogLevel$fShowIdeFileState $fShowMatch $fEqMatch$fFunctorMatch$fShowCompletion$fEqCompletion$fOrdCompletion$fShowPursuitQuery$fEqPursuitQuery$fShowPursuitSearchType$fEqPursuitSearchType$fShowPursuitResponse$fEqPursuitResponse $fShowSuccess$fShowIdeNamespace$fEqIdeNamespace$fOrdIdeNamespace$fGenericIdeNamespace$fNFDataIdeNamespace$fShowIdeNamespaced$fEqIdeNamespaced$fOrdIdeNamespaced$fGenericIdeNamespaced$fNFDataIdeNamespaced $fShowAstData $fEqAstData $fOrdAstData$fGenericAstData$fNFDataAstData$fFunctorAstData$fFoldableAstData$fShowIdeVolatileState$fShowIdeStateIdeError GeneralErrorNotFoundModuleFileNotFound ParseError RebuildErrorprettyPrintTypeSingleLine$fToJSONIdeError$fShowIdeErrorreadExternFileconvertExternsdeclarationtypeDeclarationTypeValueSynonymDataConstructor TypeClass ValueOperator TypeOperatortypeDeclarationForDeclaration$fFromJSONIdeDeclaration$fFromJSONDeclarationType$fShowDeclarationType$fEqDeclarationType$fOrdDeclarationType labelTimespeclogPerfdisplayTimeSpecidePrimDeclarationssearchPursuitForDeclarationsfindPackagesForModuleIdentidentifierFromIdeDeclarationnamespaceForDeclaration discardAnn withEmptyAnn unwrapMatchvalueOperatorAliasTtypeOperatorAliasTencodeTdecodeT properNameTidentTopNameT ideReadFileFilternamespaceFilter moduleFilter prefixFilterequalityFilterdeclarationTypeFilter applyFilters$fFromJSONFilter$fMonoidFilterMatcher flexMatcher runMatcher$fFromJSONMatcher$fMonoidMatcherCompletionOptions coMaxResultscoGroupReexportsgetCompletionsgetExactMatchesgetExactCompletionsdefaultCompletionOptionsapplyCompletionOptions simpleExportcompletionFromMatch$fFromJSONCompletionOptions$fShowNamespaced$fEqNamespaced$fOrdNamespacedReexportResult reResolvedreFailedprettyPrintReexportResultreexportHasFailuresresolveReexportsresolveReexports'$fNFDataReexportResult$fShowReexportResult$fEqReexportResult$fFunctorReexportResult$fGenericReexportResultextractAstInformationextractTypeAnnotations extractSpans resetIdeStategetLoadedModulenamesgetExternFiles insertModule getAllModules insertExternsinsertExternsSTM cacheRebuild cachedRebuildpopulateVolatileStateSyncpopulateVolatileStatepopulateVolatileStateSTMresolveInstancesresolveOperatorsForModule resolveDataConstructorsForModuleWildcardAnnotationsexplicitAnnotations noAnnotations caseSplit makePattern addClauseListType LoadedModulesAvailableModules ImportCommandAddImplicitImportAddQualifiedImportAddImportForIdentifierCommandLoadLoadSyncCompletePursuit CaseSplit AddClauseImportListRebuild RebuildSyncCwdResetQuit typeFilterstypeCurrentModulecompleteFilterscompleteMatchercompleteCurrentModulecompleteOptions pursuitQuerypursuitSearchType caseSplitLinecaseSplitBegin caseSplitEndcaseSplitAnnotations caseSplitType addClauseLineaddClauseAnnotationslistType commandName$fFromJSONCommand$fFromJSONListType$fFromJSONImportCommand$fShowImportCommand$fEqImportCommandparseImportsFromFilesliceImportSectionaddImplicitImportaddImplicitImport'addQualifiedImportaddQualifiedImport'addExplicitImport'addImportForIdentifierprettyPrintImport'prettyPrintImportSection answerRequest parseImport $fEqImport $fShowImport rebuildFilerebuildFileAsyncrebuildFileSync handleCommandwatchertextTprintModuleSignatures DirectiveHelpReloadClearBrowseShowPaste ReplQuery QueryLoaded QueryImport ExpressionShowHelp BrowseModuleQuitPSCi ReloadState ClearStateDeclsTypeOfKindOfShowInfo PasteLines CompleteStrImportedModule PSCiStatepsciImportedModulespsciLetBindingspsciLoadedExterns PSCiConfig psciFileGlobspsciEnvironmentinitialPSCiStatepsciImportedModuleNames allImportsOfupdateImportedModulesupdateLoadedExterns updateLets replQueriesreplQueryStrings showReplQueryparseReplQuery$fShowPSCiConfig$fShowPSCiState $fEqReplQuery$fShowReplQuery $fShowCommand $fEqDirective$fShowDirective directivesdirectiveStringsdirectiveStrings'strings stringsFor stringFordirectivesFor' directivesFordirectiveStringsForparseDirective hasArgumenthelp CompletionMliftCompletionM completion completion'formatCompletions$fShowCompletionContextguideURL helpMessageprologueMessagenoInputMessagesupportModuleMessage quitMessagesupportModuleNamesupportModuleIsDefined loadModuleloadAllModulescreateTemporaryModulecreateTemporaryModuleForKindcreateTemporaryModuleForImports importDecl indexFile modulesDir internalSpan parseCommand OtherError ProcessFailedIOExceptionThrown JSONSourceFromFileFromResolutions InternalErrorCouldntParseGitTagDateRepositoryFieldErrorRepositoryFieldMissingBadRepositoryType NotOnGithub UserErrorPackageManifestNotFoundResolutionsFileNotFoundCouldntDecodePackageManifestTagMustBeCheckedOutAmbiguousVersionsBadRepositoryFieldNoLicenseSpecifiedInvalidLicenseMissingDependencies CompileErrorDirtyWorkingTreePackageWarningNoResolvedVersionUndeclaredDependencyUnacceptableVersionDirtyWorkingTree_Warn MissingPath printErrorprintErrorToStdout renderErrorrenderWarnings printWarnings$fMonoidCollectedWarnings$fShowPackageWarning$fShowRepositoryFieldError$fShowUserError$fShowJSONSource$fShowInternalError$fShowOtherError$fShowCollectedWarnings$fEqCollectedWarnings$fOrdCollectedWarningsPrepareMPublishOptionspublishGetVersionpublishGetTagTimepublishWorkingTreeDirtydefaultPublishOptionsunsafePreparePackagepreparePackage runPrepareMwarn userError otherErrorpreparePackage' getModulesgetGitWorkingTreeStatuscheckCleanWorkingTreegetVersionFromGitTaggetManifestRepositoryInfogetResolvedDependencies$fMonadIOPrepareM$fFunctorPrepareM$fApplicativePrepareM$fMonadPrepareM$fMonadWriterPrepareM$fMonadErrorPrepareM$fShowTreeStatus$fEqTreeStatus$fOrdTreeStatus$fEnumTreeStatus$fShowDependencyStatus$fEqDependencyStatuscatchIObindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName codePointsisLeadisTrail isSurrogatetoChartoWordtoIntmkdirponFirstFileMatching#text-1.2.2.2-KC7dWoG09dA1F6jKj5GSqhData.Text.InternalTextlangDef tokenParserisUnquotedKeyHeadCharisUnquotedKeyTailCharLexerLParenRParenLBraceRBraceLSquareRSquareIndentLArrowRArrow LFatArrow RFatArrowColon DoubleColonEqualsPipeTickDotCommaSemiAt UnderscoreLNameUName QualifierNumberHoleLitprettyPrintTokenupdatePositions parseTokensparseTokensLenient whitespace parseCommentparsePositionedToken parseTokenvalidModuleName validUNamenotElemT ModuleElement ExportTypeKeycheckImportPathwithDepstoModulecompile isModuleEmptycodeGenRequireMember ExportsListOtherSkip RegularExportForeignReexportshowModuleTypefromStringLiteralstrValue commaListtrailingCommaList matchRequire matchMembermatchExportsAssignment extractLabelbaseGHC.Base parseStar parseBangparseNamedKind parseKindAtomfilterDataConstructorsfilterInstancestypeInstanceConstituentsisDctorExportedreorder shouldInlineopAddopMulopEqopNotEq opLessThanopLessThanOrEq opGreaterThanopGreaterThanOrEqopAppendopSubopNegateopDivopModopConjopDisjopNotinlineSTuntilFixedPointMaybetryAlltryParseunpackFixityAliasRCunRCfirstEqasLink asNamespace typeLiteralsmatchRowfunKindprettyPrintJS'literalsaccessorindexerlamapp instanceOfunary'unarynegateOperatorbinaryprettyStatementsdesugarLetPattern parseFunction parseObjectparseTypeLevelStringparseTypeWildcardparseTypeVariableparseTypeConstructor parseForAllparseConstrainedTypetypeOrConstrainedType parseAnyTypeparseNameAndTypeparseRowEndingparseRowprettyPrintRowWithTypeRenderOptions troSuggesting troUnicodeconstraintsAsBoxconstraintAsBoxappliedFunctionkindedinsertPlaceholders constrainedexplicitParens matchTypeAtom matchTypeforall_suggestingOptionsunicodeOptions typeAsBoxImplprettyPrintType' renderHead renderLabel renderTailconvertconvertForAllspreprocessTypelistprettyPrintValueAtomellipsisprettyPrintObjectprettyPrintUpdateEntryprettyPrintLiteralValueprettyPrintDeclarationprettyPrintCaseAlternativeprettyPrintDoNotationElementprettyPrintLiteralBinderRedundancyError qualifyNamegetConstructors initialize genericMergemissingCasesSinglemissingCasesMultipleisExhaustiveGuard otherwise missingCasescheckExhaustive IncompletemissingAlternative usedModulesparseInfixExprindexersAndAccessors kindedIdentparseDataDeclarationparseTypeDeclarationparseTypeSynonymDeclarationparseValueWithWhereClauseparseValueWithIdentAndBindersparseValueDeclarationparseLocalValueDeclarationparseExternDeclaration parseFixityparseFixityDeclarationparseImportDeclarationparseTypeClassDeclarationparseConstraintparseInstanceDeclarationparseTypeInstanceDeclaration parseDerivingInstanceDeclarationbooleanLiteralparseNumericLiteralparseCharLiteralparseStringLiteralparseBooleanLiteralparseArrayLiteralparseObjectLiteralparseIdentifierAndValueparseAbsparseVarparseConstructor parseCaseparseCaseAlternativeparseIfThenElseparseLetparseValueAtom parseHoleparsePropertyUpdate parseAccessorparseDoparseDoNotationLetparseDoNotationBindparseDoNotationElementparseUpdaterBodyFieldsparseUpdaterBodyparseAnonymousArgumentparseNumberLiteralparseNullaryConstructorBinderparseConstructorBinderparseObjectBinderparseArrayBinderparseVarOrNamedBinderparseNullBinderparseIdentifierAndBinderparseBinderAtomtoBindingGroupcollapseBindingGroupsForValue usedIdentsusedImmediateIdents usedTypeNames declTypeNametoDataBindingGroup isTypeSynonym mkDeclaration fromValueDecl primExports addExportthrowDeclConflictthrowExportConflict ImportMap filterModule resolveImportlintImportDecl findUsedRefs matchName runDeclRefcheckDuplicateImportselaborateExportsreorderExportsrenameInModule FixityRecordGHC.NumTypeFixityRecordValueFixityRecordrebracketModule removeParensexternsFixitiescollectFixitiesensureNoDuplicatescustomOperatorTable updateTypesusingPredicate freshKind solveKindsubstituteKind occursCheck unifyKinds solveTypes starIfUnknowninfer freshKindVarinfer'replaceAllTypeSynonyms'CoercionModeSingModedefaultCoercion subsumes' SElaborate SNoElaborate Elaborate NoElaboratedesugarGuardedExprs validateCases desugarAbsstripPositioned inSameGrouptoDeclstoTuplemakeCaseDeclaration desugarDoDesugar MemberMap desugarModulememberToNameAndTypetypeClassDictionaryDeclaration#typeClassMemberToDictionaryAccessor!typeInstanceDictionaryDeclaration declIdentfindQualModulesimportToCoreFnexternToCoreFnexportToCoreFnmkTypeClassConstructor properToIdent literalToJSON identToJSONproperNameToJSONqualifiedToJSONmoduleNameToJSON bindToJSON recordToJSON exprToJSONcaseAlternativeToJSON binderToJSON RenameState rsBoundNames rsUsedNames runRenamenewScope updateScope lookupIdentfindDeclIdents renameInDecl renameInValuerenameInLiteralrenameInCaseAlternativerenameInBinderRename initState EntailsResultSolvedUnsolvedDeferredMatching TypeClassDictEvidence NamedInstance WarnInstanceIsSymbolInstancenamedInstanceIdentifier pairwiseAll pairwiseAnyCompareSymbolInstanceAppendSymbolInstance UnionInstance ConsInstanceRowToListInstancecombineContextsmatches mkContext pairwiseMcheckInEnvironment evalWriterT checkSubsumeaccessorSearchSplitBindingGroup_splitBindingGroupUntyped_splitBindingGroupTyped_splitBindingGroupNamestypeDictionaryForBindingGroupcheckTypedBindingGroupElementtypeForBindingGroupElement checkTypeKindinstantiatePolyTypeWithUnknowns inferBinderbinderRequiresMonotypeinstantiateForBinders checkBinderscheckcheck'checkPropertiescheckFunctionApplicationcheckFunctionApplication'ensureNoDuplicatePropertiesinferLetBindingcheckGuardedRhscheckTypeSynonyms typeCheckAll addDataTypeaddDataConstructoraddTypeSynonymvalueIsNotDefinedaddValue addTypeClassaddTypeClassDictionariescheckDuplicateTypeArgumentscheckTypeClassInstanceNewtypeDerivedInstances ndiClassesndiDerivedInstancesextractNewtypeNamederiveInstanceunwrapTypeConstructorderiveNewtypeInstance dataGenericdataGenericRep dataMaybe typesProxy dataNewtype dataFunctor unguarded deriveGenericderiveGenericRepcheckIsWildcardderiveEq deriveOrd deriveNewtype findTypeDecllamNulllamCaselamCase2mkVarMnmkVar labelToIdent objectType decomposeRec decomposeRec' deriveFunctorNothingghc-prim GHC.TypesIO mtl-2.2.1-BLKBelFsPB3BoFeSWSOYj6Control.Monad.Error.Class MonadErrorcheckForeignDeclspure Applicative TypeClassEnvenvUnhandledMembers envValuesenvTypeClasses getReExportscollectDeclarations findImportlookupTypeDeclarationlookupModuleDeclarations handleEnvfilterTypeClassMemberstypeClassConstraintForlookupValueDeclarationlookupValueOpDeclarationlookupTypeOpDeclarationlookupTypeClassDeclarationlookupKindDeclarationhandleTypeClassMembersvalsAndMembersToEnvtypeClassesToEnvsplitMapfilterExportedChildrenallDeclarations|>internalErrorInModuleDeclarationAugmentIntermediateDeclaration AugmentType AugmentClassaugmentDeclarations AugmentChildgetDeclarationTitlebasicDeclarationconvertDeclaration convertSortedtypeCheckIfNecessary typeCheckinsertValueTypespartiallyDesugar runParserFileInfo throwLeftfileInfoToString readFileAslookupPrimClass unsafeLookuplookupPrimTypeKindprimType primClassarrayrecordintstringcharbooleanfailunionrowCons typeConcat typeString declAsHtmlrenderChildren codeAsHtml renderLink fragmentForlinkToDeclaration renderAliasremoveRelativeLinksv withClasspartitionChildrenFirstNotFirstmoduleAsMarkdowndeclAsMarkdown childToStringtell' headerLevel fencedBlockticksencodeRebuildErrors textError ToResolveTypeClassToResolveSynonymToResolveresolveSynonymsresolveTypeClassesfindType findSynonym convertExport convertDeclconvertOperatorconvertTypeOperator queryPursuithandler ideReadFile'mkFilter moduleFilter'declarationFilterfilterModuleDecls runFilter ScoredMatchdistanceMatcherdistanceMatcher' mkMatchersortCompletions flexMatchflexRate flexScore NamespacedmatchesFromModulesgroupCompletionReexports resolveRef parseModule'insertModuleSTM getFileStategetFileStateSTMgetVolatileStategetVolatileStateSTMsetVolatileStateSTMresolveLocationsresolveLocationsForModuleconvertDeclaration'resolveDocumentationresolveDocumentationForModuleresolveOperatorsmapIffindTypeDeclarationfindTypeDeclaration'splitTypeConstructor prettyCtorprettyPrintWildcardprettyWildcard parseType'parseTypeDeclaration'splitFunctionType ImportParse ipModuleNameipStartipEnd ipImportsparseImportsFromFile'addExplicitImportparseModuleHeaderideSpanupdateAtFirstOrPrependMakeActionsEnvrebuildModuleOpen shushProgress shushCodegen sortExternsopenModuleExportsmaeOutputDirectorymaeFilePathMapmaeForeignPathMapmaePrefixComment isEditorModefindAvailableExternsfindAllSourceFilesloadModulesAsyncfindCompletionsfindPursuitCompletionsfindPursuitPackages printModulesoutputDirectorylistAvailableModulesloadModulesSync loadModules reloadFilehaskeline-0.7.3.0#System.Console.Haskeline.CompletioncompleteWordWithPrevcompletionContextgetAllQualificationsgetAllImportsOfCompletionContext CtxDirective CtxFilePath CtxModule CtxIdentifierCtxTypeCtxFixedcompleteDirective directiveArgcompleteImport headSatisfiesgetLoadedModulesgetModuleNamesmapLoadedModulesAndQualify getIdentNames getDctorNames getTypeNamesnubOnFst typeDecls identNames dctorNames moduleNamespsciExpression psciImportpsciDeclarationpsciDeprecatedLet parseRest psciCommandtrim trimStarttrimEnd acceptableparseReplQuery' printErrorsrebuildhandleReloadStatehandleClearStatehandleExpression handleDeclshandleShowLoadedModuleshandleShowImportedModules handleImport handleTypeOf handleKindOf handleBrowsehandleCompleteCollectedWarningsnoResolvedVersionsundeclaredDependenciesunacceptableVersionsdirtyWorkingTree missingPathsdisplayUserError spdxExamplesdisplayRepositoryErrordisplayInternalErrordisplayJSONSourcedisplayOtherErrorcollectWarningswarnNoResolvedVersionswarnUndeclaredDependencieswarnUnacceptableVersionswarnDirtyWorkingTreewarnMissingPathsMissing NoResolution ResolvedOtherResolvedVersion getTagTime isValidSPDXasToplevelDependenciesDependencyStatus TreeStatusCleanDirty unPrepareM catchLeft checkLicense extractGithub readProcess'asDirectoryAndDependencyStatuswarnUndeclared handleDepstryExtractVersiongetInputAndDepsFiles