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.

compileModule :: Module -> Compile [JsStmt]

Compile Haskell module.

compileImport :: ImportDecl -> Compile [JsStmt]

Compile the given import.

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

Compile Haskell declaration.

compileDecl :: Decl -> Compile [JsStmt]

Compile a declaration.

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

Compile a top-level pattern bind.

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

Compile a normal simple pattern binding.

compileFFIFunc :: Type -> Name -> (String, String, FayReturnType) -> Compile [JsStmt]

Compile a foreign function.

compileFFIMethod :: Type -> Name -> (String, String, FayReturnType) -> Compile [JsStmt]

Compile a foreign method.

compileFFI :: Type -> Name -> (String, String, FayReturnType) -> JsExp -> [JsName] -> [JsName] -> Compile [JsStmt]

Compile an FFI call.

data ArgType

These are the data types that are serializable directly to native JS data types. Strings, floating points and arrays. The others are: actiosn 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.

Constructors

FunctionType

JsType

StringType

DoubleType

ListType

BoolType

UnknownType

Instances

Eq ArgType

Show ArgType

serialize :: ArgType -> JsExp -> JsExp

Serialize a value to native JS, if possible.

functionTypeArgs :: Type -> [ArgType]

Get arg types of a function type.

typeArity :: Type -> Integer

Get the arity of a type.

compileDataDecl :: 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 :: [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.

compileRhs :: Rhs -> Compile JsExp

Compile a right-hand-side expression.

compileFunMatch :: 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.

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.

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 :: FayReturnType -> 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 :: 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.