fay- A compiler for Fay, a Haskell subset that compiles to JavaScript.

Safe HaskellNone



All Fay types and instances.



data JsLit Source

Literal value type.


Eq JsLit 
Show JsLit 
IsString JsLit

Just handy to have.

Printable JsLit

Print literals.

data JsName Source

A name of some kind.


Eq JsName 
Show JsName 
Printable JsName

Print one of the kinds of names.

class Printable a where Source

Print some value.


printJS :: a -> Printer Source


Printable ModulePath

Print a module path.

Printable JsLit

Print literals.

Printable JsName

Print one of the kinds of names.

Printable JsExp

Print an expression.

Printable JsStmt

Print a single statement.

Printable (ModuleName l)

Print module name.

Printable (SpecialCon l)

Print special constructors (tuples, list, etc.)

Printable (QName l)

Print (and properly encode to JS) a qualified name.

Printable (Name l)

Print (and properly encode) a name.

data Fay a Source

The JavaScript FFI interfacing monad.

data CompileReader Source

Configuration and globals for the compiler.




readerConfig :: Config

The compilation configuration.

readerCompileLit :: Sign -> Literal -> Compile JsExp
readerCompileDecls :: Bool -> [Decl] -> Compile [JsStmt]

data CompileWriter Source

Things written out by the compiler.




writerCons :: [JsStmt]


writerFayToJs :: [(String, JsExp)]

Fay to JS dispatchers.

writerJsToFay :: [(String, JsExp)]

JS to Fay dispatchers.


data Config Source

Configuration of the compiler. The fields with a leading underscore


Show Config 
Default Config

Default configuration.

data CompileState Source

State of the compiler.




stateInterfaces :: Map ModuleName Symbols

Exported identifiers for all modules

stateRecordTypes :: [(QName, [QName])]

Map types to constructors

stateRecords :: [(QName, [Name])]

Map constructors to fields

stateNewtypes :: [(QName, Maybe QName, Type)]

Newtype constructor, destructor, wrapped type tuple

stateImported :: [(ModuleName, FilePath)]

Map of all imported modules and their source locations.

stateNameDepth :: Integer

Depth of the current lexical scope, used for creating unshadowing variables.

stateModuleName :: ModuleName

Name of the module currently being compiled.

stateJsModulePaths :: Set ModulePath

Module paths that have code generated for them.

stateUseFromString :: Bool

Use JS Strings instead of [Char] for string literals?

stateTypeSigs :: Map QName Type

Module level declarations having explicit type signatures

data FundamentalType Source

These 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.

data PrintState Source

The state of the pretty printer.




psLine :: Int

The current line.

psColumn :: Int

Current column.

psIndentLevel :: Int

Current indentation level.

psNewline :: Bool

Just outputted a newline?

data PrintReader Source

Global options of the printer




prPretty :: Bool

Are we to pretty print?

prPrettyThunks :: Bool

Use pretty thunk names?

prPrettyOperators :: Bool

Use pretty operators?

defaultPrintReader :: PrintReader Source

default printer options (non-pretty printing)

data PrintWriter Source

Output of printer




pwMappings :: [Mapping]

Source mappings.

pwOutput :: ShowS

The current output.


Monoid PrintWriter

Output concatenation

newtype Printer Source

The printer.


IsString Printer

Write out a string, updating the current position information.

Monoid Printer 

indented :: Printer -> Printer Source

Print the given printer indented.

askIf :: (PrintReader -> Bool) -> Printer -> Printer -> Printer Source

exec one of Printers depending on PrintReader property.

newline :: Printer Source

Output a newline and makes next line indented when prPretty is True. Does nothing when prPretty is False

write :: String -> Printer Source

Write 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 newline)

mapping :: SrcSpan -> Printer Source

Generate a mapping from the Haskell location to the current point in the output.

data SerializeContext Source

The serialization context indicates whether we're currently serializing some value or a particular field in a user-defined data type.

data ModulePath Source

The name of a module split into a list for code generation.


mkModulePath :: ModuleName a -> ModulePath Source

Construct the complete ModulePath from a ModuleName.

mkModulePaths :: ModuleName a -> [ModulePath] Source

Construct intermediate module paths from a ModuleName. mkModulePaths A.B => [[A], [A,B]]

mkModulePathFromQName :: QName a -> ModulePath Source

Converting a QName to a ModulePath is only relevant for constructors since they can conflict with module names.