feat: add declarative prolog dsl

Author: kelvin-olaiya

src/main/scala/io/github/kelvindev15/PrologProgram.scala

@@ -0,0 +1,29 @@
+package io.github.kelvindev15.prolog
+
+import io.github.kelvindev15.prolog.core.Term
+import io.github.kelvindev15.prolog.core.Theory.Theory
+
+trait PrologProgram:
+  def staticTheory: Theory
+  def dynamicTheory: Theory
+  def goal: Option[Term]
+  def withGoal(goal: Term): PrologProgram
+  def setStaticTheory(theory: Theory): PrologProgram
+  def setDynamicTheory(theory: Theory): PrologProgram
+
+object PrologProgram:
+  def apply(staticTheory: Theory = Theory(), dynamicTheory: Theory = Theory()): PrologProgram =
+    PrologProgramImpl(staticTheory, dynamicTheory, None)
+
+  private case class PrologProgramImpl(
+    staticTheory: Theory,
+    dynamicTheory: Theory,
+    goal: Option[Term],
+  ) extends PrologProgram:
+    override def setStaticTheory(theory: Theory): PrologProgram = PrologProgramImpl(theory, dynamicTheory, goal)
+    override def setDynamicTheory(theory: Theory): PrologProgram = PrologProgramImpl(staticTheory, theory, goal)
+    override def withGoal(goal: Term): PrologProgram = PrologProgramImpl(staticTheory, dynamicTheory, Some(goal))
+
+
+
+

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

@@ -16,45 +16,45 @@ trait DSLExtensions:
     def :-(body: Term): Rule = Rule(struct, body)
 
   extension (term: Term)
-    def and(other: Term): Term = Goals.Conjunction(term, other)
+    def and(other: Term): Struct = Goals.Conjunction(term, other)
     @targetName("conjunctWith")
-    def &:(other: Term): Term = term and other
-    def or(other: Term): Term = Goals.Disjunction(term, other)
+    def &:(other: Term): Struct = term and other
+    def or(other: Term): Struct = Goals.Disjunction(term, other)
     @targetName("disjointWith")
-    def |: (other: Term): Term = term or other
+    def |: (other: Term): Struct = term or other
     @targetName("univ")
-    def `=..`(other: Term): Term = Struct(Atom("=.."), term, other)
+    def `=..`(other: Term): Struct = Struct(Atom("=.."), term, other)
     @targetName("equality")
-    def `=`(other: Term): Term = Struct(Atom("="), term, other)
+    def `=`(other: Term): Struct = Struct(Atom("="), term, other)
     @targetName("strictEquality")
-    def ==(other: Term): Term = Struct(Atom("=="), term, other)
-    def is(other: Term): Term = Struct(Atom("is"), term, other)
+    def ==(other: Term): Struct = Struct(Atom("=="), term, other)
+    def is(other: Term): Struct = Struct(Atom("is"), term, other)
     @targetName("plus")
-    def +(other: Term): Term = Struct(Atom("+"), term, other)
+    def +(other: Term): Struct = Struct(Atom("+"), term, other)
     @targetName("times")
-    def *(other: Term): Term = Struct(Atom("*"), term, other)
+    def *(other: Term): Struct = Struct(Atom("*"), term, other)
     @targetName("div")
-    def /(other: Term): Term = Struct(Atom("/"), term, other)
+    def /(other: Term): Struct = Struct(Atom("/"), term, other)
     @targetName("intDiv")
-    def `//`(other: Term): Term = Struct(Atom("//"), term, other)
-    def mod(other: Term): Term = Struct(Atom("mod"), term, other)
+    def `//`(other: Term): Struct = Struct(Atom("//"), term, other)
+    def mod(other: Term): Struct = Struct(Atom("mod"), term, other)
     @targetName("numericEquality")
-    def =:=(other: Term): Term = Struct(Atom("=:="), term, other)
+    def =:=(other: Term): Struct = Struct(Atom("=:="), term, other)
     @targetName("numericInequality")
-    def =\=(other: Term): Term = Struct(Atom("=\\="), term, other)
+    def =\=(other: Term): Struct = Struct(Atom("=\\="), term, other)
     @targetName("lessThan")
-    def <(other: Term): Term = Struct(Atom("<"), term, other)
+    def <(other: Term): Struct = Struct(Atom("<"), term, other)
     @targetName("greaterThan")
-    def >(other: Term): Term = Struct(Atom(">"), term, other)
+    def >(other: Term): Struct = Struct(Atom(">"), term, other)
     @targetName("greaterOrEqualThan")
-    def >=(other: Term): Term = Struct(Atom(">="), term, other)
+    def >=(other: Term): Struct = Struct(Atom(">="), term, other)
     @targetName("lessOrEqualThan")
-    def =<(other: Term): Term = Struct(Atom("=<"), term, other)
+    def =<(other: Term): Struct = Struct(Atom("=<"), term, other)
     @targetName("termLessThan")
-    def @<(other: Term): Term = Struct(Atom("@<"), term, other)
+    def @<(other: Term): Struct = Struct(Atom("@<"), term, other)
     @targetName("termGreaterThan")
-    def @>(other: Term): Term = Struct(Atom("@>"), term, other)
+    def @>(other: Term): Struct = Struct(Atom("@>"), term, other)
     @targetName("termGreaterThanOrEqual")
-    def @>=(other: Term): Term = Struct(Atom("@>="), term, other)
+    def @>=(other: Term): Struct = Struct(Atom("@>="), term, other)
     @targetName("termLessThanOrEqual")
-    def @=<(other: Term): Term = Struct(Atom("@=<"), term, other)
+    def @=<(other: Term): Struct = Struct(Atom("@=<"), term, other)

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

@@ -18,48 +18,48 @@ trait DSLPrologBuiltins:
   @targetName("iff")
   def :-(terms: Term*): Directive = Directive(terms *)
 
-  def `var`(term: Term): Term = Struct(Atom("var"), term)
-  def nonvar(term: Term): Term = Struct(Atom("nonvar"), term)
-  def atom(term: Term): Term = Struct(Atom("atom"), term)
-  def number(term: Term): Term = Struct(Atom("number"), term)
-  def atomic(term: Term): Term = Struct(Atom("atomic"), term)
-  def ground(term: Term): Term = Struct(Atom("ground"), term)
+  def `var`(term: Term): Struct = Struct(Atom("var"), term)
+  def nonvar(term: Term): Struct = Struct(Atom("nonvar"), term)
+  def atom(term: Term): Struct = Struct(Atom("atom"), term)
+  def number(term: Term): Struct = Struct(Atom("number"), term)
+  def atomic(term: Term): Struct = Struct(Atom("atomic"), term)
+  def ground(term: Term): Struct = Struct(Atom("ground"), term)
 
-  def member(term: Term, l: Term): Term = Struct(Atom("member"), term, l)
-  def append(l1: Term, l2: Term): Term = Struct(Atom("append"), l1, l2)
+  def member(term: Term, l: Term): Struct = Struct(Atom("member"), term, l)
+  def append(l1: Term, l2: Term): Struct = Struct(Atom("append"), l1, l2)
 
-  def dynamic(indicators: Indicator*): Term =
+  def dynamic(indicators: Indicator*): Struct =
     Directive(Struct(Atom("dynamic"), Conjunction.wrapIfNecessary(indicators*)))
 
-  def clause(head: Term, body: Term): Term = Struct(Atom("clause"), head, body)
-  def asserta(clause: Term): Term = Struct(Atom("asserta"), clause)
-  def assertz(clause: Term): Term = Struct(Atom("assertz"), clause)
-  def retract(clause: Term): Term = Struct(Atom("retract"), clause)
+  def clause(head: Term, body: Term): Struct = Struct(Atom("clause"), head, body)
+  def asserta(clause: Term): Struct = Struct(Atom("asserta"), clause)
+  def assertz(clause: Term): Struct = Struct(Atom("assertz"), clause)
+  def retract(clause: Term): Struct = Struct(Atom("retract"), clause)
 
-  def functor(term: Term, functor: Term, arity: Term): Term =
+  def functor(term: Term, functor: Term, arity: Term): Struct =
     Struct(Atom("functor"), term, functor, arity)
 
-  def arg(number: Term, term: Struct, arg: Term): Term = Struct(Atom("arg"), number, term, arg)
+  def arg(number: Term, term: Struct, arg: Term): Struct = Struct(Atom("arg"), number, term, arg)
 
-  def atom_chars(atom: Term, list: Term): Term = Struct(Atom("atom_chars"), atom, list)
-  def number_chars(atom: Term, list: Term): Term = Struct(Atom("atom"), atom, list)
+  def atom_chars(atom: Term, list: Term): Struct = Struct(Atom("atom_chars"), atom, list)
+  def number_chars(atom: Term, list: Term): Struct = Struct(Atom("atom"), atom, list)
 
   @targetName("cut")
   val `!`: Atom = Atom("!")
 
   val repeat: Atom = Atom("repeat")
 
-  def call(goal: Term): Term = Struct(Atom("call"), goal)
-  def once(goal: Term): Term = Struct(Atom("once"), goal)
-  def not(goal: Term): Term = Struct(Atom("not"), goal)
+  def call(goal: Term): Struct = Struct(Atom("call"), goal)
+  def once(goal: Term): Struct = Struct(Atom("once"), goal)
+  def not(goal: Term): Struct = Struct(Atom("not"), goal)
 
-  def findall(res: Term, goal: Term, list: Term): Term = Struct(Atom("findall"), res, goal, list)
+  def findall(res: Term, goal: Term, list: Term): Struct = Struct(Atom("findall"), res, goal, list)
 
   @targetName("naf")
-  def !(goal: Term): Term = Struct(Atom("\\+"), goal)
+  def !(goal: Term): Struct = Struct(Atom("\\+"), goal)
 
-  def op(precedence: Constant.Numeric, associativity: AssociativitySpec, name: Atom): Term =
+  def op(precedence: Constant.Numeric, associativity: AssociativitySpec, name: Atom): Struct =
     Struct(Atom("op"), precedence, associativity, name)
 
-  def length(term: Term, len: Term): Term = Struct(Atom("length"), term, len)
+  def length(term: Term, len: Term): Struct = Struct(Atom("length"), term, len)
 

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

@@ -0,0 +1,57 @@
+package io.github.kelvindev15.prolog.dsl
+
+import io.github.kelvindev15.prolog.PrologProgram
+import io.github.kelvindev15.prolog.core.{Struct, Term}
+import io.github.kelvindev15.prolog.core.Struct.{Clause, Directive, Fact, Rule}
+import io.github.kelvindev15.prolog.core.Theory.Theory
+import io.github.kelvindev15.prolog.dsl.DeclarativeDSL.{MutableDynamicTheoryWrapper, MutableTheoryWrapper}
+
+
+trait DeclarativeDSL:
+  dsl: PrologDSL =>
+  private var prologProgram: PrologProgram = PrologProgram()
+
+  def prolog(program: PrologProgram ?=> Unit): PrologProgram =
+    given p: PrologProgram = prologProgram
+    program
+    prologProgram
+
+  def staticTheory(using program: PrologProgram)(theory: MutableTheoryWrapper ?=> Unit): Unit =
+    given t: MutableTheoryWrapper = MutableTheoryWrapper()
+    theory
+    prologProgram = program.setStaticTheory(t.theory)
+
+  def dynamicTheory(using program: PrologProgram)(theory: MutableDynamicTheoryWrapper ?=> Unit): Unit =
+    given t: MutableDynamicTheoryWrapper = MutableTheoryWrapper()
+    theory
+    prologProgram = prologProgram.setDynamicTheory(t.theory)
+
+  def assert(using dynamicTheory: MutableDynamicTheoryWrapper)(clause: Clause): Unit =
+    dynamicTheory add "assert"(clause)
+
+  def assertA(using dynamicTheory: MutableDynamicTheoryWrapper)(clause: Clause): Unit =
+    dynamicTheory add "asserta"(clause)
+
+  def assertZ(using dynamicTheory: MutableDynamicTheoryWrapper)(clause: Clause): Unit =
+    dynamicTheory add "assertz"(clause)
+
+  def rule(using theory: MutableTheoryWrapper | MutableDynamicTheoryWrapper)(rule: Rule): Unit = theory add rule
+  def fact(using theory: MutableTheoryWrapper | MutableDynamicTheoryWrapper)(fact: Fact): Unit = theory add fact
+  def directive(using theory: MutableTheoryWrapper)(directive: Directive): Unit = theory add directive
+  def clause(using theory: MutableTheoryWrapper | MutableDynamicTheoryWrapper)(c: Clause): Unit = theory add c
+
+  def solve(using program: PrologProgram)(goal: () => Term): Unit =
+    prologProgram = prologProgram withGoal goal()
+
+object DeclarativeDSL:
+  trait MutableDynamicTheoryWrapper:
+    var theory: Theory = Theory()
+    def add(clause: Clause): Theory = { theory = theory add clause; theory }
+    def remove(clause: Clause): Theory = { theory = theory remove clause; theory }
+
+  trait MutableTheoryWrapper extends MutableDynamicTheoryWrapper
+  object MutableTheoryWrapper:
+    def apply(t: Theory): MutableTheoryWrapper = new MutableTheoryWrapper:
+      theory = t
+    def apply(clauses: Clause*): MutableTheoryWrapper = new MutableTheoryWrapper:
+      theory = Theory(clauses *)

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

@@ -0,0 +1,63 @@
+package io.github.kelvindev15.dsl
+
+import io.github.kelvindev15.prolog.PrologProgram
+import io.github.kelvindev15.prolog.core.Constant.Atom
+import io.github.kelvindev15.prolog.core.{Constant, Struct, Variable}
+import io.github.kelvindev15.prolog.core.Struct.{Directive, Fact, Rule}
+import io.github.kelvindev15.prolog.dsl.{DeclarativeDSL, PrologDSL}
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatest.matchers.should.Matchers
+
+class TestDeclarativeDSL extends AnyFunSuite with Matchers with PrologDSL with DeclarativeDSL:
+  test("Creation of an empty prolog program"):
+    val program: PrologProgram = prolog { }
+    program.staticTheory shouldBe empty
+    program.dynamicTheory shouldBe empty
+    program.goal shouldBe empty
+
+  test("Creation of a simple static theory"):
+    val program: PrologProgram = prolog {
+      staticTheory {
+        fact { "likes"("alice", X) }
+        rule { "grandfather"(X, Y) :- ("father"(X, Z) &: "father"(Z, Y)) }
+        directive { :- ("dynamic"("foo" / 2)) }
+      }
+    }
+    program.staticTheory should have size 3
+    program.staticTheory.head shouldBe a [Fact]
+    program.staticTheory.tail.head shouldBe a [Rule]
+    program.staticTheory.tail.tail.head shouldBe a [Directive]
+
+  test("Defining multiple times a theory overrides the theory"):
+    val program: PrologProgram = prolog {
+      staticTheory {
+        fact { "person"("luca") }
+      }
+      staticTheory { }
+
+      dynamicTheory {
+        assert { "foo"(X, Y) :- (2 is X + Y) }
+      }
+      dynamicTheory { }
+    }
+    program.staticTheory shouldBe empty
+    program.dynamicTheory shouldBe empty
+
+  test("Asserts on dynamic theories"):
+    prolog {
+      dynamicTheory {
+        assertA { "foo"(X, Y) :- (2 is X + Y) }
+        assertZ { "bar"(X, Y) :- (2.5 is X + Y) }
+      }
+    }.dynamicTheory shouldBe Seq(
+      Fact(Struct(Atom("asserta"),
+        Rule(
+          Struct(Atom("foo"), Variable("X"), Variable("Y")),
+          Struct(Atom("is"), Constant.Numeric(2), Struct(Atom("+"), Variable("X"), Variable("Y")))))),
+
+      Fact(Struct(Atom("assertz"),
+        Rule(
+          Struct(Atom("bar"), Variable("X"), Variable("Y")),
+          Struct(Atom("is"),
+            Constant.Numeric(2.5), Struct(Atom("+"), Variable("X"), Variable("Y")))))),
+    )