13.3 Accessing JavaScript from Prolog

This section describes how we can interact with JavaScript from Prolog. The interface is captured in a single predicate :=/2/.

Left := Right

Depending on Left, this predicate implements two different actions. If Left is a Prolog variable, it evaluates the expression Right in JavaScript and unifies the result to Left. If Left is a term Obj[Key], where Key is an atom, it accesses a JavaScript setter. The general form of an expression is Expression[Callable] or simply Callable. If Callable is compound it expresses a function (or method) call. Otherwise we call JavaScript eval(), except for these special values:

window

The main browser window itself (undefined when not in a browser).

prolog

The Prolog instance.

Prolog values are translated according to the rules in section 13.2.2.2 and the result is translated back to Prolog according to the rules in section 13.2.2.1. Because callables are translated to function calls, object properties or global variables we need an escape to pass them as data. This is achieved using the prefix operator #. Note that lists are passed as JavaScript arrays rather than calls to the list functor. For convenience Prolog strings are by default translated to JavaScript String objects rather than Prolog.String instances. Below are some examples:

?- Res := myfunc([1,2,3]).
?- Max := 'Math'.max(10, 20).
?- Out := document.getElementById('output').
?- Par := document.createElement(p),
   Par.textContent := #Text.
?- Par.textContent := "aap" + " " + "noot".

Some JavaScript expressions are not implemented as functions. The following “functions” are handled directly by the implementation.

instanceof

Returns the name of the class to which the object belongs. Same as Obj.constructor.name.

instanceof(ClassName)

Returns a Boolean indicating whether the object is an instance of ClassName. Note that the class name must be an atom and as JavaScript class names normally start with a capital, the names dypically need to be quoted using single quotes. For example:

?- W := window, T := W.instanceof('Window').
W = <js_Window>(1),
T = true.

-(Any)

Numerical negation

!(Any)

Logical negation.

+(Any, Any)

-(Any, Any)

*(Any, Any)

/(Any, Any)

&(Any, Any)

|(Any, Any)

&&(Any, Any)

||(Any, Any)

Binary operators. Note that some are not defined as Prolog operators and thus one must write e.g. A := &&(true,false). || is not a Prolog atom, so logical disjunction gets A := '||'(false,false).

[semidet]is_object(@Term)

True if Term is a reference to a JavaScript object.

[semidet]is_object(@Term, ?Class)

True when Term is an instance of Class. If Class is unbound it is unified with the name of the constructor, otherwise a JavaScript Term instanceof Class is executed.

js_script(+String, +Options)

Evaluate String as JavaScript. This is designed to cooperate with string quasi quotations, so we can write e.g.,

:- use_module(library(strings)).
:- js_script({|string||
function myfunc(a)
...
|}).

The implementation uses =:/2, calling the JavaScript function eval().

fetch(+URL, +Type, -Data)

Wrapper around JavaScript fetch(), conversion of the Response object and waiting for the Promise. Type is an atom or string that is used as method on the Response object. Examples are text, json, html or blob. The blob type returns the Data as a string of bytes, i.e., character codes in the range 0 ... 255.

13.3.1 Asynchronous access to JavaScript from Prolog

While section 13.3 describes synchronous calls from Prolog to JavaScript, we also need asynchronous calling to implement sleep/1, wait for user input, downloading documents from the web, etc. Asynchronous calling is achieved by yielding from the Prolog virtual machine. This can only be done when Prolog is told to expect that the VM may yield. This is implemented by Prolog.forEach() as described in section 13.2.

[det]await(+Promise, -Result)

Yield the Prolog VM, returning control back to JavaScript. When this is called from Prolog invoked using Prolog.forEach(), execution of await/2 completes when the Promise resolves and Result is unified with the value passed to the Promise.then() method. As an exception to the normal conversion rules, if the result is a single String, it is returned as a Prolog string rather than an atom. When the Promise is rejected await/2 throws an exception. Note that await/2 allows, for example, downloading a URL from Prolog:

?- FP := fetch("test.pl"), await(FP, Response),
   TP := Response.text(), await(TP, T).
FP = <js_Promise>(4),
Response = <js_Response>(5),
TP = <js_Promise>(6),
T = "% :- debug(js) ...".

Calls to await/2 may be asynchronously aborted by calling Prolog.abort() if Promise implements .abort(). See section 13.3.2 for implementing such a promise.

[semidet]is_async

True when we can call await/2 in the current state. This implies Prolog has been called from JavaScript code that is prepared to deal with Prolog yielding and Prolog is not inside a callback from C (WASM).

13.3.2 JavaScript Promise that can be aborted

A Promise resolves or is rejected. As Prolog waits for a specific promise on a call to await/2 we may want to abort long running operations. This may be achieved using the class Prolog.Promise which extends Promise. To make the promise abortable the executor function must have an abort property. Below is the code for Prolog.promise_sleep() that implements this schema. First we create the executor and use properties on the function itself to represent the necessary state information (here, the running timer). Next, we add an abort property the clears the timer and runs the reject callback of the Promise. Finally we return an instance of Prolog.Promise which implements .abort().

promise_sleep(time)
{ const f = function(resolve, reject)
  { f.reject = reject;
    f.timer = setTimeout(() =>
      { f.timer = undefined;
        resolve(true);
      }, time*1000);
  };

  f.abort = function()
  { if ( f.timer )
    { clearTimeout(f.timer);
      f.timer = undefined;
      f.reject("abort");
    }
  }

  return new Prolog.Promise(f);
}