feat: implement asTerm conversion

Author: kelvin-olaiya

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

@@ -8,6 +8,7 @@ trait Constant extends Term:
   override def variables: Seq[Variable] = Seq()
   override def isGround: Boolean = true
   override def accept[T](visitor: TermVisitor[T]): T = visitor.visit(this)
+  override def asTerm: Term = this
 
 object Constant:
   def apply(value: Any): Constant = value match

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

@@ -14,17 +14,16 @@ object Goals:
     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 val functor: Constant.Atom = Functors.GOAL_DISJUNCTION
     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 wrapIfNecessary(args: Term*): Term = BinaryRecursiveStruct.wrapIfNecessary(Disjunction.apply)(args*)
+    def apply(args: Term*): Disjunction = 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
+    private case class DisjunctionImpl(left: Term, right: Term) extends Disjunction
 
 

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

@@ -17,3 +17,4 @@ object Prolog:
     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/core/PrologList.scala

@@ -37,6 +37,9 @@ object PrologList:
     override val arity: Int = 0
     override val arguments: Seq[Term] = Seq()
     override val size: Int = 0
+    override def asTerm: Term = Functors.EMPTY_LIST
+
     override val functor: Constant.Atom = Functors.EMPTY_LIST
 
-  private case class ConsImpl(head: Term, tail: (PrologList | Variable)) extends Cons
+  private case class ConsImpl(head: Term, tail: (PrologList | Variable)) extends Cons:
+    override def asTerm: Term = Struct(Functors.CONS, head.asTerm, tail.asTerm)

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

@@ -14,6 +14,7 @@ object RecursiveStruct:
     def right: Term
     final override val arguments: Seq[Term] = Seq(left, right)
     override def linearizedArguments: Seq[Term] = accept(BinaryToFlatVisitor())
+    final override def asTerm: Term = Struct(functor, left.asTerm, right.asTerm)
 
   object BinaryRecursiveStruct:
     def wrapIfNecessary(struct: Seq[Term] => BinaryRecursiveStruct)(args: Term*): Term = args.size match

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

@@ -3,7 +3,7 @@ package io.github.kelvindev15.prolog.core
 import io.github.kelvindev15.prolog.core.Constant.Atom
 import io.github.kelvindev15.prolog.core.Goals.Conjunction
 import io.github.kelvindev15.prolog.core.Prolog.Functors.CLAUSE
-import io.github.kelvindev15.prolog.core.Prolog.Syntax
+import io.github.kelvindev15.prolog.core.Prolog.{Functors, Syntax}
 import io.github.kelvindev15.prolog.utils.TermVisitor
 
 trait Struct extends Term:
@@ -24,19 +24,27 @@ object Struct:
 
   private case class StructImpl(functor: Atom, arguments: Term*) extends Struct:
     override val arity: Int = arguments.size
+    override def asTerm: Term = this
 
   trait Indicator extends Struct:
-    val functor: Atom
-    val arity: Int
-    override val arguments: Seq[Term] = Seq(functor, Constant(arity))
+    val functor: Atom = Functors.INDICATOR
+    val arity: Int = 2
+    val indicatedFunctor: Atom
+    val indicatedArity: Constant.Numeric
+    override val arguments: Seq[Term] = Seq(indicatedFunctor, indicatedArity)
 
   object Indicator:
-    def apply(functor: Atom, arity: Int): Indicator = IndicatorImpl(functor, arity)
-    private case class IndicatorImpl(functor: Atom, arity: Int) extends Indicator
+    def apply(indicatedFunctor: Atom, indicatedArity: Constant.Numeric): Indicator =
+      IndicatorImpl(indicatedFunctor, indicatedArity)
+    private case class IndicatorImpl(indicatedFunctor: Atom, indicatedArity: Constant.Numeric) extends Indicator:
+      override def asTerm: Term = Struct(functor, indicatedFunctor, indicatedArity)
 
   trait Clause extends Struct:
     val head: Option[Struct]
     val body: Term
+    final override def asTerm: Term = head
+      .map { h => Struct(functor, h.asTerm, body.asTerm) }
+      .getOrElse(Struct(functor, body.asTerm))
 
   trait Directive extends Clause:
     final override val head: Option[Struct] = None

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

@@ -9,3 +9,4 @@ trait Visitable:
 trait Term extends Visitable:
   def isGround: Boolean
   def variables: Seq[Variable]
+  def asTerm: Term

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

@@ -15,5 +15,6 @@ object Variable:
     case n if n.matches(VariableRegex.regex) => Var(name)
     case _ => throw IllegalArgumentException("Incorrect name of a variable")
   def anonymous(): Variable = Var("_")
-  private case class Var(name: String) extends Variable
+  private case class Var(name: String) extends Variable:
+    override def asTerm: Term = this
 

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

@@ -16,7 +16,11 @@ object DSLExtensions:
 
   extension (term: Term)
     def and(other: Term): Term = Goals.Conjunction(term, other)
+    @targetName("conjunctWith")
+    def &:(other: Term): Term = term and other
     def or(other: Term): Term = Goals.Disjunction(term, other)
+    @targetName("disjointWith")
+    def |: (other: Term): Term = term or other
     @targetName("univ")
     def `=..`(other: Term): Term = Struct(Atom("=.."), term, other)
     @targetName("equality")

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

@@ -12,7 +12,16 @@ trait PrologDSL:
   export DSLVariables.*
 
   def theory(clauses: Clause*): Theory = Theory(clauses*)
-  
+
+  private def wrap(terms: Term*)(f: (Term, Term) => Term): Term = terms.size match
+    case 1 => terms.head
+    case n if n > 1 => f(terms.head, wrap(terms.tail*)(f))
+
+  @targetName("disjunction")
+  def ||(terms: Term*): Term = wrap(terms*)(_ or _)
+  @targetName("conjunction")
+  def &&(terms: Term*): Term = wrap(terms*)(_ and _)
+
   def list(terms: Term*): PrologList = PrologList(terms *)
   def cons(term: Term, tail: (PrologList | Variable)): PrologList = Cons(term, tail)
   def cons(terms: Term*)(tail: (PrologList | Variable)): PrologList = terms.size match
@@ -23,4 +32,4 @@ trait PrologDSL:
   def head(terms: Term*): Seq[Term] = terms
   extension (list: Seq[Term])
     @targetName("pipe")
-    def |(tail: (PrologList | Variable)) = cons(list*)(tail)
+    def |(tail: (PrologList | Variable)): Term = cons(list*)(tail)

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

@@ -0,0 +1,6 @@
+package io.github.kelvindev15.prolog.utils
+
+import io.github.kelvindev15.prolog.core.Term
+
+trait TermConvertible:
+  def toTerm: Term

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

@@ -2,6 +2,7 @@ package io.github.kelvindev15.dsl
 
 
 import io.github.kelvindev15.prolog.core.Constant.Atom
+import io.github.kelvindev15.prolog.core.Goals.{Conjunction, Disjunction}
 import io.github.kelvindev15.prolog.core.Struct.{Directive, Fact, Rule}
 import io.github.kelvindev15.prolog.core.Variable.anonymous
 import io.github.kelvindev15.prolog.core.{Constant, PrologList, RecursiveStruct, Struct, Term, Variable}
@@ -16,11 +17,20 @@ class TestDSL extends AnyFunSuite with Matchers with PrologDSL:
     f shouldBe a [Fact]
 
   test("Creation of a rule"):
-    val r = "grandfather"(X, Y) :- ("father"(X, Z) and "father"(Z, Y))
+    val r = "grandfather"(X, Y) :- &&("father"(X, Z), "father"(Z, Y))
     r shouldBe a [Rule]
     r.head.get shouldBe Struct(Atom("grandfather"), Variable("X"), Variable("Y"))
     r.body shouldBe a [RecursiveStruct]
 
+  test("Creation of a compound goal"):
+    Seq(A &: B &: C, &&(A, B, C)) foreach { _ shouldBe Conjunction(A, B, C) }
+    (A and B and C) shouldBe Conjunction(Conjunction(A, B), C)
+
+
+  test("Creation of a disjunction of goals"):
+    Seq(A |: B |: C, ||(A, B, C)) foreach { _ shouldBe Disjunction(A, B, C) }
+    (A or B or C) shouldBe Disjunction(Disjunction(A, B), C)
+
   test("Creation of a directive"):
     val d: Term = :-("op"(1199, "xfx", "-->"))
     d shouldBe a [Directive]

src/test/scala/io/github/kelvindev15/prolog/core/TestTermConversion.scala

@@ -0,0 +1,44 @@
+package io.github.kelvindev15.prolog.core
+
+import io.github.kelvindev15.prolog.core.Constant.Atom
+import io.github.kelvindev15.prolog.core.Goals.{Conjunction, Disjunction}
+import io.github.kelvindev15.prolog.core.PrologList.{Cons, Nil}
+import io.github.kelvindev15.prolog.core.Struct.{Directive, Fact, Indicator, Rule}
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatest.matchers.should.Matchers
+
+class TestTermConversion extends AnyFunSuite with Matchers:
+
+  test("A rule is a binary struct with :- as a functor"):
+    val head = Struct(Atom("grandfather"), Variable("X"), Variable("Y"))
+    val bodyArgs = Seq(Struct(Atom("father"), Variable("X"), Variable("Z")),
+      Struct(Atom("father"), Variable("Z"), Variable("Y")))
+    Rule(head, bodyArgs*).asTerm shouldBe Struct(Atom(":-"), head, Struct(Atom(","), bodyArgs*))
+
+  test("A fact is a binary struct with :- as a functor"):
+    val head = Struct(Atom("sequence"), Atom("a"), Atom("b"), Atom("c"), Atom("d"))
+    Fact(head).asTerm shouldBe Struct(Atom(":-"), head, Atom("true"))
+
+  test("A directive is a unary struct with :- as a functor"):
+    Directive(Struct(Atom("dynamic"), Indicator(Atom("foo"), Constant.Numeric(2)))).asTerm shouldBe
+      Struct(Atom(":-"), Struct(Atom("/"), Atom("foo"), Constant.Numeric(2)))
+
+  test("A conjunction of goals is a binary recursive struct with , as a functor"):
+    val functor = Atom(",")
+    Conjunction(Atom("a"), Atom("b"), Atom("c")).asTerm shouldBe
+      Struct(functor, Atom("a"), Struct(functor, Atom("b"), Atom("c")))
+
+  test("A disjunction of goals is a binary recursive struct with , as a function"):
+    val functor = Atom(";")
+    Disjunction(Atom("a"), Atom("b"), Atom("c")).asTerm shouldBe
+      Struct(functor, Atom("a"), Struct(functor, Atom("b"), Atom("c")))
+
+  test("The functor of an empty list is []"):
+    Nil.asTerm shouldBe Atom("[]")
+
+  test("A prolog list is binary recursive struct with . as a functor"):
+    val functor = Atom(".")
+    PrologList(Atom("a"), Atom("b"), Atom("c"), Atom("d")).asTerm shouldBe
+      Struct(functor, Atom("a"), Struct(functor, Atom("b"),
+        Struct(functor, Atom("c"),
+          Struct(functor, Atom("d"), Atom("[]")))))