,      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  6 None&246G      !"#$%&'()*+,-./0123456789:;<=>?@ABCDG      !"#$%&'()*+,-./0123456789:;<=>?@ABCD None*+-./*Einternal errorFmodule not foundGlAttempt to explicitly import a name which is not exported (or, possibly, does not even exist). For example: import Prelude(Bool(Right))The fields are: )optional parent in the import list, e.g. Bool in  Bool(Right)the name which is not exported)the module which does not export the nameH+type class is used where a type is expectedI+type is used where a type class is expectedJname is ambiguousKname is not in scopeL scope errorM no annotationNwildcard in a record construction expression. The list contains resolved names of the fields and information about values assigned to those fields.Oxwildcard in a record pattern. The list contains resolved names of the fields that are brought in scope by this pattern.Pexport( declaration, and the symbols it exportsQ part of an import declarationRimport: declaration, and the table of symbols that it introducesShere the type name is definedThere the value name is boundU-type variable, and location where it is boundV+local value, and location where it is boundW global typeX global valueY\A pair of the name information and original annotation. Used as an annotation type for AST.ZQualified name, where [] points to the module where the name was originally defined. The module part is never empty.MAlso contains name and version of the package where it was defined. If it's \6, then the entity is defined in the "current" package.]8Possibly qualified name. If the name is not qualified, [ is the empty string.[!String representing a module name^.String representing an unqualified entity name_uThe set of symbols (entities) exported by a single module. Contains the sets of value-level and type-level entities.`'Information about a type-level entititya type classb data familyc type familydnewtypee data typef type synonymg(Information about a value-level entitityhdata constructorirecord field selectorj class methodkvalue or functionlRepesents the symbol's fixitym Display a ]n Display an ZoDisplay an error.@Note: can span multiple lines; the trailing newline is included.FpEFGHIJKqLMNOPQRSTUVWXYrZst]uvw[^_xyz`abcdef{|ghi}~jklmnoApEFGHIJKqLMNOPQRSTUVWXYrZst]uvw[^_xyz`abcdef{|ghi}~jkmnopKJIHGFEq XWVUTSRQPONMLYrZst]uvw[^_xyz`fedcba{|{|{|{|{|{|gkjih}~}lmnoNoneCompute the extension set for the given module, based on the global preferences (e.g. specified on the command line) and module's LANGUAGE pragmas. base languageglobal extensions None++Global symbol table  contains global names NoneB1Local symbol table  contains locally bound namesNoneEF)Information about a field in the wildcardthe field's simple namethe field's original nameowhether there is a global value in scope with the same name as the field but different from the field selectorAInformation about the names being introduced by a record wildcardDuring resolving traversal, we always (lazily) construct this list when we process PRec or RecConstr, even if it doesn't contain a wildcard.]Then, if the pattern or construction actually contains a wildcard, we use the computed value. NoneIf < ("qualified"), then only the qualified names are inserted.If :, then both qualified and unqualified names are insterted.error for "not found" conditionerror for "not found" conditionNone2468MGet bound value identifiers.sFor record wildcards we need to know which fields the given constructor has. So we pass the global table for that.None(12346=HM\Contains information about the node's enclosing scope. Can be accessed through the lenses: , , , .:Describes how we should treat names in the current contextA type that implements < provides a way to perform a shallow scope-aware traversal.The algebra for L. It's newtype-wrapped because an implicit parameter cannot be polymorphic.Create an initial scope]Merge local tables of two scopes. The other fields of the scopes are assumed to be the same. Analogous to  , but for $ None 2346HMChain a sequence of nodes where every node may introduce some variables into scope for the subsequent nodes. Examples: patterns (see note [Nested pattern scopes]), statements.          None!"2346FJKMqLMNOPQRSTUVWXYrNone MvCompute module's global table. It contains both the imported entities and the global entities defined in this module.9Compute the symbols that are defined in the given module.[The import table is needed to resolve possible top-level record wildcard bindings, such as  A {..} = foo the import table for this module the import table for this module the import table for this moduleNone%Convert a GADT to a normal data type.None3Print some value. The printer. The state of the pretty printer.The current line.Current column. Current indentation level. Just outputted a newline? Output of printer Source mappings.The current output.Global options of the printerAre we to pretty print?Use pretty thunk names?Use pretty operators?-default printer options (non-pretty printing)Default state.!Print the given printer indented.kOutput a newline and makes next line indented when prPretty is True. Does nothing when prPretty is FalsegWrite out a raw string, respecting the indentation Note: if you pass a string with newline characters, it will print them out even if prPretty is set to False. Also next line won't be indented. If you want write a smart newline (that is the one which will be written out only if prPretty is true, and after which the line will be indented) use )7exec one of Printers depending on PrintReader property.PGenerate a mapping from the Haskell location to the current point in the output.>Write out a string, updating the current position information.Output concatenation!  !    ! Safe-Inferred ! ! ! !None24=BK"$A standard module monad transformer.i is the type of module info, m is the underlying monad.#tDifferent libraries (Cabal, haskell-src-exts, ...) use different types to represent module names. Hence this class.$1This class defines the interface that is used by %/, so that you can use it in monads other than ".tYou don't typically have to define your own instances of this class, but here are a couple of cases when you might: A pure (non-&*) mockup module monad for testing purposesA transformer over "7You need a more complex way to retrieve the module info'The type of module info(GRead the module info, given a list of search paths and the module name)@Convert module name from arbitrary representation to Cabal's one%~Tries to find the module in the current set of packages, then find the module's info file, and reads and caches its contents.Returns \ if the module could not be found in the current set of packages. If the module is found, but something else goes wrong (e.g. there's no info file for it), an exception is thrown.*Run a " action"+#,$'-.(/01)%*the monadic action to run~return value, plus all cached module infos (that is, the initial set plus all infos that have been read by the action itself)2345 "#,$'-.(%* "+#,$'-.(/01)%*2345None=K6786678None=FK9)This function takes care of the possible hiding clause :;<=>9 all symbolsmentioned symbolsimported symbols?@ABC; :;<=>9?@ABCNone=KMDTake a set of modules and return a list of sets, where each sets for a strongly connected component in the import graph. The boolean determines if imports using SOURCE are taken into account.EAnnotate a module with scoping information. This assumes that all module dependencies have been resolved and cached  usually you need to run F1 first, unless you have one module in isolation.GCompute interfaces for a set of mutually recursive modules and write the results to the cache. Return the set of import/export errors.FF takes a list of possibly recursive modules and computes the interface of each module. The computed interfaces are written into the mB's cache and are available to further computations in this monad.Returns the set of import/export errors. Note that the interfaces are registered in the cache regardless of whether there are any errors, but if there are errors, the interfaces may be incomplete.HLike FN, but also returns a list of interfaces, one per module and in the same orderDE base language6global extensions (e.g. specified on the command line) input moduleoutput (annotated) moduleG@module and all extensions with which it is to be compiled. Use  to build this list.F base language6global extensions (e.g. specified on the command line) input modules errors in export or import listsH base language6global extensions (e.g. specified on the command line) input modules4output modules, and errors in export or import listsEFHDEGFHNone'qLMNOPQRSTUVWXYrZst]uvw_xyzghi}~jkEHNoneI.Extract the module name from a qualified name.JExtract the name from a QName.K(Change or add the ModuleName of a QName.LExtract the string from a Name.IJMKNOLIJMKNOLIJMKNOLNonePThe CPP's parsing state."Parse some Fay code.QKApply incredibly simplistic CPP handling. It only recognizes the following: +#if FAY #ifdef FAY #ifndef FAY #else #endiflNote that this implementation replaces all removed lines with blanks, so that line numbers remain accurate.RThe parse mode for Fay.PSTU"QR#"#"#PUTS"QR#  Safe-Inferred VWXYZ[\]^_`abW]^_`ab VWXYZ[\]^_`ab!None)cdefghijklmnopqrstuvwxyz{|}~)cdefghijklmnopqrstuvwxyz{|}~)cdefghijklmnopqrstuvwxyz{|}~"None$$$#None$;The name of a module split into a list for code generation.&4Construct the complete ModulePath from a ModuleName.'FConstruct intermediate module paths from a ModuleName. mkModulePaths A.B => [[A], [A,B]](pConverting a QName to a ModulePath is only relevant for constructors since they can conflict with module names.$%&'($%&'($%&'( Safe-Inferred)3Alias of liftIO, I hate typing it. Hate reading it.*)Do any of the (monadic) predicates match?+ Flip of map.,3Read from a process returning both std err and out.)*+,\      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)*+,*+),)*+,$None24.Helpful for writing qualified symbols (Fay.*).Helpful for some things.Helpful for some things.'$'%None /Make an identifier from the built-in HJ module.<Mapping from unqualified names to qualified primitive names.:Lookup a primop that was resolved to a Prelude definition.[If this is resolved to a Prelude identifier or if it's unqualified, check if it's a primopNone- Error type.-./0123456789:;<=>?@ABCDEFGHI-./0123456789:;<=>?@ABCDEFGHI-IHGFEDCBA@?>=<;:9876543210/.-IHGFEDCBA@?>=<;:9876543210/.&NoneJThe serialization context indicates whether we're currently serializing some value or a particular field in a user-defined data type.MIThese are the data types that are serializable directly to native JS data types. Strings, floating points and arrays. The others are: actions in the JS monad, which are thunks that shouldn't be forced when serialized but wrapped up as JS zero-arg functions, and unknown types can't be converted but should at least be forced.JKLMNOPQRSTUVWXYZ[\JKLMNOPQRSTUVWXYZ[\JLKM\[ZYXWVUTSRQPON'None]Literal value type.cA name of some kind.oExpression type.Statement type.Just handy to have.?]^_`abcdefghijklmnopqrstuvwxyz{|}~>]^_`abcdefghijklmnopqrstuvwxyz{|}~]ba`_^c nmlkjihgfedo~}|{zyxwvutsrqpNone EFHMxConvert a Haskell value to a Fay json value. This can fail when primitive values aren't handled by explicit cases. & can be used to resolve this issue.Convert a Haskell value to a Fay json value. This can fail when primitive values aren't handled by explicit cases. When this happens, you can add additional cases via the first parameter.qThe first parameter is a function that can be used to override the conversion. This usually looks like using ' to additional type- specific cases.,Convert a Fay json value to a Haskell value.~Convert a Fay json value to a Haskell value. This is like readFromFay, except it yields helpful error messages on failure.,Convert a Fay json value to a Haskell value.qThe first parameter is a function that can be used to override the conversion. This usually looks like using ' to additional type- specific cases.%Parse a data type or record or tuple.Parse a tuple.(Parse a data constructor from an object.RMake a simple ADT constructor from an object: { "slot1": 1, "slot2": 2} -> Foo 1 2;Make a record from a key-value: { "x": 1 } -> Foo { x = 1 }Parse a float.Parse a double. Parse an int. Parse a bool.Parse a string. Parse a char. Parse a Text.Parse an array. Parse unit.None%DConfiguration of the compiler. The fields with a leading underscoreRun optimizationsFlatten function application?Export the runtime?Export the stdlib?Export only the stdlib?5Possibly a fay package name, and a include directory.Pretty print the JS output?-Output a HTML file including the produced JS.(Output a source map file as outfile.map.$Any JS files to link to in the HTML.%Don't invoke main in the produced JS.3Warn on dubious stuff, not related to typechecking.File path to output to.Typecheck with GHC.Typecheck with -Wall.&Run Google Closure on the produced JS.(The package config e.g. packages-6.12.3.Included Fay packages.#Custom source location for fay-baseProduce strict and uncurried JavaScript callable wrappers for all exported functions with type signatures in the given module:Only invoke GHC for typechecking, don't produce any output#Optimize away newtype constructors?Use pretty thunk names?Use pretty operators?Print commands sent to GHC?/Reading _configDirectoryIncludes is safe to do.8Get all include directories without the package mapping.:Get all include directories not included through packages.:Add a mapping from (maybe) a package to a source directory Add several include directories.;Add several include directories without package references.&Reading _configPackages is safe to do.Add a package to compilation#Add several packages to compilation5Should a strict wrapper be generated for this module?Default configuration.)%%(NoneEuGiven a configuration, resolve any packages specified to their data file directories for importing the *.hs sources.Resolve package.?Does a directory exist and does it contain any Haskell sources?Describe the given package.5Get the package version from the package description.!Make a share directory generator.None=BK%The JavaScript FFI interfacing monad.Compile monad.Uns the compiler+Configuration and globals for the compiler.The compilation configuration.#Things written out by the compiler. Constructors.Fay to JS dispatchers.JS to Fay dispatchers.State of the compiler.$Exported identifiers for all modulesMap types to constructorsMap constructors to fields3Newtype constructor, destructor, wrapped type tuple7Map of all imported modules and their source locations.LDepth of the current lexical scope, used for creating unshadowing variables.,Name of the module currently being compiled./Module paths that have code generated for them.5Use JS Strings instead of [Char] for string literals?9Module level declarations having explicit type signaturesSimple concatenating instance.  !$%&'(-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~o~}|{zyxwvutsrqp]ba`_^cnmlkjihgfed-IHGFEDCBA@?>=<;:9876543210/. !M\[ZYXWVUTSRQPON  JLK$%&'(  )None 3Wrap an expression in a thunk.Wrap an expression in a thunk.Generate unique names.>Resolve a given maybe-qualified name to a fully qualifed name.lResolve a given maybe-qualified name to a fully qualifed name. Use this when a resolution failure is a bug.Resolve a newtype constructor.Resolve a newtype destructor.&Qualify a name for the current module.6Qualify a QName for the current module if unqualified.Make a top-level binding.Force an expression in a thunk.(Is a JS expression a literal (constant)?7Deconstruct a parse result (a la maybe, foldr, either).Get a config option.Optimize pattern matching conditions by merging conditions in common. TODO This is buggy and no longer used. Fails on tests/case3Throw a JS exception.(Throw a JS exception (in an expression).Is an alt a wildcard?Is a pattern a wildcard?4Return formatter string if expression is a FFI call.CGenerate a temporary, SCOPED name for testing conditions and such.|Generate a temporary, SCOPED name for testing conditions and such. We don't have name tracking yet, so instead we use this.Print out a compiler warning.Pretty print a source location.(Lookup the record for a given type name. Get the fields for a given type.Get the flag used for GHC, this differs between GHC-7.6.0 and GHC-everything-else so we need to specially test for that. It's lame, but that's random flag name changes for you..Run the top level compilation for all modules.%Runs compilation for a single module.4Check if the given language pragmas are all present.if then else for when .'     '     '     *None3EFState.Optimize monad.The arity of a function. Arity here is defined to be the number of arguments that can be directly uncurried from a curried lambda abstraction. So x y z -> if x then (a -> a) else (a -> a) has an arity of 3, not 4.9Run an optimizer, which may output additional statements.&Inline x >> y to x;y in the JS output.Flatten a a>>(b>>c) to [a,b,c]. Try to collect nested a>>(b>>c).RPerform any top-level cross-module optimizations and GO DEEP to optimize further.Perform tail-call optimization.6Strip redundant forcing from the whole generated code.8Strip redundant forcing from an application if possible.OApply the given function to the top-level expressions in the given statements.NApply the given function to the top-level expressions in the given statement.9Collect functions and their arity from the whole codeset.Get the arity of an expression.'Change foo(x)(y) to foo$uncurried(x,y)./Rename an uncurried copy of a curried function. !" !" !"+None#MGet all non local identifiers that should be exported in the JS module scope.$=Is this *resolved* name a new type constructor or destructor?%.Is this *resolved* name a new type destructor?&/Is this *resolved* name a new type constructor?'>Add a ModulePath to CompileState, meaning it has been printed.('Has this ModulePath been added/printed?)+Find the type signature of a top level name#*$%&'()#*$%&'()#*$%&'(),None-36B +,-./0123+./0123+,-./0123-None4|Generate a temporary, SCOPED name for testing conditions and such. We don't have name tracking yet, so instead we use this.59Generates temporary names where the scope doesn't matter.6LDon't call this directly, use withScopedTmpName or unscopedTmpNames instead.45645456 None36;Top level, desugar a whole module possibly returning errorsDesugar with the option to specify a prefix for generated names. Useful if you want to provide valid haskell name that HSE can print.7(a f ) => b -> a f b (f b) => a -> a f b8)Convert do notation into binds and thens.97(,) => x y -> (x,y) (,,) => x y z -> (x,y,z) etc:*case { ... } => foo -> case foo of { ... };6if | p -> x | q -> y => case () of _ | p -> x | q -> y<(a,) => b -> (a,b)=!{a} => {a=a} for R{a} expressions>{a} => {a=a} for R{a} patterns?Desugar list comprehensions.@We only have Enum instance for Int, but GHC hard codes [x..y] syntax to GHC.Base.Enum instead of using our Enum class so we check for obviously incorrect usages and throw an error on them. This can only checks literals, but it helps a bit.A;Adds an explicit import Prelude statement when appropriate.BFor each toplevel FFI pattern binding, search the module for the relevant type declaration; if found, add a type signature to the ffi expression. e.g. foo :: Int foo = ffi "3" becomes foo :: Int foo = ffi "3" :: IntCa D/ b => op a b a + b => (+) a b for expressionsEa : b => (:) a b for patterns(a) => a for patterns78F9:;<=>?@AGBHICEJKL78F9:;<=>?@AGBHICEJKL None2The opposite of Ptr+. Serialize the specified polymorphic type. foo :: Automatic a -> String=Do not serialize the specified type. This is useful for, e.g. &foo :: String -> String foo = ffi "%1"`This would normally serialize and unserialize the string, for no reason, in this case. Instead: foo :: Ptr String -> Ptr String$Will just give an identity function.Values that may be undefined Defined x encodes to x, Undefined decodes to undefined. An undefined property in a record will be removed when encoding.HValues that may be null Nullable x decodes to x, Null decodes to null.Declare a foreign action. The foreign value.Bottom. .None M7Compile the given pattern against the given expression.N"Compile a pattern variable e.g. x.OCompile a record field pattern.P-Compile a literal value from a pattern match.Q#Compile as binding in pattern matchR%Compile a pattern match on a newtype.SCompile a pattern application.TCompile a pattern list.MNOPQRSTMNOPQRSTMNOPQRST/NoneUPrint the JS to a flat string.V Print the JS to a pretty string.WEEncode String to JS-format lterals. Could use the Text.JSON library.XPrints pretty operators. prPrettyOperator flag determines the way of accessing operators (e.g. `($)`) and identifiers with apostrophes (e.g. length'H). If prPrettyOperators is set true, then these will be accessed with square brackets (e.g. Prelude["$"] or Prelude["length'"]). Otherwise special characters will be escaped and accessed with dot (e.g. Prelude.$36$ or Prelude.length$39$). Alphanumeric_ identifiers are always accessed with dot operator (e.g. Prelude.length)YPrint a list of statements.ZUnqualify a JsName.['Print a constructor name given a QName.\Print an unqualified name.]<Print a constructor name given a Name. Helper for printCons.^bWords reserved in haskell as well are not needed here: case, class, do, else, if, import, in, let_eThis is a hack for names generated in the Haskell AST. Should be removed once it's no longer needed.$Encode a Haskell name to JavaScript.`3Normalize the given name to JavaScript-valid names.aIntercalate monoids.b Print one of the kinds of names.cPrint an expression.dPrint a module path.ePrint a single statement.f/Print special constructors (tuples, list, etc.)g#Print (and properly encode) a name.hPrint module name.i3Print (and properly encode to JS) a qualified name.jPrint literals.UVWXYZ[\]^k_`abcdefghijUVWXYZ[\]^k_`aUVWXYZ[\]^k_`abcdefghij0None 3ElKCompile an FFI expression (also used when compiling top level definitions).mLWarn about uses of naked x.y which will not play nicely with Google Closure.nMake a Fay!JS encoder.oA name used for transcoding.p?The name used for the forced version of a transcoding variable.q!Get arg types of a function type.r9Convert a Haskell type to an internal FFI representation.sExpand a type application.tGenerate a user-defined type.uTranslate: JS ! Fay.vTranslate: Fay ! JS.wMake a translator.xDGet a JS-representation of a fundamental type for encoding/decoding.yGet the arity of a type.z7Format the FFI format string with the given arguments.{.Generate n name-typ pairs from the given list.|Generate Fay!JS encoding.}Generate JS!Fay decoding.~Make a JS!Fay decoder.LThe argument types used in serialization of parametrized user-defined types.@Get the index of a name from the set of type variables bindings..Extract the name from a possibly-kinded tyvar.lmnopqrstuvwxyzSource Location.The format string. Arguments. The JS code.{|}~lny|}~lmnopqrstuvwxyz{|}~1None 246Compile Haskell expression.Compile variable.Compile Haskell literal.Compile simple application.Helper for compileApp.Compile a negate applicationCompile a let expression.Compile let declaration.Compile a list expression.Compile an if.Compile case expressions.7Compile the given pattern against the given expression.Compile a guarded alt.Compile guardsCompile a lambda.$Compile [e1..] arithmetic sequences.&Compile [e1..e3] arithmetic sequences.'Compile [e1,e2..] arithmetic sequences.)Compile [e1,e2..e3] arithmetic sequences.wCompile a record construction with named fields | GHC will warn on uninitialized fields, they will be undefined in JS.Compile a record update.Make a Fay list.5Optimize short literal [e1..e3] arithmetic sequences.8Optimize short literal [e1,e2..e3] arithmetic sequences.[Maximum number of elements to allow in strict list representation of arithmetic sequences.2None 246Compile Haskell declaration.Compile a declaration.!Compile a top-level pattern bind.(Compile a normal simple pattern binding.FCompile a data declaration (or a GADT, latter is converted to former).CCompile a function which pattern matches (causing a case analysis).%Compile a right-hand-side expression.3None The data-files source directory."The default compiler reader value.The default compiler state.4None'Call out to GHC to type-check the file.5None E$Start the compilation process using  compileModule to compile a file.Compile a module$Compile a module given its file path5Lookup a module from include directories and compile.Compile an import.<Find an import's filepath and contents from its module name.6None EPreprocess and collect all information needed during code generation.3Preprocess a module given its filepath and content.Preprocess from an AST PreprocessingFind newtype declarationsAdd new types to the state$Add record declarations to the stateNone  246M >Compile a Haskell source string to a JavaScript source string.!Compile the top-level Fay module.Compile a source string.-Compile given the location and source string.Compile a parse HSE module.6For a module A.B, generate | var A = {}; | A.B = {};ZGenerate exports for non local names, local exports have already been added to the module.7Generate strict wrappers for the exports of the module.sIs the module a standard module, i.e., one that we'd rather not output code for if we're compiling separate files.  " "  None 246 \Compile the given file and write the output to the given path, or if nothing given, stdout.fCompile the given file and write to the output, also generates HTML and sourcemap files if configured.Compile the given file.7Compile a file returning additional generated metadata.Compile a file returning the resulting internal state of the compiler. Don't use this directly, it's only exposed for the test suite..Compile the given module to a runnable module.,Convert a Haskell filename to a JS filename.,Print a compile error for human consumption.TGet the JS runtime source. This will return the user supplied runtime if it exists."Get the default JS runtime source. \ !-./0123456789:;<=>?@ABCDEFGHI7-IHGFEDCBA@?>=<;:9876543210/. ! 7899:;;<=>?@@ABCCDEFGHIJKLMNOPPQRSTU#V#W#X#Y#Z[\]^_`abcdefghijklmnopqrstuvwxyz{&|&}&~&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''   )             125       ! " # $ % & ' ( ) * + , - . / 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 { | } ~                                                        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG=HIJKKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop q r s t u v w x y z { | }!~!!!!!!!!!!!!!!K!!!!!!!!!!!!!!!!!!!!!!!!!!"~"""""""""""""""K""""""""""""""""""""#V        !"#$%&'()**+,-./01223456789:;<=>?@ABCDEFGHIJKLKMKNKOKPKQKRKSKTKUKVKWKXKYKZK[K\K]K^K_K`KaKbKcKdKeKfKgKhKiKjKkKlKmKnKoKpKqKrKsKtKuKvKwKxKyKzK{K|K}K~KKKKKKKKKKKKKKKK     II      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV W X Y Z [ \ ] ^ _`abcdefghijkljkmjknjkojkpjkqjkrjksjktjkujkvjkwjkxjkyjkzjk{jk|jk}jk~jkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjk$$$$~$$$$$$$$$$$$$$$$$K$$$$$$$$$$$$$$$$$$%%%%'(((((( ))))))))))))))))))))))))))))))))))))))***** * * * * ***********++++++++, , ,!,",",#,$,%,&--'-( ) * + , - . / 0 1 2 3 4 5678 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/[/\/]/^/_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u1v1w1x1y1z1{1|1}1~11111111111111122222223334555556666666  fay-0.23.1.3 Fay.TypesFay.Types.CompileResultFay.Compiler.ParseFay.Compiler.PreludeFay.Types.CompileError Fay.Convert Fay.Config Fay.CompilerFay.Compiler.DesugarFay.FFIFay#Language.Haskell.Names.Open.DerivedLanguage.Haskell.Names.Types"Language.Haskell.Names.SyntaxUtils(Language.Haskell.Names.GlobalSymbolTable'Language.Haskell.Names.LocalSymbolTable&Language.Haskell.Names.RecordWildcards!Language.Haskell.Names.ScopeUtilsLanguage.Haskell.Names.GetBound Language.Haskell.Names.Open.Base%Language.Haskell.Names.Open.Instances Language.Haskell.Names.Annotated$Language.Haskell.Names.ModuleSymbolsFay.Compiler.GADTFay.Types.PrinterFay.Compiler.ModuleTLanguage.Haskell.Names.ExportsLanguage.Haskell.Names.Imports Language.Haskell.Names.RecursiveLanguage.Haskell.NamesFay.Compiler.QName Paths_fayFay.ExtsFay.Exts.ScopedFay.Types.ModulePathFay.Exts.NoAnnotationFay.Compiler.PrimOp Fay.Types.FFI Fay.Types.JsFay.Compiler.PackagesFay.Compiler.MiscFay.Compiler.OptimizerFay.Compiler.StateFay.Compiler.Desugar.TypesFay.Compiler.Desugar.NameFay.Compiler.PatternFay.Compiler.PrintFay.Compiler.FFIFay.Compiler.ExpFay.Compiler.DeclFay.Compiler.DefaultsFay.Compiler.TypecheckFay.Compiler.ImportFay.Compiler.InitialPass PrintableprintJSPrinter runPrinter PrintStatepsLinepsColumn psIndentLevel psNewline PrintWriter pwMappingspwOutput PrintReaderprPrettyprPrettyThunksprPrettyOperatorsdefaultPrintReaderpwOutputStringdefaultPrintState execPrinterindentednewlinewriteaskIfmapping CompileResult resOutput resImportedresSourceMappingsparseFaydefaultExtensions ModulePath unModulePath mkModulePath mkModulePathsmkModulePathFromQNameioanyMforreadAllFromProcess CompileErrorUnsupportedWhereInMatchUnsupportedWhereInAltUnsupportedRhsUnsupportedRecursiveDoUnsupportedQualStmtUnsupportedPatternUnsupportedModuleSyntaxUnsupportedLiteralUnsupportedLetBindingUnsupportedLetUnsupportedImportUnsupportedFieldPatternUnsupportedExpressionUnsupportedExportSpecUnsupportedEnumUnsupportedDeclarationUnableResolveQualifiedShouldBeDesugared ParseErrorInvalidDoBlockGHCErrorFfiNeedsTypeSigFfiFormatNoSuchArgFfiFormatInvalidJavaScriptFfiFormatIncompleteArgFfiFormatBadChars EmptyDoBlockCouldn'tFindImportSerializeContextSerializeUserArgSerializeAnywhereFundamentalType UnknownType AutomaticPtrTypeBoolTypeIntType DoubleType StringTypeDateTypeNullableDefined UserDefined TupleTypeListTypeJsType FunctionTypeJsLitJsBool JsFloatingJsIntJsStrJsCharJsName JsModuleName JsBuiltIn JsConstructorJsTmpJsParamJsApplyJsForceJsThunkJsParametrizedTypeJsThis JsNameVarJsExpJsOrJsAnd JsUndefinedJsLitObjJsObjJsInfixJsNeqJsEqJsIndex JsInstanceOf JsThrowExpJsNewJsListJsUpdatePropExternJsGetPropExtern JsUpdatePropJsLookup JsGetPropJsParenJsNull JsTernaryIfJsNegAppJsAppJsFunJsSeqJsRawExpJsStmt JsExpStmtJsBlock JsContinueJsSetPropExternJsSetConstructor JsSetModule JsSetQName JsSetPropJsUpdateJsWhileJsThrow JsEarlyReturnJsIfJsVar showToFay encodeFay readFromFay readFromFay' decodeFayConfigconfigOptimizeconfigFlattenAppsconfigExportRuntimeconfigExportStdlibconfigExportStdlibOnlyconfigPrettyPrintconfigHtmlWrapperconfigSourceMapconfigHtmlJSLibs configLibrary configWarnconfigFilePathconfigTypecheck configWallconfigGClosureconfigPackageConfconfigBasePath configStrictconfigTypecheckOnlyconfigRuntimePathconfigOptimizeNewtypesconfigPrettyThunksconfigPrettyOperatorsconfigShowGhcCalls defaultConfigdefaultConfigWithSandboxconfigDirectoryIncludesconfigDirectoryIncludePaths%nonPackageConfigDirectoryIncludePathsaddConfigDirectoryIncludeaddConfigDirectoryIncludesaddConfigDirectoryIncludePathsconfigPackagesaddConfigPackageaddConfigPackagesshouldExportStrictWrapper CompileModuleCompile unCompile CompileReader readerConfigreaderCompileLitreaderCompileDecls CompileWriter writerCons writerFayToJs writerJsToFay CompileStatestateInterfacesstateRecordTypes stateRecords stateNewtypes stateImportedstateNameDepthstateModuleNamestateJsModulePathsstateUseFromString stateTypeSigsrunCompileModuledesugardesugar'desugarPatParendesugarExpParenPtr UndefinedNullffi compileExp compileDecl compileWith compileViaStrcompileToplevelModulecompileModuleFromContentscompileModuleFromAST compileFromTocompileFromToAndGenerateHtml compileFilecompileFileWithResultcompileFileWithStatetoJsNameshowCompileErrorgetConfigRuntime getRuntime$fGTraversablecModuleName$fGTraversablecSpecialCon$fGTraversablecQName$fGTraversablecName$fGTraversablecBoxed$fGTraversablecIPName$fGTraversablecQOp$fGTraversablecOp$fGTraversablecCName$fGTraversablecModule$fGTraversablecModuleHead$fGTraversablecExportSpecList$fGTraversablecExportSpec$fGTraversablecImportDecl$fGTraversablecImportSpecList$fGTraversablecImportSpec$fGTraversablecAssoc$fGTraversablecDecl$fGTraversablecAnnotation$fGTraversablecDataOrNew$fGTraversablecDeclHead$fGTraversablecInstHead$fGTraversablecInstRule$fGTraversablecDeriving$fGTraversablecBinds$fGTraversablecIPBind$fGTraversablecMatch$fGTraversablecQualConDecl$fGTraversablecConDecl$fGTraversablecFieldDecl$fGTraversablecGadtDecl$fGTraversablecClassDecl$fGTraversablecInstDecl$fGTraversablecBangType$fGTraversablecRhs$fGTraversablecGuardedRhs$fGTraversablecType$fGTraversablecTyVarBind$fGTraversablecKind$fGTraversablecFunDep$fGTraversablecContext$fGTraversablecAsst$fGTraversablecLiteral$fGTraversablecExp$fGTraversablecXName$fGTraversablecXAttr$fGTraversablecBracket$fGTraversablecSplice$fGTraversablecSafety$fGTraversablecCallConv$fGTraversablecModulePragma$fGTraversablecTool$fGTraversablecActivation$fGTraversablecRule$fGTraversablecRuleVar$fGTraversablecWarningText$fGTraversablecPat$fGTraversablecPXAttr$fGTraversablecRPatOp$fGTraversablecRPat$fGTraversablecPatField$fGTraversablecStmt$fGTraversablecQualStmt$fGTraversablecFieldUpdate$fGTraversablecAlt$fGTraversablecPromoted$fGTraversablecBooleanFormula$fGTraversablecTypeEqn$fGTraversablecOverlap$fGTraversablecSign$fGTraversablecNamespace EInternal EModNotFound ENotExported EClassAsType ETypeAsClass EAmbiguous ENotInScope ScopeErrorNoneRecExpWildcardRecPatWildcardExport ImportPartImport TypeBinder ValueBinderTypeVar LocalValue GlobalType GlobalValueScopedOrigName ModuleNameSbase Data.MaybeNothingGNameNameSSymbols SymTypeInfoSymClass SymDataFam SymTypeFam SymNewTypeSymDataSymType SymValueInfoSymConstructor SymSelector SymMethodSymValue SymFixityppGName ppOrigNameppErrorErrorNameInfo origGNamegModulegName HasOrigNameorigName st_origName st_fixity sv_typeNamesv_constructors sv_className sv_origName sv_fixity ExtensionSetvalSymstySymsmkValmkTysLoc$fSrcInfoScoped$fMonoidSymbols$fHasOrigNameSymTypeInfo$fHasOrigNameSymValueInfomoduleExtensionsdropAnn getModuleName getImportsgetModuleDeclsgetExportSpecList getModuleHead qNameToNamegetDeclHeadName nameToString stringToNamespecialConToStringunCName getErrorsgetModuleExtensionsTableResultSpecialvalLenstyLenstoGNameemptylookupL lookupValue lookupTypefromMaps fromListsvaluestypes toSymbols $fMonoidTableaddValueWcField wcFieldNamewcFieldOrigNamewcExistsGlobalValueWcNamesgetElidedFieldsnameOfPatFieldnameOfUpdField patWcNames expWcNames scopeErrornonenoScope sv_parentcomputeSymbolTableghc-prim GHC.TypesTrueFalse resolveCName resolveCNamesGetBoundgetBound getBoundSign$fGetBoundPatl$fGetBoundQualStmtl$fGetBoundStmtl$fGetBoundMatchl$fGetBoundClassDecll$fGetBoundFieldDecll$fGetBoundConDecll$fGetBoundGadtDecll$fGetBoundQualConDecll$fGetBoundDecll$fGetBoundBindsl$fGetBound(,)l$fGetBoundMaybel $fGetBound[]lScopegTablelTablenameCtxwcNames NameContext ResolvableAlg rtraverse initialScopemergeLocalScopesrmaptraverse-with-class-0.2.0.3Data.Generics.Traversablegmap_gTable_lTable_nameCtx_wcNamesOther ReferenceV ReferenceTBindingVBindingTConstraintProxyrunAlgalgdefaultRtraverseintro setNameCtx setWcNamesbinderVbinderTexprVexprT $fResolvableachainc<|-:$fResolvableSrcSpanInfo$fResolvableSrcSpan$fResolvableScoped$fResolvableQualStmt$fResolvable[]$fResolvableGuardedRhs$fResolvableAlt$fResolvableExp$fResolvableBinds$fResolvableMatch$fResolvablePatField$fResolvablePat$fResolvableFieldDecl$fResolvableConDecl$fResolvableDeclHead$fResolvableType$fResolvableDeclannotate annotateRec moduleTable moduleSymbols Constructors SelectorNameConNameTypeNamegetTopDeclSymbols convertGADT$fIsStringPrinter$fMonoidPrintWriterwriteRWS$fMonoidPrinterModuleTModName MonadModule getModuleInfotransformers-0.4.3.0Control.Monad.IO.ClassMonadIO ModuleInforeadModuleInfoconvertModuleName runModuleT modToString lookupInCache insertInCache ModuleName fromString$fMonadModuleModuleT$fMonadIOModuleT$fMonadTransModuleT $fModName[]processExportsresolveExportSpecListresolveExportSpeccomputeImportedSymbols preludeNameprocessImports processImportresolveImportDeclresolveImportSpecList symbolMapresolveImportSpecann2syms checkUnique$fModNameModuleName groupModulesannotateModulecomputeInterfaces findFixPoint getInterfacesqModNameunQual changeModuleunname unQualify changeModule' withIdentCPPStateapplyCPP parseModeCPPElseCPPIfNoCPPcatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameType TyVarBindStmtSrcLoc SpecialConRhsQualStmt QualConDeclQOpQNamePatFieldPatName ModulePragmaModuleMatchLiteral ImportSpec ImportDecl GuardedRhsGadtDecl FieldUpdate FieldDecl ExportSpecExpExDeclHeadDecl ClassDeclBangTypeAltX moduleName moduleExportsmoduleNameStringmkIdentnoIconvertFieldDeclfieldDeclNames declHeadNameSign srcSpanInfoGHC.Base++GHC.ErrerrorfoldrGHC.PrimseqGHC.Listconcatfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$ undefinedGHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negatefail>>=>>fmapreturn Control.Arrowfirst||| fromIntegral realToFrac toInteger toRational Control.MonadliftMjoinControl.Applicative<*>pure AlternativeBoundedEnumEq GHC.FloatFloating FractionalIntegralMonad Data.DataDataFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalTypeable MonadPlus ApplicativeBoolCharDoubleFloatInt integer-gmpGHC.Integer.TypeIntegerOrderingRationalIO Data.EitherEitherStringLeftRightLTEQGTMaybe<**> GHC.UnicodeisSpaceisAlphaisDigit Text.ReadreadmplusmzerogmapMogmapMpgmapMgmapQigmapQgmapQrgmapQlgmapT dataCast2 dataCast1 dataTypeOftoConstrgunfoldgfoldloptionalliftA3liftA2liftA<**>manysome<|>getConstConst unwrapMonad WrapMonad WrappedMonad unwrapArrow WrapArrow WrappedArrow getZipListZipList&&&***second+++ Data.Functionon Data.Functor<$>Prelude$!readIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputCharGHC.IO.ExceptionioError Data.Listunwordswordsunlineslinesproductsumfoldl1'foldl1foldl'unfoldrsortBysort permutations subsequencestailsinitsgroupBygroupdeleteFirstsByunzip7unzip6unzip5unzip4zipWith7zipWith6zipWith5zipWith4zip7zip6zip5zip4genericReplicate genericIndexgenericSplitAt genericDrop genericTake genericLength minimumBy maximumByminimummaximuminsertByinsert mapAccumR mapAccumL partition transpose intercalate intersperse intersectBy intersectunionByunion\\deleteBynubBynub isInfixOf isSuffixOf isPrefixOf findIndices findIndexfind elemIndices elemIndex stripPrefix dropWhileEnd Data.Char isSeparatorisSymbol isPunctuationisNumberisMarkisLettergeneralCategory digitToInttoTitletoUppertoLower isAsciiUpper isAsciiLowerGHC.IOFilePath userErrorIOErrorreads Data.Monoid<>mconcatmappendmemptyMonoidisRightisLeftpartitionEithersrightsleftseitherData.Ord comparingDown readLitChar lexLitCharlex readParenreadList readsPrecacoshatanhasinhcoshtanhsinhacosatanasincostansinlogBase**logsqrtpiatan2isIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadixlcmgcd^^^oddevendivModquotRemdivremquotrecip/floorceilingroundtruncateproperFractionmaxBoundminBoundfromEnumtoEnumpredsuccGHC.CharchrText.ParserCombinators.ReadPReadS intToDigit showLitChar showParen showStringshowCharshowsShowSshowListshow showsPrecmfilterapliftM5liftM4liftM3liftM2unlesswhen replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMvoidforever<=<>=>msumforM_forMfilterMmapM_mapM sequence_sequence=<<unzip3unzipzipWith3zipWithzip3!! concatMaplookupnotElemelemallanyorandreversebreakspansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrfoldr1scanl1scanlfoldllengthnullinitlasttailheadmapMaybe catMaybes listToMaybe maybeToList fromMaybefromJust isNothingisJustmaybeJustuncurrycurrysubtractsignumabs*+asTypeOfuntilflip.constidord<$isAsciiisLatin1 isControlisPrintisUpperisLower isOctDigit isHexDigit isAlphaNum/=compare<=&&||not<>maxmin safe-0.3.9Safe toEnumSafe toEnumNote toEnumDef toEnumMayfindIndexJustNotefindIndexJustDef findIndexJustelemIndexJustNoteelemIndexJustDef elemIndexJust findJustNote findJustDeffindJustlookupJustNote lookupJustDef lookupJustreadNotereadDefreadMayatNoteatDefatMayat assertNote fromJustNote fromJustDef scanl1Note scanr1Note scanl1Def scanr1Def scanl1May scanr1May foldl1Note' foldl1Note foldr1Note foldl1Def' foldl1Def foldr1Def foldl1May' foldl1May foldr1May maximumByNote minimumByNote maximumByDef minimumByDef maximumByMay minimumByMay maximumNote minimumNote maximumDef minimumDef maximumMay minimumMaylastNoteheadNotelastDefheadDeflastMayheadMayinitSafeinitNoteinitDefinitMaytailSafetailNotetailDeftailMayabort$fIsStringModuleName$fIsStringQName$fIsStringName SrcSpanInfoSrcSpanunAnn fayBuiltin primOpsMap findPrimOp resolvePrimOp$fIsStringJsLit syb-0.4.4Data.Generics.AliasesextQextRparseDataOrTuple parseTuple parseObject makeSimple makeRecord parseFloat parseDoubleparseInt parseBool parseString parseChar parseText parseArray parseUnit GenericParser encodeGeneric lookupField parseUTCTimebadData justRight_configDirectoryIncludes_configPackages$fDefaultConfigresolvePackagesresolvePackagedoesSourceDirExistdescribePackagepackageVersion getShareGen$fMonoidCompileWriter liftModuleT$fMonadModuleCompilethunk stmtsThunk uniqueNamestryResolveNameunsafeResolveNamelookupNewtypeConstlookupNewtypeDestqualify qualifyQName bindToplevelforce isConstant parseResultconfigoptimizePatConditionsthrowthrowExp isWildCardAlt isWildCardPatffiExpwithScopedTmpJsNamewithScopedTmpNamewarn printSrcLoc typeToRecs typeToFieldsgetGhcPackageDbFlag runTopCompilehasLanguagePragmasifOptimizeNewtypesorigName2QNamereplaceWithBuiltInsioWarnprintSrcSpanInfo printSrcSpan recToFieldsshouldBeDesugaredhasLanguagePragmaOptStateOptimize FuncArity runOptimizer inlineMonadflattencollectoptimizeTopleveltcostripAndUncurrywalkAndStripForcesapplyToExpsInStmtsapplyToExpsInStmt collectFuncsexpArityuncurryBindingrenameUncurriedoptStmts optUncurry!getNonLocalExportsWithoutNewtypes isNewtype isNewtypeDest isNewtypeCons addModulePathaddedModulePath findTypeSiggetLocalExportsWithoutNewtypesDesugar unDesugar DesugarReaderreaderNameDepth readerNoInforeaderTmpNamePrefix runDesugarunscopedTmpNamestmpNamedesugarSection desugarDodesugarTupleCon desugarLCasedesugarMultiIfdesugarTupleSectiondesugarFieldPundesugarPatFieldPundesugarListComp checkEnumdesugarImplicitPreludedesugarToplevelFFITypeSigsdesugarInfixOphaskell-src-exts-1.16.0.1%Language.Haskell.Exts.Annotated.BuildopdesugarInfixPat desugarStmt'desugarFFITypeSigsdesugarBindsTypeSigsaddFFIExpTypeSigs transformBi universeBi transformBiM compilePat compilePVarcompilePatFields compilePLit compilePAsPatcompileNewtypePat compilePApp compilePList printJSString printJSPretty toJsStringLit printProp printStmtsident printConsprintConsUnQual printConsName reservedWords encodeName normalizeName mintercalate$fPrintableJsName$fPrintableJsExp$fPrintableModulePath$fPrintableJsStmt$fPrintableSpecialCon$fPrintableName$fPrintableModuleName$fPrintableQName$fPrintableJsLitallowedNameChars compileFFIExp warnDotUses emitFayToJstranscodingObjtranscodingObjForcedfunctionTypeArgsargType expandApp userDefinedjsToFayfayToJs translatetypeRep typeArity formatFFI explodeFields fayToJsHash jsToFayHash emitJsToFayargTypesgetIndextyvar compileVar compileLit compileApp compileApp' compileNegApp compileLetcompileLetDecl compileList compileIf compileCase compilePatAltcompileGuardedAlt compileGuards compileLambdacompileEnumFromcompileEnumFromTocompileEnumFromThencompileEnumFromThenTocompileRecConstrcompileRecUpdatemakeList optEnumFromTooptEnumFromThenTomaxStrictASLen compileDeclscompilePatBindcompileUnguardedRhscompileDataDeclcompileFunCase compileRhsmkTyVars faySourceDirdefaultCompileReaderdefaultCompileState typecheck startCompilecompileModuleFromFilecompileModuleFromName compileImport findImport initialPasspreprocessFileWithSource preprocessASTscanNewtypeDeclscompileNewtypeDeclscanRecordDecls scanTypeSigscompileFileWithSourcecreateModulePathgenerateExportsgenerateStrictExportsanStdlibModulecompileToModule