fix: Evaluation

src/prolog/components/terms/Structure.kt

@@ -1,6 +1,7 @@
 package prolog.components.terms
 
-import prolog.Substitution
+import prolog.Substituted
+import prolog.builtins.equivalent
 import prolog.components.Resolvent
 import prolog.unifyLazy
 
@@ -9,8 +10,26 @@ typealias Argument = Term
 open class Structure(val name: Atom, val arguments: List<Argument>): Goal(), Head, Body, Resolvent {
     override val functor: Functor = "${name.name}/${arguments.size}"
 
-    override fun solve(goal: Goal): Sequence<Substitution> {
-        return unifyLazy(goal, this)
+    override fun solve(goal: Goal, subs: Substituted): Sequence<Substituted> {
+        return unifyLazy(goal, this, subs)
+    }
+
+    override fun compareTo(other: Term): Int {
+        when (other) {
+            is Structure -> {
+                val arityComparison = arguments.size.compareTo(other.arguments.size)
+                if (arityComparison != 0) return arityComparison
+                val nameComparison = name.compareTo(other.name)
+                if (nameComparison != 0) return nameComparison
+                arguments.zip(other.arguments).forEach { (arg1, arg2) ->
+                    val argsComparison = equivalent(arg1, arg2)
+                    if (!argsComparison) return arg1.compareTo(arg2)
+                }
+                return 0
+            }
+            // Structure is always greater than other terms
+            else -> return 1
+        }
     }
 
     override fun toString(): String {