feat: implement disjunction of goals

Author: kelvin-olaiya

src/main/scala/io/github/kelvindev15/prolog/CompoundGoal.scala

@@ -0,0 +1,30 @@
+package io.github.kelvindev15.prolog
+
+import io.github.kelvindev15.prolog.Constant.Atom
+import io.github.kelvindev15.prolog.Prolog.Functors
+import io.github.kelvindev15.prolog.RecursiveStruct.BinaryRecursiveStruct
+import io.github.kelvindev15.prolog.utils.TermVisitor
+
+object Goals:
+  trait Conjunction extends BinaryRecursiveStruct:
+    override val functor: Constant.Atom = Functors.GOAL_CONJUNCTION
+    override def accept[T](visitor: TermVisitor[T]): T = visitor.visit(this)
+
+  object Conjunction:
+    def wrapIfNecessary(args: Term*): Term = BinaryRecursiveStruct.wrapIfNecessary(Conjunction.apply)(args*)
+    def apply(args: Term*): Conjunction = BinaryRecursiveStruct.fold(ConjunctionImpl.apply)(args*)
+    def unapply(conjunction: Conjunction): Option[(Term, Term)] = Option((conjunction.first, conjunction.second))
+
+    private case class ConjunctionImpl(left: Term, right: Term) extends Conjunction
+
+  trait Disjunction extends BinaryRecursiveStruct:
+    override val functor: Constant.Atom = Atom(";")
+    override def accept[T](visitor: TermVisitor[T]): T = visitor.visit(this)
+
+  object Disjunction:
+    def wrapIfNecessary(args: Term*): Term = BinaryRecursiveStruct.wrapIfNecessary(Disjunction.apply)(args *)
+    def apply(args: Term*): Conjunction = BinaryRecursiveStruct.fold(DisjunctionImpl.apply)(args *)
+    def unapply(disjunction: Disjunction): Option[(Term, Term)] = Option((disjunction.first, disjunction.second))
+    private case class DisjunctionImpl(left: Term, right: Term) extends Conjunction
+
+

src/main/scala/io/github/kelvindev15/prolog/Goals.scala

@@ -10,7 +10,8 @@ object Prolog:
     val VariableRegex: Regex = "[A-Z_][a-zA-Z_0-9]*".r
 
   object Functors:
-    val COMPOUND_GOAL: Atom = Atom(",")
+    val GOAL_CONJUNCTION: Atom = Atom(",")
+    val GOAL_DISJUNCTION: Atom = Atom(";")
     val CLAUSE: Atom = Atom(":-")
     val EMPTY_LIST: Atom = Atom("[]")
     val CONS: Atom = Atom(".")

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

@@ -16,6 +16,11 @@ object RecursiveStruct:
     override def linearizedArguments: Iterable[Term] = accept(BinaryToFlatVisitor())
 
   object BinaryRecursiveStruct:
+    def wrapIfNecessary(struct: Seq[Term] => BinaryRecursiveStruct)(args: Term*): Term = args.size match
+      case 0 => throw IllegalArgumentException("Cannot create a goal from an empty sequence")
+      case 1 => args.head
+      case _ => struct(args)
+
     object Tuple:
       def unapply(tuple: BinaryRecursiveStruct): Option[(Term, Term)] =
         Option((tuple.left, tuple.right))

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

@@ -1,6 +1,7 @@
 package io.github.kelvindev15.prolog
 
 import io.github.kelvindev15.prolog.Constant.Atom
+import io.github.kelvindev15.prolog.Goals.Conjunction
 import io.github.kelvindev15.prolog.Prolog.Functors.CLAUSE
 import io.github.kelvindev15.prolog.Prolog.Syntax
 import io.github.kelvindev15.prolog.utils.TermVisitor
@@ -40,7 +41,7 @@ object Struct:
     final override def variables: Iterable[Variable] = head.variables ++ body.variables
 
   object Rule:
-    def apply(head: Struct, args: Term*): Rule = RuleImpl(head, CompoundGoal.ifNecessary(args*))
+    def apply(head: Struct, args: Term*): Rule = RuleImpl(head, Conjunction.wrapIfNecessary(args*))
     private case class RuleImpl(head: Struct, body: Term) extends Rule
 
   trait Fact extends Rule:

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

@@ -1,7 +1,7 @@
 package io.github.kelvindev15.prolog.utils
 
 import io.github.kelvindev15.prolog.RecursiveStruct.BinaryRecursiveStruct
-import io.github.kelvindev15.prolog.{CompoundGoal, Term}
+import io.github.kelvindev15.prolog.Term
 import io.github.kelvindev15.prolog.RecursiveStruct.BinaryRecursiveStruct.Tuple
 
 class BinaryToFlatVisitor extends TermVisitor[Iterable[Term]]:

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

@@ -1,38 +1,45 @@
 package io.github.kelvindev15.prolog
 
 import io.github.kelvindev15.prolog.Constant.Atom
+import io.github.kelvindev15.prolog.Goals.{Conjunction, Disjunction}
 import io.github.kelvindev15.prolog.PrologList.{Cons, Nil}
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
 class TestRecursiveStructs extends AnyFunSuite with Matchers:
-  private val cmpGoal = CompoundGoal(Atom("X"), Atom("Y"), Atom("Z"))
+  private val cmpGoal = Conjunction(Atom("X"), Atom("Y"), Atom("Z"))
 
-  test("Cannot create a compound goal from no term") {
+  test("Cannot create a conjunction of goals from no terms") {
     assertThrows[IllegalArgumentException] {
-      CompoundGoal.ifNecessary()
+      Conjunction.wrapIfNecessary()
     }
   }
 
-  test("A Compound goal is a recursive predicate with arity 2 and with ',' as a functor") {
+  test("A conjunction of goal is a recursive predicate with arity 2 and with ',' as a functor") {
     cmpGoal shouldBe a [Term]
     cmpGoal.arity shouldBe 2
     cmpGoal.functor shouldBe Atom(",")
   }
 
-  test("Compound goal arguments") {
+  test("Goal conjunction arguments") {
     cmpGoal.first shouldBe Atom("X")
-    cmpGoal.second shouldBe CompoundGoal(Atom("Y"), Atom("Z"))
+    cmpGoal.second shouldBe Conjunction(Atom("Y"), Atom("Z"))
   }
+  private val goals = Seq(
+    Atom("X"),
+    Conjunction(Atom("X"), Variable("O")),
+    Variable("Z"),
+    Conjunction(Constant(1), Constant(2)))
+  private val linearizationExpectation = goals.take(3) ++ Seq(Constant(1), Constant(2))
 
   test("Compound goal linearized arguments") {
-    val goals = Seq(
-      Atom("X"),
-      CompoundGoal(Atom("X"), Variable("O")),
-      Variable("Z"),
-      CompoundGoal(Constant(1), Constant(2)))
-    val complexCompoundGoal = CompoundGoal(goals*)
-    complexCompoundGoal.linearizedArguments shouldBe goals.take(3) ++ Seq(Constant(1), Constant(2))
+    val complexGoalConjunction = Conjunction(goals *)
+    complexGoalConjunction.linearizedArguments shouldBe linearizationExpectation
+  }
+
+  test("Disjunction of goals linearized arguments") {
+    val complexGoalDisjunction = Disjunction(goals *)
+    complexGoalDisjunction.linearizedArguments shouldBe linearizationExpectation
   }
 
   private val list = PrologList(Atom("a"), Atom("b"), Atom("c"), Atom("d"))