commonMain.it.unibo.tuprolog.solve.concurrent.fsm.Utils.kt Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of solve-concurrent-jvm Show documentation

Experimental, state-machine-based implementation of an OR-Concurrent, Prolog-like logic solver, based on Kotlin coroutines

There is a newer version: 1.0.4

Show newest version

@file:JvmName("Utils")

package it.unibo.tuprolog.solve.concurrent.fsm

import it.unibo.tuprolog.core.Clause
import it.unibo.tuprolog.core.Rule
import it.unibo.tuprolog.core.Struct
import it.unibo.tuprolog.core.Term
import it.unibo.tuprolog.solve.Signature
import it.unibo.tuprolog.solve.concurrent.ConcurrentExecutionContext
import it.unibo.tuprolog.solve.primitive.Solve
import it.unibo.tuprolog.utils.Cursor
import it.unibo.tuprolog.utils.cursor
import kotlin.jvm.JvmName

fun Sequence.ensureRules(): Sequence =
    @Suppress("USELESS_CAST")
    map { require(it.isRule); it.castToRule() }

fun Term.unfoldGoals(): Sequence =
    when {
        this.isTuple -> castToTuple().toSequence().flatMap { it.unfoldGoals() }
        else -> sequenceOf(this)
    }

fun Term.toGoals(): Cursor =
    unfoldGoals().map {
        when {
            it.isVar -> Struct.of("call", it)
            else -> it
        }
    }.cursor()

fun ConcurrentExecutionContext.createChild(inferProcedureFromGoals: Boolean = true): ConcurrentExecutionContext {
    val currentGoal = this.currentGoal!!.castToStruct()

    return copy(
        goals = currentGoal.toGoals(),
        procedure = if (inferProcedureFromGoals) currentGoal else procedure,
        parent = this,
        depth = depth + 1,
        step = step + 1
    )
}

fun ConcurrentExecutionContext.replaceWithChild(inferProcedureFromGoals: Boolean = true): ConcurrentExecutionContext {
    val currentGoal = this.currentGoal!!.castToStruct()

    return copy(
        goals = currentGoal.toGoals(),
        procedure = if (inferProcedureFromGoals) currentGoal else procedure,
        depth = depth + 1,
        step = step + 1
    )
}

fun ConcurrentExecutionContext.createChildAppendingRules(
    rule: Rule,
    inferProcedureFromGoals: Boolean = true
): ConcurrentExecutionContext {
    val tempExecutionContext = createChild(inferProcedureFromGoals)
    return tempExecutionContext.copy(rule = rule)
}

fun ConcurrentExecutionContext.replaceWithChildAppendingRules(
    rule: Rule,
    inferProcedureFromGoals: Boolean = true
): ConcurrentExecutionContext {
    val tempExecutionContext = replaceWithChild(inferProcedureFromGoals)
    return tempExecutionContext.copy(rule = rule)
}

fun ConcurrentExecutionContext.toRequest(
    goal: Struct,
    signature: Signature
) = Solve.Request(signature, goal.args, this, executionMaxDuration = maxDuration)