Language.Fay

The Haskell→Javascript compiler.

Documentation

compile :: CompilesTo from to => CompileConfig -> from -> IO (Either CompileError (to, CompileState))

Compile something that compiles to something else.

runCompile :: CompileConfig -> Compile a -> IO (Either CompileError (a, CompileState))

Run the compiler.

compileViaStr :: (Show from, Show to, CompilesTo from to) => CompileConfig -> (from -> Compile to) -> String -> IO (Either CompileError (String, CompileState))

Compile a Haskell source string to a JavaScript source string.

compileToAst :: (Show from, Show to, CompilesTo from to) => CompileConfig -> (from -> Compile to) -> String -> IO (Either CompileError (to, CompileState))

Compile a Haskell source string to a JavaScript source string.

compileFromStr :: (Parseable a, MonadError CompileError m) => (a -> m a1) -> String -> m a1

Compile from a string.

printCompile :: (Show from, Show to, CompilesTo from to) => CompileConfig -> (from -> Compile to) -> String -> IO ()

printTestCompile :: String -> IO ()

Compile a String of Fay and print it as beautified JavaScript.

compileModule :: Module -> Compile [JsStmt]

Compile Haskell module.

compileImport :: ImportDecl -> Compile [JsStmt]

Compile the given import.

compileDecls :: Bool -> [Decl] -> Compile [JsStmt]

Compile Haskell declaration.

compileDecl :: Bool -> Decl -> Compile [JsStmt]

Compile a declaration.

compilePatBind :: Bool -> Maybe Type -> Decl -> Compile [JsStmt]

Compile a top-level pattern bind.

compileFFI

Arguments

:: Name

Name of the to-be binding.

-> String

The format string.

-> Type

Type signature.

-> Compile [JsStmt]

Compile an FFI call.

formatFFI

Arguments

:: String

The format string.

-> [(JsParam, FundamentalType)]

Arguments.

-> Compile String

The JS code.

Format the FFI format string with the given arguments.

serialize :: FundamentalType -> JsExp -> JsExp

Serialize a value to native JS, if possible.

typeRep :: FundamentalType -> JsExp

Get a JS-representation of a fundamental type for encoding/decoding.

functionTypeArgs :: Type -> [FundamentalType]

Get arg types of a function type.

argType :: Type -> FundamentalType

Convert a Haskell type to an internal FFI representation.

typeArity :: Type -> Int

Get the arity of a type.

compileNormalPatBind :: Bool -> Name -> Exp -> Compile [JsStmt]

Compile a normal simple pattern binding.

compileDataDecl :: Bool -> Decl -> [QualConDecl] -> Compile [JsStmt]

Compile a data declaration.

qname :: QName -> String

Extract the string from a qname.

unname :: Name -> String

Extra the string from an ident.

compileFunCase :: Bool -> [Match] -> Compile [JsStmt]

Compile a function which pattern matches (causing a case analysis).

optimizeTailCalls

Arguments

:: [JsParam]

The function parameters.

-> Name

The function name.

-> [JsStmt]

The body of the function.

-> [JsStmt]

A new optimized function body.

Optimize functions in tail-call form.

flatten :: JsExp -> Maybe [JsExp]

Flatten an application expression into function : arg : arg : []

expand :: JsExp -> Maybe [JsExp]

Expand a forced value into the value.

prettyPrintFile :: String -> IO String

Format a JS file using js-beautify, or return the JS as-is if js-beautify is unavailable

compileRhs :: Rhs -> Compile JsExp

Compile a right-hand-side expression.

compileGuards :: [GuardedRhs] -> Compile JsExp

Compile guards

compileFunMatch :: Bool -> Match -> Compile [JsStmt]

Compile a pattern match binding.

compileExp :: Exp -> Compile JsExp

Compile Haskell expression.

compileApp :: Exp -> Exp -> Compile JsExp

Compile simple application.

compileInfixApp :: Exp -> QOp -> Exp -> Compile JsExp

Compile an infix application, optimizing the JS cases.

compileList :: [Exp] -> Compile JsExp

Compile a list expression.

makeList :: [JsExp] -> JsExp

compileIf :: Exp -> Exp -> Exp -> Compile JsExp

Compile an if.

compileLambda :: [Pat] -> Exp -> Compile JsExp

Compile a lambda.

compileCase :: Exp -> [Alt] -> Compile JsExp

Compile case expressions.

compileDoBlock :: [Stmt] -> Compile JsExp

Compile a do block.

compileStmt :: Maybe Exp -> Stmt -> Compile (Maybe Exp)

Compile a statement of a do block.

compilePatAlt :: JsExp -> Alt -> Compile [JsStmt]

Compile the given pattern against the given expression.

compilePat :: JsExp -> Pat -> [JsStmt] -> Compile [JsStmt]

Compile the given pattern against the given expression.

compilePLit :: JsExp -> Literal -> [JsStmt] -> Compile [JsStmt]

Compile a literal value from a pattern match.

compilePAsPat :: JsExp -> Name -> Pat -> [JsStmt] -> Compile [JsStmt]

Compile as binding in pattern match

compileRecConstr :: QName -> [FieldUpdate] -> Compile JsExp

Compile a record construction with named fields | GHC will warn on uninitialized fields, they will be undefined in JS.

equalExps :: JsExp -> JsExp -> JsExp

Equality test for two expressions, with some optimizations.

isConstant :: JsExp -> Bool

Is a JS expression a literal (constant)?

compilePApp :: QName -> [Pat] -> JsExp -> [JsStmt] -> Compile [JsStmt]

Compile a pattern application.

compilePList :: [Pat] -> [JsStmt] -> JsExp -> Compile [JsStmt]

Compile a pattern list.

compileInfixPat :: JsExp -> Pat -> [JsStmt] -> Compile [JsStmt]

Compile an infix pattern (e.g. cons and tuples.)

compileGuardedAlt :: GuardedAlts -> Compile JsExp

Compile a guarded alt.

compileLet :: [Decl] -> Exp -> Compile JsExp

Compile a let expression.

compileLetDecl :: Decl -> Compile [JsStmt]

Compile let declaration.

compileLit :: Literal -> Compile JsExp

Compile Haskell literal.

uniqueNames :: [JsParam]

Generate unique names.

optimizePatConditions :: [[JsStmt]] -> [[JsStmt]]

Optimize pattern matching conditions by merging conditions in common.

throw :: String -> JsExp -> JsStmt

Throw a JS exception.

throwExp :: String -> JsExp -> JsExp

Throw a JS exception (in an expression).

isWildCardAlt :: Alt -> Bool

Is an alt a wildcard?

isWildCardPat :: Pat -> Bool

Is a pattern a wildcard?

tmpName :: JsExp -> JsName

A temporary name for testing conditions and such.

thunk :: JsExp -> JsExp

Wrap an expression in a thunk.

monad :: JsExp -> JsExp

Wrap an expression in a thunk.

stmtsThunk :: [JsStmt] -> JsExp

Wrap an expression in a thunk.

unserialize :: FundamentalType -> JsExp -> JsExp

force :: JsExp -> JsExp

Force an expression in a thunk.

forceInlinable :: CompileConfig -> JsExp -> JsExp

Force an expression in a thunk.

resolveOpToVar :: QOp -> Compile Exp

Resolve operators to only built-in (for now) functions.

hjIdent :: String -> QName

Make an identifier from the built-in HJ module.

bindToplevel :: Bool -> QName -> JsExp -> Compile JsStmt

Make a top-level binding.

emitExport :: ExportSpec -> Compile ()

Emit exported names.

parseResult :: ((SrcLoc, String) -> b) -> (a -> b) -> ParseResult a -> b

Parse result.

config :: (CompileConfig -> a) -> Compile a

Get a config option.