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