Clause

src/prolog/builtins/analysingAndConstructionOperators.kt

@@ -1,97 +0,0 @@
-package prolog.builtins
-
-import prolog.Answers
-import prolog.Substitutions
-import prolog.ast.arithmetic.Integer
-import prolog.ast.terms.*
-import prolog.logic.*
-import java.util.Locale
-import java.util.Locale.getDefault
-
-/**
- * [True] when [Term] is a term with [FunctorInfo] Name/Arity.
- *
- * If Term is a [Variable] it is unified with a new term whose arguments are all different variables.
- * If Term is [atomic], Arity will be unified with the integer 0, and Name will be unified with Term.
- */
-class Functor(private val term: Term, private val functorName: Term, private val functorArity: Term) :
-    Structure(Atom("functor"), listOf(term, functorName, functorArity)) {
-    override fun satisfy(subs: Substitutions): Answers {
-        return when {
-            nonvariable(term, subs) -> {
-                val t = applySubstitution(term, subs) as Head
-
-                Conjunction(
-                    Unify(t.functor.arity, functorArity),
-                    Unify(t.functor.name, functorName)
-                ).satisfy(subs)
-            }
-
-            variable(term, subs) -> {
-                require(atomic(functorName, subs) && atomic(functorArity, subs)) {
-                    "Arguments are not sufficiently instantiated"
-                }
-
-                val name = applySubstitution(functorName, subs) as Atom
-                val arity = applySubstitution(functorArity, subs) as Integer
-                val result = Structure(name, List(arity.value) { AnonymousVariable.create() })
-                sequenceOf(Result.success(mapOf(term to result)))
-            }
-
-            else -> throw IllegalStateException()
-        }
-    }
-
-    override fun applySubstitution(subs: Substitutions): Functor = Functor(
-        term.applySubstitution(subs),
-        functorName.applySubstitution(subs),
-        functorArity.applySubstitution(subs)
-    )
-}
-
-class Arg(private val arg: Term, private val term: Term, private val value: Term) :
-    Structure(Atom("arg"), listOf(arg, term, value)) {
-    override fun satisfy(subs: Substitutions): Answers = sequence {
-        require(nonvariable(term, subs)) { "Arguments are not sufficiently instantiated" }
-        require(compound(term, subs)) {
-            val expected = CompoundTerm::class.simpleName?.lowercase()
-            val actual = term::class.simpleName?.lowercase()
-            "Type error: `$expected' expected, found `$term' ($actual)"
-        }
-
-        val t = applySubstitution(term, subs) as Structure
-
-        when {
-            variable(arg, subs) -> {
-                // Value will be unified with the successive arguments of term.
-                // On successful unification, arg is unified with the argument number.
-                // Backtracking yields alternative solutions.
-                var count = 0
-                for (argument in t.arguments) {
-                    unifyLazy(value, argument, subs).forEach { result ->
-                        result.map {
-                            val sub = arg to Integer(count + 1)
-                            yield(Result.success(it + sub))
-                        }
-                    }
-                    count++
-                }
-
-            }
-
-            else -> {
-                val a = applySubstitution(arg, subs) as Integer
-
-                require(0 <= a.value) { "Domain error: not_less_than_zero" }
-
-                // Fail silently if the argument is out of bounds
-                if (0 == a.value || t.arguments.size < a.value) {
-                    return@sequence
-                }
-
-                val argument = t.arguments[a.value - 1]
-                yieldAll(unifyLazy(argument, value, subs))
-            }
-        }
-    }
-}