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

LogicProgrammingScopeWithPrologStandardLibrary

interface LogicProgrammingScopeWithPrologStandardLibrary<S : LogicProgrammingScopeWithPrologStandardLibrary<S>> : BaseLogicProgrammingScope<S>

Adds one builder per predicate of (roughly) the ISO Prolog standard library — plus a handful of well-known de-facto standard ones (assert, findall, member, ...) — so common goals can be written as ordinary Kotlin function/property calls instead of structOf("member", item, list)-style boilerplate:

logicProgramming {
    findall("X", call("member".invoke("X", "List")), "Bag") // findall(X, call(member(X, List)), Bag)
    not(atom("X")) `if` (`var`("X"))                          // not(atom(X)) :- var(X)
}

Each builder simply wraps its arguments (auto-toTerm-ed) into a Struct named after the predicate; none of them actually run the predicate — that is :dsl-solve's job, further up the DSL stack. A few predicates not representable as legal Kotlin identifiers as-is are escaped with backticks (` `catch` `, ` `throw` `, ` `var` `) or renamed (e.g. naf for \+/1).

Inheritors

LogicProgrammingScope

Properties

open val _: Var

at_end_of_stream

open val at_end_of_stream: Atom

The at_end_of_stream/0 Atom.

cut

open val cut: Atom

The cut (!/0) Atom.

emptyBlock

abstract val emptyBlock: EmptyBlock

emptyLogicList

abstract val emptyLogicList: EmptyList

fail

abstract val fail: Truth

halt

open val halt: Atom

The halt/0 Atom.

open val nl: Atom

The nl/0 Atom.

repeat

open val repeat: Atom

The repeat/0 Atom.

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

abolish

open fun abolish(indicator: Any): Struct

Builds an abolish/1 Struct.

anonymous

abstract fun anonymous(): Var

append

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

Builds an append/3 Struct.

arg

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

Builds an arg/3 Struct.

arithEq

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

Builds a =:=/2 Struct (arithmetic equality).

arithNeq

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

Builds a =\=/2 Struct (arithmetic inequality).

assert

open fun assert(clause: Any): Struct

Builds an assert/1 Struct.

asserta

open fun asserta(clause: Any): Struct

Builds an asserta/1 Struct.

assertz

open fun assertz(clause: Any): Struct

Builds an assertz/1 Struct.

at_end_of_stream

open fun at_end_of_stream(alias: Any): Struct

Builds an at_end_of_stream/1 Struct.

atom

open fun atom(atom: Any): Struct

Builds an atom/1 Struct (type-checking predicate, not to be confused with Struct.functor).

atom_chars

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

Builds an atom_chars/2 Struct.

atom_codes

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

Builds an atom_codes/2 Struct.

atom_concat

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

Builds an atom_concat/3 Struct.

atom_length

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

Builds an atom_length/2 Struct.

atomic

open fun atomic(atomic: Any): Struct

Builds an atomic/1 Struct.

atomOf

abstract fun atomOf(value: Char): Atom

abstract fun atomOf(value: String): Atom

bagof

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

Builds a bagof/3 Struct.

between

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

Builds a between/3 Struct.

blockOf

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

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

abstract fun blockOf(vararg terms: Term): Block

call

open fun call(goal: Any): Struct

Builds a call/1 Struct.

callable

open fun callable(goal: Any): Struct

Builds a callable/1 Struct.

catch

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

Builds a catch/3 Struct.

char_code

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

Builds a char_code/2 Struct.

clause

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

Builds a clause/2 Struct; not to be confused with MinimalLogicProgrammingScope.clause.

clauseOf

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

compound

open fun compound(struct: Any): Struct

Builds a compound/1 Struct.

consOf

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

consult

open fun consult(url: Any): Struct

Builds a consult/1 Struct.

contains

abstract operator fun contains(variable: Var): Boolean

abstract operator fun contains(variable: String): Boolean

copy_term

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

Builds a copy_term/2 Struct.

current_flag

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

Builds a current_flag/2 Struct.

current_op

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

Builds a current_op/3 Struct.

current_prolog_flag

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

Builds a current_prolog_flag/2 Struct. Deprecated in favor of current_flag.

directiveOf

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

dynamic

open fun dynamic(indicator: Any): Struct

Builds a dynamic/1 Struct.

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

Builds a =/2 Struct; same functor as LogicProgrammingScopeWithOperators.equalsTo.

factOf

abstract fun factOf(head: Struct): Fact

findall

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

Builds a findall/3 Struct.

float

open fun float(number: Any): Struct

Builds a float/1 Struct.

functor

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

Builds a functor/3 Struct.

get

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

ground

open fun ground(term: Any): Struct

Builds a ground/1 Struct.

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

Builds a ==/2 Struct (term structural equality).

include

open fun include(url: Any): Struct

Builds an include/1 Struct.

indicatorOf

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

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

initialization

open fun initialization(goal: Any): Struct

Builds an initialization/1 Struct.

integer

open fun integer(number: Any): Struct

Builds an integer/1 Struct.

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

load

open fun load(url: Any): Struct

Builds a load/1 Struct.

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

member

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

Builds a member/2 Struct.

naf

open fun naf(goal: Any): Struct

Builds a \+/1 Struct (negation as failure).

natural

open fun natural(number: Any): Struct

Builds a natural/1 Struct.

neq

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

Builds a \=/2 Struct; same functor as LogicProgrammingScopeWithOperators.notEqualsTo.

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.

nid

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

Builds a \==/2 Struct (term structural inequality).

nonvar

open fun nonvar(number: Any): Struct

Builds a nonvar/1 Struct.

not

open fun not(goal: Any): Struct

Builds a not/1 Struct.

number

open fun number(number: Any): Struct

Builds a number/1 Struct.

number_chars

open fun number_chars(first: Any, second: Any): Struct

Builds a number_chars/2 Struct.

number_codes

open fun number_codes(first: Any, second: Any): Struct

Builds a number_codes/2 Struct.

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 fun op(precedence: Any, specifier: Any, functor: Any): Struct

Builds an op/3 Struct.

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

retract

open fun retract(clause: Any): Struct

Builds a retract/1 Struct.

retractall

open fun retractall(clause: Any): Struct

Builds a retractall/1 Struct.

ruleOf

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

set_flag

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

Builds a set_flag/2 Struct.

set_prolog_flag

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

Builds a set_prolog_flag/2 Struct. Deprecated in favor of set_flag.

setof

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

Builds a setof/3 Struct.

solve

open fun solve(goal: Any): Struct

Builds a solve/1 Struct.

static

open fun static(indicator: Any): Struct

Builds a static/1 Struct.

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

sub_atom

open fun sub_atom(atom: Any, before: Any, length: Any, after: Any, sub_atom: Any): Struct

Builds a sub_atom/5 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

throw

open fun throw(error: Any): Struct

Builds a throw/1 Struct.

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.