L-Z      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ _ ` 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 RSTUVWXY NoneZ%Convert a GADT to a normal data type.ZZZ Safe-Inferred3Read from a process returning both std err and out. Safe-InferredRGet all files in a folder and its subdirectories. Taken from Real World Haskell _http://book.realworldhaskell.org/read/io-case-study-a-library-for-searching-the-filesystem.html Safe-Inferred!Get the union of a list of lists. Flip of map.None+EF<Convert a Haskell value to a value representing a Fay value.<Convert a value representing a Fay value to a Haskell value.[%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 double.a Parse an int.bParse an integer.cParse a number.d Parse a bool.eParse a string.f Parse a char.g Parse a Text.hParse an array.i Parse unit.[\]^_`abcdefghi[\]^_`abcdefghi Safe-InferredWord version of flip (>>=).When the value is Just.Wrap up a form in a Maybe. Flip of mapMaybe. Monadic version of maybe. )Do any of the (monadic) predicates match?    None240.Helpful for writing qualified symbols (Fay.*).1Helpful for some things.2Helpful for some things.'  !"#$%&'()*+,-./012$  !"#$%&'()*+,-./'.-,+*)('&%$#"!  /210'  !"#$%&'()*+,-./012 Safe-Inferred33Alias of liftIO, I hate typing it. Hate reading it.3333Nonej.Extract the module name from a qualified name.kExtract the name from a QName.l(Change or add the ModuleName of a QName.mExtract the string from a Name.jknlopmjknlopmjknlopmNone q/Make an identifier from the built-in HJ module.r<Mapping from unqualified names to qualified primitive names.s:Lookup a primop that was resolved to a Prelude definition.t[If this is resolved to a Prelude identifier or if it's unqualified, check if it's a primopqrstqstqrst Safe-Inferred uvwxyz{|}~v|}~ uvwxyz{|}~None*456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]*456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]*UTSRQPONMLKJIHGFEDCBA@?>=<;:987654VWXYZ[\]*456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\] None$^_`abcdefghijklmnopqrstuvwxyz{|}~$^_`abcdefghijklmnopqrstuvwxyz{|}~$~}|{zyxwvutsrqponmlkjihgfedcba`_^$^_`abcdefghijklmnopqrstuvwxyz{|}~ None=BKBThe serialization context indicates whether we're currently serializing some value or a particular field in a user-defined data type.IThese 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.Literal value type.A name of some kind.Expression type.Statement type.%The JavaScript FFI interfacing monad. Error type.Print some value.The printer monad. The state of the pretty printer.Are we to pretty print?The current line.Current column.Source mappings.Current indentation level..The current output. TODO: Make more efficient.Just outputted a newline?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 signatures;The name of a module split into a list for code generation.Configuration of the compiler.Run 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.0#Custom source location for fay-base1`Produce strict and uncurried wrappers for all functions with type signatures in the given module2:Only invoke GHC for typechecking, don't produce any output44Construct the complete ModulePath from a ModuleName.5FConstruct intermediate module paths from a ModuleName. mkModulePaths A.B => [[A], [A,B]]6pConverting a QName to a ModulePath is only relevant for constructors since they can conflict with module names.Just handy to have.Default state.Simple concatenating instance.      !"#$%&'()*+,-./0123456      !"#$%&'()*+,-./0123456      !"#$%&'()*+,-./0123456        !"#$%&'()*+,-./0123456None 3"The CPP's parsing state.Wrap 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.EOptimize pattern matching conditions by merging conditions in common.Throw 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.7%Runs compilation for a single module.8Parse some Fay code.KApply 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.The parse mode for Fay.4Check if the given language pragmas are all present..78.78+78 None98Get 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.>Add a package to compilation?#Add several packages to compilationADefault configuration. 9:;<=>?@A9:;<=>?@ 9:;<=>?@A 9:;<=>?@ANoneEuGiven 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-36B|Generate a temporary, SCOPED name for testing conditions and such. We don't have name tracking yet, so instead we use this.;Top level, desugar a whole module possibly returning errors Desugaring)Convert do notation into binds and thens.7(,) => x y -> (x,y) (,,) => x y z -> (x,y,z) etcDesugar 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.For 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" :: Int)None E$Start the compilation process using  compileModule to compile a file.BCompile 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.BBBNone 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 stateNoneEFState.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.NoneMGet 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? None2CThe opposite of Ptr+. Serialize the specified polymorphic type. foo :: Automatic a -> StringD=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.EValues that may be undefined Defined x encodes to x, Undefined decodes to undefined. An undefined property in a record will be removed when encoding.HHValues that may be null Nullable x decodes to x, Null decodes to null.KDeclare a foreign action. CDEFGHIJKThe foreign value.Bottom. CDEFGHIJK HJIEGFDCKCDEGFHJIKNone 7Compile the given pattern against the given expression."Compile a pattern variable e.g. x.Compile a record field pattern.-Compile a literal value from a pattern match.#Compile as binding in pattern match%Compile a pattern match on a newtype.Compile a pattern application.Compile a pattern list.0Compile an infix pattern (e.g. cons and tuples.)   None 24 Print the JS to a flat string.  Print the JS to a pretty string. Unqualify 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, leteThis 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.!Print the given printer indented.Output a newline.>Write out a string, updating the current position information.PGenerate a mapping from the Haskell location to the current point in the output.Intercalate monadic action.Concatenate two printables.A printer is a printable.Just write out strings. Print one of the kinds of names.Print an expression.Print a module path.Print a single statement.Print a list of statements.#Print (and properly encode) a name. /Print special constructors (tuples, list, etc.)!Print module name."3Print (and properly encode to JS) a qualified name.#jPrint literals. These need some special encoding for JS-format literals. Could use the Text.JSON library.      !"#           !"#None E$KCompile an FFI expression (also used when compiling top level definitions).%LWarn about uses of naked x.y which will not play nicely with Google Closure.&Make a Fay!JS encoder.'A name used for transcoding.(?The name used for the forced version of a transcoding variable.)!Get arg types of a function type.*9Convert a Haskell type to an internal FFI representation.+Extract the type.,Expand a type application.-Generate a user-defined type..Translate: JS ! Fay./Translate: Fay ! JS.0Make a translator.1DGet a JS-representation of a fundamental type for encoding/decoding.2Get the arity of a type.37Format the FFI format string with the given arguments.4.Generate n name-typ pairs from the given list.5Generate Fay!JS encoding.6Generate JS!Fay decoding.7Make a JS!Fay decoder.8LThe argument types used in serialization of parametrized user-defined types.9@Get the index of a name from the set of type variables bindings.:.Extract the name from a possibly-kinded tyvar.$%&'()*+,-./0123Source Location.The format string. Arguments. The JS code.456789:$&2567$%&'()*+,-./0123456789:None 246LCompile Haskell expression.;Compile variable.<Compile Haskell literal.=Compile simple application.>Helper for compileApp.?Compile a negate application@6Compile an infix application, optimizing the JS cases.ACompile a let expression.BCompile let declaration.CCompile a list expression.DCompile an if.ECompile case expressions.F7Compile the given pattern against the given expression.GCompile a guarded alt.HCompile guardsICompile a lambda.J$Compile [e1..] arithmetic sequences.K&Compile [e1..e3] arithmetic sequences.L'Compile [e1,e2..] arithmetic sequences.M)Compile [e1,e2..e3] arithmetic sequences.NwCompile a record construction with named fields | GHC will warn on uninitialized fields, they will be undefined in JS.OCompile a record update.PMake a Fay list.Q5Optimize short literal [e1..e3] arithmetic sequences.R8Optimize short literal [e1,e2..e3] arithmetic sequences.S[Maximum number of elements to allow in strict list representation of arithmetic sequences.L;<=>?@ABCDEFGHIJKLMNOPQRSL<BHL;<=>?@ABCDEFGHIJKLMNOPQRSNone 246TCompile Haskell declaration.MCompile a declaration.U!Compile a top-level pattern bind.V(Compile a normal simple pattern binding.WFCompile a data declaration (or a GADT, latter is converted to former).XCCompile a function which pattern matches (causing a case analysis).Y%Compile a right-hand-side expression.TMZUVWXYTMZUVWXYTMZUVWXYNone[ The data-files source directory.\"The default compiler reader value.]The default compiler state.[\][\][\] None^'Call out to GHC to type-check the file.^^^ None  246M N>Compile a Haskell source string to a JavaScript source string.O!Compile the top-level Fay module.PCompile a source string._-Compile given the location and source string.QCompile a parse HSE module.`6For a module A.B, generate | var A = {}; | A.B = {};aZGenerate exports for non local names, local exports have already been added to the module.b7Generate strict wrappers for the exports of the module.csIs the module a standard module, i.e., one that we'd rather not output code for if we're compiling separate files. NOP_Q`abc 78BLMNOPQ 7NBLMOPQ8 NOP_Q`abcNone 246 R\Compile the given file and write the output to the given path, or if nothing given, stdout.SGCompile the given file and write to the output, also generate any HTML.TCompile the given file.U#Compile a file returning the state.d.Compile the given module to a runnable module.V,Convert a Haskell filename to a JS filename.W,Print a compile error for human consumption.XTGet the JS runtime source. This will return the user supplied runtime if it exists.Y"Get the default JS runtime source. RSTUdVWXY      !"#$%&'()*+,-./0123456RSTUVWXYTURSVWXY RSTUdVWXYe!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST-./23456789:;<=>?@ABCDEFGHIJKLMNOUVWXYZ[\] - . / 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O U 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    x                                                                                     d  l  l k  k      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO P Q R   S T UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~l      !"#$% & ' ( ) * +,- fay-0.19.1.1Fay.System.Process.ExtraFay.System.Directory.ExtraFay.Data.List.Extra Fay.ConvertFay.Control.Monad.ExtraFay.Exts.NoAnnotationFay.Control.Monad.IOFay.ExtsFay.Exts.Scoped Fay.Types Fay.CompilerFay.Compiler.ConfigFay.FFIFayFay.Compiler.GADTFay.Compiler.QNameFay.Compiler.PrimOp Paths_fayFay.Compiler.MiscFay.Compiler.PackagesFay.Compiler.DesugarFay.Compiler.ImportFay.Compiler.InitialPassFay.Compiler.OptimizerFay.Compiler.StateFay.Compiler.PatternFay.Compiler.PrintFay.Compiler.FFIFay.Compiler.ExpFay.Compiler.DeclFay.Compiler.DefaultsFay.Compiler.TypecheckreadAllFromProcessgetRecursiveContentsunionOffor showToFay readFromFaybindwhenJustjustforMaybemaybeManyMType TyVarBindStmt SrcSpanInfoSrcSpanSrcLoc SpecialConRhsQualStmt QualConDeclQOpQNamePatFieldPatName ModulePragma ModuleNameModuleMatchLiteral ImportSpec ImportDecl GuardedRhs GuardedAltsGadtDecl FieldUpdate FieldDecl ExportSpecExpExDeclHeadDecl ClassDeclBangTypeAltunAnn$fIsStringModuleName$fIsStringQName$fIsStringNameioX moduleName moduleExportsmoduleNameStringmkIdentnoIconvertFieldDeclfieldDeclNames declHeadName srcSpanInfoSerializeContextSerializeUserArgSerializeAnywhereFundamentalType UnknownType AutomaticPtrTypeBoolTypeIntType DoubleType StringTypeDateTypeNullableDefined UserDefined TupleTypeListTypeJsType FunctionTypeJsLitJsBool JsFloatingJsIntJsStrJsCharJsName JsModuleName JsBuiltIn JsConstructorJsTmpJsParamJsApplyJsForceJsThunkJsParametrizedTypeJsThis JsNameVarJsExpJsOrJsAnd JsUndefinedJsLitObjJsObjJsInfixJsNeqJsEqJsIndex JsInstanceOf JsThrowExpJsNewJsListJsUpdatePropExternJsGetPropExtern JsUpdatePropJsLookup JsGetPropJsParenJsNull JsTernaryIfJsNegAppJsAppJsFunJsSeqJsRawExpJsStmt JsExpStmtJsBlock JsContinueJsSetPropExternJsSetConstructor JsSetModule JsSetQName JsSetPropJsUpdateJsWhileJsThrow JsEarlyReturnJsIfJsVar CompileErrorUnsupportedWhereInMatchUnsupportedWhereInAltUnsupportedRhsUnsupportedRecursiveDoUnsupportedQualStmtUnsupportedPatternUnsupportedModuleSyntaxUnsupportedLiteralUnsupportedLetBindingUnsupportedLetUnsupportedImportUnsupportedFieldPatternUnsupportedExpressionUnsupportedExportSpecUnsupportedEnumUnsupportedDeclarationUnableResolveQualifiedShouldBeDesugared ParseErrorInvalidDoBlockGHCErrorFfiNeedsTypeSigFfiFormatNoSuchArgFfiFormatInvalidJavaScriptFfiFormatIncompleteArgFfiFormatBadChars EmptyDoBlockCouldn'tFindImport PrintableprintJSPrinter runPrinter PrintStatepsPrettypsLinepsColumn psMappings psIndentLevelpsOutput psNewline CompileModule CompileResultCompile unCompile CompileReader readerConfigreaderCompileLitreaderCompileDecls CompileWriter writerCons writerFayToJs writerJsToFay CompileStatestateInterfacesstateRecordTypes stateRecords stateNewtypes stateImportedstateNameDepthstateModuleNamestateJsModulePathsstateUseFromString stateTypeSigs ModulePath unModulePath CompileConfigconfigOptimizeconfigFlattenAppsconfigExportRuntimeconfigExportStdlibconfigExportStdlibOnlyconfigDirectoryIncludesconfigPrettyPrintconfigHtmlWrapperconfigSourceMapconfigHtmlJSLibs configLibrary configWarnconfigFilePathconfigTypecheck configWallconfigGClosureconfigPackageConfconfigPackagesconfigBasePath configStrictconfigTypecheckOnlyconfigRuntimePath mkModulePath mkModulePathsmkModulePathFromQNamerunCompileModuleparseFayconfigDirectoryIncludePaths%nonPackageConfigDirectoryIncludePathsaddConfigDirectoryIncludeaddConfigDirectoryIncludesaddConfigDirectoryIncludePathsaddConfigPackageaddConfigPackagesshouldExportStrictWrapper$fDefaultCompileConfig compileWithPtr UndefinedNullffi compileExp compileDecl compileViaStrcompileToplevelModulecompileModuleFromContentscompileModuleFromAST compileFromTocompileFromToAndGenerateHtml compileFilecompileFileWithStatetoJsNameshowCompileErrorgetConfigRuntime getRuntime convertGADTparseDataOrTuple parseTuple parseObject makeSimple makeRecord parseDoubleparseInt parseInteger parseNumber parseBool parseString parseChar parseText parseArray parseUnitqModNameunQual changeModuleunname unQualify changeModule' withIdent fayBuiltin primOpsMap findPrimOp resolvePrimOpcatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName$fIsStringJsLit$fDefaultPrintState$fMonoidCompileWriter liftModuleT$fErrorCompileError$fMonadModuleCompileCPPStatethunk stmtsThunk uniqueNamestryResolveNameunsafeResolveNamelookupNewtypeConstlookupNewtypeDestqualify qualifyQName bindToplevelforce isConstant parseResultconfigoptimizePatConditionsthrowthrowExp isWildCardAlt isWildCardPatffiExpwithScopedTmpJsNamewithScopedTmpNamewarn printSrcLoc typeToRecs typeToFieldsgetGhcPackageDbFlag runTopCompileapplyCPP parseModehasLanguagePragmasCPPElseCPPIfNoCPPorigName2QNamereplaceWithBuiltInsioWarnprintSrcSpanInfo printSrcSpan recToFieldsshouldBeDesugareddefaultExtensionshasLanguagePragmaresolvePackagesresolvePackagedoesSourceDirExistdescribePackagepackageVersion getShareGendesugardesugarSection desugarStmt'desugarTupleCondesugarListComp checkEnumdesugarToplevelFFITypeSigsDesugar unDesugar DesugarReaderreaderNameDepth readerNoInfo runDesugar desugarDodesugarTupleSectiondesugarPatParendesugarFieldPundesugarPatFieldPundesugarImplicitPreludedesugarFFITypeSigsdesugarBindsTypeSigsaddFFIExpTypeSigs transformBi universeBi transformBiM startCompilecompileModuleFromFilecompileModuleFromName compileImport findImport initialPasspreprocessFileWithSource preprocessASTscanNewtypeDeclscompileNewtypeDeclscanRecordDecls scanTypeSigsOptStateOptimize FuncArity runOptimizer inlineMonadflattencollectoptimizeTopleveltcostripAndUncurrywalkAndStripForcesapplyToExpsInStmtsapplyToExpsInStmt collectFuncsexpArityuncurryBindingrenameUncurriedoptStmts optUncurry!getNonLocalExportsWithoutNewtypes isNewtype isNewtypeDest isNewtypeCons addModulePathaddedModulePathgetLocalExportsWithoutNewtypes findTypeSig compilePat compilePVarcompilePatFields compilePLit compilePAsPatcompileNewtypePat compilePApp compilePListcompileInfixPat printJSString printJSPrettyident printConsprintConsUnQual printConsName reservedWords encodeName normalizeNameindentednewlinewritemapping intercalateM+>$fPrintablePrinter $fPrintable[]$fPrintableJsName$fPrintableJsExp$fPrintableModulePath$fPrintableJsStmt$fPrintable[]0$fPrintableName$fPrintableSpecialCon$fPrintableModuleName$fPrintableQName$fPrintableJsLit compileFFIExp warnDotUses emitFayToJstranscodingObjtranscodingObjForcedfunctionTypeArgsargTypebangType expandApp userDefinedjsToFayfayToJs translatetypeRep typeArity formatFFI explodeFields fayToJsHash jsToFayHash emitJsToFayargTypesgetIndextyvar compileVar compileLit compileApp compileApp' compileNegAppcompileInfixApp compileLetcompileLetDecl compileList compileIf compileCase compilePatAltcompileGuardedAlt compileGuards compileLambdacompileEnumFromcompileEnumFromTocompileEnumFromThencompileEnumFromThenTocompileRecConstrcompileRecUpdatemakeList optEnumFromTooptEnumFromThenTomaxStrictASLen compileDeclscompilePatBindcompileUnguardedRhscompileDataDeclcompileFunCase compileRhsmkTyVars faySourceDirdefaultCompileReaderdefaultCompileState typecheckcompileFileWithSourcecreateModulePathgenerateExportsgenerateStrictExportsanStdlibModulecompileToModule