LogicProgrammingScope

The at_end_of_stream/0 Atom.

The cut (!/0) Atom.

The halt/0 Atom.

The nl/0 Atom.

The repeat/0 Atom.

The Termificator used by toTerm to convert arbitrary values into Terms within this scope.

The VariablesProvider this scope's own VariablesProvider methods delegate to.

Builds an abolish/1 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)).

Builds an append/3 Struct.

Builds an arg/3 Struct.

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

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

Builds an assert/1 Struct.

Builds an asserta/1 Struct.

Builds an assertz/1 Struct.

Builds an at_end_of_stream/1 Struct.

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

Builds an atom_chars/2 Struct.

Builds an atom_codes/2 Struct.

Builds an atom_concat/3 Struct.

Builds an atom_length/2 Struct.

Builds an atomic/1 Struct.

Builds a bagof/3 Struct.

Builds a between/3 Struct.

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

Builds a call/1 Struct.

Builds a callable/1 Struct.

Builds a catch/3 Struct.

Builds a char_code/2 Struct.

Builds a clause/2 Struct; not to be confused with MinimalLogicProgrammingScope.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.

Builds a compound/1 Struct.

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

Builds a consult/1 Struct.

Alias of containsKey.

Checks whether this Substitution binds term.

Checks whether term (auto-toTerm-ed) occurs as a bound value in this Substitution.

Creates a copy of this scope, backed by scope (see VariablesProvider.copy).

Builds a copy_term/2 Struct.

Builds a current_flag/2 Struct.

Builds a current_op/3 Struct.

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

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

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

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.

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

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

Builds a dynamic/1 Struct.

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

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

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

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

Builds a findall/3 Struct.

Builds a float/1 Struct.

Builds a functor/3 Struct.

Looks up the Term this Substitution binds term to, null if unbound.

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

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

Builds a ground/1 Struct.

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

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

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

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

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.

Builds an include/1 Struct.

Builds an initialization/1 Struct.

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

Builds an integer/1 Struct.

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

Builds an is/2 Struct (arithmetic evaluation).

Builds a load/1 Struct.

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.

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

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

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

Builds a member/2 Struct.

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

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

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

Builds a natural/1 Struct.

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

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.

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

Alias of lowerThanOrEqualsTo.

Alias of greaterThanOrEqualsTo.

Builds a nonvar/1 Struct.

Builds a not/1 Struct.

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

Builds a number/1 Struct.

Builds a number_chars/2 Struct.

Builds a number_codes/2 Struct.

Builds an op/3 Struct.

Builds a ;/2 Struct (disjunction).

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

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

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

Builds a rem/2 Struct (integer remainder).

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

Builds a retract/1 Struct.

Builds a retractall/1 Struct.

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.

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

Builds a set_flag/2 Struct.

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

Builds a setof/3 Struct.

Builds a solve/1 Struct.

Builds a static/1 Struct.

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

Builds a sub_atom/5 Struct.

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

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

Builds a throw/1 Struct.

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

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

Builds the Substitution.Unifier binding this Var to termObject (auto-toTerm-ed).

Builds the Substitution.Unifier binding the Var named by this String (via varOf) to termObject.

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.

Converts this value into a Term, via termificator. See Termificator.termify for the conversion rules.

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

Builds a =../2 Struct (univ).

Builds a var/1 Struct.

Builds a write/1 Struct.