Checkpoint

src/prolog/logic/terms.kt

@@ -47,17 +47,17 @@ fun numbervars(
             }
 
             val from = term as Variable
-            var suggestedName = "${from.name}($start)"
+            var suggestedName = "${from.name}@$start"
             // If the suggested name is already in use, find a new one
-            while ((subs + sessionSubs).filter { (it.key as Variable).name == suggestedName }.isNotEmpty()) {
+            while ((subs + sessionSubs).any { (it.key as Variable).name == suggestedName }) {
                 val randomInfix = ((0..9) + ('a'..'z') + ('A'..'Z')).random()
-                suggestedName = "${from.name}_${randomInfix}_($start)"
+                suggestedName = "${from.name}@${randomInfix}_($start)"
             }
             return Pair(start + 1, mapOf(from to Variable(suggestedName)))
         }
 
         compound(term, subs) -> {
-            val from = term as Structure
+            val from = applySubstitution(term, subs) as Structure
             var n = start
             val s: MutableMap<Term, Term> = sessionSubs.toMutableMap()
             from.arguments.forEach { arg ->

src/prolog/logic/unification.kt

@@ -4,23 +4,24 @@ import prolog.Answer
 import prolog.Answers
 import prolog.Substitutions
 import prolog.ast.arithmetic.Expression
-import prolog.ast.logic.LogicOperator
-import prolog.ast.terms.*
-import kotlin.NoSuchElementException
-import prolog.ast.arithmetic.Number
-import prolog.ast.arithmetic.Integer
 import prolog.ast.arithmetic.Float
+import prolog.ast.arithmetic.Integer
+import prolog.ast.arithmetic.Number
+import prolog.ast.logic.Clause
+import prolog.ast.logic.Fact
+import prolog.ast.logic.LogicOperator
+import prolog.ast.logic.Rule
+import prolog.ast.terms.*
 
 // Apply substitutions to a term
 fun applySubstitution(term: Term, subs: Substitutions): Term = when {
+    term is Fact -> {
+        Fact(applySubstitution(term.head, subs) as Head)
+    }
+
     variable(term, emptyMap()) -> {
-        var result = subs[(term as Variable)]
-
-        while (result != null && result is Variable && result in subs) {
-            result = subs[result]
-        }
-
-        result ?: term
+        val variable = term as Variable
+        subs[variable]?.let { applySubstitution(term = it, subs = subs) } ?: term
     }
     atomic(term, subs) -> term
     compound(term, subs) -> {
@@ -105,9 +106,9 @@ fun unifyLazy(term1: Term, term2: Term, subs: Substitutions): Answers = sequence
 }
 
 fun unify(term1: Term, term2: Term): Answer {
-    val substitutions = unifyLazy(term1, term2, emptyMap()).toList()
-    return if (substitutions.isNotEmpty()) {
-        substitutions.first()
+    val substitutions = unifyLazy(term1, term2, emptyMap()).iterator()
+    return if (substitutions.hasNext()) {
+        substitutions.next()
     } else {
         Result.failure(NoSuchElementException())
     }