Checkpoint

src/prolog/builtins/controlOperators.kt

@@ -0,0 +1,76 @@
+package prolog.builtins
+
+import prolog.ast.logic.LogicOperand
+import prolog.ast.terms.Atom
+import prolog.ast.terms.Body
+import prolog.ast.terms.Goal
+import prolog.ast.logic.LogicOperator
+import prolog.logic.Substituted
+
+/**
+ * Always fail.
+ */
+object Fail : Atom("fail"), Body {
+    override fun prove(subs: Substituted): Sequence<Substituted> = emptySequence()
+}
+
+/**
+ * Same as fail, but the name has a more declarative connotation.
+ */
+typealias False = Fail
+
+/**
+ * Always succeed.
+ */
+object True : Atom("true"), Body {
+    override fun prove(subs: Substituted): Sequence<Substituted> = sequenceOf(emptyMap())
+}
+
+// TODO Repeat/0
+
+// TODO !/0 (Cut)
+
+/**
+ * Conjunction (and). True if both Goal1 and Goal2 are true.
+ */
+class Conjunction(private val left: LogicOperand, private val right: LogicOperand) : LogicOperator(Atom(","), left, right) {
+    override fun prove(subs: Substituted): Sequence<Substituted> = sequence {
+        left.prove(subs).forEach { left ->
+            right.prove(subs + left).forEach { right ->
+                yield(left + right)
+            }
+        }
+    }
+}
+
+/**
+ * Disjunction (or). True if either Goal1 or Goal2 succeeds.
+ */
+open class Disjunction(private val left: LogicOperand, private val right: LogicOperand) :
+    LogicOperator(Atom(";"), left, right) {
+    override fun prove(subs: Substituted): Sequence<Substituted> = sequence {
+        yieldAll(left.prove(subs))
+        yieldAll(right.prove(subs))
+    }
+}
+
+@Deprecated("Use Disjunction instead")
+class Bar(leftOperand: LogicOperand, rightOperand: LogicOperand) : Disjunction(leftOperand, rightOperand)
+
+// TODO ->
+
+// TODO *->
+
+/**
+ * True if 'Goal' cannot be proven.
+ */
+class Not(private val goal: Goal) : LogicOperator(Atom("\\+"), rightOperand = goal) {
+    override fun prove(subs: Substituted): Sequence<Substituted> {
+        // If the goal can be proven, return an empty sequence
+        if (goal.prove(subs).toList().isNotEmpty()) {
+            return emptySequence()
+        }
+        // If the goal cannot be proven, return a sequence with an empty map
+        return sequenceOf(emptyMap())
+    }
+}