13.2.2 Translating data between JavaScript and Prolog

JavaScript and Prolog are both dynamically typed languages. The WASM module defines a faithful translation between JavaScript data and Prolog data that aims at completeness as well as keeping the data representation clean in the common cases. We describe the translation in two descriptions because round tripping does not always result in the original object.

13.2.2.1 Translating JavaScript data to Prolog

This section describes how data from JavaScript is translated into Prolog. The interface is primarily designed for passing JavaScript data as typically used to a natural Prolog representation. In addition a number of classes are provided to create Prolog specific data structures such as strings (as opposed to atoms), variables, compound terms, etc.

Number

Translate to a Prolog integer or floating point number.

BigInt

Translate to a Prolog integer.

String

Translate to a Prolog atom. Use new Prolog.String(text) to create a Prolog string. See below.

Boolean

Translate to one of the Prolog atoms true or false.

undefined

Translate the Prolog atom undefined.

null

Translate the Prolog atom null.

Array

Translate to a Prolog list.

Objects holding the key $:Type

Such objects are converted depending on the value for this key. The interface defines classes to simplify creating such objects.

s

Represent a Prolog string. The key v holds the text. May be created using new Prolog.string(text). May be created using new Prolog.String(text).

r

Represent a Prolog rational number. The keys n and d represent the numerator and denominator. For example, to represent 1r3, use {$:"r", n:1, d:3}. May be created using new Prolog.Rational(n, d), where n and d can be JavaScript numbers or big integers.

t

Represent a Prolog compound term. The object should hold exactly one key whose value is an array that holds the argument values. For example a term point(1,2) is constructed using {$:"t", point:[1,2]}. May be created using new Prolog.Compound(functor, args)

v

Represent a variable. If the key v is present this identifies the variable. Two variables processed in the same translation with the same identifier represent the same Prolog variable. If the v key is omitted the variable will be unique. May be created using new Prolog.Var(id).

l

Represent a Prolog list. As a JavaScript Array we only need this typed object to create a partial list. The v key contains the “normal” elements and the key tail contains the tail of the list. May be created using new Prolog.List(array, tail).

Object of class Object

Plain JavaScript objects are translated into a Prolog dict. Note that JavaScript object keys are always strings and (thus) all dict keys are atoms. This, {1:"one"} is translated into _{'1': one}.

ArrayBuffer

Instances of ArrayBuffer are translated into a Prolog string that consists of characters in the range 0 ... 255.

Objects of a one class not being Object

Instances of non-plain JavaScript objects are translated into a Prolog blob. Such objects are written as <js_Class(id)>. The Prolog interface allows for passing the objects back and calling methods on them. See section 13.3.

13.2.2.2 Translating Prolog data to JavaScript

Most of the translation from Prolog data to JavaScript is the reverse of the translation described in section 13.2.2.1. In some cases however reverse translation is ambiguous. For example, both 42 and 42n (a JavaScript BigInt) translate to a simple Prolog integer. The other way around, as JavaScript Number is a float, both Prolog 42 and 42.0 translate to 42 in JavaScript.

Variable

Translate to a JavaScript Prolog.Variable instance where the identifier is a unique number of each unique variable.

Integer

Translate to a JavaScript Number when possible or BigInt otherwise. Currently JavaScript Number can represent integers upto 2^53 precisely.

Rational

Translate to a JavaScript Prolog.Rational instance.

Float

Translate to a JavaScript Number.

Atom

Translate to a JavaScript String.

String

Translate to a JavaScript Prolog.String instance.

List

When a proper list create a JavaScript Array, otherwise create a JavaScript Prolog.List instance.

Compound term

Create a JavaScript Prolog.Compound instance.

Dict

Create a plain JavaScript Object with the same keys. If the dict has a non-var tag, add a $tag property.