feat: implement prolog solution

Author: kelvin-olaiya

src/main/scala/io/github/kelvindev15/prolog/engine/PrologEngine.scala

@@ -0,0 +1,63 @@
+package io.github.kelvindev15.prolog.engine
+
+import io.github.kelvindev15.prolog.PrologProgram
+import io.github.kelvindev15.prolog.core.{Struct, Term, Variable}
+import io.github.kelvindev15.prolog.core.Theory.Theory
+import io.github.kelvindev15.prolog.engine.Solver.Solution
+import io.github.kelvindev15.prolog.engine.Solver.Solution.{Halt, Yes}
+import io.github.kelvindev15.prolog.engine.visitors.{BackVisitor, TuPKtTermVisitor}
+import it.unibo.tuprolog.core.{Clause as KClause, Struct as KStruct, Substitution as KSubstitution, Term as KTerm}
+import it.unibo.tuprolog.solve.Solver as KSolver
+import it.unibo.tuprolog.solve.channel.{InputStore, OutputStore}
+import it.unibo.tuprolog.solve.classic.ClassicSolverFactory
+import it.unibo.tuprolog.solve.flags.FlagStore
+import it.unibo.tuprolog.theory.Theory as KTheory
+import it.unibo.tuprolog.unify.Unificator
+import it.unibo.tuprolog.solve.Solution as KSolution
+
+trait Solver:
+  def solve(program: PrologProgram): Iterator[Solution]
+
+import scala.jdk.CollectionConverters.*
+
+object Solver:
+  type Substitution = Map[Variable, Term]
+  enum Solution:
+    case Yes(query: Struct, substitution: Substitution)
+    case No(query: Struct)
+    case Halt
+
+  private val visitor = TuPKtTermVisitor()
+  private val back = BackVisitor()
+  given Conversion[Term, KTerm] = _.accept(visitor)
+  given Conversion[KTerm, KClause] = _.asClause()
+  given Conversion[KTerm, KStruct] = _.asStruct()
+  given Conversion[Theory, KTheory] with
+    override def apply(theory: Theory): KTheory = KTheory.of(theory.map(_.asClause()) *)
+  given Conversion[KStruct, Struct] = back.visitStruct(_)
+  given Conversion[KSubstitution, Substitution] = {
+    case substitution: KSubstitution.Unifier => Map(
+      substitution.asScala.toSeq.map(p => (back.visitVar(p._1),  back.visitTerm(p._2)))*
+    )
+  }
+  given Conversion[KSolution, Solution] = {
+    case yes: KSolution.Yes => Yes(yes.getQuery, yes.getSubstitution)
+    case no: KSolution.No => Solution.No(no.getQuery)
+    case halt: KSolution.Halt => Halt
+  }
+  given Conversion[java.util.Iterator[KSolution], Iterator[Solution]] = _.asScala.map(identity)
+
+  private def tuPrologClassicSolverOf(staticTheory: Theory, dynamicTheory: Theory): KSolver =
+    ClassicSolverFactory.INSTANCE.solverOf(
+      Unificator.getDefault,
+      ClassicSolverFactory.INSTANCE.getDefaultRuntime,
+      FlagStore.DEFAULT,
+      staticTheory,
+      dynamicTheory,
+      InputStore.fromStandard(),
+      OutputStore.fromStandard()
+    )
+
+  def tuPrologSolver(): Solver = (program: PrologProgram) =>
+    val solver = tuPrologClassicSolverOf(program.dynamicTheory, program.staticTheory)
+    program.goal.map { goal => solver.solve(goal.asStruct()).iterator() }.get

src/main/scala/io/github/kelvindev15/prolog/engine/Solver.scala

@@ -0,0 +1,20 @@
+package io.github.kelvindev15.prolog.engine.visitors
+
+import io.github.kelvindev15.prolog.core.Constant.Atom
+import io.github.kelvindev15.prolog.core.{Struct, Term, Variable}
+import it.unibo.tuprolog.core
+import it.unibo.tuprolog.core.{TermVisitor, Atom as KAtom, Struct as KStruct, Term as KTerm, Var as KVariable}
+
+import scala.jdk.CollectionConverters.*
+
+class BackVisitor extends TermVisitor[Term]:
+  override def defaultValue(term: KTerm): Term = term match
+    case atom: KAtom => visitAtom(atom)
+    case variable: KVariable => visitVar(variable)
+
+  override def visitAtom(term: KAtom): Atom = Atom(term.getValue)
+  override def visitStruct(term: KStruct): Struct =
+    Struct(Atom(term.getFunctor), term.getArgs.asScala.map(visitTerm).toSeq*)
+  override def visitVar(term: KVariable): Variable = Variable(term.getName)
+
+

src/main/scala/io/github/kelvindev15/prolog/engine/visitors/BackVisitor.scala

@@ -1,15 +1,15 @@
 package io.github.kelvindev15.engine
 
 import io.github.kelvindev15.prolog.dsl.{DeclarativeDSL, PrologDSL}
-import io.github.kelvindev15.prolog.engine.PrologEngine.Solution
+import io.github.kelvindev15.prolog.engine.Solver.Solution
 import io.github.kelvindev15.prolog.engine.Solver
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 
 class TestPrologEngine extends AnyFlatSpec with Matchers with PrologDSL with DeclarativeDSL:
 
   "A prolog with no solution" should "return a single NO answer" in:
-    val solution = Solver.solve {
+    val solution = Solver.tuPrologSolver().solve {
       prolog {
         staticTheory {
           clause { "father"("mala", "paga") }
@@ -18,4 +18,7 @@ class TestPrologEngine extends AnyFlatSpec with Matchers with PrologDSL with Dec
         solve { "father"("mala", X) }
       }
     }
-    solution shouldBe a [Solution]
+    solution shouldBe a [Iterator[Solution]]
+    for
+      s <- solution
+    do println(s)