GHC.JS.Make

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

Solo is the canonical lifted 1-tuple, just like Tuple2 is the canonical lifted 2-tuple (pair) and Tuple3 is the canonical lifted 3-tuple (triple).

The most important feature of Solo is that it is possible to force its "outside" (usually by pattern matching) without forcing its "inside", because it is defined as a datatype rather than a newtype. One situation where this can be useful is when writing a function to extract a value from a data structure. Suppose you write an implementation of arrays and offer only this function to index into them:

index :: Array a -> Int -> a

Now imagine that someone wants to extract a value from an array and store it in a lazy-valued finite map/dictionary:

insert "hello" (arr index 12) m

This can actually lead to a space leak. The value is not actually extracted from the array until that value (now buried in a map) is forced. That means the entire array may be kept live by just that value! Often, the solution is to use a strict map, or to force the value before storing it, but for some purposes that's undesirable.

One common solution is to include an indexing function that can produce its result in an arbitrary Applicative context:

indexA :: Applicative f => Array a -> Int -> f a

When using indexA in a pure context, Solo serves as a handy Applicative functor to hold the result. You could write a non-leaky version of the above example thus:

case arr indexA 12 of
  Solo a -> insert "hello" a m

While such simple extraction functions are the most common uses for unary tuples, they can also be useful for fine-grained control of strict-spined data structure traversals, and for unifying the implementations of lazy and strict mapping functions.

construct a js declaration with the given identifier