dsl-theory/it.unibo.tuprolog.dsl.theory/LogicProgrammingScopeImpl

LogicProgrammingScopeImpl

class LogicProgrammingScopeImpl(val scope: Scope, val termificator: Termificator, val variablesProvider: VariablesProvider, val unificator: Unificator, val theoryFactory: TheoryFactory) : LogicProgrammingScope, VariablesProvider, Unificator, TheoryFactory

Default, stateless implementation of LogicProgrammingScope: forwards VariablesProvider, Unificator and TheoryFactory operations to variablesProvider, unificator and theoryFactory respectively (via Kotlin delegation), and every other scope operation up its supertypes' default implementations. Obtained through LogicProgrammingScope.of/LogicProgrammingScope.empty rather than constructed directly in typical usage.

Throws

IllegalArgumentException

if scope is not the same object as both termificator's and variablesProvider's scope, or if unificator is not equal to theoryFactory's.

Constructors

LogicProgrammingScopeImpl

constructor(scope: Scope, termificator: Termificator, variablesProvider: VariablesProvider, unificator: Unificator, theoryFactory: TheoryFactory)

Properties

open override val _: Var

open override val A: Var

at_end_of_stream

open val at_end_of_stream: Atom

open override val B: Var

open override val C: Var

context

open override val context: Substitution

cut

open val cut: Atom

open override val D: Var

open override val E: Var

emptyBlock

open override val emptyBlock: EmptyBlock

emptyLogicList

open override val emptyLogicList: EmptyList

open override val F: Var

fail

open override val fail: Truth

open override val G: Var

open override val H: Var

halt

open val halt: Atom

open override val I: Var

open override val J: Var

open override val K: Var

open override val L: Var

open override val M: Var

open override val N: Var

open val nl: Atom

open override val O: Var

open override val P: Var

open override val Q: Var

open override val R: Var

repeat

open val repeat: Atom

open override val S: Var

scope

open override val scope: Scope

open override val T: Var

termificator

open override val termificator: Termificator

theoryFactory

open override val theoryFactory: TheoryFactory

The TheoryFactory this scope's TheoryFactory implementation (and theory/mutableTheory) forward to.

open override val U: Var

unificator

open override val unificator: Unificator

open override val V: Var

variables

open override val variables: Map<String, Var>

variablesProvider

open override val variablesProvider: VariablesProvider

open override val W: Var

open override val X: Var

open override val Y: Var

open override val Z: Var

Functions

abolish

open fun abolish(indicator: Any): Struct

and

open infix fun Any.and(other: Any): Struct

anonymous

open override fun anonymous(): Var

append

open fun append(left: Any, right: Any, result: Any): Struct

arg

open fun arg(index: Any, compound: Any, argument: Any): Struct

arithEq

open infix fun Any.arithEq(right: Any): Struct

arithNeq

open infix fun Any.arithNeq(right: Any): Struct

assert

open fun assert(clause: Any): Struct

asserta

open fun asserta(clause: Any): Struct

assertz

open fun assertz(clause: Any): Struct

at_end_of_stream

open fun at_end_of_stream(alias: Any): Struct

atom

open fun atom(atom: Any): Struct

atom_chars

open fun atom_chars(atom: Any, chars: Any): Struct

atom_codes

open fun atom_codes(atom: Any, codes: Any): Struct

atom_concat

open fun atom_concat(first: Any, second: Any, result: Any): Struct

atom_length

open fun atom_length(atom: Any, length: Any): Struct

atomic

open fun atomic(atomic: Any): Struct

atomOf

open override fun atomOf(value: Char): Atom

open override fun atomOf(value: String): Atom

bagof

open fun bagof(template: Any, goal: Any, bag: Any): Struct

between

open fun between(min: Any, max: Any, number: Any): Struct

blockOf

open override fun blockOf(terms: Iterable<Term>): Block

open override fun blockOf(terms: Sequence<Term>): Block

open override fun blockOf(vararg terms: Term): Block

open fun blockOf(vararg terms: Any): Block

call

open fun call(goal: Any): Struct

callable

open fun callable(goal: Any): Struct

catch

open fun catch(goal: Any, error: Any, continuation: Any): Struct

char_code

open fun char_code(char: Any, code: Any): Struct

clause

open fun clause(head: Any, body: Any): Struct

open fun clause(function: LogicProgrammingScope.() -> Any): Clause

clauseOf

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

compound

open fun compound(struct: Any): Struct

consOf

open override fun consOf(head: Term, tail: Term): Cons

open fun consOf(head: Any, tail: Any): Cons

consult

open fun consult(url: Any): Struct

contains

open operator override fun contains(variable: Var): Boolean

open operator override fun contains(variable: String): Boolean

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

containsKey

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

containsValue

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

copy

open override fun copy(scope: Scope): LogicProgrammingScope

Copies this scope onto scope, propagating it to termificator and variablesProvider as well.

open override fun copy(unificator: Unificator): LogicProgrammingScope

Copies this scope onto unificator, propagating it to theoryFactory as well.

copy_term

open fun copy_term(term: Any, copy: Any): Struct

current_flag

open fun current_flag(name: Any, value: Any): Struct

current_op

open fun current_op(precedence: Any, specifier: Any, functor: Any): Struct

current_prolog_flag

open fun ~~current_prolog_flag~~(name: Any, value: Any): Struct

directive

open fun directive(function: LogicProgrammingScope.() -> Any): Directive

directiveOf

open override fun directiveOf(body1: Term, vararg body: Term): Directive

open fun directiveOf(term: Any, vararg terms: Any): Directive

div

open operator fun Term.div(other: Any): Indicator

open operator fun Boolean.div(other: Any): Struct

open operator fun Char.div(other: Any): Struct

open operator fun Number.div(other: Any): Struct

open operator fun String.div(other: Any): Struct

dynamic

open fun dynamic(indicator: Any): Struct

emptyMutableTheory

open override fun emptyMutableTheory(): MutableTheory

open override fun emptyMutableTheory(unificator: Unificator): MutableTheory

emptyTheory

open override fun emptyTheory(): Theory

open override fun emptyTheory(unificator: Unificator): Theory

open infix fun Any.eq(right: Any): Struct

equalsTo

open infix fun Any.equalsTo(other: Any): Struct

fact

open fun fact(function: LogicProgrammingScope.() -> Any): Fact

factOf

open override fun factOf(head: Struct): Fact

open fun factOf(term: Any): Fact

findall

open fun findall(template: Any, goal: Any, bag: Any): Struct

float

open fun float(number: Any): Struct

functor

open fun functor(struct: Any, functor: Any, arity: Any): Struct

get

open operator override fun get(variable: String): Var?

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

getValue

open operator override fun getValue(thisRef: Any?, property: KProperty<*>): Var

greaterThan

open infix fun Any.greaterThan(other: Any): Struct

greaterThanOrEqualsTo

open infix fun Any.greaterThanOrEqualsTo(other: Any): Struct

ground

open fun ground(term: Any): Struct

open infix fun Any.id(right: Any): Struct

open infix fun Any.if(other: Any): Rule

open fun Any.if(vararg other: Any): Rule

impliedBy

open infix fun Any.impliedBy(other: Any): Rule

open fun Any.impliedBy(vararg other: Any): Rule

include

open fun include(url: Any): Struct

indicatorOf

open override fun indicatorOf(name: Term, arity: Term): Indicator

open override fun indicatorOf(name: String, arity: Int): Indicator

initialization

open fun initialization(goal: Any): Struct

intDiv

open infix fun Any.intDiv(other: Any): Struct

integer

open fun integer(number: Any): Struct

intOf

open override fun intOf(value: Byte): Integer

open override fun intOf(value: Int): Integer

open override fun intOf(value: Long): Integer

open override fun intOf(value: Short): Integer

open override fun intOf(value: String): Integer

open override fun intOf(value: BigInteger): Integer

open override fun intOf(value: String, radix: Int): Integer

invoke

open operator fun String.invoke(term: Any, vararg terms: Any): Struct

open infix fun Any.is(other: Any): Struct

load

open fun load(url: Any): Struct

logicList

open fun logicList(vararg items: Any, tail: Any?): List

logicListFrom

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

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

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

logicListOf

open override fun logicListOf(terms: Iterable<Term>): List

open override fun logicListOf(terms: Sequence<Term>): List

open override fun logicListOf(vararg terms: Term): List

open fun logicListOf(vararg terms: Any): List

lowerThan

open infix fun Any.lowerThan(other: Any): Struct

lowerThanOrEqualsTo

open infix fun Any.lowerThanOrEqualsTo(other: Any): Struct

match

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

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

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

matches

open infix fun Any.matches(other: Any): Boolean

member

open fun member(item: Any, list: Any): Struct

merge

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

open override fun merge(substitution1: Substitution, substitution2: Substitution, occurCheckEnabled: Boolean): Substitution

mgu

open fun mgu(term1: Any, term2: Any, occurCheckEnabled: Boolean): Substitution

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

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

mguWith

open infix fun Any.mguWith(other: Any): Substitution

minus

open operator fun Term.minus(other: Any): Struct

open operator fun Boolean.minus(other: Any): Struct

open operator fun Char.minus(other: Any): Struct

open operator fun Number.minus(other: Any): Struct

open operator fun String.minus(other: Any): Struct

mutableTheory

open fun mutableTheory(vararg clauseFunctions: LogicProgrammingScope.() -> Any): MutableTheory

Builds a MutableTheory out of clauseFunctions, one per clause. Otherwise identical to theory, down to how each lambda is run and its result converted via toClause; delegates to TheoryFactory.mutableTheoryOf (via theoryFactory).