Added loose operators

src/prolog/builtins/verificationOperators.kt

@@ -0,0 +1,57 @@
+package prolog.builtins
+
+import prolog.Answers
+import prolog.Substitutions
+import prolog.ast.terms.Atom
+import prolog.ast.terms.Operator
+import prolog.ast.terms.Term
+import prolog.logic.applySubstitution
+import prolog.logic.atomic
+import prolog.logic.compound
+import prolog.logic.nonvariable
+import prolog.logic.variable
+
+class Atomic(private val term: Term) : Operator(Atom("atomic"), null, term) {
+    override fun satisfy(subs: Substitutions): Answers {
+        if (atomic(term, subs)) {
+            return sequenceOf(Result.success(emptyMap()))
+        }
+        return emptySequence()
+    }
+
+    override fun applySubstitution(subs: Substitutions): Atomic = Atomic(applySubstitution(term, subs))
+}
+
+class Compound(private val term: Term) : Operator(Atom("compound"), null, term) {
+    override fun satisfy(subs: Substitutions): Answers {
+        if (compound(term, subs)) {
+            return sequenceOf(Result.success(emptyMap()))
+        }
+        return emptySequence()
+    }
+
+    override fun applySubstitution(subs: Substitutions): Compound = Compound(applySubstitution(term, subs))
+}
+
+class NonVar(private val term: Term) : Operator(Atom("nonvar"), null, term) {
+    override fun satisfy(subs: Substitutions): Answers {
+        if (nonvariable(term, subs)) {
+            return sequenceOf(Result.success(emptyMap()))
+        }
+
+        return emptySequence()
+    }
+
+    override fun applySubstitution(subs: Substitutions): NonVar = NonVar(applySubstitution(term, subs))
+}
+
+class Var(private val term: Term) : Operator(Atom("var"), null, term) {
+    override fun satisfy(subs: Substitutions): Answers {
+        if (variable(term, subs)) {
+            return sequenceOf(Result.success(emptyMap()))
+        }
+        return emptySequence()
+    }
+
+    override fun applySubstitution(subs: Substitutions): Var = Var(applySubstitution(term, subs))
+}