core/it.unibo.tuprolog.core/Substitution/Fail

Fail

sealed interface Fail : Substitution

A type for failed Substitutions, assigning no Var

Properties

abstract val entries: Set<Map.Entry<Var, Term>>

abstract val isFailed: Boolean

Whether this Substitution is a failed one

abstract val isSuccess: Boolean

Whether this Substitution is a successful one (i.e., a Unifier)

abstract val keys: Set<Var>

expect abstract val size: Int

abstract val tags: Map<String, Any>

abstract val values: Collection<Term>

Functions

abstract override fun applyTo(term: Term): Nothing?

Applies this Substitution to the given Term, returning null if it is Substitution.Fail

open fun <U : Substitution> as(): U?

open override fun asFail(): Substitution.Fail

Casts the current Substitution to Fail, if possible, or returns null otherwise

open fun asUnifier(): Substitution.Unifier?

Casts the current Substitution to Unifier, if possible, or returns null otherwise

fun Map<Var, Term>.asUnifier(): Substitution.Unifier

Conversion from a raw Map<Var, Term> to the Substitution.Unifier type

open fun <U : Substitution> castTo(): U

open fun castToFail(): Substitution.Fail

Casts the current Substitution to Fail, if possible

open fun castToUnifier(): Substitution.Unifier

Casts the current Substitution to Unifier, if possible

abstract fun containsKey(key: Var): Boolean

open fun containsTag(name: String): Boolean

abstract fun containsValue(value: Term): Boolean

abstract override fun filter(predicate: (Map.Entry<Var, Term>) -> Boolean): Substitution.Fail

abstract override fun filter(predicate: (key: Var, value: Term) -> Boolean): Substitution.Fail

Returns a new substitution containing all key-value pairs matching the given predicate.

abstract override fun filter(variables: Collection<Var>): Substitution.Fail

Returns a new substitution containing all key-value pairs whose key is in variables.

abstract operator fun get(key: Var): Term?

open fun getByName(name: String): Term?

Retrieves the Term bound to the (first) Var whose Var.name equals name, or null if none is found.

open override fun getOriginal(variable: Var): Nothing?

Retrieves the original variable name of the provided variable, if any, or null otherwise

open fun <T : Any> getTag(name: String): T?

expect abstract fun isEmpty(): Boolean

abstract operator override fun minus(other: Substitution): Substitution.Fail

Returns a new substitution containing all entries of the original substitution except those entries which variable keys are contained in the given other substitution.

abstract operator override fun minus(variable: Var): Substitution.Fail

Returns a new substitution without the entry (if any) for variable.

abstract operator override fun minus(keys: Iterable<Var>): Substitution.Fail

Returns a new substitution containing all entries of the original substitution except those entries which variable keys are contained in the given keys iterable.

abstract override fun minus(variable: Var, vararg otherVariables: Var): Substitution.Fail

Returns a new substitution without the entries (if any) for variable and otherVariables.

abstract operator fun plus(other: Substitution): Substitution

abstract fun plus(other: Substitution, tagsMerger: TagsOperator): Substitution

Creates a new Substitution that is the composition (a.k.a. union) of this and other. The composition is not guaranteed to be a Substitution.Unifier, even if both arguments are. In fact, the composition algorithm performs the following checks:

abstract override fun replaceTags(tags: Map<String, Any>): Substitution.Fail

open fun <T> whenIs(unifier: (Substitution.Unifier) -> T? = null, fail: (Substitution.Fail) -> T? = null, otherwise: (Substitution) -> T = { throw IllegalStateException("Cannot handle solution $it") }): T

Dispatches on the concrete type of this Substitution, invoking unifier if it is a Unifier, fail if it is a Fail, or otherwise if the relevant callback was not provided (null).