protocol

termp

Term utility predicates protocol.

Availability:
logtalk_load(types(loader))
Author: Paulo Moura
Version: 1:35:0
Date: 2022-05-13
Compilation flags:
static
Extends:
public comparingp
Remarks:
(none)
Inherited public predicates:
 (<)/2  (=:=)/2  (=<)/2  (=\=)/2  (>)/2  (>=)/2

Public predicates

depth/2

True if the depth of Term is Depth. The depth of atomic terms is zero; the depth of a compound term is one plus the maximum depth of its sub-terms.

Compilation flags:
static
Template:
depth(Term,Depth)
Mode and number of proofs:
depth(@term,?integer) - zero_or_one

ground/1

True if the argument is ground. Deprecated. Use the ground/1 standard predicate instead.

Compilation flags:
static
Template:
ground(Term)
Mode and number of proofs:
ground(@term) - zero_or_one

new/1

Creates a new term instance (if meaningful).

Compilation flags:
static
Template:
new(Term)
Mode and number of proofs:
new(-nonvar) - zero_or_one

occurs/2

True if the variable occurs in the term.

Compilation flags:
static
Template:
occurs(Variable,Term)
Mode and number of proofs:
occurs(@var,@term) - zero_or_one

subsumes/2

The first term subsumes the second term. Deprecated. Use the subsumes_term/2 standard predicate instead.

Compilation flags:
static
Template:
subsumes(General,Specific)
Mode and number of proofs:
subsumes(@term,@term) - zero_or_one

subterm/2

The first term is a subterm of the second term.

Compilation flags:
static
Template:
subterm(Subterm,Term)
Mode and number of proofs:
subterm(?term,+term) - zero_or_more

valid/1

Term is valid.

Compilation flags:
static
Template:
valid(Term)
Mode and number of proofs:
valid(@nonvar) - zero_or_one

check/1

Checks if a term is valid. Throws an exception if the term is not valid.

Compilation flags:
static
Template:
check(Term)
Mode and number of proofs:
check(@nonvar) - one

variant/2

Each term is a variant of the other (i.e. they are structurally equivalent).

Compilation flags:
static
Template:
variant(Term1,Term2)
Mode and number of proofs:
variant(@term,@term) - zero_or_one

variables/2

Returns a list of all term variables (ordered as found when doing a depth-first, left-to-right traversal of Term). Deprecated. Use the standard term_variables/2 predicate instead.

Compilation flags:
static
Template:
variables(Term,List)
Mode and number of proofs:
variables(@term,-list) - one

singletons/2

Returns a list of all term singleton variables (ordered as found when doing a depth-first, left-to-right traversal of Term).

Compilation flags:
static
Template:
singletons(Term,Singletons)
Mode and number of proofs:
singletons(@term,-list) - one

numbervars/3

Grounds a term by replacing all variables with '$VAR'(N) terms with N starting at From. The Next argument is unified with the next value for N after binding all variables.

Compilation flags:
static
Template:
numbervars(Term,From,Next)
Mode and number of proofs:
numbervars(?term,+integer,?integer) - zero_or_one

numbervars/1

Grounds a term by replacing all variables with '$VAR'(N) terms with N starting at 0.

Compilation flags:
static
Template:
numbervars(Term)
Mode and number of proofs:
numbervars(?term) - zero_or_one

varnumbers/3

Replaces all '$VAR'(N) sub-terms in a term with fresh variables for all values of N grater or equal to From. Variables in Term are shared with Copy.

Compilation flags:
static
Template:
varnumbers(Term,From,Copy)
Mode and number of proofs:
varnumbers(@term,+integer,?term) - zero_or_one

varnumbers/2

Replaces all '$VAR'(N) sub-terms in a term with fresh variables for all values of N grater or equal to 0. Variables in Term are shared with Copy.

Compilation flags:
static
Template:
varnumbers(Term,Copy)
Mode and number of proofs:
varnumbers(@term,?term) - zero_or_one

Protected predicates

(no local declarations; see entity ancestors if any)

Private predicates

(no local declarations; see entity ancestors if any)

Operators

(none)

See also

term