test: clause/2

Author: kelvin-olaiya

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

@@ -2,11 +2,14 @@ package io.github.kelvindev15.prolog.dsl
 
 import io.github.kelvindev15.prolog.core.Constant.Atom
 import io.github.kelvindev15.prolog.core.Struct.Fact
-import io.github.kelvindev15.prolog.core.{Constant, PrologList, Struct, Term}
+import io.github.kelvindev15.prolog.core.{Constant, Prolog, PrologList, Struct, Term}
 
 trait DSLConversions:
   dsl: PrologDSL =>
   given Conversion[String, Atom] = Atom(_)
-  given Conversion[AnyVal, Constant.Numeric] = Constant.Numeric(_)
+  given Conversion[AnyVal, Constant] = {
+    case boolean: Boolean => Atom(if (boolean) "true" else "false")
+    case other => Constant.Numeric(other)
+  }
   given Conversion[Struct, Fact] = Fact(_)
   given Conversion[Seq[Term], PrologList] = PrologList(_*)

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

@@ -3,7 +3,7 @@ package io.github.kelvindev15.prolog.dsl
 import io.github.kelvindev15.prolog.core.Constant.Atom
 import io.github.kelvindev15.prolog.core.Goals.Conjunction
 import io.github.kelvindev15.prolog.core.Struct.{Directive, Indicator}
-import io.github.kelvindev15.prolog.core.{Constant, Struct, Term}
+import io.github.kelvindev15.prolog.core.{Constant, Prolog, Struct, Term}
 
 import scala.annotation.targetName
 
@@ -63,4 +63,5 @@ trait DSLPrologBuiltins:
     Struct(Atom("op"), precedence, associativity, name)
 
   def length(term: Term, len: Term): Struct = Struct(Atom("length"), term, len)
+  val `[]`: Atom = Prolog.Functors.EMPTY_LIST
 

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

@@ -8,6 +8,7 @@ trait DSLVariables:
   def A: Variable = Variable("A")
   def B: Variable = Variable("B")
   def C: Variable = Variable("C")
+  def D: Variable = Variable("D")
   def H: Variable = Variable("H")
   def S: Variable = Variable("S")
   def T: Variable = Variable("T")

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

@@ -28,3 +28,6 @@ object Solver:
 
   def lazySolve(using solver: Solver = tuPrologSolver())(prologProgram: PrologProgram): LazyList[Solution] =
     solver lazySolve prologProgram
+    
+  def solutionsOf(using solver: Solver = tuPrologSolver())(prologProgram: PrologProgram): Seq[Solution] =
+    solver solutionsOf prologProgram

src/main/scala/io/github/kelvindev15/prolog/engine/solvers/TuPrologClassicSolver.scala

@@ -1,30 +1,32 @@
 package io.github.kelvindev15.prolog.engine.solvers
 
 import io.github.kelvindev15.prolog.PrologProgram
-import io.github.kelvindev15.prolog.core.{Struct, Term}
 import io.github.kelvindev15.prolog.core.theory.Theory
+import io.github.kelvindev15.prolog.core.{Struct, Term}
 import io.github.kelvindev15.prolog.engine.Solver
 import io.github.kelvindev15.prolog.engine.Solver.Solution.{Halt, Yes}
 import io.github.kelvindev15.prolog.engine.Solver.{Solution, Substitution}
 import io.github.kelvindev15.prolog.engine.visitors.{From2PKtTermVisitor, To2PKtTermVisitor}
+import it.unibo.tuprolog.core.{Clause as KClause, Struct as KStruct, Substitution as KSubstitution, Term as KTerm}
 import it.unibo.tuprolog.solve.channel.{InputChannel, OutputChannel}
 import it.unibo.tuprolog.solve.classic.ClassicSolverFactory
 import it.unibo.tuprolog.solve.flags.FlagStore
-import it.unibo.tuprolog.unify.Unificator
-import it.unibo.tuprolog.core.{Clause as KClause, Struct as KStruct, Substitution as KSubstitution, Term as KTerm}
 import it.unibo.tuprolog.solve.{Solution as KSolution, Solver as KSolver}
 import it.unibo.tuprolog.theory.Theory as KTheory
+import it.unibo.tuprolog.unify.Unificator
+
 import scala.jdk.CollectionConverters.*
 
 class TuPrologClassicSolver extends Solver:
-  private val to2pktVisitor = To2PKtTermVisitor()
+  private val to2pktVisitor = To2PKtTermVisitor.withNewScope
   private val from2pktVisitor = From2PKtTermVisitor()
 
   given Conversion[Term, KTerm] = _.accept(to2pktVisitor)
   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()) *)
+    override def apply(theory: Theory): KTheory =
+      KTheory.of(theory.map(_.accept(To2PKtTermVisitor.withNewScope).asClause())*)
   given Conversion[KStruct, Struct] = from2pktVisitor.visitStruct(_)
   given Conversion[KSubstitution, Substitution] = {
     case substitution: KSubstitution.Unifier => Map(
@@ -54,5 +56,5 @@ class TuPrologClassicSolver extends Solver:
     )
 
   override def solve(program: PrologProgram): Iterator[Solution] =
-    val solver = classicSolverOf(program.dynamicTheory, program.staticTheory)
+    val solver = classicSolverOf(program.staticTheory, program.dynamicTheory)
     program.goal.map { goal => solver.solve(goal.asStruct()).iterator() }.get

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

@@ -1,26 +1,42 @@
 package io.github.kelvindev15.prolog.engine.visitors
 
 import io.github.kelvindev15.prolog.core.Constant.Atom
+import io.github.kelvindev15.prolog.core.PrologList.Cons
 import io.github.kelvindev15.prolog.core.RecursiveStruct.BinaryRecursiveStruct
 import io.github.kelvindev15.prolog.core.Struct.{Clause, Directive, Fact, Rule}
-import io.github.kelvindev15.prolog.core.{Constant, RecursiveStruct, Struct, Variable}
+import io.github.kelvindev15.prolog.core.{Constant, PrologList, RecursiveStruct, Struct, Variable}
 import io.github.kelvindev15.prolog.utils.TermVisitor
-import it.unibo.tuprolog.core.{Scope as KScope, Term as KTerm}
+import it.unibo.tuprolog.core.{Scope as KScope, Term as KTerm,
+  Atom as KAtom,
+  Numeric as KNum,
+  Struct as KStruct,
+  Fact as KFact,
+  Rule as KRule,
+  Var as KVar,
+  Directive as KDirective,
+  Cons as KCons,
+  EmptyList as KEmptyList,
+}
 
-class To2PKtTermVisitor() extends TermVisitor[KTerm]:
-  private val scope: KScope = KScope.empty()
-  override def visit(atom: Atom): KTerm = scope.atomOf(atom.unquotedValue)
+class To2PKtTermVisitor(scope: KScope = KScope.empty()) extends TermVisitor[KTerm]:
+  override def visit(atom: Atom): KTerm = KAtom.of(atom.unquotedValue)
   override def visit(numeric: Constant.Numeric): KTerm = numeric.value match
-    case value: Double => scope.numOf(value)
-    case value: Int => scope.numOf(value)
+    case value: Double => KNum.of(value)
+    case value: Int => KNum.of(value)
   override def visit(struct: Struct): KTerm = struct match
     case clause: Clause => super.visit(clause)
-    case _ => scope.structOf(struct.functor.unquotedValue, struct.arguments.map(this.visit)*)
-  override def visit(fact: Fact): KTerm = fact.head.map(h => scope.factOf(h.accept(this).asStruct())).get
+    case list: PrologList => visit(list)
+    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 => scope.ruleOf(h.accept(this).asStruct(), rule.body.accept(this))).get
-  override def visit(directive: Directive): KTerm =  scope.directiveOf(directive.body.accept(this))
+    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 = scope.varOf(variable.name)
   override def visit(binaryRecursiveStruct: BinaryRecursiveStruct): KTerm =
     visit(binaryRecursiveStruct.asInstanceOf[Struct])
+  override def visit(list: PrologList): KTerm = list match
+    case head: Cons => KCons.of(visit(head.head), visit(head.tail))
+    case PrologList.Nil => KEmptyList.getInstance()
 
+object To2PKtTermVisitor:
+  def withNewScope: To2PKtTermVisitor = To2PKtTermVisitor(KScope.empty())

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

@@ -1,6 +1,6 @@
 package io.github.kelvindev15.prolog.utils
 
-import io.github.kelvindev15.prolog.core.{Constant, Struct, Term, Variable}
+import io.github.kelvindev15.prolog.core.{Constant, PrologList, RecursiveStruct, 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.{Clause, Directive, Fact, Rule}
@@ -24,6 +24,9 @@ trait TermVisitor[T]:
   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()
+  def visit(recursiveStruct: RecursiveStruct): T = recursiveStruct match
+    case list: PrologList => visit(list)
+    case binary: BinaryRecursiveStruct => visit(binary)
+  def visit(binaryRecursiveStruct: BinaryRecursiveStruct): T = visit(binaryRecursiveStruct.asInstanceOf[Struct])
+  def visit(list: PrologList): T = throw NotImplementedError()
 

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

@@ -0,0 +1,37 @@
+package io.github.kelvindev15.engine
+
+import io.github.kelvindev15.engine.utils.TestUtils
+import io.github.kelvindev15.prolog.PrologProgram
+import io.github.kelvindev15.prolog.dsl.{DeclarativeDSL, PrologDSL}
+import io.github.kelvindev15.prolog.engine.Solver
+import io.github.kelvindev15.prolog.engine.Solver.Solution
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatest.matchers.should.Matchers
+
+class TestBuiltins extends AnyFunSuite with Matchers with PrologDSL with DeclarativeDSL with TestUtils:
+  test("Test var(X)"):
+    expectOne[Solution.Yes]:
+      Solver solve (PrologProgram.emptyTheory withGoal `var`(X))
+    expectOne[Solution.No]:
+      Solver solve (PrologProgram.emptyTheory withGoal `var`(23))
+    expectOne[Solution.No]:
+      Solver solve (PrologProgram.emptyTheory withGoal &&(X `=` Y, Y `=` 23 , `var`(X)))
+
+  test("Test atom(X)"):
+    expectOne[Solution.No]:
+      Solver solve (PrologProgram.emptyTheory withGoal atom(23))
+    expectOne[Solution.Yes]:
+      Solver solve (PrologProgram.emptyTheory withGoal atom("apples"))
+    expectOne[Solution.Yes]:
+      Solver solve (PrologProgram.emptyTheory withGoal atom("'/us/chris/pl.123'"))
+    expectOne[Solution.No]:
+      Solver solve (PrologProgram.emptyTheory withGoal atom(X))
+    expectOne[Solution.No]:
+      Solver solve (PrologProgram.emptyTheory withGoal atom("book"("bronte", "w_h", X)))
+
+  test("Test atomic(X)"):
+    expectOne[Solution.Yes]:
+      Solver solve (PrologProgram.emptyTheory withGoal atomic(23.4))
+    expectOne[Solution.No]:
+      Solver solve (PrologProgram.emptyTheory withGoal atomic(X))
+

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

@@ -55,3 +55,18 @@ class TestPrologEngine extends AnyFlatSpec with Matchers with TestUtils with Pro
         goal:
           query
     } expectSolutionsIn fruits.map(e => query.yes(X -> e))
+
+  "clause/2" should "give two solution with an append theory" in:
+    val append = "app"
+    val query = clause(append(A, B, C), Y)
+    Solver lazySolve {
+      prolog:
+        staticTheory:
+          fact { append(Nil, X, X) }
+          rule { append(cons(A)(B), C, cons(A)(D)) :- append(B, C, D) }
+        goal:
+          query
+    } expectSolutionsIn Seq(
+      query.yes(A -> Nil, B -> C,  Y -> true),
+      query.yes(A -> cons(A, B), C -> cons(A, D), Y -> append(B, B, D))
+    )

src/test/scala/io/github/kelvindev15/engine/utils/TestUtils.scala

@@ -20,7 +20,7 @@ trait TestUtils:
   extension(solutions: Iterable[Solution])
     def expectSolutionsIn(expectedSolutions: Iterable[Solution]): Unit =
       solutions should contain allElementsOf expectedSolutions.to(LazyList)
-      
+
   extension(query: Struct)
     def yes(substitutions: (Variable, Term)*): Yes = Yes(query, Substitution(substitutions*))
     def no: Solution.No = Solution.No(query)