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

MinimalLogicProgrammingScope

interface MinimalLogicProgrammingScope<S : MinimalLogicProgrammingScope<S>> : BaseLogicProgrammingScope<S>

Core term/clause-building mixin of the Prolog DSL: overloads it.unibo.tuprolog.core.Scope's own structOf/tupleOf/logicListOf/... factory methods to accept plain Any arguments (auto-toTerm-ed), adds the "calling a String" shorthand for building Structs, and adds scoped clause builders (rule/fact/directive/clause) that isolate each clause's variables in their own newScope.

Calling a String with one or more arguments builds a Struct with that string as functor:

logicProgramming {
    "parent"("abraham", "isaac") // Struct: parent(abraham, isaac)
    "ancestor"("X", "Y")         // "X"/"Y" are termified to Vars, since they match a variable name pattern
}

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

open fun blockOf(vararg terms: Any): Block

Overload of it.unibo.tuprolog.core.Scope.blockOf accepting plain values, toTerm-ing each of terms.

clause

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

Runs function with a newScope as its receiver and coerces its result to a Clause: returned as-is if it already is a Clause (e.g. a Rule), or wrapped into a Fact via factOf if it is a plain Struct.

clauseOf

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

consOf

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

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

Overload of it.unibo.tuprolog.core.Scope.consOf accepting plain values, toTerm-ing both head and tail.

contains

abstract operator fun contains(variable: Var): Boolean

abstract operator fun contains(variable: String): Boolean

directive

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

Runs function with a newScope as its receiver and coerces its result to a Directive via directiveOf.

directiveOf

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

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

Overload of it.unibo.tuprolog.core.Scope.directiveOf accepting plain values, toTerm-ing term and each of terms.

fact

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

Runs function with a newScope as its receiver and coerces its result to a Fact via factOf.

factOf

abstract fun factOf(head: Struct): Fact

open fun factOf(term: Any): Fact

Overload of it.unibo.tuprolog.core.Scope.factOf accepting a plain value, toTerm-ing term.

get

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

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

invoke

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

Builds a Struct whose functor is this String and whose arguments are term followed by terms.

logicList

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

Builds a logic list out of items (each toTerm-ed), optionally ending in tail (also toTerm-ed) rather than the empty list — mirroring it.unibo.tuprolog.core.Scope.logicListFrom's last parameter.

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

open fun logicListOf(vararg terms: Any): List

Overload of it.unibo.tuprolog.core.Scope.logicListOf accepting plain values, toTerm-ing each of terms.

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

rule

open fun rule(function: S.() -> Any): Rule

Runs function with a newScope as its receiver and coerces its result to a Rule — typically built via the head ifbody / head impliedBybody infix builders from LogicProgrammingScopeWithOperators.

ruleOf

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

scope

open fun <R> scope(function: S.() -> R): R

Runs function with a newScope as its receiver, isolating any it.unibo.tuprolog.core.Var it creates.

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

open fun structOf(functor: String, vararg args: Any): Struct

Overload of it.unibo.tuprolog.core.Scope.structOf accepting plain values, toTerm-ing each of args.

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

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

open fun tupleOf(vararg terms: Any): Tuple

Overload of it.unibo.tuprolog.core.Scope.tupleOf accepting plain values, toTerm-ing each of terms.

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