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

LogicProgrammingScopeWithOperators

interface LogicProgrammingScopeWithOperators<S : LogicProgrammingScopeWithOperators<S>> : BaseLogicProgrammingScope<S>

Adds infix/operator builders mirroring Prolog's own arithmetic, relational and logical operators, so that Structs (and Rules, for if/impliedBy) can be written as Kotlin expressions instead of nested BaseLogicProgrammingScope.toTerm/structOf calls:

logicProgramming {
    "X" `is` ("Y" + 1)                 // Struct: is(X, +(Y, 1))
    ("X" greaterThan 0) and ("Y" lowerThan 10) // Struct: ','(>(X, 0), <(Y, 10))
    "even"("X") `if` ("X" rem 2 eq 0)  // Rule: even(X) :- =(rem(X, 2), 0)
}

Each Prolog operator is overloaded once per receiver type (Term, Any, Number, Boolean, Char, String, ...) only where Kotlin's own operator-overload resolution requires it to disambiguate from conflicting stdlib operators (e.g. Number.plus); the Any-receiver versions (equalsTo, and, is, ...) cover every other case directly, toTerm-ing both operands.

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

and

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

Builds a conjunction (, /2, right-associative), i.e. a Tuple: if this value is already a Tuple, other is appended to it as one more item, rather than nesting a new 2-ary tuple around it — so a and b and c flattens to a single 3-ary tuple (a, b, c) rather than (a, (b, c)).

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

directiveOf

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

div

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

Builds an Indicator out of this Term (the name) and other (the arity), e.g. "foo" / 2. Note this overload does not build a Prolog //2 struct — use structOf directly for that.

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

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

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

Same as the Number receiver overload of div above, for a non-Number left-hand side.

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

Builds a //2 Struct (Prolog division), e.g. "X" / 2. Unlike the Term receiver overload of div above, this does not build an Indicator.

equalsTo

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

Builds a Struct whose functor is '='/2 (term unification operator).

factOf

abstract fun factOf(head: Struct): Fact

get

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

greaterThan

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

Builds a >/2 Struct (arithmetic greater-than).

greaterThanOrEqualsTo

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

Builds a >=/2 Struct (arithmetic greater-than-or-equal).

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

Alias of impliedBy reading in head-first order: head ifbody builds the Rule head :- body.

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

Vararg overload of if: head.if(body1, body2, ...) builds the Rule head :- (body1, body2, ...).

impliedBy

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

Builds the Rule this :- other, i.e. other implies (is the body of a rule whose head is) this value.

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

Vararg overload of impliedBy: wraps other into a single conjunction (via Tuple.wrapIfNeeded) before building the Rule, so a multi-goal body can be listed as separate arguments instead of chained with and.

indicatorOf

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

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

intDiv

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

Builds a ///2 Struct (integer division).

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

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

Builds an is/2 Struct (arithmetic evaluation).

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

lowerThan

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

Builds a </2 Struct (arithmetic lower-than).

lowerThanOrEqualsTo

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

Builds an =</2 Struct (arithmetic lower-than-or-equal).

minus

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

Builds a -/2 Struct, e.g. "X" - 1.

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

Same as the Term receiver overload of minus above, for a non-Term left-hand side.

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.

nonGreaterThan

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

Alias of lowerThanOrEqualsTo.

nonLowerThan

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

Alias of greaterThanOrEqualsTo.

notEqualsTo

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

Builds a \=/2 Struct (term non-unifiability).

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

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

Builds a ;/2 Struct (disjunction).

plus

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

Builds a +/2 Struct, e.g. 1 + "X".

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

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

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

Same as the Term receiver overload of plus above, for a non-Term left-hand side.

pow

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

Builds a **/2 Struct (arithmetic power).

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

rem

open infix operator fun Term.rem(other: Any): Struct

Builds a rem/2 Struct (integer remainder).

open infix operator fun Boolean.rem(other: Any): Struct

open infix operator fun Char.rem(other: Any): Struct

open infix operator fun Number.rem(other: Any): Struct

open infix operator fun String.rem(other: Any): Struct

Same as the Term receiver overload of rem above, for a non-Term left-hand side.

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

sup

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

Builds a ^/2 Struct (existential quantification, e.g. for bagof/setof, or integer power).

then

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

Builds a ->/2 Struct (if-then).

times

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

Builds a */2 Struct, e.g. "X" * 2.

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

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

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

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

Same as the Term receiver overload of times above, for a non-Term left-hand side.

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