dsl-core/it.unibo.tuprolog.dsl/LogicProgrammingScopeWithSubstitutions

LogicProgrammingScopeWithSubstitutions

interface LogicProgrammingScopeWithSubstitutions<S : LogicProgrammingScopeWithSubstitutions<S>> : BaseLogicProgrammingScope<S>

Adds builders and accessors for Substitutions, so a Var to value pair can be written directly ("X" to 1, mirroring Kotlin's own kotlin.to for Pairs) and a built Substitution can be queried by a plain Var-like value instead of a variable name/Var pair:

logicProgramming {
    val subst = "X" to 1        // Substitution.Unifier {X = 1}
    subst["X"]                  // 1, looked up by variable name instead of by Var instance
    "X" in subst                // true
}

Inheritors

LogicProgrammingScope

Properties

open val _: Var

emptyBlock

abstract val emptyBlock: EmptyBlock

emptyLogicList

abstract val emptyLogicList: EmptyList

fail

abstract val fail: Truth

termificator

abstract val termificator: Termificator

The Termificator used by toTerm to convert arbitrary values into Terms within this scope.

variables

abstract val variables: Map<String, Var>

Functions

anonymous

abstract fun anonymous(): Var

atomOf

abstract fun atomOf(value: Char): Atom

abstract fun atomOf(value: String): Atom

blockOf

abstract fun blockOf(terms: Iterable<Term>): Block

abstract fun blockOf(terms: Sequence<Term>): Block

abstract fun blockOf(vararg terms: Term): Block

clauseOf

abstract fun clauseOf(head: Struct?, vararg body: Term): Clause

consOf

abstract fun consOf(head: Term, tail: Term): Cons

contains

abstract operator fun contains(variable: Var): Boolean

abstract operator fun contains(variable: String): Boolean

open operator fun Substitution.contains(term: Any): Boolean

Alias of containsKey.

containsKey

open fun Substitution.containsKey(term: Any): Boolean

Checks whether this Substitution binds term.

containsValue

open fun Substitution.containsValue(term: Any): Boolean

Checks whether term (auto-toTerm-ed) occurs as a bound value in this Substitution.

directiveOf

abstract fun directiveOf(body1: Term, vararg body: Term): Directive

factOf

abstract fun factOf(head: Struct): Fact

get

abstract operator fun get(variable: String): Var?

open operator fun Substitution.get(term: Any): Term?

Looks up the Term this Substitution binds term to, null if unbound.

indicatorOf

abstract fun indicatorOf(name: Term, arity: Term): Indicator

abstract fun indicatorOf(name: String, arity: Int): Indicator

intOf

abstract fun intOf(value: Byte): Integer

abstract fun intOf(value: Int): Integer

abstract fun intOf(value: Long): Integer

abstract fun intOf(value: Short): Integer

abstract fun intOf(value: String): Integer

abstract fun intOf(value: BigInteger): Integer

abstract fun intOf(value: String, radix: Int): Integer

logicListFrom

abstract fun logicListFrom(terms: Iterable<Term>, last: Term?): List

abstract fun logicListFrom(terms: Sequence<Term>, last: Term?): List

abstract fun logicListFrom(vararg terms: Term, last: Term?): List

logicListOf

abstract fun logicListOf(terms: Iterable<Term>): List

abstract fun logicListOf(terms: Sequence<Term>): List

abstract fun logicListOf(vararg terms: Term): List

newScope

abstract fun newScope(): S

Creates a fresh scope of type S, backed by a brand-new, empty Scope — so that it.unibo.tuprolog.core.Vars created within it are unrelated to the ones created through this scope. Used by builders such as MinimalLogicProgrammingScope.rule/MinimalLogicProgrammingScope.fact to isolate each clause's variables.

numOf

abstract fun numOf(value: Byte): Integer

abstract fun numOf(value: Double): Real

abstract fun numOf(value: Float): Real

abstract fun numOf(value: Int): Integer

abstract fun numOf(value: Long): Integer

abstract fun numOf(value: Number): Numeric

abstract fun numOf(value: Short): Integer

abstract fun numOf(value: String): Numeric

abstract fun numOf(value: BigDecimal): Real

abstract fun numOf(value: BigInteger): Integer

realOf

abstract fun realOf(value: Double): Real

abstract fun realOf(value: Float): Real

abstract fun realOf(value: String): Real

abstract fun realOf(value: BigDecimal): Real

ruleOf

abstract fun ruleOf(head: Struct, body1: Term, vararg body: Term): Rule

structOf

abstract fun structOf(functor: String, args: Iterable<Term>): Struct

abstract fun structOf(functor: String, args: List<Term>): Struct

abstract fun structOf(functor: String, args: Sequence<Term>): Struct

abstract fun structOf(functor: String, vararg args: Term): Struct

substitutionOf

abstract fun substitutionOf(assignments: Iterable<Pair<Var, Term>>): Substitution

abstract fun substitutionOf(assignments: Sequence<Pair<Var, Term>>): Substitution

abstract fun substitutionOf(vararg assignments: Pair<String, Term>): Substitution

open infix fun Var.to(termObject: Any): Substitution.Unifier

Builds the Substitution.Unifier binding this Var to termObject (auto-toTerm-ed).

open infix fun String.to(termObject: Any): Substitution.Unifier

Builds the Substitution.Unifier binding the Var named by this String (via varOf) to termObject.

toSpecificSubTypeOfTerm

open fun <T : Term> Any.toSpecificSubTypeOfTerm(type: KClass<T>, converter: (Struct) -> T): T

Converts this value into a Term (via toTerm) and coerces it to type: returned as-is if it already is a type, passed through converter if it is a Struct (e.g. to turn a plain Struct into a Fact), or rejected otherwise.

toTerm

open fun Any.toTerm(): Term

Converts this value into a Term, via termificator. See Termificator.termify for the conversion rules.

truthOf

abstract fun truthOf(value: Boolean): Truth

tupleOf

abstract fun tupleOf(terms: Iterable<Term>): Tuple

abstract fun tupleOf(terms: Sequence<Term>): Tuple

abstract fun tupleOf(vararg terms: Term): Tuple

unifierOf

abstract fun unifierOf(assignments: Iterable<Pair<Var, Term>>): Substitution.Unifier

abstract fun unifierOf(assignments: Sequence<Pair<Var, Term>>): Substitution.Unifier

abstract fun unifierOf(vararg assignments: Pair<String, Term>): Substitution.Unifier

varOf

abstract fun varOf(name: Char): Var

abstract fun varOf(name: String): Var

whatever

abstract fun whatever(): Var

where

abstract fun where(lambda: Scope.() -> Unit): Scope

with

abstract fun <R> with(lambda: Scope.() -> R): R