feat: add list creation methods

Author: kelvin-olaiya

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

@@ -7,28 +7,36 @@ trait PrologList extends RecursiveStruct:
   val size: Int
 
 object PrologList:
+  extension (listTerminator: (PrologList | Variable))
+    def linearizedArguments: Seq[Term] = listTerminator match
+      case l: PrologList => l.linearizedArguments
+      case v: Variable => Seq(v)
+
+  given Conversion[(PrologList | Variable), Term] = _.asInstanceOf[Term]
+
   trait Cons extends PrologList:
     val head: Term
-    val tail: PrologList
-    override def linearizedArguments: Iterable[Term] = Seq(head) ++ tail.linearizedArguments
+    val tail: (PrologList | Variable)
+
+    override def linearizedArguments: Seq[Term] = Seq(head) ++ tail.linearizedArguments
     override val arity: Int = 2
     override val arguments: Seq[Term] = Seq(head, tail)
     override val size: Int = linearizedArguments.size
     override val functor: Constant.Atom = Functors.CONS
 
+  def apply(elements: Term*): PrologList = elements.size match
+    case 0 => Nil
+    case 1 => Cons(elements.head, Nil)
+    case _ => Cons(elements.head, apply(elements.tail *))
+
   object Cons:
-    def apply(head: Term, tail: PrologList): PrologList = ConsImpl(head, tail)
-    
+    def apply(head: Term, tail: (PrologList | Variable)): PrologList = ConsImpl(head, tail)
+
   object Nil extends PrologList:
-    override def linearizedArguments: Iterable[Term] = Seq()
+    override def linearizedArguments: Seq[Term] = Seq()
     override val arity: Int = 0
     override val arguments: Seq[Term] = Seq()
     override val size: Int = 0
     override val functor: Constant.Atom = Functors.EMPTY_LIST
 
-  private case class ConsImpl(head: Term, tail: PrologList) extends Cons
-
-  def apply(elements: Term*): PrologList = elements.size match
-    case 0 => Nil
-    case 1 => Cons(elements.head, Nil)
-    case _ => Cons(elements.head, apply(elements.tail*))
+  private case class ConsImpl(head: Term, tail: (PrologList | Variable)) extends Cons

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

@@ -3,7 +3,7 @@ package io.github.kelvindev15.prolog.core
 import io.github.kelvindev15.prolog.utils.BinaryToFlatVisitor
 
 trait RecursiveStruct extends Struct:
-  def linearizedArguments: Iterable[Term]
+  def linearizedArguments: Seq[Term]
 
 object RecursiveStruct:
   trait BinaryRecursiveStruct extends RecursiveStruct:
@@ -13,7 +13,7 @@ object RecursiveStruct:
     def left: Term
     def right: Term
     final override val arguments: Seq[Term] = Seq(left, right)
-    override def linearizedArguments: Iterable[Term] = accept(BinaryToFlatVisitor())
+    override def linearizedArguments: Seq[Term] = accept(BinaryToFlatVisitor())
 
   object BinaryRecursiveStruct:
     def wrapIfNecessary(struct: Seq[Term] => BinaryRecursiveStruct)(args: Term*): Term = args.size match

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

@@ -9,7 +9,7 @@ import scala.annotation.targetName
 object DSLFacilities:
   given Conversion[String, Atom] = Atom(_)
   given Conversion[AnyVal, Constant.Numeric] = Constant.Numeric(_)
-  
+    
   extension (atom: Atom)
     def apply(terms: Term*): Struct = Struct(atom, terms *)
 
@@ -19,6 +19,7 @@ object DSLFacilities:
     @targetName("iff")
     def :-(body: Term): Rule = Rule(struct, body)
     def and(other: Term): Struct = Goals.Conjunction(struct, other)
+    def or(other: Term): Struct = Goals.Disjunction(struct, other)
 
   @targetName("iff")
   def :-(terms: Term*): Directive = Directive(terms*)

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

@@ -1,6 +1,8 @@
 package io.github.kelvindev15.prolog.dsl
 
+import io.github.kelvindev15.prolog.core.PrologList.{Cons, Nil}
 import io.github.kelvindev15.prolog.core.Struct.Clause
+import io.github.kelvindev15.prolog.core.{PrologList, Term, Variable}
 import io.github.kelvindev15.prolog.core.Theory.Theory
 
 import scala.annotation.targetName
@@ -10,5 +12,8 @@ trait PrologDSL:
   export DSLVariables.*
 
   def theory(clauses: Clause*): Theory = Theory(clauses*)
-  
+  def list(terms: Term*): PrologList = PrologList(terms *)
+  def cons(term: Term, tail: (PrologList | Variable)): PrologList = Cons(term, tail)
+  def nil: PrologList = Nil
+
 

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

@@ -4,7 +4,7 @@ import io.github.kelvindev15.prolog.core.RecursiveStruct.BinaryRecursiveStruct
 import io.github.kelvindev15.prolog.core.RecursiveStruct.BinaryRecursiveStruct.Tuple
 import io.github.kelvindev15.prolog.core.Term
 
-class BinaryToFlatVisitor extends TermVisitor[Iterable[Term]]:
-  override def visit(tuple: BinaryRecursiveStruct): Iterable[Term] = tuple match
+class BinaryToFlatVisitor extends TermVisitor[Seq[Term]]:
+  override def visit(tuple: BinaryRecursiveStruct): Seq[Term] = tuple match
     case Tuple(l, r @ Tuple(_, _)) => Seq(l) ++ visit(r)
     case Tuple(l, r) => Seq(l, r)

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

@@ -50,4 +50,11 @@ class TestDSL extends AnyFunSuite with Matchers with PrologDSL {
     t should have size 2
     t.head shouldBe Fact(Struct(Atom("search"), Variable("X"), Struct(Atom("cons"), Variable("X"), anonymous())))
   }
+
+  test("Creation of lists") {
+    cons("item1", nil).arguments shouldBe Seq(Atom("item1"), nil)
+    cons(1, X).arguments should have size 2
+    cons(H, T).variables shouldBe Seq(Variable("H"), Variable("T"))
+    list(1, 2, 3) shouldBe cons(1, cons(2, cons(3, nil)))
+  }
 }

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

@@ -3,7 +3,6 @@ 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.{Constant, PrologList, Term, Variable}
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
@@ -60,3 +59,15 @@ class TestRecursiveStructs extends AnyFunSuite with Matchers:
   test("Creation of a prolog list with Cons and Nil") {
     Cons(Atom("a"), Cons(Atom("b"), Cons(Atom("c"), Cons(Atom("d"), Nil)))) shouldBe list
   }
+
+  test("A list can end also with a variable") {
+    val list = Cons(Atom("a"), Variable("X"))
+    list shouldBe a [PrologList]
+    list.linearizedArguments shouldBe Seq(Atom("a"), Variable("X"))
+  }
+
+  test("A list not ending with a variable") {
+    val list = PrologList(Atom("a"), Variable("X"))
+    list shouldBe Cons(Atom("a"), Cons(Variable("X"), Nil))
+    assert(list != Cons(Atom("a"), Variable("X")))
+  }