Example for reading prolog file, adding a clause and unifying

[vasily-kartashov]

I am looking for an example of how to

• Load a Prolog script,
• Add few more facts to the load program programmatically
• Find a solution to a resulting predicate

In details, let say I have a script main.pl:

increment(A, B) :-
    diff(C),
    B is A + C.   

Then I'd like to enhance it on Java side

Struct.of("diff", Integer.of(15));

and then run

Struct.of("increment", Atom.of(15), Integer.of("X"));

... something that the returns the value of X as an int

[gciatto]

Hello @vasily-kartashov ,
I can produce that example today.
Do you prefer a Java example, a Kotlin example or something else?

[gciatto]

Exception occurring when doing what?

[vasily-kartashov]

Oh, when I run the example

package com.kartashov.prolog.benchmark.tup;

import it.unibo.tuprolog.core.Integer;
import it.unibo.tuprolog.core.Struct;
import it.unibo.tuprolog.core.Var;
import it.unibo.tuprolog.solve.Solver;
import it.unibo.tuprolog.theory.Theory;
import it.unibo.tuprolog.theory.parsing.ClausesReader;

import java.io.IOException;

class Runner {
    public static void main(String... args) throws IOException {
        var reader = ClausesReader.getWithDefaultOperators();
        var theory = readTheory(reader, "prelude.prolog");
        var solver = Solver.getClassic().mutableSolverWithDefaultBuiltins(theory);
        var fact = Struct.of("diff", Integer.of(15));
        solver.assertZ(fact);

        var query = Struct.of("increment", Integer.of(15), Var.of("X"));
        var solution = solver.solveOnce(query);
        if (solution.isYes()) {
            var value = solution.getSubstitution().getByName("X");
            var valueAsBigInteger = value.asInteger().getValue();
            int actualValue = valueAsBigInteger.toInt();
            System.out.println(actualValue); // should print 30
        }
    }

    private static Theory readTheory(ClausesReader reader, String name) {
        var stream = Runner.class.getClassLoader().getResourceAsStream(name);
        if (stream == null) {
            throw new RuntimeException("Cannot load program");
        }
        return reader.readTheory(stream);
    }
}

[gciatto]

BTW the exception message suggests it is an issue occurring when accessing some SolverFactory dynamically, eg via Solver. getClassic() or Solver.getStream().

That usually means the solve-classic or solve-streams modules are not in class path (only one is needed though).
Yet, this should not be the case, since apparently you're declaring dependencies correctly.

Try using the ClassicSolverFactory explicitly instead of Solver.getClassic()

[vasily-kartashov]

@gciatto-unibo ClassicSolverFactory.INSTANCE did the trick, thank you!

[gciatto]

Nice to hear.
BTW that means :solve-classic is in the classpath... so I don't see why Solver.getClassic() doesn't work. This is an issue.
Can you please open an issue on the GitLab repo, providing details on how to reproduce the problem?

No hurry, take your time.

[vasily-kartashov]

@gciatto-unibo I'll make the whole project publicly available at one point, which will make referencing the issues much simpler.

On an unrelated note. You've mentioned that Primitive allows exposing Java code to Prolog. Is there an example? I'd like to start with a really simple predicate like log:info("The request {}", Request) that will channel the input to a default java logger.

[gciatto]

There is no primitive example in Java atm. I can produce one, but I currently on vacation.

So best I can to atm is to explain the steps in a post.

BTW this is an interesting topic, so maybe we should spawn a new discussion.

For the moment, you may perform logging without primitives: just change the default OutputChannel the Solver uses as stdOut. The stdOut channel is the sink where messages are output whenever the prolog solver meets a write/1 predicate. On the Java side OutputChannels may be created out of lambda expressions, which may, in turn, propagate the output string to some logger. The stdOut channel of a MutableSolver can be replaced via ad-hoc methods.

[vasily-kartashov]

@gciatto-unibo Cheers.

Another question that interests me is support for modules. I am looking for a way to "explain" to the TheoryReader how to resolve module names to let's say InputStreams, and let the module and use_module directives to guide the assembly?

Something along those lines:

var reader = ClauseReader.withNameResolver(name -> {
    var path = name + ".prolog";
    return Runner.class.getClassLoader().getResourceAsStream(path);
});
reader.readTheory("application");

and with the application.prolog as:

:- use_module(prelude).

server(Request, Response) :-
   ...

and the prelude.prolog being:

:- module(prelude, [...]).

...

---

In the end I'd like to have a Runner java app, containing most of the webserver logic, compiled into an executable jar. And then this runner jar should be able to bootstrap from a single file that I feed to it

/runner
    /src
        ...
    /target
        runner.jar
/application
    application.prolog
    library.prolog
    other_modules.prolog

So I'd like to be able to say

java -jar runner/target/runner.jar $(pwd)/application/application.prolog

and the runner should be able to resolve the rest of the modules all by itself.

[gciatto]

If the module to be loaded is a prolog file, you can exploit the consult/1 predicate which becomes available by adding the IOLib into your solver.

Otherwise, if you want to load a Kotlin-based library from Prolog, say the IOLib itself, this is currently not supported. More in general, a Prolog ISO Standard module management system is currently missing, so there use no use_module predicate ATM.

If you need it, you may add a feature request on GitLab and I'll take care of it in the next months.

However, if I have correctly understood your idea, you want to execute some prolog code upon each http request.
If the prolog code you're relying upon should be executed very frequently, I suggest avoiding consulting a theory on the fly: that involves parsing the same prolog script over and over again.

Conversely, it would be far more efficient to parse any external theory once and for all in Java, then initialising a new solver out of them upon each http request.
Initialising a solver out of a parsed theory is very efficient instead.

[vasily-kartashov]

@gciatto-unibo Thank you for your help!

So here's how I envisioned it: https://github.com/vasily-kartashov/FrameworkBenchmarks/tree/master/frameworks/Prolog/tuprolog

To test it you can run from the root of the project:

./tfb --mode benchmark --test tuprolog

There are more test cases to cover, a lot to refactor and optimize, but the idea should be more palpable. I'll continue with more detailed questions in separate discussion topics to avoid polluting this one.

[gciatto]

@vasily-kartashov I've exemplified how primitives can be written in Java:
https://github.com/tuProlog/2p-kt/blob/master/examples/src/test/java/it/unibo/tuprolog/examples/PrimitiveExamplesJvm.java

The example relies on version 0.18.0 which should be publicly available in a few hours.