test: some prolog programs resolutions

Author: kelvin-olaiya

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

@@ -4,6 +4,7 @@ import io.github.kelvindev15.prolog.utils.BinaryToFlatVisitor
 
 trait RecursiveStruct extends Struct:
   def linearizedArguments: Seq[Term]
+  override def foreach(action: Term => Unit): Unit = linearizedArguments.foreach(action)
 
 object RecursiveStruct:
   trait BinaryRecursiveStruct extends RecursiveStruct:

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

@@ -15,6 +15,7 @@ trait Struct extends Term:
   override def isGround: Boolean = arguments.forall(_.isGround)
 
   override def accept[T](visitor: TermVisitor[T]): T = visitor.visit(this)
+  def foreach(action: Term => Unit): Unit = arguments.foreach(action)
 
 object Struct:
   private def isFunctorWellFormed(functor: String): Boolean = functor.matches(Syntax.AtomRegex.regex)

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

@@ -40,8 +40,8 @@ trait DeclarativeDSL:
   def directive(using theory: MutableTheoryWrapper)(directive: Directive): Unit = theory add directive
   def clause(using theory: MutableTheoryWrapper)(c: Clause): Unit = theory add c
 
-  def solve(using program: PrologProgram)(goal: Term): Unit =
-    prologProgram = prologProgram withGoal goal
+  def goal(using program: PrologProgram)(g: Term): Unit =
+    prologProgram = prologProgram withGoal g
 
 object DeclarativeDSL:
   trait MutableTheoryWrapper:

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

@@ -1,19 +1,18 @@
 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.core.{Struct, Term, Variable}
 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.{Solution as KSolution, Solver as KSolver}
+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.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]
@@ -48,16 +47,21 @@ object Solver:
   given Conversion[java.util.Iterator[KSolution], Iterator[Solution]] = _.asScala.map(identity)
 
   private def tuPrologClassicSolverOf(staticTheory: Theory, dynamicTheory: Theory): KSolver =
-    ClassicSolverFactory.INSTANCE.solverOf(
+    ClassicSolverFactory.INSTANCE.solverWithDefaultBuiltins(
       Unificator.getDefault,
       ClassicSolverFactory.INSTANCE.getDefaultRuntime,
       FlagStore.DEFAULT,
       staticTheory,
       dynamicTheory,
-      InputStore.fromStandard(),
-      OutputStore.fromStandard()
+      InputChannel.stdIn(),
+      OutputChannel.stdOut(),
+      OutputChannel.stdErr(),
+      OutputChannel.warn()
     )
 
   def tuPrologSolver(): Solver = (program: PrologProgram) =>
     val solver = tuPrologClassicSolverOf(program.dynamicTheory, program.staticTheory)
     program.goal.map { goal => solver.solve(goal.asStruct()).iterator() }.get
+    
+  def solve(using solver: Solver = tuPrologSolver())(prologProgram: PrologProgram): Iterator[Solution] = 
+    solver.solve(prologProgram)

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

@@ -1,20 +1,34 @@
 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 io.github.kelvindev15.prolog.core.PrologList.Cons
+import io.github.kelvindev15.prolog.core.*
 import it.unibo.tuprolog.core
-import it.unibo.tuprolog.core.{TermVisitor, Atom as KAtom, Struct as KStruct, Term as KTerm, Var as KVariable}
+import it.unibo.tuprolog.core.{TermVisitor, Atom as KAtom, Cons as KCons, Constant as KConstant, EmptyList as KEmptyList, Integer as KInteger, Real as KReal, 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 emptyList: KEmptyList => visitEmptyList(emptyList)
+    case list: KCons => visitCons(list)
     case atom: KAtom => visitAtom(atom)
     case variable: KVariable => visitVar(variable)
+    case constant: KConstant => visitConstant(constant)
+
 
   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)
 
+  override def visitEmptyList(term: KEmptyList): PrologList = io.github.kelvindev15.prolog.core.PrologList.Nil
+  override def visitCons(term: KCons): PrologList = term.getTail match
+    case t if t.isCons => Cons(visitTerm(term.getHead), visitCons(term.getTail.asCons()))
+    case t if t.isEmptyList => Cons(visitTerm(term.getHead), visitEmptyList(t.asEmptyList()))
+    case t if t.isVar => Cons(visitTerm(term.getHead), visitVar(term.getTail.asVar()))
+  override def visitConstant(term: KConstant): Term = term match
+    case integer: KInteger => Constant(integer.getValue.toInt)
+    case double: KReal => Constant(double.getValue.toDouble)
+
 

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

@@ -4,20 +4,13 @@ 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,
-}
+import it.unibo.tuprolog.core.{Atom as KAtom, Directive as KDirective, Fact as KFact, Numeric as KNumeric, Rule as KRule, Struct as KStruct, Term as KTerm, Var as KVar}
 
 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(numeric: Constant.Numeric): KTerm = numeric.value match
+    case value: Double => KNumeric.of(value)
+    case value: Int => KNumeric.of(value)
   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)*)

src/test/scala/io/github/kelvindev15/dsl/TestDeclarativeDSL.scala

@@ -66,7 +66,7 @@ class TestDeclarativeDSL extends AnyFunSuite with Matchers with PrologDSL with D
 
   test("Setting the goal of a prolog program"):
     prolog {
-      solve {
+      goal {
         &&(2 is X + Y, (head(H) | T) `=` S)
       }
     }.goal shouldBe Some(Conjunction(

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

@@ -1,24 +1,50 @@
 package io.github.kelvindev15.engine
 
+import io.github.kelvindev15.prolog.core.{PrologList, Term}
 import io.github.kelvindev15.prolog.dsl.{DeclarativeDSL, PrologDSL}
-import io.github.kelvindev15.prolog.engine.Solver.Solution
 import io.github.kelvindev15.prolog.engine.Solver
+import io.github.kelvindev15.prolog.engine.Solver.Solution
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 
+import scala.reflect
+import scala.reflect.ClassTag
+
 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.tuPrologSolver().solve {
-      prolog {
-        staticTheory {
-          clause { "father"("mala", "paga") }
-          clause { "father"("mala", "kel") }
+  private val rainbowColors = PrologList("red", "orange", "yellow", "green", "blue", "indigo", "violet")
+  private val rainbowProgram = prolog:
+    staticTheory {
+      for color <- rainbowColors do clause { "rainbow"(color) }
+    }
+
+  private def expect[T <: Solution](using tag: ClassTag[T])(solutions: Iterator[Solution]): Unit =
+    assert(solutions.hasNext)
+    solutions.next() shouldBe a [T]
+  private def expectOne[T <: Solution](using tag: ClassTag[T])(solution: Iterator[Solution]): Unit =
+    expect[T](solution)
+    solution.hasNext shouldBe false
+
+  "'rainbow(orange)'" should "be a Yes solution of the rainbow program" in:
+    expectOne[Solution.Yes]:
+      Solver solve (rainbowProgram withGoal "rainbow"("orange"))
+
+  "A prolog program with no solution" should "return a single NO answer" in:
+    expectOne[Solution.No]:
+      Solver solve (rainbowProgram withGoal "rainbow"("purple"))
+
+  "Member predicate" should "give a Yes solution if the term is in the list" in:
+    expect[Solution.Yes]:
+      Solver solve {
+        prolog {
+          goal { member("yellow", rainbowColors) }
+        }
+      }
+
+  "Member predicate" should "give a No solution if the term is not in the list" in:
+    expect[Solution.No]:
+      Solver solve {
+        prolog {
+          goal { member("purple", rainbowColors) }
         }
-        solve { "father"("mala", X) }
       }
-    }
-    solution shouldBe a [Iterator[Solution]]
-    for
-      s <- solution
-    do println(s)