refactor: Herstructurering

src/prolog/Program.kt

@@ -1,12 +1,15 @@
-package prolog.components
+package prolog
 
-import prolog.Substituted
+import prolog.logic.Substituted
+import prolog.ast.logic.Clause
+import prolog.ast.logic.Fact
+import prolog.ast.logic.Predicate
+import prolog.ast.logic.Resolvent
+import prolog.ast.terms.Functor
+import prolog.ast.terms.Goal
 import prolog.builtins.True
-import prolog.components.expressions.Clause
-import prolog.components.expressions.Fact
-import prolog.components.expressions.Predicate
-import prolog.components.terms.Functor
-import prolog.components.terms.Goal
+
+typealias Database = Program
 
 /**
  * Prolog Program or database.
@@ -29,7 +32,7 @@ object Program: Resolvent {
      * Queries the program with a goal.
      * @return true if the goal can be proven, false otherwise.
      */
-    fun query(goal: Goal): Boolean = solve(goal, emptyMap()).toList().isNotEmpty()
+    fun query(goal: Goal): Sequence<Substituted> = solve(goal, emptyMap())
 
     override fun solve(goal: Goal, subs: Substituted): Sequence<Substituted> {
         val functor = goal.functor
@@ -74,6 +77,4 @@ object Program: Resolvent {
         predicates = emptyMap()
         setup()
     }
-}
-
-typealias Database = Program
+}

src/prolog/ast/logic/Clause.kt

@@ -1,18 +1,19 @@
-package prolog.components.expressions
+package prolog.ast.logic
 
-import prolog.Substituted
+import prolog.logic.Substituted
+import prolog.ast.terms.Body
+import prolog.ast.terms.Functor
+import prolog.ast.terms.Goal
+import prolog.ast.terms.Head
 import prolog.builtins.True
-import prolog.builtins.equivalent
-import prolog.components.Resolvent
-import prolog.components.terms.*
-import prolog.unifyLazy
+import prolog.logic.unifyLazy
 
 /**
  * ‘Sentence’ of a Prolog program.
  *
- * A clause consists of a [Head] and body separated by the [neck][prolog.terms.Neck] operator, or it is a [Fact].
+ * A clause consists of a [Head] and body separated by the neck operator, or it is a [Fact].
  *
- * @see [prolog.components.terms.Variable]
+ * @see [prolog.ast.terms.Variable]
  * @see [Predicate]
  */
 abstract class Clause(private val head: Head, private val body: Body) : Resolvent {
@@ -40,4 +41,4 @@ abstract class Clause(private val head: Head, private val body: Body) : Resolven
             else           -> "$head :- $body"
         }
     }
-}
+}

src/prolog/ast/logic/Fact.kt

@@ -0,0 +1,6 @@
+package prolog.ast.logic
+
+import prolog.ast.terms.Head
+import prolog.builtins.True
+
+class Fact(head: Head) : Clause(head, True())

src/prolog/ast/logic/Predicate.kt

@@ -1,9 +1,8 @@
-package prolog.components.expressions
+package prolog.ast.logic
 
-import prolog.Substituted
-import prolog.components.Resolvent
-import prolog.components.terms.Functor
-import prolog.components.terms.Goal
+import prolog.logic.Substituted
+import prolog.ast.terms.Functor
+import prolog.ast.terms.Goal
 
 /**
  * Collection of [Clause]s with the same [Functor].
@@ -37,7 +36,7 @@ class Predicate : Resolvent {
      * Adds a clause to the predicate.
      */
     fun add(clause: Clause) {
-        require (clause.functor == functor) { "Clause functor does not match predicate functor" }
+        require(clause.functor == functor) { "Clause functor does not match predicate functor" }
         clauses.add(clause)
     }
 

src/prolog/ast/logic/Provable.kt

@@ -1,6 +1,6 @@
-package prolog.components
+package prolog.ast.logic
 
-import prolog.Substituted
+import prolog.logic.Substituted
 
 interface Provable {
     /**

src/prolog/ast/logic/Resolvent.kt

@@ -1,7 +1,7 @@
-package prolog.components
+package prolog.ast.logic
 
-import prolog.Substituted
-import prolog.components.terms.Goal
+import prolog.logic.Substituted
+import prolog.ast.terms.Goal
 
 /**
  * Can be instructed to solve a goal.

src/prolog/ast/logic/Rule.kt

@@ -0,0 +1,6 @@
+package prolog.ast.logic
+
+import prolog.ast.terms.Body
+import prolog.ast.terms.Head
+
+class Rule(head: Head, body: Body) : Clause(head, body)

src/prolog/ast/terms/Atom.kt

@@ -1,8 +1,8 @@
-package prolog.components.terms
+package prolog.ast.terms
 
-import prolog.Substituted
-import prolog.components.Resolvent
-import prolog.unifyLazy
+import prolog.ast.logic.Resolvent
+import prolog.logic.Substituted
+import prolog.logic.unifyLazy
 
 open class Atom(val name: String) : Goal(), Head, Body, Resolvent {
     override val functor: Functor = "$name/_"
@@ -11,14 +11,14 @@ open class Atom(val name: String) : Goal(), Head, Body, Resolvent {
 
     override fun compareTo(other: Term): Int {
         return when (other) {
-            is Variable  -> 1
-            is Atom      -> name.compareTo(other.name)
+            is Variable -> 1
+            is Atom -> name.compareTo(other.name)
             is Structure -> -1
-            else         -> throw IllegalArgumentException("Cannot compare $this with $other")
+            else -> throw IllegalArgumentException("Cannot compare $this with $other")
         }
     }
 
     override fun toString(): String {
         return name
     }
-}
+}

src/prolog/ast/terms/Body.kt

@@ -0,0 +1,5 @@
+package prolog.ast.terms
+
+import prolog.ast.logic.Provable
+
+interface Body : Provable

src/prolog/ast/terms/Goal.kt

@@ -1,8 +1,8 @@
-package prolog.components.terms
+package prolog.ast.terms
 
-import prolog.Substituted
-import prolog.components.Program
-import prolog.components.Provable
+import prolog.Program
+import prolog.ast.logic.Provable
+import prolog.logic.Substituted
 
 /**
  * Ask the Prolog engine.
@@ -15,4 +15,4 @@ abstract class Goal : Term, Provable {
     abstract val functor: Functor
 
     override fun prove(subs: Substituted): Sequence<Substituted> = Program.solve(this, subs)
-}
+}

src/prolog/ast/terms/Head.kt

@@ -0,0 +1,10 @@
+package prolog.ast.terms
+
+/**
+ * Part of a [Clause][prolog.ast.logic.Clause] before the neck operator.
+ */
+interface Head : Term {
+    val functor: Functor
+}
+
+typealias Functor = String

src/prolog/ast/terms/Operator.kt

@@ -1,12 +1,7 @@
-package prolog.components.expressions
+package prolog.ast.terms
 
-import prolog.Substituted
-import prolog.components.Provable
-import prolog.components.terms.Atom
-import prolog.components.terms.CompoundTerm
-import prolog.components.terms.Goal
-
-typealias Operand = Goal
+import prolog.ast.logic.Provable
+import prolog.logic.Substituted
 
 abstract class Operator(
     private val symbol: Atom,
@@ -22,3 +17,5 @@ abstract class Operator(
         }
     }
 }
+
+typealias Operand = Goal

src/prolog/ast/terms/Structure.kt

@@ -1,13 +1,15 @@
-package prolog.components.terms
+package prolog.ast.terms
 
-import prolog.Substituted
+import prolog.ast.logic.Resolvent
 import prolog.builtins.equivalent
-import prolog.components.Resolvent
-import prolog.unifyLazy
+import prolog.logic.Substituted
+import prolog.logic.unifyLazy
 
 typealias Argument = Term
 
-open class Structure(val name: Atom, val arguments: List<Argument>): Goal(), Head, Body, Resolvent {
+typealias CompoundTerm = Structure
+
+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, subs: Substituted): Sequence<Substituted> {
@@ -38,6 +40,4 @@ open class Structure(val name: Atom, val arguments: List<Argument>): Goal(), Hea
             else -> "${name.name}(${arguments.joinToString(", ")})"
         }
     }
-}
-
-typealias CompoundTerm = Structure
+}

src/prolog/ast/terms/Term.kt

@@ -0,0 +1,9 @@
+package prolog.ast.terms
+
+/**
+ * Value in Prolog.
+ *
+ * A [Term] is either a [Variable], [Atom], integer, float or [CompoundTerm].
+ * In addition, SWI-Prolog also defines the type string.
+ */
+interface Term : Comparable<Term>

src/prolog/ast/terms/Variable.kt

@@ -1,6 +1,6 @@
-package prolog.components.terms
+package prolog.ast.terms
 
-import java.util.Optional
+import java.util.*
 
 data class Variable(val name: String) : Term {
     private var alias: Optional<Term> = Optional.empty()
@@ -23,9 +23,9 @@ data class Variable(val name: String) : Term {
 
     override fun compareTo(other: Term): Int {
         return when (other) {
-            is Variable  -> name.compareTo(other.name)
+            is Variable -> name.compareTo(other.name)
             // Variables are always less than atoms
-            else         -> -1
+            else -> -1
         }
     }
 
@@ -35,4 +35,4 @@ data class Variable(val name: String) : Term {
             else -> name
         }
     }
-}
+}

src/prolog/builtins/arithmetic.kt

@@ -0,0 +1 @@
+package prolog.builtins

src/prolog/builtins/control.kt

@@ -1,15 +1,12 @@
 package prolog.builtins
 
-import prolog.Substituted
-import prolog.components.expressions.Operand
-import prolog.components.expressions.Operator
-import prolog.components.terms.Atom
-import prolog.components.terms.Body
+import prolog.ast.terms.*
+import prolog.logic.Substituted
 
 /**
  * Always fail.
  */
-class Fail: Atom("fail"), Body {
+class Fail : Atom("fail"), Body {
     override fun prove(subs: Substituted): Sequence<Substituted> = emptySequence()
 }
 
@@ -21,7 +18,7 @@ typealias False = Fail
 /**
  * Always succeed.
  */
-class True: Atom("true"), Body {
+class True : Atom("true"), Body {
     override fun prove(subs: Substituted): Sequence<Substituted> = sequenceOf(emptyMap())
 }
 
@@ -49,7 +46,7 @@ class Conjunction(leftOperand: Operand, rightOperand: Operand) : Operator(Atom("
 /**
  * Disjunction (or). True if either Goal1 or Goal2 succeeds.
  */
-class Disjunction(leftOperand: Operand, rightOperand: Operand) : Operator(Atom(";"), leftOperand, rightOperand) {
+open class Disjunction(leftOperand: Operand, rightOperand: Operand) : Operator(Atom(";"), leftOperand, rightOperand) {
     override fun prove(subs: Substituted): Sequence<Substituted> = sequence {
         if (leftOperand != null) {
             yieldAll(leftOperand.prove(subs))
@@ -57,3 +54,24 @@ class Disjunction(leftOperand: Operand, rightOperand: Operand) : Operator(Atom("
         yieldAll(rightOperand.prove(subs))
     }
 }
+
+@Deprecated("Use Disjunction instead")
+class Bar(leftOperand: Operand, rightOperand: Operand) : Disjunction(leftOperand, rightOperand)
+
+// TODO ->
+
+// TODO *->
+
+/**
+ * True if 'Goal' cannot be proven.
+ */
+class Not(goal: Goal) : Operator(Atom("\\+"), rightOperand = goal) {
+    override fun prove(subs: Substituted): Sequence<Substituted> {
+        // If the goal can be proven, return an empty sequence
+        if (rightOperand.prove(subs).toList().isNotEmpty()) {
+            return emptySequence()
+        }
+        // If the goal cannot be proven, return a sequence with an empty map
+        return sequenceOf(emptyMap())
+    }
+}

src/prolog/builtins/meta.kt

@@ -0,0 +1 @@
+package prolog.builtins

src/prolog/builtins/other.kt

@@ -1,9 +1,9 @@
 package prolog.builtins
 
-import prolog.Substituted
-import prolog.components.expressions.Operand
-import prolog.components.expressions.Operator
-import prolog.components.terms.Atom
+import prolog.ast.terms.Atom
+import prolog.ast.terms.Operand
+import prolog.ast.terms.Operator
+import prolog.logic.Substituted
 
 class Query(rightOperand: Operand) : Operator(Atom("?-"), null, rightOperand) {
     override fun prove(subs: Substituted): Sequence<Substituted> = rightOperand.prove(subs)

src/prolog/builtins/terms.kt

@@ -1,7 +1,7 @@
 package prolog.builtins
 
-import prolog.components.terms.Atom
-import prolog.components.terms.Term
+import prolog.ast.terms.Atom
+import prolog.ast.terms.Term
 
 /**
  * True when Term is a term with functor Name/Arity. If Term is a variable it is unified with a new term whose

src/prolog/builtins/unification.kt

@@ -1,9 +1,9 @@
 package prolog.builtins
 
-import prolog.components.terms.Atom
-import prolog.components.terms.Structure
-import prolog.components.terms.Term
-import prolog.components.terms.Variable
+import prolog.ast.terms.Atom
+import prolog.ast.terms.Structure
+import prolog.ast.terms.Term
+import prolog.ast.terms.Variable
 
 /**
  * True if Term1 is equivalent to Term2. A variable is only identical to a sharing variable.
@@ -18,3 +18,7 @@ fun equivalent(term1: Term, term2: Term): Boolean {
         else -> false
     }
 }
+
+/**
+ *
+ */

src/prolog/builtins/verification.kt

@@ -1,8 +1,8 @@
 package prolog.builtins
 
-import prolog.components.terms.CompoundTerm
-import prolog.components.terms.Term
-import prolog.components.terms.Variable
+import prolog.ast.terms.CompoundTerm
+import prolog.ast.terms.Term
+import prolog.ast.terms.Variable
 
 /**
  * True if [Term] is bound (i.e., not a variable) and is not compound.

src/prolog/components/expressions/Fact.kt

@@ -1,6 +0,0 @@
-package prolog.components.expressions
-
-import prolog.builtins.True
-import prolog.components.terms.Head
-
-class Fact(head: Head) : Clause(head, True())

src/prolog/components/expressions/Rule.kt

@@ -1,6 +0,0 @@
-package prolog.components.expressions
-
-import prolog.components.terms.Body
-import prolog.components.terms.Head
-
-class Rule(head: Head, body: Body): Clause(head, body)

src/prolog/components/terms/Body.kt

@@ -1,5 +0,0 @@
-package prolog.components.terms
-
-import prolog.components.Provable
-
-interface Body : Provable

src/prolog/components/terms/Head.kt

@@ -1,10 +0,0 @@
-package prolog.components.terms
-
-/**
- * Part of a [Clause][prolog.components.expressions.Clause] before the [neck][prolog.terms.Neck] operator.
- */
-interface Head : Term {
-    val functor: Functor
-}
-
-typealias Functor = String

src/prolog/components/terms/Term.kt

@@ -1,23 +0,0 @@
-package prolog.components.terms
-
-/**
- * Value in Prolog.
- *
- * A [Term] is either a [Variable], [Atom], integer, float or [CompoundTerm].
- * In addition, SWI-Prolog also defines the type string.
- */
-interface Term : Comparable<Term>
-
-/*
-<program> ::= <clause list> <query> | <query>
-<clause list> ::= <clause> | <clause list> <clause>
-<clause> ::= <predicate> . | <predicate> :- <predicate list>.
-<predicate list> ::= <predicate> | <predicate list> , <predicate>
-<predicate> ::= <atom> | <atom> ( <term list> )
-<term list> ::= <term> | <term list> , <term>
-<term> ::= <numeral> | <atom> | <variable> | <structure>
-<structure> ::= <atom> ( <term list> )
-<query> ::= ?- <predicate list>.
-<small atom> ::= <lowercase letter> | <small atom> <character>
-<variable> ::= <uppercase letter> | <variable> <character>
-*/

src/prolog/logic/unify.kt

@@ -1,12 +1,12 @@
-package prolog
+package prolog.logic
 
+import prolog.ast.terms.Structure
+import prolog.ast.terms.Term
+import prolog.ast.terms.Variable
 import prolog.builtins.atomic
 import prolog.builtins.compound
 import prolog.builtins.equivalent
 import prolog.builtins.variable
-import prolog.components.terms.Term
-import prolog.components.terms.Variable
-import prolog.components.terms.Structure
 import java.util.*
 
 typealias Substituted = Map<Variable, Term>