Previous: , Up: Web deployment   [Contents][Index]

3.2 JavaScript API reference

The Scheme class is used to load a Hoot binary, start the program, and initialize reflection.

Class: Scheme

A Scheme runtime environment.

Static method on Scheme: load_main path abi [user_imports {}]

Fetch and execute the Hoot Wasm binary at the URL path and return an array of Scheme values produced by the program.

The abi parameter is for more advanced usage where multiple Hoot binaries share a single application binary interface (ABI). This should be set to {} when loading the first Scheme binary. It is better to use the load_extension method for subsequent binaries, though.

The user_imports parameter is for providing concrete implementations of functions declared using the Foreign function interface. It uses a two-tier nested object structure to map import names to the functions that implement them.

For example, this Scheme code:

(define-foreign make-text-node
  "document" "createTextNode"
  (ref string) -> (ref null extern))

Could be instantiated like so:

Scheme.load_main("hello.wasm", {}, {
  document: {
    createTextNode: Document.prototype.createTextNode.bind(document)
Method on Scheme: load_extension path [user_imports {}]

Fetch and load an additional Hoot binary at the URL path that shares the ABI of this. Optionally, a set of user-defined imported functions can be specified with the user_imports parameter.

All of the fundamental Scheme types have an associated JavaScript class that can reflect their values. Calling the repr function on an instance of a reflected Scheme object will return a Scheme-like printing of the object.

repr(pair) // => "(1 . 2)"
Class: Char

A Unicode character.

Class: Eof

End-of-file object.

Class: Null

The empty list.

Class: Unspecified

The unspecified value.

Class: Complex real imag

Complex number with real part real and imaginary part imag.

Class: Fraction num denom

An exact fraction with numerator num and denominator denom.

The HeapObject class is the parent class of all of the remaining Scheme types.

Class: HeapObject

A Scheme heap object.

Instance Variable of HeapObject: reflector

The reflector for this, an instance of the Scheme class.

The reflector property can be used in conjuction with the load_extension method to load additional Hoot binaries that share the same ABI.

Class: Procedure

A Scheme procedure.

Procedure instances can be invoked with the call method to perform a Javascript to Scheme function call.

Method on Procedure: call args…

Call procedure with args and return an array of result values.

Class: Pair

An immutable cons cell.

Class: MutablePair

A mutable cons cell.

Class: Vector

An immutable vector.

Class: MutableVector

A mutable vector.

Class: Bytevector

An immutable bytevector.

Class: MutableBytevector

A mutable bytevector.

Class: Bitvector

An immutable bitvector.

Class: MutableBitvector

A mutable bitvector.

Class: MutableString

A mutable string.

Class: Sym

A symbol.

Class: Keyword

A keyword.

Class: Variable

A mutable variable.

Class: AtomicBox

A mutable box with atomic updates.

Class: HashTable

A hash table.

Class: WeakTable

A weak key hash table.

Class: Fluid

A dynamic variable.

Class: DynamicState

A set of fluids.

Class: Syntax

A syntax object.

Class: Port

An I/O port.

Class: Struct

A user-defined structure.

Previous: Web server setup, Up: Web deployment   [Contents][Index]