The Prolog class provides several methods for calling
Prolog from JavaScript.
String and returns
true or false. This simple calling pattern is
intended for trivial goals such as setting a Prolog flag. For example,
the call below limits the Prolog stacks to 10Mb.
Prolog.call("set_prolog_flag(stack_limit, 10 000 000)");
String, optionally binding
Prolog variables embedded in Goal from properties of the Object
Input. The returned object is an instance of class Query.
This instance can be used as a JavaScript iterator. The value
returned in each iteration is an Object with properties for
each variable in Goal that is not in Input and
does not start with an underscore. For example, we can iterate over the
members of a list like below. Further details on class Query
are provided in section
13.2.1. The translation of data between Prolog and JavaScript is
described in section
13.2.2.
for(let r of Prolog.query("member(Elem,List)",
{List: ["aap", "noot", "mies"]}))
{ console.log(r.Elem);
}
This interface is also practical for calling (fast) Prolog predicates
to compute a single answer from an input using the Query.once()
method. Assuming a Prolog predicate fib/2 that computes the nth Fibonacci
number, we can call this using the code below. Note that if the fib/2
fails or raises an exception the object returned by Query.once()
does not contain the
Out key and thus our function returns undefined.
function fib(in, out)
{ return Prolog.query("fib(In,Out)", {In:in}).once().Out;
}
The .query() method is indented for fast queries
that do not require the yield mechanism, i.e., the execution
should not require asynchronous operations and the browser is not
responsive during the execution.
.query(). For each answer, OnAnswer
is a
Function that is called with a Object that
holds the bindings for the output arguments of Goal.
The returned Promise is resolved when the query
completes. The value passed to the .then() method of
the Promise is the number of answers if OnAnswer
is provided or an Array of answers if OnAnswer
is omitted. If Goal raises an exception the Promise
is rejected.
Multiple calls to Prolog can be activated at any time. Prolog
processes such queries in LIFO (Last In, First Out)
mode. If queries need to be processed sequentially use JavaScript await
or the Promise.finally() method to wait for
completion.
The method Prolog.query()
returns an instance of the JavaScript class Query that may
be used to explore the solutions of the query. The Query
class implements the JavaScript iterator protocol.
done and value. If exception
handling is enabled it returns an object
{done:true, error:true,
message:String}..value
of the object returned by .next() on success and the
complete object on failure or error. In addition, on a logical result
(no error), a field
success is added with a boolean value. Thus, the return
value may contain these keys:
success key is set to true.success:false}error:true, message:String}
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.
new Prolog.String(text)
to create a Prolog string. See below.true or false.undefined.null.$:Typev holds the text. May be
created using new Prolog.string(text). May be created using new
Prolog.String(text).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.point(1,2) is constructed using
{$:"t", point:[1,2]}. May be created using new
Prolog.Compound(functor, args)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).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).Objectdict.
Note that JavaScript object keys are always strings and (thus) all dict
keys are atoms. This, {1:"one"} is translated into
_{'1': one}.ArrayBuffer are translated into a Prolog
string that consists of characters in the range 0 ... 255.Object<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.
Prolog.Variable instance where
the identifier is a unique number of each unique variable.Number when possible or
BigInt otherwise. Currently JavaScript Number
can represent integers upto 2^53 precisely.Prolog.Rational instance.Number.String.Prolog.String instance.Array,
otherwise create a JavaScript Prolog.List instance.Prolog.Compound instance.Object with the same keys. If the
dict has a non-var tag, add a $tag property.