tau-prolog / sandbox

An online Tau Prolog sandbox

Tau Prolog

A Prolog interpreter in JavaScript

Tau Prolog is a client-side Prolog interpreter fully implemented in JavaScript, whose development has been directed by the ISO Prolog Standard.

ISO Prolog Standard compliance. Tau Prolog development has been directed by the ISO Prolog Standard, designed to promote the applicability and portability of Prolog text and data among several data processing systems.

Compatible with browsers and Node.js. Tau Prolog has been developed to be used with either Node.js or a browser seamlessly. Just use the <script> tag or the require function to add Tau Prolog to your project and start coding.

DOM manipulation and event handling. Taking the best from JavaScript and Prolog, Tau Prolog allows you to handle browser events and modify the DOM of a web using Prolog predicates, making Prolog even more powerful.

Asynchronous predicates. Tau Prolog has been developed following a non-blocking, callback-based approach, allowing you, for instance, to sleep the main thread or to do AJAX requests without blocking the browser.

A brief look

1. Load the library

<script src="tau-prolog.js"></script>

2. Create a session

var session = pl.create();

3. Consult a program

session.consult(`
    likes(sam, salad).
    likes(dean, pie).
    likes(sam, apples).
    likes(dean, whiskey).
`, {
    success: function() { /* Program loaded correctly */ },
    error: function(err) { /* Error parsing program */ }
});

or

session.consult("path/to/src.pl", {
    success: function() { /* Program loaded correctly */ },
    error: function(err) { /* Error parsing program */ }
});

4. Query a goal

session.query("likes(sam, X).", {
    success: function(goal) { /* Goal loaded correctly */ },
    error: function(err) { /* Error parsing goal */ }
});

5. Look for answers

session.answer({
    success: function(answer) {
        console.log(session.format_answer(answer)); // X = salad ;
        session.answer({
            success: function(answer) {
                console.log(session.format_answer(answer)); // X = apples ;
            },
            // ...
        });
    },
    fail: function() { /* No more answers */ },
    error: function(err) { /* Uncaught exception */ },
    limit: function() { /* Limit exceeded */ }
});

This is a general scheme of how to use Tau Prolog:

// Consult
session.consult(program, {
    success: function() {
        // Query
        session.query(goal, {
            success: function(goal) {
                // Answers
                session.answer({
                    success: function(answer) { /* Answer */ },
                    error:   function(err) { /* Uncaught error */ },
                    fail:    function() { /* Fail */ },
                    limit:   function() { /* Limit exceeded */ }
                })
            },
            error: function(err) { /* Error parsing goal */ }
        });
    },
    error: function(err) { /* Error parsing program */ }
});

For further information, check the Documentation.

Downloads

You can download a custom bundle including only the modules you need here. Source code of Tau Prolog is available on GitHub. You can also install Tau Prolog from npm:

$ npm install tau-prolog

Documentation

Get Started with Tau Prolog

• A simple tutorial
• Compatibility with Node.js
• Manipulating the DOM with Prolog
• Making your own packages
• Promises interface
• Prototypes and Prolog objects

Prolog Predicate Reference

• Built-in predicates
• Lists module
• DOM module
• Random module
• Statistics module
• JavaScript module
• OS module
• CharsIO module
• Format module
• Concurrent module

License

Tau Prolog source code is released under the terms of the BSD 3-Clause License.

sandbox's Issues

Feature request non-blocking sandbox, ev. needs yielding engine

TauProlog has a new interfaces:

promiseQuery: queries a goal and returns a promise that is resolved
when the goal loads successfully, or rejected when there is an error. It
takes the same arguments as the query method.
http://tau-prolog.org/manual/promises-interface

The test case was a large limit and then:

longrunning :- 
    between(1,300,_),
    between(1,300,_),
    between(1,300,_),
    fail.
longrunning.

But I find that this sandbox here is blocking:

http://tau-prolog.org/sandbox/

Is there another sandbox already online?

Consider indent through write/1

Hi,

I tried code that does indent through write, by
adding spaces in front of the text. But it didn't work.

Was more expecting as output display:

abc
  def
ghi

Bye

Output Strings in the Sandbox Console.

I need to output text to the sandbox query console, either with write or format. Write output the text as a list and write("Testtext") returns [T,e,s,t,t,e,x,t] for example, isnstead of "Testtext".
I don´t get format to work at all.

How can I output strings as strings with write, or format in the sandbox?

Reconsult

According to the ISO core standard, it is allowed to dynamically
create clauses of a predicate, even if it doesn't have a dynamic
declaration. assertz/1 and friends are allowed to do this.

But since it is implicit dynamic, it should then be retrievable
via the clause/2 builtin. Currrently I get the following:

sandbox: save dialog cannot be cancelled

1. Press Save in the Menu of the sandbox.
2. A nice dialog box is show asking for Title and Description
3. Now, I do not want to save what I did, but want to continue writing my program
4. Neither [Escape] work, nor I see any Cancel box.
5. So I am now forced to give up what I did or do an unnecessary save

Parsing error gives JavaScript error

This works fine:

?- hilbert((p->p), X, 2).
X = 'ax-mp'('ax-mp'('ax-2','ax-1',(p->(_114->__115->_114)->p)),
'ax-mp'('ax-1','ax-1',(_114->__115->_114)),(p->_114->__115->_114)) ;
parsing query: hilbert((p->p),X,2) ok!

But when I forget the parenthesis around p->p, it redirects me to GitHub:

?- hilbert(p->p, X, 2).
javascript error: TypeError: try_answer(...) is undefined
Report error on GitHub
error parsing query:throw(error(syntax_error(', or ) expected'),[line(1),column(9),found(->)]))

I am more expecting a parsing error without a JavaScript error.

strange slowdown when typing query larger than input field

I get this errror:

Also chrome kind of halts when the right margin of the query field is reached.

Feature request write family of predicates in the sandbox

Would it be possible to allow write inside the sandbox?
Currently these ISO core standard predicates are simply
not recognized:

But interestingly SWISH allows them;

Entering space cancels line of entered text under Mobile Firefox

(This problem does not exist under Mobile Chrome)

When entering text for an interactive query, typing space cancels the entire line of text typed so far.

This used to work some time ago.

Firefox Version 66.0.2

It could be the case that not all errors in the program are reported

I was playing around with the Tau Prolog sandbox. My expectation
was to gain some information whether an export/1 directive
exists or not. If it exists I wouldn't see an error, and if it doesn't
exists I would get some error. Neither happens right now:

HTML eats <

Enter the query:

I=1,N is 1 <<I.

And Tau responds with:

?- I=1,N is 1 <

So everything behind the < is eaten by HTML (in the HTML source, the first < is written as < and the second is not).