commonMain.it.unibo.tuprolog.solve.primitive.QuaternaryRelation.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of solve-jvm Show documentation
Resolution-agnostic API for logic solvers
There is a newer version: 1.0.4
package it.unibo.tuprolog.solve.primitive

import it.unibo.tuprolog.core.Substitution
import it.unibo.tuprolog.core.Term
import it.unibo.tuprolog.solve.ExecutionContext

abstract class QuaternaryRelation(operator: String) : PrimitiveWrapper(operator, 4) {
    /** Template method aimed at computing the application of this relation to three [Term]s */
    protected abstract fun Solve.Request.computeAll(
        first: Term,
        second: Term,
        third: Term,
        fourth: Term,
    ): Sequence

    override fun uncheckedImplementation(request: Solve.Request): Sequence {
        return request.computeAll(
            request.arguments[0],
            request.arguments[1],
            request.arguments[2],
            request.arguments[3],
        )
    }

    abstract class WithoutSideEffects(operator: String) : QuaternaryRelation(operator) {
        protected abstract fun Solve.Request.computeAllSubstitutions(
            first: Term,
            second: Term,
            third: Term,
            fourth: Term,
        ): Sequence

        final override fun Solve.Request.computeAll(
            first: Term,
            second: Term,
            third: Term,
            fourth: Term,
        ): Sequence {
            return computeAllSubstitutions(first, second, third, fourth).map { replyWith(it) }
        }
    }

    abstract class NonBacktrackable(operator: String) : QuaternaryRelation(operator) {
        protected abstract fun Solve.Request.computeOne(
            first: Term,
            second: Term,
            third: Term,
            fourth: Term,
        ): Solve.Response

        final override fun Solve.Request.computeAll(
            first: Term,
            second: Term,
            third: Term,
            fourth: Term,
        ): Sequence {
            return sequenceOf(computeOne(first, second, third, fourth))
        }
    }

    abstract class Functional(operator: String) : NonBacktrackable(operator) {
        protected abstract fun Solve.Request.computeOneSubstitution(
            first: Term,
            second: Term,
            third: Term,
            fourth: Term,
        ): Substitution

        final override fun Solve.Request.computeOne(
            first: Term,
            second: Term,
            third: Term,
            fourth: Term,
        ): Solve.Response {
            return replyWith(computeOneSubstitution(first, second, third, fourth))
        }
    }

    abstract class Predicative(operator: String) : NonBacktrackable(operator) {
        protected abstract fun Solve.Request.compute(
            first: Term,
            second: Term,
            third: Term,
            fourth: Term,
        ): Boolean

        final override fun Solve.Request.computeOne(
            first: Term,
            second: Term,
            third: Term,
            fourth: Term,
        ): Solve.Response {
            return if (compute(first, second, third, fourth)) replySuccess() else replyFail()
        }
    }
}