Sync

src/prolog/ast/arithmetic/Integer.kt

@@ -3,8 +3,9 @@ package prolog.ast.arithmetic
 import prolog.Answers
 import prolog.Substitutions
 import prolog.ast.logic.LogicOperand
+import prolog.ast.terms.Body
 
-data class Integer(override val value: Int) : Number, LogicOperand() {
+data class Integer(override val value: Int) : Number, Body, LogicOperand() {
     // Integers are already evaluated
     override fun simplify(subs: Substitutions): Simplification = Simplification(this, this)
 

src/prolog/ast/terms/Body.kt

@@ -1,5 +1,8 @@
 package prolog.ast.terms
 
+import prolog.Substitutions
 import prolog.ast.logic.Satisfiable
 
-interface Body : Term, Satisfiable
+interface Body : Term, Satisfiable {
+    override fun applySubstitution(subs: Substitutions): Body
+}

src/prolog/builtins/arithmeticOperators.kt

@@ -40,8 +40,8 @@ class EvaluatesToDifferent(private val left: Expression, private val right: Expr
     }
 
     override fun applySubstitution(subs: Substitutions): EvaluatesToDifferent = EvaluatesToDifferent(
-        left.applySubstitution(subs) as Expression,
-        right.applySubstitution(subs) as Expression
+        applySubstitution(left, subs),
+        applySubstitution(right, subs)
     )
 }
 
@@ -63,8 +63,8 @@ class EvaluatesTo(private val left: Expression, private val right: Expression) :
     }
 
     override fun applySubstitution(subs: Substitutions): EvaluatesTo = EvaluatesTo(
-        left.applySubstitution(subs) as Expression,
-        right.applySubstitution(subs) as Expression
+        applySubstitution(left, subs),
+        applySubstitution(right, subs)
     )
 }
 
@@ -89,8 +89,8 @@ class Is(val number: Expression, val expr: Expression) :
     }
 
     override fun applySubstitution(subs: Substitutions): Is = Is(
-        number.applySubstitution(subs) as Expression,
-        expr.applySubstitution(subs) as Expression
+        applySubstitution(number, subs),
+        applySubstitution(expr, subs)
     )
 }
 
@@ -117,8 +117,8 @@ open class Add(private val expr1: Expression, private val expr2: Expression) :
     }
 
     override fun applySubstitution(subs: Substitutions): Add = Add(
-        expr1.applySubstitution(subs) as Expression,
-        expr2.applySubstitution(subs) as Expression
+        applySubstitution(expr1, subs),
+        applySubstitution(expr2, subs)
     )
 }
 
@@ -140,8 +140,8 @@ open class Subtract(private val expr1: Expression, private val expr2: Expression
     }
 
     override fun applySubstitution(subs: Substitutions): Subtract = Subtract(
-        expr1.applySubstitution(subs) as Expression,
-        expr2.applySubstitution(subs) as Expression
+        applySubstitution(expr1, subs),
+        applySubstitution(expr2, subs)
     )
 }
 
@@ -158,8 +158,8 @@ class Multiply(val expr1: Expression, val expr2: Expression) :
     }
 
     override fun applySubstitution(subs: Substitutions): Multiply = Multiply(
-        expr1.applySubstitution(subs) as Expression,
-        expr2.applySubstitution(subs) as Expression
+        applySubstitution(expr1, subs),
+        applySubstitution(expr2, subs)
     )
 }
 
@@ -173,8 +173,8 @@ class Divide(private val expr1: Expression, private val expr2: Expression) :
     }
 
     override fun applySubstitution(subs: Substitutions): Divide = Divide(
-        expr1.applySubstitution(subs) as Expression,
-        expr2.applySubstitution(subs) as Expression
+        applySubstitution(expr1, subs),
+        applySubstitution(expr2, subs)
     )
 }
 
@@ -206,9 +206,9 @@ class Between(private val expr1: Expression, private val expr2: Expression, priv
     }
 
     override fun applySubstitution(subs: Substitutions): Between = Between(
-        expr1.applySubstitution(subs) as Expression,
-        expr2.applySubstitution(subs) as Expression,
-        expr3.applySubstitution(subs) as Expression
+        applySubstitution(expr1, subs),
+        applySubstitution(expr2, subs),
+        applySubstitution(expr3, subs)
     )
 
     override fun toString(): String = "$expr1..$expr3..$expr2"

src/prolog/builtins/controlOperators.kt

@@ -55,7 +55,7 @@ open class Conjunction(val left: LogicOperand, private val right: LogicOperand)
                 right.fold(
                     // If the right part succeeds, yield the result with the left substitutions
                     onSuccess = { rightSubs ->
-                        yield(Result.success(leftSubs + rightSubs))
+                        yield(Result.success(rightSubs + leftSubs))
                     },
                     onFailure = { exception ->
                         // If the right part fails, check if it's a cut
@@ -74,8 +74,8 @@ open class Conjunction(val left: LogicOperand, private val right: LogicOperand)
         }
 
         fun findNextCutSolution(appliedCut: AppliedCut): Answers = sequence {
-            val leftSubs = appliedCut.subs
-            right.satisfy(subs + (appliedCut.subs!!)).firstOrNull()?.map { rightSubs ->
+            val leftSubs = appliedCut.subs ?: emptyMap()
+            right.satisfy(subs + leftSubs).firstOrNull()?.map { rightSubs ->
                 // If the right part succeeds, yield the result with the left substitutions
                 yield(Result.success(leftSubs + rightSubs))
                 return@sequence