Java/Scala/Prolog Integration and Cross-Platform Scala

1. Why Java-Scala-Prolog Integration

Each language in the trio brings distinct strengths:

Example application areas: an agent whose reasoning engine is written in Prolog; a game where the AI opponent's strategy is specified declaratively in Prolog; using Prolog databases for storing knowledge and running inference rules.

2. Integration Approaches

The course identifies four integration strategies, each with different trade-offs:

In tuProlog 4.0, the following technologies are available for each direction:

• Prolog using Java (library-oriented): ->/2, new_object/3, returns/2
• Java using Prolog (library-oriented): Term hierarchy, Engine class
• Prolog using Java (encapsulation-oriented): a Java class becomes a Prolog library
• Scala using Prolog (encapsulation-oriented): a Prolog theory embedded into Scala

3. Prolog Calling Java

tuProlog allows Prolog code to create and manipulate Java objects directly through three key predicates.

new_object/3

Creates a Java object from Prolog:

new_object(+ClassName, +ArgumentList, -ObjRef)

Calls the Java constructor of ClassName, passing ArgumentList, and unifying ObjRef with the resulting object reference (an opaque term like '$obj2').

<-/2 (Method Call)

Calls a method on a Java object (no return value expected):

ObjRef <- MethName(Args)

returns/2 (Method Call with Result)

Calls a method and captures the return value:

ObjRef <- MethName(Args) returns ObjRef2

Example: Creating a Window from Prolog

Vector Example

A library-like Prolog module wrapping java.util.Vector:

vector_new(V) :- new_object('java.util.Vector', [], V).
vector_add(V, E) :-
    new_object('java.lang.Integer', [E], I),
    V <- add(I).
vector_size(V, S) :- V <- size returns S.
vector_lookup(V, P, E) :- V <- elementAt(P) returns E.

% Usage:
% ?- vector_new(X), vector_add(X,1), vector_add(X,2), vector_lookup(X, 0, N).

4. Java Calling Prolog

The tuProlog Java library provides a full API for embedding a Prolog engine in Java applications. The main classes are in the alice.tuprolog package.

Core Classes

Direct Goal Solution

import alice.tuprolog.*;

public class Test1 {
    public static void main(String[] args) throws Exception {
        Prolog engine = new Prolog();
        SolveInfo info = engine.solve("append([1],[2,3],X).");
        System.out.println(info.getSolution());
        // "append([1],[2,3],[1,2,3])"
    }
}

Getting All Solutions

public class Test2 {
    public static void main(String[] args) throws Exception {
        Prolog engine = new Prolog();
        SolveInfo info = engine.solve("append(X,Y,[1,2,3]).");
        while (info.isSuccess()) {
            System.out.println("solution: " + info.getSolution()
                + " - bindings: X/" + info.getTerm("X")
                + " Y/" + info.getTerm("Y"));
            if (engine.hasOpenAlternatives()) {
                info = engine.solveNext();
            } else { break; }
        }
    }
}

Creating and Using Terms Programmatically

public class Test3 {
    public static void main(String[] args) throws Exception {
        Prolog engine = new Prolog();

        // Parse a term from string
        Term list1 = engine.toTerm("[1]");

        // Build terms programmatically
        Term list2 = new Struct(new Term[]{new Int(2), new Int(3)});

        // Build compound term
        Term app = new Struct("append", list1, list2, new Var("X"));

        SolveInfo info = engine.solve(app);
        System.out.println(info.getSolution());
        // "append([1],[2,3],[1,2,3])"
    }
}

Term Hierarchy

Reading Results

public class Test4 {
    public static void main(String[] args) throws Exception {
        Prolog engine = new Prolog();
        Term t = new Struct();
        for (int i = 10; i >= 0; i--) {
            t = new Struct(new Int(i), t);
        }
        Term app = new Struct("append", t, t, new Var("X"));
        SolveInfo info = engine.solve(app);
        Struct t2 = (Struct) info.getTerm("X");
        for (java.util.Iterator i = t2.listIterator(); i.hasNext();) {
            System.out.print(" " + i.next());
        }
        // 0 1 2 ... 10 0 1 2 ... 10
    }
}

Setting a Theory

public class Test5 {
    public static void main(String[] args) throws Exception {
        Prolog engine = new Prolog();
        Theory t = new Theory(
            "search(E,[E|_]). " +
            "search(E,[_|L]) :- search(E,L)."
        );
        engine.setTheory(t);
        SolveInfo info = engine.solve("search(1,[1,2,3]).");
        System.out.println(" " + info.getSolution());
    }
}

5. Prolog Libraries Written in Java

This is the encapsulation-oriented approach for Prolog using Java: a Java class that implements a Prolog library, where each Java method defines a Prolog predicate.

How It Works

• Write a Java class extending Library
• Each method defines a predicate: public boolean <name>_<arity>(T1 arg1, ..., Tn argN)
• For evaluable functions: public Term <name>_<arity>(T1 arg1, ..., Tn argN)
• Parameter types can be Term, Var, Number, etc.
• Load with load_library('lib.mylibrary').

Example Library

public class TestLibrary extends Library {
    private int termAsInt(Term t) {
        return ((Number) t).intValue();
    }

    // try with: X is sum(10, 20).
    public Term sum_2(Term arg0, Term arg1) {
        return new Int(termAsInt(arg0) + termAsInt(arg1));
    }

    // try with: X is minus(20, 10).
    public Term minus_2(Term arg0, Term arg1) {
        return new Int(termAsInt(arg0) - termAsInt(arg1));
    }

    // try with: sum(Y, 8, 21).
    public boolean sum_3(Term arg0, Term arg1, Term arg) {
        try {
            if (arg instanceof Var)
                return arg.unify(this.getEngine(), sum_2(arg0, arg1));
            if (arg0 instanceof Var)
                return arg0.unify(this.getEngine(), minus_2(arg, arg1));
            return arg1.unify(this.getEngine(), minus_2(arg, arg0));
        } catch (Exception e) { return false; }
    }
}

6. Scala Using Prolog

The most elegant integration uses Scala's functional abstractions to wrap Prolog theories, treating solutions as a lazy stream. This is the encapsulation-oriented approach applied to Scala.

Key Components

Scala provides implicit conversions and an engine factory:

Using the Integration

object TryScala2P extends App:
  import Scala2P.{*, given}

  val engine: Term => LazyList[Term] = mkPrologEngine("""
    member([H|T], H, T).
    member([H|T], E, [H|T2]) :- member(T, E, T2).
    permutation([], []).
    permutation(L, [H|TP]) :- member(L, H, T), permutation(T, TP).
  """)

  // Solutions as a lazy stream
  engine("permutation([1,2,3], L)") foreach (println(_))
  // permutation([1,2,3],[1,2,3]) ... permutation([1,2,3],[3,2,1])

  // Using structured terms
  val input = Struct("permutation", (1 to 20), Var())
  engine(input) map (extractTerm(_, 1)) foreach (println(_))

Functional/Monadic Approach to Logic Programming

The course also shows a pure-FP encoding of Prolog-like search in Scala, demonstrating how the same patterns can be expressed without a Prolog engine:

def lookup[A](list: List[A]): LazyList[(A, Int, List[A])] = list match
  case Nil => LazyList()
  case h :: t =>
    (h, 0, t) #::
    (for (e, n, t2) <- lookup(t) yield (e, n + 1, h :: t2))

println(lookup(List(10, 20, 30, 20)).toList)
// List((10,0,List(20,30,20)), (20,1,List(10,30,20)), ...)

// Find positions of 20
println(lookup(List(10, 20, 30, 20))
  .collect { case (20, n, _) => n }.toList)
// List(1, 3)

7. Scala Cross-Platform: Scala.js and Scala Native

Scala is not just a JVM language. It compiles to JavaScript (Scala.js) and native machine code (Scala Native), enabling write once, run on three platforms.

The Three Target Ecosystem

SBT Configuration

// project/plugins.sbt
addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.21.0")
addSbtPlugin("org.scala-native" % "sbt-scala-native" % "0.5.10")

// build.sbt
import sbt.Keys.scalaVersion
ThisBuild / scalaVersion := "3.3.5"
name := "scala-js-native"

val js = project.settings(
  scalaJSUseMainModuleInitializer := true
).enablePlugins(ScalaJSPlugin)

val native = project.settings(
  nativeConfig ~= { _.withBaseName("native-out") }
).enablePlugins(ScalaNativePlugin)

Cross-Project Configuration

// Using sbt-crossproject for multi-platform builds
lazy val shared = crossProject(JSPlatform, JVMPlatform, NativePlatform)
  .crossType(CrossType.Full)       // or CrossType.Pure
  .settings(libraryDependencies ++= Seq(
    "org.scalatest" %%% "scalatest" % "3.2.19"
  ))
  .jsSettings(/* JS-specific */)
  .jvmSettings(/* JVM-specific */)
  .nativeSettings(/* Native-specific */)

How Scala.js and Scala Native Work

The compiler takes plain Scala code and, using a compiler plugin, produces an intermediate representation (IR). The IR is then optimised, linked, and compiled to the target platform. Scala 3 has native, out-of-the-box support for both JavaScript and Native targets with advanced features like givens, extension methods, and enums compiling seamlessly.

Architecture for Multi-Platform: Clean Architecture

The recommended pattern is Ports & Adapters (Hexagonal Architecture):

• Pure Core (platform-agnostic, in shared/): domain models, business logic, pure functions using only cross-platform libraries (Cats, Circe).
• Platform Adapters (target-specific): JVM uses JDBC/Doobie, JS uses DOM/Laminar, Native uses POSIX/C interop.

8. Facades, ScalablyTyped, and Ecosystem

To bridge Scala with platform-native APIs (JavaScript in the browser, C in the OS), Scala.js and Scala Native use a mechanism called facades — type declarations that tell the compiler how to emit correct calls to foreign APIs.

Scala.js Facades

import scala.scalajs.js
import js.annotation._

// Facade for browser's window.alert
@js.native
@JSGlobal
object window extends js.Object {
  def alert(msg: String): Unit = js.native
}

// Using a facade
window.alert("Hello from Scala.js!")

Scala Native C Bindings

import scalanative.unsafe._
import scalanative.unsigned._

@link("m")
@extern
object libm {
  def sqrt(d: CDouble): CDouble = extern
}

// Using a C binding
val result = libm.sqrt(16.0)  // 4.0

ScalablyTyped: Automated Facade Generation

Writing facades manually for large libraries is impractical. ScalablyTyped solves this by automatically converting TypeScript definition files (.d.ts) into type-safe Scala.js facades:

// With ScalablyTyped, NPM packages feel like native Scala libraries
import scala.scalajs.js
import customtypings.tensorflowTfjs.mod as tf

val data = js.Array(1.0, 2.0, 3.0, 4.0)
val tensor = tf.tensor1d(data)
val squared = tensor.square()
tensor.dispose()

SBT Configuration for ScalablyTyped

lazy val scalablytyped = (project in file("scalablytyped"))
  .enablePlugins(ScalaJSBundlerPlugin, ScalablyTypedConverterGenSourcePlugin)
  .settings(name := "scala-js-facade-scalablytyped",
    scalaJSUseMainModuleInitializer := true,
    Compile / npmDependencies += "@tensorflow/tfjs" -> "4.22.0",
    stOutputPackage := "customtypings")

Modern Frontend Frameworks for Scala.js

Triple-Target Ecosystem

Major Scala libraries are published for all three targets using %%% (instead of %%):

Check Your Understanding