feat: Cut

src/prolog/ast/logic/Clause.kt

@@ -7,6 +7,7 @@ import prolog.ast.terms.Functor
 import prolog.ast.terms.Goal
 import prolog.ast.terms.Head
 import prolog.builtins.True
+import prolog.exceptions.AppliedCut
 import prolog.logic.unifyLazy
 
 /**
@@ -28,9 +29,20 @@ abstract class Clause(private val head: Head, private val body: Body) : Resolven
             headAnswer.map { newHeadSubs ->
                 // If the body can be proven, yield the (combined) substitutions
                 body.satisfy(subs + newHeadSubs).forEach { bodyAnswer ->
-                    bodyAnswer.map { newBodySubs ->
-                        yield(Result.success(newHeadSubs + newBodySubs))
-                    }
+                    bodyAnswer.fold(
+                        onSuccess = { newBodySubs ->
+                            yield(Result.success(newHeadSubs + newBodySubs))
+                        },
+                        onFailure = { error ->
+                            if (error is AppliedCut) {
+                                // Find single solution and return immediately
+                                yield(Result.failure(AppliedCut(newHeadSubs + error.subs)))
+                                return@sequence
+                            } else {
+                                yield(Result.failure(error))
+                            }
+                        }
+                    )
                 }
             }
         }

src/prolog/ast/logic/Predicate.kt

@@ -4,6 +4,7 @@ import prolog.Answers
 import prolog.Substitutions
 import prolog.ast.terms.Functor
 import prolog.ast.terms.Goal
+import prolog.exceptions.AppliedCut
 
 /**
  * Collection of [Clause]s with the same [Functor].
@@ -53,6 +54,23 @@ class Predicate : Resolvent {
         require(goal.functor == functor) { "Goal functor does not match predicate functor" }
         // Try to unify the goal with the clause
         // If the unification is successful, yield the substitutions
-        clauses.forEach { yieldAll(it.solve(goal, subs)) }
+        clauses.forEach { clause ->
+            clause.solve(goal, subs).forEach { clauseResult ->
+                clauseResult.fold(
+                    onSuccess = {
+                        yield(Result.success(it))
+                    },
+                    onFailure = {
+                        if (it is AppliedCut) {
+                            // If it's a cut, yield the result with the left substitutions
+                            yield(Result.failure(AppliedCut(it.subs)))
+                            return@sequence
+                        } else {
+                            yield(Result.failure(it))
+                        }
+                    }
+                )
+            }
+        }
     }
 }

src/prolog/builtins/controlOperators.kt

@@ -7,6 +7,7 @@ import prolog.ast.terms.Atom
 import prolog.ast.terms.Body
 import prolog.ast.terms.Goal
 import prolog.ast.logic.LogicOperator
+import prolog.exceptions.AppliedCut
 
 /**
  * Always fail.
@@ -29,21 +30,64 @@ object True : Atom("true"), Body {
 
 // TODO Repeat/0
 
-// TODO !/0 (Cut)
+class Cut() : Atom("!") {
+    override fun satisfy(subs: Substitutions): Answers {
+        return sequenceOf(Result.failure(AppliedCut(emptyMap())))
+    }
+}
 
 /**
  * Conjunction (and). True if both Goal1 and Goal2 are true.
  */
-class Conjunction(private val left: LogicOperand, private val right: LogicOperand) : LogicOperator(Atom(","), left, right) {
+class Conjunction(private val left: LogicOperand, private val right: LogicOperand) :
+    LogicOperator(Atom(","), left, right) {
     override fun satisfy(subs: Substitutions): Answers = sequence {
-        left.satisfy(subs).forEach { leftResult ->
-            leftResult.mapCatching { left ->
-                right.satisfy(subs + left).forEach { rightResult ->
-                    rightResult.map { right ->
-                        yield(Result.success(left + right))
+        // Satisfy the left part first, which either succeeds or fails
+        left.satisfy(subs).forEach { left ->
+            left.fold(
+                // If it succeeds, satisfy the right part with the updated substitutions and return all results
+                onSuccess = { leftSubs ->
+                    right.satisfy(subs + leftSubs).forEach {
+                        it.fold(
+                            // If the right part succeeds, yield the result with the left substitutions
+                            onSuccess = { rightSubs ->
+                                yield(Result.success(leftSubs + rightSubs))
+                            },
+                            // If the right part fails, check if it's a cut
+                            onFailure = { exception ->
+                                if (exception is AppliedCut) {
+                                    // If it's a cut, yield the result with the left substitutions
+                                    yield(Result.failure(AppliedCut(leftSubs + exception.subs)))
+                                    return@sequence
+                                } else {
+                                    // If it's not a cut, yield the failure
+                                    yield(Result.failure(exception))
+                                }
+                            }
+                        )
+                    }
+                },
+                // If it fails, check these conditions:
+                onFailure = { exception ->
+                    // 1. If the left part is a cut, satisfy the right part ONCE, and stop searching for more solutions
+                    if (exception is AppliedCut) {
+                        right.satisfy(subs + exception.subs).first().fold(
+                            onSuccess = {
+                                // If the right part succeeds, yield the result with the left substitutions
+                                yield(Result.success(exception.subs + it))
+                                return@sequence
+                            },
+                            onFailure = {
+                                // If the right part fails, yield the failure
+                                yield(Result.failure(it))
+                            }
+                        )
+                    } else {
+                        // 2. Any other failure should be returned as is
+                        yield(Result.failure(exception))
                     }
                 }
-            }
+            )
         }
     }
 }

src/prolog/exceptions/AppliedCut.kt

@@ -0,0 +1,5 @@
+package prolog.exceptions
+
+import prolog.Substitutions
+
+class AppliedCut(val subs: Substitutions): Exception()