manual's Introduction

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

Load the library

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

Create a session

var session = pl.create();

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 */ }
});

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

Query a goal

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

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

License

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

manual's People

Contributors

Stargazers

Watchers

manual's Issues

Minor typo on the Prototypes and Prolog objects page

On this page:

http://tau-prolog.org/manual/prototypes-and-prolog-objects

Look for "wheter". Change to "whether".

Documentation suggestion: explanation of threads in Javascript context

I searched through the documentation and so far I could not find any text that gives an overview on what Tau-Prolog threads are. I'm not looking for an extensive technical discussion, just something that differentiates what they are from the normal definition of threads. Given that the Javascript interpreter is single threaded, I assume that that Tau-Prolog threads are a custom construct whose execution scheduling is controlled by Tau-Prolog itself?

I hope you can see my confusion here given that the Javascript interpreter is single-threaded. For veteran developers, threads in the classic sense are an execution resource that is scheduled at the O/S level via task switching.

Note, a short example that shows a simple use case for Tau-Prolog threads would be wonderful. Threads seem to be a very useful feature that I would like to understand.

Typo found in built-in predicates page

On this page:

http://tau-prolog.org/documentation#builtin

Look for "descomposition". Change it to "decomposition".

=../2 – Check the descomposition of a term.

Suggested additional text:

This is known as the "univ" operator in Prolog.

That way the reader can search the web for additional information on the operator, which will be very hard to do using the the text "=.." as a search term.

JavaScript linter frowns upon var, suggests let or const

Was just having a look at:
http://tau-prolog.org/manual/compatibility-with-nodejs

And the example snippet:

var pl = require("tau-prolog");

But my JavaScript linter from IntelliJ says I should use let or const.

tau-prolog / manual Goto Github PK