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