Language.Fay

The Haskell→Javascript compiler.

Documentation

compile :: CompilesTo from to => Config -> from -> IO (Either CompileError to)

Compile something that compiles to something else.

runCompile :: Config -> Compile a -> IO (Either CompileError a)

Run the compiler.

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

Compile a Haskell source string to a JavaScript source string.

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

Compile a Haskell source string to a JavaScript source string.

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

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]

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

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

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

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

compileFFI :: Type -> Name -> (String, String, String) -> 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]

qname :: QName -> String

unname :: Name -> String

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]

expand :: JsExp -> Maybe [JsExp]

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

optimizeApp :: JsExp -> JsExp

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

compileList :: [Exp] -> Compile JsExp

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

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

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

compileDoBlock :: [Stmt] -> Compile JsExp

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

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]

equalExps :: JsExp -> JsExp -> JsExp

isConstant :: JsExp -> Bool

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

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

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

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.

thenm :: JsExp -> JsExp -> JsExp

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 :: String -> JsExp -> JsExp

force :: JsExp -> JsExp

Force an expression in a thunk.

forceInlinable :: Config -> 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.

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

Parse result.