Assert{a,z,}

src/prolog/Program.kt

@@ -12,7 +12,7 @@ import prolog.ast.terms.Goal
  * This object is a singleton that manages a list of databases.
  */
 object Program : Resolvent {
-    private val internalDb = Database("")
+    val internalDb = Database("")
     private val databases: MutableList<Database> = mutableListOf(internalDb)
 
     var storeNewLine: Boolean = false
@@ -35,7 +35,7 @@ object Program : Resolvent {
         }
     }
 
-    fun load(clauses: List<Clause>) = internalDb.load(clauses)
+    fun load(clauses: List<Clause>, index: Int? = null) = internalDb.load(clauses, index)
 
     fun clear() {
         databases.forEach { it.clear() }

src/prolog/ast/Database.kt

@@ -14,7 +14,7 @@ import prolog.ast.terms.Goal
  * Prolog Program or Database
  */
 class Database(val sourceFile: String): Resolvent {
-    private var predicates: Map<Functor, Predicate> = emptyMap()
+    var predicates: Map<Functor, Predicate> = emptyMap()
 
     fun initialize() {
         Logger.info("Initializing database from $sourceFile")
@@ -39,14 +39,14 @@ class Database(val sourceFile: String): Resolvent {
     /**
      * Loads a list of clauses into the program.
      */
-    fun load(clauses: List<Clause>) {
+    fun load(clauses: List<Clause>, index: Int? = null) {
         for (clause in clauses) {
             val functor = clause.functor
             val predicate = predicates[functor]
 
             if (predicate != null) {
                 // If the predicate already exists, add the clause to it
-                predicate.add(clause)
+                predicate.add(clause, index)
             } else {
                 // If the predicate does not exist, create a new one
                 predicates += Pair(functor, Predicate(listOf(clause)))

src/prolog/ast/logic/Clause.kt

@@ -19,7 +19,7 @@ import prolog.logic.unifyLazy
  * @see [prolog.ast.terms.Variable]
  * @see [Predicate]
  */
-abstract class Clause(val head: Head, val body: Body) : Resolvent {
+abstract class Clause(val head: Head, val body: Body) : Term, Resolvent {
     val functor: Functor = head.functor
 
     override fun solve(goal: Goal, subs: Substitutions): Answers = sequence {
@@ -70,4 +70,18 @@ abstract class Clause(val head: Head, val body: Body) : Resolvent {
     }
 
     override fun toString(): String = if (body is True) head.toString() else "$head :- $body"
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is Clause) return false
+
+        if (head != other.head) return false
+        if (body != other.body) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        return super.hashCode()
+    }
 }

src/prolog/ast/logic/Predicate.kt

@@ -36,9 +36,9 @@ class Predicate : Resolvent {
     /**
      * Adds a clause to the predicate.
      */
-    fun add(clause: Clause) {
+    fun add(clause: Clause, index: Int? = null) {
         require(clause.functor == functor) { "Clause functor does not match predicate functor" }
-        clauses.add(clause)
+        if (index != null) clauses.add(index, clause) else clauses.add(clause)
     }
 
     /**

src/prolog/builtins/databaseOperators.kt

@@ -0,0 +1,38 @@
+package prolog.builtins
+
+import prolog.Answers
+import prolog.Substitutions
+import prolog.ast.logic.Clause
+import prolog.ast.terms.Atom
+import prolog.ast.terms.Structure
+import prolog.ast.logic.Predicate
+import prolog.Program
+import prolog.ast.terms.Functor
+
+class Assert(clause: Clause) : AssertZ(clause) {
+    override val functor: Functor = "assert/1"
+}
+
+/**
+ * Assert a [Clause] as a first clause of the [Predicate] into the [Program].
+ */
+class AssertA(val clause: Clause) : Structure(Atom("asserta"), listOf(clause)) {
+    override fun satisfy(subs: Substitutions): Answers {
+        // Add clause to the program
+        Program.load(listOf(clause), 0)
+
+        return sequenceOf(Result.success(emptyMap()))
+    }
+}
+
+/**
+ * Assert a [Clause] as a last clause of the [Predicate] into the [Program].
+ */
+open class AssertZ(val clause: Clause) : Structure(Atom("assertz"), listOf(clause)) {
+    override fun satisfy(subs: Substitutions): Answers {
+        // Add clause to the program
+        Program.load(listOf(clause))
+
+        return sequenceOf(Result.success(emptyMap()))
+    }
+}