feat: redesign api

Author: kelvin-olaiya

docs/docs/documentazione/analysis.md

@@ -46,7 +46,7 @@ o *termini composti* (chiamati anche *strutture*).
 ### Constanti
 
 Le constanti sono ciò che danno il nome agli oggetti o alle relazioni. Possono essere di due tipi: *atomi* o *numeri*.
-* Gli atomi si compongo di lettere e/o cifre. Il primo carattere di un atomo deve essere un lettera maiuscola.  
+* Gli atomi si compongo di lettere e/o cifre. Il primo carattere di un atomo deve essere un lettera minuscola.  
   Non ci sono vincoli sulla composizione della sequenza di caratteri se questa è racchiusa tra apici `''`.  
   Gli atomi possono contenere anche i simboli `+`, `-` `*`,`/`, `\ `,`~`, `^`,`<`, `>`, `:`, `.`, `?`, `@`, 
   `#`, `$`, `&`. La sequenza di caratteri può contenere il carattere `_` per aumentare la leggibilità.

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

@@ -0,0 +1,20 @@
+package io.github.kelvindev15.prolog
+
+import io.github.kelvindev15.prolog.Prolog.Functors
+import io.github.kelvindev15.prolog.RecursiveStruct.BinaryRecursiveStruct
+import io.github.kelvindev15.prolog.utils.TermVisitor
+
+trait CompoundGoal extends BinaryRecursiveStruct:
+  override val functor: Constant.Atom = Functors.COMPOUND_GOAL
+  override def accept[T](visitor: TermVisitor[T]): T = visitor.visit(this)
+
+object CompoundGoal:
+  def ifNecessary(args: Term*): Term = args.size match
+    case 0 => throw IllegalArgumentException("Cannot create a goal from an empty sequence")
+    case 1 => args.head
+    case _ => CompoundGoal(args*)
+    
+  def apply(args: Term*): CompoundGoal = BinaryRecursiveStruct.fold(CompoundGoalImpl.apply)(args*)
+  def unapply(compoundGoal: CompoundGoal): Option[(Term, Term)] = Option((compoundGoal.first, compoundGoal.second))
+
+  private case class CompoundGoalImpl(left: Term, right: Term) extends CompoundGoal

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

@@ -1,26 +1,34 @@
 package io.github.kelvindev15.prolog
 
+import io.github.kelvindev15.prolog.Struct.quoteIfFunctorIsMalformed
+import io.github.kelvindev15.prolog.utils.TermVisitor
+
 trait Constant extends Term:
-  final override val isGround: Boolean = true
-  final override val variables: Seq[Variable] = Seq()
+  val value: Any
+  override def variables: Iterable[Variable] = Seq()
+  override def isGround: Boolean = true
+  override def accept[T](visitor: TermVisitor[T]): T = visitor.visit(this)
 
 object Constant:
-  def apply(value: Any): Constant = value match {
-    case v: (Double | Int) => Numeric(v)
-    case v: String => Atom(v)
-    case invalid => throw IllegalArgumentException(s"$invalid is an invalid value for a constant")
-  }
-
-  trait Atom extends Constant with Struct
+  def apply(value: Any): Constant = value match
+    case n: (Int | Double) => Numeric(n)
+    case s: String => Atom(s)
+    case _ => throw IllegalArgumentException("Cannot create a constant with the provided argument")
+  trait Atom extends Constant with Struct:
+    override val value: String
+    override val arity: Int = 0
+    override val arguments: Iterable[Term] = Seq()
+    override val functor: Atom = this
 
   object Atom:
-    def apply(value: String): Atom = AtomImpl(value)
+    private def removeQuotes(value: String) = value.replaceAll("^'+|'+$", "")
+    def apply(value: String): Atom = AtomImpl(removeQuotes(value))
+    private case class AtomImpl(private val _value: String) extends Atom:
+      override val value: String = quoteIfFunctorIsMalformed(_value)
 
-    private case class AtomImpl(value: String) extends Atom
-    
-  trait Numeric extends Constant
+  trait Numeric extends Constant:
+    override val value: AnyVal
 
   object Numeric:
     def apply(value: AnyVal): Numeric = NumericImpl(value)
-
     private case class NumericImpl(value: AnyVal) extends Numeric

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

@@ -1,5 +1,38 @@
 package io.github.kelvindev15.prolog
 
+import scala.annotation.targetName
+
+/*object LangFeatures:
+  extension (a: Atom)
+    def apply(args: Term*): CompoundTerm = CompoundTerm(a, args*)
+
+  extension (t: Term)
+    @targetName("univ")
+    def `=..`(o: Term): Term = Struct("=..", t, o)
+  given Conversion[String, Atom] with
+    override def apply(value: String): Atom = Atom(value)
+*/
 object Language:
   object Builtins
 
+    /*val `true`: Atom = "true"
+    val fail: Atom = "fail"
+    def `var`(term: Term): Term = "var"(term)
+    def nonvar(term: Term): Term = "nonvar"(term)
+    def atom(term: Term): Term = "atom"(term)
+    def number(term: Term): Term = "number"(term)
+    def atomic(term: Term): Term = "atomic"(term)
+    def clause(x: Term, y: Term): Term = "clause"(x, y)
+    def asserta(x: Term): Term = "asserta"(x)
+    def assertz(x: Term): Term = "assertz"(x)
+    def retract(x: Term): Term = "retract"(x)
+    def listing(x: Atom): Term = "listing"(x)
+    def functor(t: Term, f: Term, n: Term): Term = "functor"(t, f, n)
+    def arg(n: Term, t: Term, a: Term): Term = "functor"(n, t, a)
+    @targetName("univ")
+    def `=..`(x: Term, l: Term): Term = x.`=..`(l)
+    def atom_chars(a: Term, l: Term): Term = "atom_chars"(a, l)
+    def number_chars(a: Term, l: Term): Term = "number_chars"(a, l)
+    @targetName("cut")
+    val `!`: Term = "!"
+*/

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

@@ -0,0 +1,19 @@
+package io.github.kelvindev15.prolog
+
+import io.github.kelvindev15.prolog.Constant.Atom
+
+import scala.util.matching.Regex
+
+object Prolog:
+  object Syntax:
+    val AtomRegex: Regex = "^[a-z][a-zA-Z_0-9]*$".r
+    val VariableRegex: Regex = "[A-Z_][a-zA-Z_0-9]*".r
+    
+  object Functors:
+    val COMPOUND_GOAL: Atom = Atom(",")
+    val CLAUSE: Atom = Atom(":-")
+    val CONS: Atom = Atom(".")
+    val TRUE: Atom = Atom("true")
+    val FAIL: Atom = Atom("fail")
+    val EMPTY_LIST: Atom = Atom("[]")
+

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

@@ -0,0 +1,27 @@
+package io.github.kelvindev15.prolog
+
+import io.github.kelvindev15.prolog.Constant.Atom
+import io.github.kelvindev15.prolog.utils.BinaryToFlatVisitor
+
+trait RecursiveStruct extends Struct:
+  def linearizedArguments: Iterable[Term]
+
+object RecursiveStruct:
+  trait BinaryRecursiveStruct extends RecursiveStruct:
+    final override val arity: Int = 2
+    val left: Term
+    val right: Term
+    val first: Term = left
+    val second: Term = right
+    final override val arguments: Iterable[Term] = Seq(left, right)
+    override def linearizedArguments: Iterable[Term] = accept(BinaryToFlatVisitor())
+  
+  object BinaryRecursiveStruct:
+    object Tuple:
+      def unapply(tuple: BinaryRecursiveStruct): Option[(Term, Term)] =
+        Option((tuple.left, tuple.right))
+
+    def fold[T <: BinaryRecursiveStruct](struct: (Term, Term) => T)(args: Term*): T = args.size match
+      case n if n < 2 => throw IllegalArgumentException("There must be at least two arguments")
+      case 2 => struct(args.head, args.tail.head)
+      case _ => struct(args.head, fold(struct)(args.tail *))

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

@@ -1,39 +1,55 @@
 package io.github.kelvindev15.prolog
 
 import io.github.kelvindev15.prolog.Constant.Atom
-import io.github.kelvindev15.prolog.Term.Recursive
+import io.github.kelvindev15.prolog.Prolog.Functors.{CLAUSE, COMPOUND_GOAL}
+import io.github.kelvindev15.prolog.Prolog.Syntax
+import io.github.kelvindev15.prolog.utils.TermVisitor
 
-trait Struct extends Term
+trait Struct extends Term:
+  val functor: Atom
+  val arity: Int
+  val arguments: Iterable[Term]
+
+  override def variables: Iterable[Variable] = arguments.flatMap(_.variables)
+  override def isGround: Boolean = arguments.forall(_.isGround)
+
+  override def accept[T](visitor: TermVisitor[T]): T = visitor.visit(this)
 
 object Struct:
+  private def isFunctorWellFormed(functor: String): Boolean = functor.matches(Syntax.AtomRegex.regex)
+  def quoteIfFunctorIsMalformed(functor: String): String =
+    if (isFunctorWellFormed(functor)) functor else s"'$functor'"
   def apply(functor: Atom, args: Term*): Struct = StructImpl(functor, args*)
 
-  private case class StructImpl(functor: Atom, args: Term*) extends Struct:
-    override def isGround: Boolean = args.forall(_.isGround)
-    override def variables: Seq[Variable] = args.collect { case t: Variable => t }
+  object Functor:
+    def unapply(struct: Struct): Option[Atom] = Option(struct.functor)
+    
+  object Args:
+    def unapply(struct: Struct): Option[Iterable[Term]] = Option(struct.arguments)  
+  
+  private case class StructImpl(functor: Atom, arguments: Term*) extends Struct:
+    override val arity: Int = arguments.size
 
   trait Rule extends Struct:
     val head: Struct
     val body: Term
-
-    override def isGround: Boolean = head.isGround && body.isGround
-    override def variables: Seq[Variable] = head.variables ++ body.variables
+    final override val functor: Atom = CLAUSE
+    final override val arity: Int = 2
+    final override val arguments: Iterable[Term] = Seq(head, body)
+    final override def isGround: Boolean = head.isGround && body.isGround
+    final override def variables: Iterable[Variable] = head.variables ++ body.variables
 
   object Rule:
-    private val cmpGoalPredicate = Recursive.of(Atom(","), 2)
-
-    def apply(head: Struct, body: Term*): Rule =
-      if (body.size > 1)
-        RuleImpl(head, cmpGoalPredicate.fold(body*))
-      else
-        RuleImpl(head, body.headOption.getOrElse(Atom("true")))
-
-  private case class RuleImpl(head: Struct, body: Term) extends Rule
+    def apply(head: Struct, args: Term*): Rule = RuleImpl(head, CompoundGoal.ifNecessary(args*))
+    private case class RuleImpl(head: Struct, body: Term) extends Rule
 
   trait Fact extends Rule:
-    final override val body = Atom("true")
+    override val body: Term = Atom("true")
 
   object Fact:
-    def apply(fact: Struct): Fact = FactImpl(fact)
+    def apply(head: Struct): Fact = FactImpl(head)
+    private case class FactImpl(head: Struct) extends Fact
+
+
+
 
-    private case class FactImpl(override val head: Struct) extends Fact

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

@@ -1,29 +1,12 @@
 package io.github.kelvindev15.prolog
 
-import io.github.kelvindev15.prolog.Constant.Atom
+import io.github.kelvindev15.prolog.utils.TermVisitor
 
-trait Term:
-  def isGround: Boolean
-  def variables: Seq[Variable]
-
-object Term:
-  trait Recursive:
-    val functor: Atom
-    val arity: Int
-    def fold(term: Term*): Term
-
-  object Recursive:
-    def of(functor: Atom, arity: Int): Recursive = RecursiveImpl(functor, arity)
+trait Visitable:
+  self: Term =>
+  def accept[T](visitor: TermVisitor[T]): T
 
-    private case class RecursiveImpl(functor: Atom, arity: Int) extends Recursive:
-      if (arity <= 1)
-        throw IllegalArgumentException("Arity should be at least 2")
-
-      override def fold(term: Term*): Term =
-        if (term.size == arity)
-          Struct(functor, term *)
-        else if (term.size < arity || (term.size - arity) % (arity - 1) != 0)
-            throw IllegalArgumentException("Number of provided terms are incompatible with the arity of this predicate")
-        else
-          val tmp = term.splitAt(arity - 1)
-          Struct(functor, tmp._1 :+ fold(tmp._2*)*)
+trait Term extends Visitable:
+  def isGround: Boolean
+  def variables: Iterable[Variable]
+  

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

@@ -1,17 +1,19 @@
 package io.github.kelvindev15.prolog
 
+import io.github.kelvindev15.prolog.Prolog.Syntax.VariableRegex
+import io.github.kelvindev15.prolog.utils.TermVisitor
+
 trait Variable extends Term:
   val name: String
   final def isAnonymous: Boolean = name == "_" 
   final override def isGround: Boolean = false
-  final override def variables: Seq[Variable] = Seq(this)
-
+  final override def variables: Iterable[Variable] = Seq(this)
+  override def accept[T](visitor: TermVisitor[T]): T = visitor.visit(this)
+  
 object Variable:
-  def apply(name: String): Variable =
-    require(
-      name == "_" || name.matches("""\p{Upper}[a-zA-Z0-9_]*"""),
-      "A variable name should be an alphanumerical string beginning with an with an uppercase letter"
-    )
-    VariableImpl(name: String)
-
-  private case class VariableImpl(name: String) extends Variable
+  def apply(name: String): Variable = name match
+    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
+  

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

@@ -0,0 +1,6 @@
+package io.github.kelvindev15.prolog.dsl
+
+trait PrologDSL:
+  def program(using scope: Any)(): Any = ???
+
+

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

@@ -0,0 +1,10 @@
+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.RecursiveStruct.BinaryRecursiveStruct.Tuple
+
+class BinaryToFlatVisitor extends TermVisitor[Iterable[Term]]:
+  override def visit(tuple: BinaryRecursiveStruct): Iterable[Term] = tuple match
+    case Tuple(l, r @ Tuple(_, _)) => Seq(l) ++ visit(r)
+    case Tuple(l, r) => Seq(l, r)

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

@@ -0,0 +1,17 @@
+package io.github.kelvindev15.prolog.utils
+
+import io.github.kelvindev15.prolog.Constant.{Atom, Numeric}
+import io.github.kelvindev15.prolog.RecursiveStruct.BinaryRecursiveStruct
+import io.github.kelvindev15.prolog.Struct.{Fact, Rule}
+import io.github.kelvindev15.prolog.{Constant, Struct, Variable}
+
+trait TermVisitor[T]:
+  def visit(constant: Constant): T = throw NotImplementedError()
+  def visit(atom: Atom): T = throw NotImplementedError()
+  def visit(numeric: Numeric): T = throw NotImplementedError()
+  def visit(variable: Variable): T = throw NotImplementedError()
+  def visit(struct: Struct): T = throw NotImplementedError()
+  def visit(rule: Rule): T = throw NotImplementedError()
+  def visit(fact: Fact): T = throw NotImplementedError()
+  def visit(binaryRecursiveStruct: BinaryRecursiveStruct): T = throw NotImplementedError()
+