h$~(      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                     7 None fay%Convert a GADT to a normal data type.None fayParse some Fay code. Safe-Inferred fay3Alias of liftIO, I hate typing it. Hate reading it.fay)Do any of the (monadic) predicates match?fay3Read from a process returning both std err and out. #'VU( )T*+ ,-.ghijklmnopqrts/0  12X3456^789_&%$:;<=" !>JM?@ABCDKLERPQFGHINOSWYZ[\]`abcfeduvwxyz{|}~ 'VU( )T*+ ,-/0  12X3456^89_&%$:;<=" !>JM?@ABCDKLERPQFGHINOSWYZ[]c#-/8feduvwxyz{|}~?\`ab.ghijklmnopqrts7=" ! None>$fay$A standard module monad transformer.i is the type of module info, m is the underlying monad.fayDifferent libraries (Cabal, haskell-src-exts, ...) use different types to represent module names. Hence this class.fay1This class defines the interface that is used by /, so that you can use it in monads other than .You 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 infofayThe type of module infofayRead the module info, given a list of search paths and the module namefayTries to find the module in the current set of packages, then find the module's info file, and reads and caches its contents.Returns K 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.fayRun a  actionfaythe monadic action to runfayreturn value, plus all cached module infos (that is, the initial set plus all infos that have been read by the action itself) Nonefay.Extract the module name from a qualified name.fayExtract the name from a QName.fay(Change or add the ModuleName of a QName.fayExtract the string from a Name.None C$fayConfiguration of the compiler. The fields with a leading underscorefayRun optimizationsfayFlatten function application?fayExport the runtime?fayExport the stdlib?fayExport only the stdlib?fayPretty print the JS output?fay-Output a HTML file including the produced JS.fay(Output a source map file as outfile.map.fay$Any JS files to link to in the HTML.fay%Don't invoke main in the produced JS.fay3Warn on dubious stuff, not related to typechecking.fayFile path to output to.fayTypecheck with GHC.fayTypecheck with -Wall.fay&Run Google Closure on the produced JS.fay(The package config e.g. packages-6.12.3.fay#Custom source location for fay-basefayProduce strict and uncurried JavaScript callable wrappers for all exported functions with type signatures in the given modulefay:Only invoke GHC for typechecking, don't produce any outputfay#Optimize away newtype constructors?fayUse pretty thunk names?fayUse pretty operators?fayPrint commands sent to GHC?fayOutput a TypeScript file.fay/Reading _configDirectoryIncludes is safe to do.fay8Get all include directories without the package mapping.fay:Get all include directories not included through packages.fay:Add a mapping from (maybe) a package to a source directoryfay Add several include directories.fay;Add several include directories without package references.fay&Reading _configPackages is safe to do.fayAdd a package to compilationfay#Add several packages to compilationfay5Should a strict wrapper be generated for this module?fayDefault configuration.&&None &$fayConvert 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.fayConvert 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.The first parameter is a function that can be used to override the conversion. This usually looks like using ' to additional type- specific cases.fay,Convert a Fay json value to a Haskell value.fayConvert a Fay json value to a Haskell value. This is like readFromFay, except it yields helpful error messages on failure.fay,Convert a Fay json value to a Haskell value.The first parameter is a function that can be used to override the conversion. This usually looks like using ' to additional type- specific cases.None$)None>%fay.Helpful for writing qualified symbols (Fay.*).fayHelpful for some things.fayHelpful for some things.$None &'3fay/Make an identifier from the built-in HJ module.fay:Lookup a primop that was resolved to a Prelude definition.fayIf this is resolved to a Prelude identifier or if it's unqualified, check if it's a primopNone 'fayGet the default runtime source. Safe-Inferred'None)fayThe serialization context indicates whether we're currently serializing some value or a particular field in a user-defined data type.fayThese 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.None+fay;The name of a module split into a list for code generation.fay4Construct the complete ModulePath from a ModuleName.fayConstruct intermediate module paths from a ModuleName. mkModulePaths A.B => [[A], [A,B]]fayConverting a QName to a ModulePath is only relevant for constructors since they can conflict with module names.None,CfayLiteral value type.fayA name of some kind.fayExpression type.fayStatement type.fayJust handy to have.?None?2fayPrint some value.fay The printer.fay The state of the pretty printer.fayThe current line.fayCurrent column.fayCurrent indentation level.fayJust outputted a newline?fayOutput of printerfaySource mappings.fayThe current output.fayGlobal options of the printerfayAre we to pretty print?fayUse pretty thunk names?fayUse pretty operators?fay-default printer options (non-pretty printing)fayDefault state.fay!Print the given printer indented.fayOutput a newline and makes next line indented when prPretty is True. Does nothing when prPretty is FalsefayWrite 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 )fay7exec one of Printers depending on PrintReader property.fayGenerate a mapping from the Haskell location to the current point in the output.fayOutput concatenationfay>Write out a string, updating the current position information.None->2wNone23567<])fayname is not in scopefayname is ambiguousfay+type is used where a type class is expectedfay+type class is used where a type is expectedfayAttempt 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 namefaymodule not foundfayinternal errorfay global valuefay global typefay+local value, and location where it is boundfay-type variable, and location where it is boundfayhere the value name is boundfayhere the type name is definedfayimport: declaration, and the table of symbols that it introducesfay part of an import declarationfayexport( declaration, and the symbols it exportsfaywildcard in a record pattern. The list contains resolved names of the fields that are brought in scope by this pattern.faywildcard in a record construction expression. The list contains resolved names of the fields and information about values assigned to those fields.fay no annotationfay scope errorfayA pair of the name information and original annotation. Used as an annotation type for AST.fayQualified name, where  points to the module where the name was originally defined. The module part is never empty.Also contains name and version of the package where it was defined. If it's K6, then the entity is defined in the "current" package.fay8Possibly qualified name. If the name is not qualified,  is the empty string.fay!String representing a module namefay.String representing an unqualified entity namefayThe set of symbols (entities) exported by a single module. Contains the sets of value-level and type-level entities.fay'Information about a type-level entitityfay type synonymfay data typefaynewtypefay type familyfay data familyfay type classfay(Information about a value-level entitityfayvalue or functionfay class methodfayrecord field selectorfaydata constructorfay Display a fay Display an fayDisplay an error.Note: can span multiple lines; the trailing newline is included.None=fayCompute the extension set for the given module, based on the global preferences (e.g. specified on the command line) and module's LANGUAGE pragmas.fay base languagefayglobal extensions None>Ifay1Local symbol table @ contains locally bound namesNone3>fay+Global symbol table @ contains global names None?fayIf M< ("qualified"), then only the qualified names are inserted.If J:, then both qualified and unqualified names are insterted.fayerror for "not found" conditionNone%AXfaythe field's simple namefaythe field's original namefayInformation 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.NoneANone %>BZfayGet bound value identifiers.fayFor record wildcards we need to know which fields the given constructor has. So we pass the global table for that. None/9>?DfayContains information about the node's enclosing scope. Can be accessed through the lenses: , , , .fay:Describes how we should treat names in the current contextfayA type that implements < provides a way to perform a shallow scope-aware traversal.fayThe algebra for . It's newtype-wrapped because an implicit parameter cannot be polymorphic.fayCreate an initial scopefayMerge local tables of two scopes. The other fields of the scopes are assumed to be the same.fay Analogous to  , but for  !None >?Eg45"None&G'fayCompute module's global table. It contains both the imported entities and the global entities defined in this module.fay9Compute 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 {..} = foofay the import table for this modulefay the import table for this module#NoneGO$None '(?G%NoneLfayAnnotate a module with scoping information. This assumes that all module dependencies have been resolved and cached @ usually you need to run 1 first, unless you have one module in isolation.fay takes a list of possibly recursive modules and computes the interface of each module. The computed interfaces are written into the m'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.fayLike , but also returns a list of interfaces, one per module and in the same orderfay base languagefay6global extensions (e.g. specified on the command line)fay input modulefayoutput (annotated) modulefay base languagefay6global extensions (e.g. specified on the command line)fay input modulesfay errors in export or import listsfay base languagefay6global extensions (e.g. specified on the command line)fay input modulesfay4output modules, and errors in export or import lists&NoneL''NoneM $NoneMfay Error type.NoneR9fay%The JavaScript FFI interfacing monad.fayCompile monad.fayUns the compilerfay+Configuration and globals for the compiler.fayThe compilation configuration.fay#Things written out by the compiler.fay Constructors.fayFay to JS dispatchers.fayJS to Fay dispatchers.fayState of the compiler.fay$Exported identifiers for all modulesfayMap types to constructorsfayMap constructors to fieldsfay3Newtype constructor, destructor, wrapped type tuplefay7Map of all imported modules and their source locations.fayDepth of the current lexical scope, used for creating unshadowing variables.fay,Name of the module currently being compiled.fay/Module paths that have code generated for them.fay5Use JS Strings instead of [Char] for string literals?fay9Module level declarations having explicit type signaturesfaySimple concatenating instance.faySimple concatenating instance.None>XafayThe opposite of Ptr+. Serialize the specified polymorphic type. foo :: Automatic a -> Stringfay=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.fayValues that may be undefined Defined x encodes to x, Undefined decodes to undefined. An undefined property in a record will be removed when encoding.fayValues that may be null Nullable x decodes to x, Null decodes to null.fayDeclare a foreign action.fayThe foreign value.fayBottom.  (None ^fayPrint the JS to a flat string.fay Print the JS to a pretty string.fayEncode String to JS-format lterals. Could use the Text.JSON library.fayPrints pretty operators. prPrettyOperator flag determines the way of accessing operators (e.g.  *) and identifiers with apostrophes (e.g. `). 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)fayPrint a list of statements.fayUnqualify a JsName.fay'Print a constructor name given a QName.fayPrint an unqualified name.fayResolve a given maybe-qualified name to a fully qualifed name.fayResolve a given maybe-qualified name to a fully qualifed name. Use this when a resolution failure is a bug.fayResolve a newtype constructor.fayResolve a newtype destructor.fay&Qualify a name for the current module.fay6Qualify a QName for the current module if unqualified.fayMake a top-level binding.fayForce an expression in a thunk.fay(Is a JS expression a literal (constant)?fay7Deconstruct a parse result (a la maybe, foldr, either).fayGet a config option.fayOptimize pattern matching conditions by merging conditions in common. TODO This is buggy and no longer used. Fails on tests/case3fayThrow a JS exception. fay(Throw a JS exception (in an expression). fayIs an alt a wildcard? fayIs a pattern a wildcard? fay4Return formatter string if expression is a FFI call. fayGenerate a temporary, SCOPED name for testing conditions and such. fayGenerate a temporary, SCOPED name for testing conditions and such. We don't have name tracking yet, so instead we use this. fayPrint out a compiler warning. fayPretty print a source location. fay(Lookup the record for a given type name. fay Get the fields for a given type. fayGet 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. fay.Run the top level compilation for all modules.fay%Runs compilation for a single module. fay4Check if the given language pragmas are all present. fayif then else for when .'   ,None%i fayGet all non local identifiers that should be exported in the JS module scope. fay=Is this *resolved* name a new type constructor or destructor? fay.Is this *resolved* name a new type destructor? fay/Is this *resolved* name a new type constructor? fay>Add a ModulePath to CompileState, meaning it has been printed. fay'Has this ModulePath been added/printed? fay+Find the type signature of a top level name -None &k| fay7Compile the given pattern against the given expression. fay"Compile a pattern variable e.g. x. fayCompile a record field pattern. fay-Compile a literal value from a pattern match. fay#Compile as binding in pattern match fay%Compile a pattern match on a newtype. fayCompile a pattern application. fayCompile a pattern list. .None ?p" fayState. fayOptimize monad. fayThe 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. fay9Run an optimizer, which may output additional statements. fay&Inline x >> y to x;y in the JS output. fayFlatten a a>>(b>>c) to [a,b,c]. fay Try to collect nested a>>(b>>c). fayPerform any top-level cross-module optimizations and GO DEEP to optimize further. fayPerform tail-call optimization. fay6Strip redundant forcing from the whole generated code. fay8Strip redundant forcing from an application if possible. fayApply the given function to the top-level expressions in the given statements. fayApply the given function to the top-level expressions in the given statement. fay9Collect functions and their arity from the whole codeset. fayGet the arity of an expression. fay'Change foo(x)(y) to foo$uncurried(x,y). fay/Rename an uncurried copy of a curried function. /None&p fay$Start the compilation process using  compileModule to compile a file.fayCompile a module 0None &?r  fayCompile an FFI expression (also used when compiling top level definitions). fayMake a FayCJS encoder. fayGet the arity of a type. fayGenerate FayCJS encoding. fayGenerate JSCFay decoding. fayMake a JSCFay decoder.  None?s4fay;Top level, desugar a whole module possibly returning errorsfayDesugar with the option to specify a prefix for generated names. Useful if you want to provide valid haskell names that HSE can print.fay(a) => a for patterns1None &s fayPreprocess and collect all information needed during code generation. 2None &>tbfayCompile Haskell expression. fayCompile Haskell literal. fayCompile let declaration. fayCompile guards 3None &>v  fayCompile Haskell declaration.fayCompile a declaration. fay!Compile a top-level pattern bind. fay(Compile a normal simple pattern binding. fayCompile a data declaration (or a GADT, latter is converted to former). fayCompile a function which pattern matches (causing a case analysis). fay%Compile a right-hand-side expression.  4 Safe-InferredvA 5Nonew fayGiven a configuration, resolve any packages specified to their data file directories for importing the *.hs sources. fayResolve package. fay?Does a directory exist and does it contain any Haskell sources? fayDescribe the given package. fay5Get the package version from the package description. fay!Make a share directory generator. 6None x fay The data-files source directory. fay"The default compiler reader value. fayThe default compiler state. 7Nonex fay'Call out to GHC to type-check the file.  None  #$&>yfay>Compile a Haskell source string to a JavaScript source string.fay!Compile the top-level Fay module.fayCompile a source string.fayCompile a parse HSE module.   None &>| fayCompile the given file and write the output to the given path, or if nothing given, stdout.fayCompile the given file and write to the output, also generates HTML and sourcemap files if configured.fayCompile the given file.fay7Compile a file returning additional generated metadata.fayCompile a file returning the resulting internal state of the compiler. Don't use this directly, it's only exposed for the test suite.fay,Convert a Haskell filename to a JS filename.fay4Convert a Haskell filename to a TypeScript filename.fay,Print a compile error for human consumption.fayGet the JS runtime source. This will return the user supplied runtime if it exists.7 89:;<=8>?8>@8AB8CD8CE89F89G89H8IJ8IK8LM8NO8NP8NQ8NR;ST;SU8IV89W89X89Y89Z8[\8]^8]_8L`8La8Lb8Lc89d89e89f89g89h89i89j89k8Nl8Nm;Sn8op8Lq8Lr89s8tu89v8Iw;Sx8yz8L{8o|8L}8~88[89888989;;;;;8;8L;;8;88;88;;;89;S8N8N88y89898988~8~8988888989898t8t8t8t8t8t8t8t8t8t8t8t8t8t88888888888888888888]8]8]8]8A8A8A8A8A8A8A8A8A8A8A8A888888888888888888888888888888888888888y8y8y8y8y88o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o8o88888888888888888L8L8L8L8L8L8L8L8L8L8L8L8L8L8L8L8L8L8N8N8N8N88~8~8~8~8~8~8~8~8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8>8888C8C8I8I8I8I8I8989898989898989898989898989888;S;S;S;S;S;S;S;S;S +/    23              8988898989898988888888888888888888888888888888888888888888888888888888888888888888888888888888888888>8>8>8>88888888898989    8                                      !!""#$%%%''''''''''''''''''''''''''''''''''''((((((((((((((((((((((()))))))**+++++++++++ + + + + + + + + + + ++ + + + + + + + + + + + + + + + , , , , , , , , - - - - - - - - . . . . . . . . . . . . . . . . . . . . / 0 0 0 0 0 0 1 2 2 2 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 5 5 5 5 5 5 6 6 6 7 #fay-0.24.2.0-7rXiqprvHTALsEl409Mha6Fay.Compiler.PreludeFay.Compiler.Parse Fay.Config Fay.ConvertFay.Types.CompileResult Fay.TypesFay.Types.CompileErrorFay.FFI Fay.CompilerFay.Compiler.DesugarFayFay.Compiler.GADTFay.Compiler.ModuleTFay.Compiler.QNameFay.ExtsFay.Exts.NoAnnotationFay.Compiler.PrimOp Fay.Runtime Fay.Types.FFIFay.Types.ModulePath Fay.Types.JsFay.Types.Printer#Language.Haskell.Names.Open.DerivedLanguage.Haskell.Names.Types"Language.Haskell.Names.SyntaxUtils'Language.Haskell.Names.LocalSymbolTable(Language.Haskell.Names.GlobalSymbolTable!Language.Haskell.Names.ScopeUtils&Language.Haskell.Names.RecordWildcardsLanguage.Haskell.Names.ImportsLanguage.Haskell.Names.GetBound Language.Haskell.Names.Open.Base%Language.Haskell.Names.Open.Instances$Language.Haskell.Names.ModuleSymbolsLanguage.Haskell.Names.Exports Language.Haskell.Names.Annotated Language.Haskell.Names.RecursiveLanguage.Haskell.NamesFay.Exts.ScopedFay.Compiler.PrintFay.Compiler.Desugar.TypesFay.Compiler.Desugar.NameFay.Compiler.MiscFay.Compiler.StateFay.Compiler.PatternFay.Compiler.OptimizerFay.Compiler.ImportFay.Compiler.FFIFay.Compiler.InitialPassFay.Compiler.ExpFay.Compiler.Decl Paths_fayFay.Compiler.PackagesFay.Compiler.DefaultsFay.Compiler.TypecheckbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.Failfail Control.Arrowfirst||| fromIntegral realToFrac toInteger toRational<>memptymappendmconcatjoin<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralMonad Data.DataDataFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalTypeable MonadFail Applicative Data.FoldableFoldableData.Traversable Traversable SemigroupMonoid GHC.TypesBoolCharDoubleFloatIntinteger-wired-inGHC.Integer.TypeInteger GHC.MaybeMaybeOrderingRationalIOWord Data.EitherEitherFalseNothingJustTrueLeftRightLTEQGTString/=maxBoundminBound Data.Functor<$>readListconst.id GHC.UnicodetoLowerShowSshow<*isSpaceisAlphaisDigit Text.Readreadmplusmzero MonadPlusgmapMogmapMpgmapMgmapQigmapQgmapQrgmapQlgmapT dataCast2 dataCast1 dataTypeOftoConstrgunfoldgfoldl Control.Monadmfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMforMsequencemapM sequenceAtraverse&&&***second+++readIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputCharGHC.IO.ExceptionioErrorGHC.IOFilePath userErrorIOErrornotElemallanyorand concatMapconcatmsum sequence_forM_mapM_productsumminimummaximumelemlengthnullfoldl1foldr1foldlfoldrfoldMap Data.OldListunwordswordsunlineslines Data.Char isSeparatorisNumberisMarkisLetter digitToIntreadseither readLitChar lexLitCharlex readParen readsPrecText.ParserCombinators.ReadPReadSatanhacoshasinhtanhcoshsinhatanacosasintancossinlogBase**sqrtlogpiatan2isIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadixtoTitletoUpperisLowerisUpperisPrint isControl isAlphaNumisSymbol isPunctuation isHexDigit isOctDigit isAsciiUpper isAsciiLowerisLatin1isAsciigeneralCategorylcmgcd^^^oddevendivModquotRemdivremquotrecip/floorceilingroundtruncateproperFractionfromEnumtoEnumpredsuccGHC.Charchr intToDigit showLitChar showParen showStringshowCharshowsshowList showsPrecunzip3unzipzipWith3zipWithzip3!!lookupreversebreakspansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanlinitlasttailhead Data.Maybemaybe Data.Functiononvoiduncurrycurrysubtractsignumabs*+asTypeOfuntil$!flipordapliftM5liftM4liftM3liftM2liftMwhen=<<<$GHC.Err undefinederrorWithoutStackTraceerrorcompare<<=>maxmin&&||notparseFaydefaultExtensionsioanyMreadAllFromProcessConfigconfigOptimizeconfigFlattenAppsconfigExportRuntimeconfigExportStdlibconfigExportStdlibOnlyconfigPrettyPrintconfigHtmlWrapperconfigSourceMapconfigHtmlJSLibs configLibrary configWarnconfigFilePathconfigTypecheck configWallconfigGClosureconfigPackageConfconfigBasePath configStrictconfigTypecheckOnlyconfigRuntimePathconfigOptimizeNewtypesconfigPrettyThunksconfigPrettyOperatorsconfigShowGhcCallsconfigTypeScript defaultConfigdefaultConfigWithSandboxconfigDirectoryIncludesconfigDirectoryIncludePaths%nonPackageConfigDirectoryIncludePathsaddConfigDirectoryIncludeaddConfigDirectoryIncludesaddConfigDirectoryIncludePathsconfigPackagesaddConfigPackageaddConfigPackagesshouldExportStrictWrapper$fDefaultConfig $fShowConfig showToFay encodeFay readFromFay readFromFay' decodeFay CompileResult resOutput resImportedresSourceMappings$fShowCompileResultSerializeContextSerializeAnywhereSerializeUserArgFundamentalType FunctionTypeJsTypeListType TupleType UserDefinedDefinedNullableDateType StringType DoubleTypeIntTypeBoolTypePtrType Automatic UnknownType ModulePath unModulePath mkModulePath mkModulePathsmkModulePathFromQNameJsLitJsCharJsStrJsInt JsFloatingJsBoolJsName JsNameVarJsThisJsParametrizedTypeJsThunkJsForceJsApplyJsParamJsTmp JsConstructor JsBuiltIn JsModuleNameJsExpJsRawExpJsSeqJsFunJsAppJsNegApp JsTernaryIfJsNullJsParen JsGetPropJsLookup JsUpdatePropJsGetPropExternJsUpdatePropExternJsListJsNew JsThrowExp JsInstanceOfJsIndexJsEqJsNeqJsInfixJsObjJsLitObj JsUndefinedJsAndJsOrJsStmtJsVarJsMapVarJsIf JsEarlyReturnJsThrowJsWhileJsUpdate JsSetProp JsSetQName JsSetModuleJsSetConstructorJsSetPropExtern JsContinueJsBlock JsExpStmt PrintableprintJSPrinter runPrinter PrintStatepsLinepsColumn psIndentLevel psNewline PrintWriter pwMappingspwOutput PrintReaderprPrettyprPrettyThunksprPrettyOperatorsdefaultPrintReaderpwOutputStringdefaultPrintState execPrinterindentednewlinewriteaskIfmapping CompileErrorCouldn'tFindImport EmptyDoBlockFfiFormatBadCharsFfiFormatIncompleteArgFfiFormatInvalidJavaScriptFfiFormatNoSuchArgFfiNeedsTypeSigGHCErrorInvalidDoBlock ParseErrorShouldBeDesugaredUnableResolveQualifiedUnsupportedDeclarationUnsupportedEnumUnsupportedExportSpecUnsupportedExpressionUnsupportedFieldPatternUnsupportedImportUnsupportedLetUnsupportedLetBindingUnsupportedLiteralUnsupportedModuleSyntaxUnsupportedPatternUnsupportedQualStmtUnsupportedRecursiveDoUnsupportedRhsUnsupportedWhereInAltUnsupportedWhereInMatch$fShowCompileError CompileModuleCompile unCompile CompileReader readerConfigreaderCompileLitreaderCompileDecls CompileWriter writerCons writerFayToJs writerJsToFay CompileStatestateInterfacesstateRecordTypes stateRecords stateNewtypes stateImportedstateNameDepthstateModuleNamestateJsModulePathsstateUseFromString stateTypeSigs$fMonoidCompileWriter$fSemigroupCompileWriter$fMonadModuleCompile$fApplicativeFay $fFunctorFay $fMonadFay$fApplicativeCompile$fFunctorCompile$fMonadCompile$fMonadErrorCompileErrorCompile$fMonadIOCompile!$fMonadReaderCompileReaderCompile$fMonadStateCompileStateCompile!$fMonadWriterCompileWriterCompile$fShowCompileWriter$fShowCompileStatePtr UndefinedNullffirunCompileModule compileWithdesugardesugar'desugarPatParendesugarExpParen compileExp compileDecl compileViaStrcompileToplevelModulecompileModuleFromContentscompileModuleFromAST compileFromTocompileFromToAndGenerateHtml compileFilecompileFileWithResultcompileFileWithStatetoJsNametoTsNameshowCompileErrorreadConfigRuntime convertGADTliftA2foldl'delete Alternativesomemanyempty<|> Data.ListisSubsequenceOffoldMapDefault fmapDefault mapAccumR mapAccumLforControl.Applicativeoptional WrappedMonad WrapMonad unwrapMonad WrappedArrow WrapArrow unwrapArrowZipList getZipListData.Functor.ConstConstgetConstfind minimumBy maximumByunfoldrsortOnsortBysort permutations subsequencestailsinitsgroupBygroupdeleteFirstsByunzip7unzip6unzip5unzip4zipWith7zipWith6zipWith5zipWith4zip7zip6zip5zip4genericReplicate genericIndexgenericSplitAt genericDrop genericTake genericLengthinsertByinsert partition transpose intercalate intersperse intersectBy intersectunionByunion\\deleteBynubBynub isInfixOf isSuffixOf isPrefixOf findIndices findIndex elemIndices elemIndex stripPrefix dropWhileEnd fromRightfromLeftisRightisLeftpartitionEithersrightsleftsData.Ord comparingDowngetDowniterate'scanl'foldl1'unconsmapMaybe catMaybes listToMaybe maybeToList fromMaybefromJust isNothingisJustliftA3liftA<**>)base-compat-0.11.2-JggHr2fdYLe83DSFk1MYK3Data.List.Compat singleton"safe-0.3.19-AfrHSVViU1189qUhjBUb5bSafe foldl1Def' foldl1Def foldr1Def maximumByDef minimumByDef maximumDef minimumDef indexNoteindexDefindexMaypredSafepredNotepredDefpredMaysuccSafesuccNotesuccDefsuccMay toEnumSafe toEnumNote toEnumDef toEnumMayfindIndexJustNotefindIndexJustDef findIndexJustelemIndexJustNoteelemIndexJustDef elemIndexJust findJustNote findJustDeffindJustlookupJustNote lookupJustDef lookupJustreadNotereadDefreadMayreadEitherSafeatNoteatDefatMayat assertNote fromJustNote fromJustDef cycleNotecycleDefcycleMay scanl1Note scanr1Note scanl1Def scanr1Def scanl1May scanr1May foldl1Note' foldl1Note foldr1Note foldl1May' foldl1May foldr1MayminimumBoundedmaximumBounded minimumBound maximumBoundminimumBoundBymaximumBoundBy maximumByNote minimumByNote maximumByMay minimumByMay maximumNote minimumNote maximumMay minimumMaylastNoteheadNotelastDefheadDeflastMayheadMayinitSafeinitNoteinitDefinitMaytailSafetailNotetailDeftailMayabortModuleTModName MonadModule getModuleInfoControl.Monad.IO.ClassMonadIO ModuleInforeadModuleInfo runModuleT modToString lookupInCache insertInCacheqModNameunQual changeModuleunname unQualify changeModule' withIdentsyb-0.7.1-EJn6avnnYqseQTf54r0YpData.Generics.AliasesextQextRType TyVarBindStmtSrcLoc SpecialConRhsQualStmt QualConDeclQOpQNamePatFieldPatName ModulePragma ModuleNameModuleMatchLiteral ImportSpec ImportDecl GuardedRhsGadtDecl FieldUpdate FieldDecl ExportSpecExpExDeclHeadDecl ClassDeclBangTypeAltX moduleName moduleExportsmoduleNameStringmkIdentnoIconvertFieldDeclfieldDeclNames declHeadName$fIsStringModuleName$fIsStringQName$fIsStringName SrcSpanInfoSrcSpanSignunAnn fayBuiltin findPrimOp resolvePrimOpgetRuntimeSource$fIsStringJsLit$fMonoidPrintWriter$fIsStringPrinter ENotInScope EAmbiguous ETypeAsClass EClassAsType ENotExported EModNotFound EInternal GlobalValue GlobalType LocalValueTypeVar ValueBinder TypeBinderImport ImportPartExportRecPatWildcardRecExpWildcardNone ScopeErrorScopedOrigName ModuleNameSGNameNameSSymbols SymTypeInfoSymTypeSymData SymNewType SymTypeFam SymDataFamSymClass SymValueInfoSymValue SymMethod SymSelectorSymConstructorppGName ppOrigNameppErrorErrorNameInfo origGNamegModulegName HasOrigNameorigName st_origName st_fixity sv_origName sv_typeName sv_fixity sv_classNamesv_constructors ExtensionSetvalSymstySymsmkValmkTysLocmoduleExtensionsdropAnn getModuleName getImportsgetModuleDeclsgetExportSpecList qNameToNamegetDeclHeadName nameToString stringToNameunCName getErrorsTableaddValue lookupValueResultSpecial lookupType fromListsvaluestypes toSymbolscomputeSymbolTable resolveCNames scopeErrornonenoScope sv_parent wcFieldNamewcFieldOrigNameWcNames patWcNames expWcNamesprocessImportsGetBoundgetBoundScopegTablelTablenameCtxwcNames NameContext ResolvableAlg rtraverse initialScopemergeLocalScopesrmap2traverse-with-class-1.0.1.0-7Nq9ISQSBU75OQ0QQio7zPData.Generics.Traversablegmap_gTable_lTable_nameCtx_wcNamesOtherBindingTBindingV ReferenceT ReferenceVrunAlgalgdefaultRtraverseintro setWcNamesbinderVbinderTexprVexprT<|-: moduleTable moduleSymbolsprocessExportsannotateannotateModulecomputeInterfaces getInterfaces srcSpanInfo printJSString printJSPretty toJsStringLit printProp printStmtsident printConsprintConsUnQual printConsName reservedWords encodeName normalizeName mintercalate$fPrintableJsName$fPrintableJsExp$fPrintableModulePath$fPrintableJsStmt$fPrintableSpecialCon$fPrintableName$fPrintableModuleName$fPrintableQName$fPrintableJsLitallowedNameCharsDesugar DesugarReaderreaderNameDepth readerNoInforeaderTmpNamePrefix runDesugarwithScopedTmpNameunscopedTmpNamesthunk stmtsThunk uniqueNamestryResolveNameunsafeResolveNamelookupNewtypeConstlookupNewtypeDestqualify qualifyQName bindToplevelforce isConstant parseResultconfigoptimizePatConditionsthrowthrowExp isWildCardAlt isWildCardPatffiExpwithScopedTmpJsNamewarn printSrcLoc typeToRecs typeToFieldsgetGhcPackageDbFlag runTopCompilehasLanguagePragmasifOptimizeNewtypesorigName2QNamereplaceWithBuiltInsioWarnprintSrcSpanInfo printSrcSpan recToFieldsshouldBeDesugaredhasLanguagePragma!getNonLocalExportsWithoutNewtypes isNewtype isNewtypeDest isNewtypeCons addModulePathaddedModulePath findTypeSiggetLocalExportsWithoutNewtypes compilePat compilePVarcompilePatFields compilePLit compilePAsPatcompileNewtypePat compilePApp compilePListOptStateOptimize FuncArity runOptimizer inlineMonadflattencollectoptimizeTopleveltcostripAndUncurrywalkAndStripForcesapplyToExpsInStmtsapplyToExpsInStmt collectFuncsexpArityuncurryBindingrenameUncurried optUncurryoptStmts startCompile compileFFIExp emitFayToJs typeArity fayToJsHash jsToFayHash emitJsToFay initialPass compileLitcompileLetDecl compileGuards compileDeclscompilePatBindcompileUnguardedRhscompileDataDeclcompileFunCase compileRhsmkTyVarsversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameresolvePackagesresolvePackagedoesSourceDirExistdescribePackagepackageVersion getShareGen faySourceDirdefaultCompileReaderdefaultCompileState typecheck