chore: start importing the engine

Author: kelvin-olaiya

src/main/scala/io/github/kelvindev15/prolog/core/Constant.scala

@@ -17,6 +17,7 @@ object Constant:
     case _ => throw IllegalArgumentException("Cannot create a constant with the provided argument")
   trait Atom extends Constant with Struct:
     override val value: String
+    val unquotedValue: String
     override val arity: Int = 0
     override val arguments: Seq[Term] = Seq()
     override val functor: Atom = this
@@ -26,6 +27,7 @@ object Constant:
     def apply(value: String): Atom = AtomImpl(removeQuotes(value))
     private case class AtomImpl(private val _value: String) extends Atom:
       override val value: String = quoteIfFunctorIsMalformed(_value)
+      override val unquotedValue: String = _value
 
   trait Numeric extends Constant:
     override val value: AnyVal

src/main/scala/io/github/kelvindev15/prolog/core/Prolog.scala

@@ -15,6 +15,4 @@ object Prolog:
     val CLAUSE: Atom = Atom(":-")
     val EMPTY_LIST: Atom = Atom("[]")
     val CONS: Atom = Atom(".")
-    val TRUE: Atom = Atom("true")
-    val FAIL: Atom = Atom("fail")
     val INDICATOR: Atom = Atom("/")

src/main/scala/io/github/kelvindev15/prolog/dsl/DSLExtensions.scala

@@ -2,7 +2,7 @@ package io.github.kelvindev15.prolog.dsl
 
 import io.github.kelvindev15.prolog.core.Constant.Atom
 import io.github.kelvindev15.prolog.core.Struct.Rule
-import io.github.kelvindev15.prolog.core.{Goals, PrologList, Struct, Term}
+import io.github.kelvindev15.prolog.core.{Goals, Struct, Term}
 
 import scala.annotation.targetName
 

src/main/scala/io/github/kelvindev15/prolog/dsl/DSLPrologBuiltins.scala

@@ -10,6 +10,7 @@ import scala.annotation.targetName
 enum AssociativitySpec extends Atom:
   case fx, fy, xf, xfx, xfy, yfx, yfy
   override val value: String = toString
+  override val unquotedValue: String = value
 
 trait DSLPrologBuiltins:
   dsl: PrologDSL =>

src/main/scala/io/github/kelvindev15/prolog/dsl/DeclarativeDSL.scala

@@ -1,9 +1,9 @@
 package io.github.kelvindev15.prolog.dsl
 
 import io.github.kelvindev15.prolog.PrologProgram
-import io.github.kelvindev15.prolog.core.{Struct, Term}
 import io.github.kelvindev15.prolog.core.Struct.{Clause, Directive, Fact, Rule}
 import io.github.kelvindev15.prolog.core.Theory.Theory
+import io.github.kelvindev15.prolog.core.{Struct, Term}
 import io.github.kelvindev15.prolog.dsl.DeclarativeDSL.{MutableDynamicTheoryWrapper, MutableTheoryWrapper}
 
 

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

@@ -0,0 +1,53 @@
+package io.github.kelvindev15.prolog.engine
+
+import io.github.kelvindev15.prolog.PrologProgram
+import io.github.kelvindev15.prolog.core.Term
+import io.github.kelvindev15.prolog.core.Theory.Theory
+import io.github.kelvindev15.prolog.engine.PrologEngine.Solution
+import io.github.kelvindev15.prolog.engine.visitors.TuPKtTermVisitor
+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.unify.Unificator
+import it.unibo.tuprolog.solve.library.Runtime
+import it.unibo.tuprolog.theory.Theory as KTheory
+import it.unibo.tuprolog.core.{Clause as KClause, Struct as KStruct, Term as KTerm}
+import it.unibo.tuprolog.solve.Solver as KSolver
+
+import scala.jdk.CollectionConverters.*
+
+trait PrologEngine extends Function[PrologProgram, Seq[Solution]]:
+  ???
+
+object PrologEngine:
+  trait Solution
+
+object Solver:
+  private val visitor = TuPKtTermVisitor()
+  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())*)
+
+  private def solverOf(staticTheory: Theory, dynamicTheory: Theory): KSolver =
+    ClassicSolverFactory.INSTANCE.solverOf(
+      Unificator.getDefault,
+      Runtime.empty(),
+      FlagStore.DEFAULT,
+      staticTheory,
+      dynamicTheory,
+      InputStore.fromStandard(),
+      OutputStore.fromStandard()
+    )
+
+  def solve(program: PrologProgram): Solution =
+    val solver = solverOf(program.dynamicTheory, program.staticTheory)
+    program.goal.foreach { t =>
+      val goal: KStruct = Some(t.asStruct()).get
+      val sol = solver.solve(goal)
+      sol.iterator().forEachRemaining(s => {
+        println(s)
+      })
+    }
+    new Solution {}

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

@@ -0,0 +1,29 @@
+package io.github.kelvindev15.prolog.engine.visitors
+
+import io.github.kelvindev15.prolog.core.Constant.Atom
+import io.github.kelvindev15.prolog.core.Struct.{Clause, Directive, Fact, Rule}
+import io.github.kelvindev15.prolog.core.{Constant, Struct, Variable}
+import io.github.kelvindev15.prolog.utils.TermVisitor
+import it.unibo.tuprolog.core.{
+  Term as KTerm,
+  Atom as KAtom,
+  Numeric as KNumeric,
+  Var as KVar,
+  Struct as KStruct,
+  Fact as KFact,
+  Rule as KRule,
+  Directive as KDirective,
+}
+
+class TuPKtTermVisitor extends TermVisitor[KTerm]:
+  override def visit(atom: Atom): KTerm = KAtom.of(atom.unquotedValue)
+  override def visit(numeric: Constant.Numeric): KTerm = KNumeric.of(numeric.value.asInstanceOf[Double])
+  override def visit(struct: Struct): KTerm = struct match
+    case clause: Clause => super.visit(clause)
+    case _ => KStruct.of(struct.functor.unquotedValue, struct.arguments.map(this.visit)*)
+  override def visit(fact: Fact): KTerm = fact.head.map(h => KFact.of(h.accept(this).asStruct())).get
+  override def visit(rule: Rule): KTerm =
+    rule.head.map(h => KRule.of(h.accept(this).asStruct(), rule.body.accept(this))).get
+  override def visit(directive: Directive): KTerm =  KDirective.of(directive.body.accept(this))
+  override def visit(variable: Variable): KTerm = KVar.of(variable.name)
+

src/main/scala/io/github/kelvindev15/prolog/utils/TermVisitor.scala

@@ -1,17 +1,29 @@
 package io.github.kelvindev15.prolog.utils
 
-import io.github.kelvindev15.prolog.core.{Constant, Struct, Variable}
+import io.github.kelvindev15.prolog.core.{Constant, Struct, Term, Variable}
 import io.github.kelvindev15.prolog.core.Constant.{Atom, Numeric}
 import io.github.kelvindev15.prolog.core.RecursiveStruct.BinaryRecursiveStruct
-import io.github.kelvindev15.prolog.core.Struct.{Fact, Rule}
+import io.github.kelvindev15.prolog.core.Struct.{Clause, Directive, Fact, Rule}
 
 trait TermVisitor[T]:
-  def visit(constant: Constant): T = throw NotImplementedError()
+  def visit(term: Term): T = term match
+    case constant: Constant => visit(constant)
+    case variable: Variable => visit(variable)
+    case struct: Struct => visit(struct)
+  def visit(constant: Constant): T = constant match
+    case atom: Atom => visit(atom)
+    case numeric: Numeric => visit(numeric)
   def visit(atom: Atom): T = throw NotImplementedError()
   def visit(numeric: Numeric): T = throw NotImplementedError()
   def visit(variable: Variable): T = throw NotImplementedError()
   def visit(struct: Struct): T = throw NotImplementedError()
+  def visit(clause: Clause): T = clause match
+    case fact: Fact => visit(fact)
+    case rule: Rule => visit(rule)
+    case directive: Directive => visit(directive)
   def visit(rule: Rule): T = throw NotImplementedError()
   def visit(fact: Fact): T = throw NotImplementedError()
+  def visit(directive: Directive): T = throw NotImplementedError()
+  
   def visit(binaryRecursiveStruct: BinaryRecursiveStruct): T = throw NotImplementedError()
 

src/test/scala/io/github/kelvindev15/engine/TestPrologEngine.scala

@@ -0,0 +1,21 @@
+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
+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 {
+      prolog {
+        staticTheory {
+          clause { "father"("mala", "paga") }
+          clause { "father"("mala", "kel") }
+        }
+        solve { "father"("mala", X) }
+      }
+    }
+    solution shouldBe a [Solution]