Things that can be marshalled into javascript values. Instantiate for any necessary data structures.

The ToStat class handles injection of of things into the EDSL as a JS statement. This ends up being polymorphic sugar for JS blocks, see helper function expr2stat. Instantiate for any necessary data structures.

Type class that generates fresh a's for the JS backend. You should almost never need to use this directly. Instead use JSArgument, for examples of how to employ these classes please see jVar, jFunction and call sites in the Rts.

Type class that finds the form of arguments required for a JS syntax object. This class gives us a single interface to generate variables for functions that have different arities. Thus with it, we can have only one jFunction which is polymorphic over its arity, instead of jFunction2, jFunction3 and so on.

Convert a FastString to a Javascript String

Create a new anonymous function. The result is a JExpr expression. Usage:

jLam $ \x -> jVar x + one_
jLam $ \f -> (jLam $ \x -> (f `app` (x `app` x))) `app` (jLam $ \x -> (f `app` (x `app` x)))

Special case of jLam where the anonymous function requires no fresh arguments.

Construct a top-level function subject to JS hoisting. This combinator is polymorphic over function arity so you can you use to define a JS syntax object in Haskell, which is a function in JS that takes 2 or 4 or whatever arguments. For a singleton function use the Solo constructor MkSolo. Usage:

an example from the Rts that defines a 1-arity JS function > jFunction (global "h$getReg") ((MkSolo n) -> return $ SwitchStat n getRegCases mempty)

an example of a two argument function from the Rts > jFunction (global "h$bh_lne") ((x, frameSize) -> bhLneStats s x frameSize)

Construct a top-level function subject to JS hoisting. Special case where the arity cannot be deduced from the args parameter (atleast not without dependent types).

Construct a top-level function subject to JS hoisting. Special case where the function binds no parameters

Introduce only one new variable into scope for the duration of the enclosed expression. The result is a block statement. Usage:

'jVar $ x -> mconcat [jVar x ||= one_, ...'

Introduce one or many new variables into scope for the duration of the enclosed expression. This function reifies the number of arguments based on the container of the input function. We intentionally avoid lists and instead opt for tuples because lists are not sized in general. The result is a block statement. Usage:

jVars $ (x,y) -> mconcat [ x |= one_,  y |= two_,  x + y]

Create a for statement given a function for initialization, a predicate to step to, a step and a body Usage:

 jFor (|= zero_) (.<. Int 65536) preIncrS
        (j -> ...something with the counter j...)

Create a 'for in' statement. Usage:

jForIn {expression} $ x -> {block involving x}

As with "jForIn" but creating a "for each in" statement.

As with "jForIn" but creating a "for each in" statement.

Declare a variable and then Assign the variable to an expression

foo |= expr ==> var foo; foo = expr;

Assign a variable to an expression

foo |= expr ==> var foo = expr;

JS infix Equality operators

JS infix Equality operators

JS infix Equality operators

JS infix Equality operators

return the expression at idx of obj

obj .! idx ==> obj[idx]

JS infix Ord operators

JS infix Ord operators

JS infix Ord operators

JS infix Ord operators

JS infix bit shift operators

JS infix bit shift operators

JS infix bit shift operators

JS infix bit operators

JS infix bit operators

JS infix bit operators

JS if-expression

if_ e1 e2 e3 ==> e1 ? e2 : e3

if-expression that returns 1 if condition = true, 0 otherwise

if10 e ==> e ? 1 : 0

if-expression that returns 0 if condition = true, 1 otherwise

if01 e ==> e ? 0 : 1

If-expression which returns statements, see related ifBlockS

if e s1 s2 ==> if(e) { s1 } else { s2 }

If-expression which returns blocks

ifBlockS e s1 s2 ==> if(e) { s1 } else { s2 }

Version of a JS if-expression which admits monadic actions in its branches

A when-statement as syntactic sugar via ifS

jwhenS cond block ==> if(cond) { block } else {  }

an application expression, see related appS

app f xs ==> f(xs)

A statement application, see the expression form app

Return a JStgExpr

"for" loop with increment at end of body

"for" loop with increment at end of body

Prefix-increment a JStgExpr

Postfix-increment a JStgExpr

Prefix-decrement a JStgExpr

Postfix-decrement a JStgExpr

Byte indexing of o with a 8-bit offset

Byte indexing of o with a 16-bit offset

Byte indexing of o with a 32-bit offset

Byte indexing of o with a 64-bit offset

a bit mask to retrieve the lower 8-bits

a bit mask to retrieve the lower 16-bits

Sign-extend/narrow a 8-bit value

Sign-extend/narrow a 16-bit value

Given a JStgExpr, return the its type.

The empty JS statement

Select a property prop, from and object obj

obj .^ prop ==> obj.prop

The empty JS HashMap

A singleton JS HashMap

insert a key-value pair into a JS HashMap

Construct a JS HashMap from a list of key-value pairs

The JS literal null

The JS literal undefined

The JS literal false

The JS literal true

The JS literal 0

The JS literal 1

The JS literal 2

The JS literal 3

construct a js declaration with the given identifier