dsl-unify/it.unibo.tuprolog.dsl.unify/LogicProgrammingScopeWithUnificator

LogicProgrammingScopeWithUnificator

interface LogicProgrammingScopeWithUnificator<S : LogicProgrammingScopeWithUnificator<S>> : BaseLogicProgrammingScope<S> , UnificationAware, Unificator

Bare mixin wiring a Unificator into a :dsl-core scope: extends BaseLogicProgrammingScope with UnificationAware (exposing the unificator backing this scope) and Unificator itself, so Unificator.mgu, Unificator.match, Unificator.unify, Unificator.merge and Unificator.context are callable directly on the scope, without going through unificator explicitly. Implementations are expected to forward these to unificator (e.g. via Unificator by unificator, as LogicProgrammingScopeImpl does) rather than implement unification logic of their own.

This interface only makes the plain, it.unibo.tuprolog.core.Term-based Unificator operations available; LogicProgrammingScopeWithUnification builds the DSL's Any-accepting/infix sugar (mguWith, matches, unifyWith, ...) on top of it.

Type Parameters

S

the concrete, self-referential scope type (see BaseLogicProgrammingScope) that copy returns.

Inheritors

LogicProgrammingScopeWithUnification

Properties

open val _: Var

abstract val context: Substitution

abstract val emptyBlock: EmptyBlock

abstract val emptyLogicList: EmptyList

abstract val fail: Truth

abstract val termificator: Termificator

abstract val unificator: Unificator

abstract val variables: Map<String, Var>

Functions

abstract fun anonymous(): Var

abstract fun atomOf(value: Char): Atom

abstract fun atomOf(value: String): Atom

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

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

abstract fun blockOf(vararg terms: Term): Block

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

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

abstract operator fun contains(variable: Var): Boolean

abstract operator fun contains(variable: String): Boolean

abstract fun copy(unificator: Unificator): S

Creates a copy of this scope, backed by the same it.unibo.tuprolog.core.Scope, using unificator instead of the current one.

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

abstract fun factOf(head: Struct): Fact

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

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

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

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

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

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

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

abstract fun logicListOf(vararg terms: Term): List

open fun match(term1: Term, term2: Term): Boolean

open fun match(term1: Term, term2: Term, occurCheckEnabled: Boolean): Boolean

open fun merge(substitution1: Substitution, substitution2: Substitution): Substitution

abstract fun merge(substitution1: Substitution, substitution2: Substitution, occurCheckEnabled: Boolean): Substitution

open fun mgu(term1: Term, term2: Term): Substitution

abstract fun mgu(term1: Term, term2: Term, occurCheckEnabled: Boolean): Substitution

abstract fun newScope(): S

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

abstract fun realOf(value: Double): Real

abstract fun realOf(value: Float): Real

abstract fun realOf(value: String): Real

abstract fun realOf(value: BigDecimal): Real

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

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

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

toSpecificSubTypeOfTerm

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

open fun Any.toTerm(): Term

abstract fun truthOf(value: Boolean): Truth

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

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

abstract fun tupleOf(vararg terms: Term): Tuple

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

open fun unify(term1: Term, term2: Term): Term?

open fun unify(term1: Term, term2: Term, occurCheckEnabled: Boolean): Term?

abstract fun varOf(name: Char): Var

abstract fun varOf(name: String): Var

abstract fun whatever(): Var

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

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