☰

*ON THIS PAGE*# Basic data types and properties

**Author(s):** Daniel Cabeza, Manuel Hermenegildo.## Usage and interface

## Documentation on exports

**Other properties:** `gndstr(T)`
`gndstr(T)`
`gndstr(T)`
**Other properties:** `constant(T)`
`constant(T)`
`constant(T)`
**Other properties:** `callable(T)`
`callable(T)`
`callable(T)`
`list(L,T)`
*Meta-predicate* with arguments: `list(?,pred(1))`.

**Other properties:** `list(L,T)`
`list(L,T)`
`list(X,T)`
*Meta-predicate* with arguments: `nlist(?,pred(1))`.

**Other properties:** `nlist(L,T)`
`nlist(L,T)`
`nlist(X,T)`
**Other properties:** `member(X,L)`
`member(X,L)`
`member(_X,L)`
`member(X,L)`
*Meta-predicate* with arguments: `sequence_or_list(?,pred(1))`.

**Other properties:** `sequence_or_list(S,T)`
`sequence_or_list(S,T)`
`sequence_or_list(E,T)`
**Other properties:** `character_code(T)`
`character_code(T)`
`character_code(I)`
`predname(P)`
**Other properties:** `predname(P)`
`predname(P)`
`predname(P)`
**Other properties:** `atm_or_atm_list(T)`
`atm_or_atm_list(T)`
`atm_or_atm_list(T)`
*Meta-predicate* with arguments: `inst(?,pred(1))`.

**Other properties:** `inst(Term,Prop)`
`inst(Term,Prop)`
*Meta-predicate* with arguments: `iso(goal)`.

**Other properties:** `iso(G)`
*Meta-predicate* with arguments: `not_further_inst(goal,?)`.

**Other properties:** `not_further_inst(G,V)`
`sideff(G,X)`
*Meta-predicate* with arguments: `sideff(goal,?)`.

**Other properties:** `sideff(G,X)`
*Meta-predicate* with arguments: `regtype(goal)`.

**Other properties:** `regtype(G)`
*Meta-predicate* with arguments: `native(goal)`.

**Other properties:** `native(P)`
*Meta-predicate* with arguments: `native(goal,?)`.

**Other properties:** `native(P,K)`
*Meta-predicate* with arguments: `rtcheck(goal)`.

**Other properties:** `rtcheck(G)`
*Meta-predicate* with arguments: `rtcheck(goal,?)`.

**Other properties:** `rtcheck(G,Status)`
*Meta-predicate* with arguments: `eval(goal)`.

*Meta-predicate* with arguments: `equiv(goal,goal)`.

*Meta-predicate* with arguments: `bind_ins(goal)`.

*Meta-predicate* with arguments: `error_free(goal)`.

*Meta-predicate* with arguments: `memo(goal)`.

*Meta-predicate* with arguments: `pe_type(goal)`.

## Documentation on imports

This module has the following direct dependencies:

This library contains the set of basic properties used by the builtin predicates, and which constitute the basic data types and properties of the language. They are intented to be used as properties in assertions (for both runtime and compile time checking).

Note that most of those properties can be used directly from goals as type testing builtins, and they should be correct when terms are sufficiently instantiated. Calling with uninstantiated terms have undefined behaviour (failure or non termination, depending on the type). Please use the run-time checking facilities (`inst/2` and `compat/2`) to ensure well-defined behaviour. For low-level instantiation checks we encourage the use `term_typing` builtins.

**Library usage:**

This module is automatically imported by the`assertions`package. It can be imported explicitly with the`:- use_module(engine(basic_props))`directive.**Exports:***Properties:*`member/2`,`compat/2`,`inst/2`,`iso/1`,`deprecated/1`,`not_further_inst/2`,`sideff/2`,`regtype/1`,`native/1`,`native/2`,`rtcheck/1`,`rtcheck/2`,`no_rtcheck/1`,`eval/1`,`equiv/2`,`bind_ins/1`,`error_free/1`,`memo/1`,`filter/2`,`pe_type/1`.*Regular Types:*`term/1`,`int/1`,`nnegint/1`,`flt/1`,`num/1`,`atm/1`,`struct/1`,`gnd/1`,`gndstr/1`,`constant/1`,`callable/1`,`internal_module_id/1`,`operator_specifier/1`,`list/1`,`list/2`,`nlist/2`,`sequence/2`,`sequence_or_list/2`,`character_code/1`,`string/1`,`num_code/1`,`predname/1`,`atm_or_atm_list/1`,`flag_values/1`.

REGTYPEterm/1

The most general type (includes all possible terms).**Other properties:** `term(X)`
`term(X)`
`term(X)`

Usage:`term(X)`

X is any term.

*The following properties hold globally:*

(`native/1`)This predicate is understood natively by CiaoPP.

*The following properties hold globally:*

(`sideff/2`)term(X) is side-effect free.

*The following properties hold globally:*

(`eval/1`)term(X) is evaluable at compile-time.

*The following properties hold globally:*

(`equiv/2`)term(X) is equivalent to true.

REGTYPEint/1

The type of integers. The range of integers is `[-2^2147483616, 2^2147483616)`. Thus for all practical purposes, the range of integers can be considered infinite.**Other properties:** `int(T)`
`int(T)`
`int(T)`

Usage:`int(T)`

T is an integer.

*The following properties hold globally:*

(`native/1`)This predicate is understood natively by CiaoPP.

*The following properties hold globally:*

(`sideff/2`)int(T) is side-effect free.

*If the following properties hold at call time:*

(`nonvar/1`)T is currently a term which is not a free variable.*then the following properties hold globally:*

(`eval/1`)int(T) is evaluable at compile-time.

(`is_det/1`)All calls of the form int(T) are deterministic.

*The following properties hold upon exit:*

(`int/1`)T is an integer.

*The following properties hold globally:*

(`test_type/2`)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPEnnegint/1

The type of non-negative integers, i.e., natural numbers.**Other properties:** `nnegint(T)`
`nnegint(T)`
`nnegint(T)`

Usage:`nnegint(T)`

T is a non-negative integer.

*The following properties hold globally:*

(`native/1`)This predicate is understood natively by CiaoPP.

*The following properties hold globally:*

(`sideff/2`)nnegint(T) is side-effect free.

*If the following properties hold at call time:*

(`nonvar/1`)T is currently a term which is not a free variable.*then the following properties hold globally:*

(`eval/1`)nnegint(T) is evaluable at compile-time.

*The following properties hold upon exit:*

(`nnegint/1`)T is a non-negative integer.

*The following properties hold globally:*

(`test_type/2`)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPEflt/1

The type of floating-point numbers. The range of floats is the one provided by the C `double` type, typically `[4.9e-324, 1.8e+308]` (plus or minus). There are also three special values: Infinity, either positive or negative, represented as `1.0e1000` and `-1.0e1000`; and Not-a-number, which arises as the result of indeterminate operations, represented as `0.Nan`**Other properties:** `flt(T)`
`flt(T)`
`flt(T)`

Usage:`flt(T)`

T is a float.

*The following properties hold globally:*

(`native/1`)This predicate is understood natively by CiaoPP.

*The following properties hold globally:*

(`sideff/2`)flt(T) is side-effect free.

*If the following properties hold at call time:*

(`nonvar/1`)T is currently a term which is not a free variable.*then the following properties hold globally:*

(`eval/1`)flt(T) is evaluable at compile-time.

(`is_det/1`)All calls of the form flt(T) are deterministic.

*The following properties hold upon exit:*

(`flt/1`)T is a float.

*The following properties hold globally:*

(`test_type/2`)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPEnum/1

The type of numbers, that is, integer or floating-point.**Other properties:** `num(T)`
`num(T)`
`num(T)`

Usage:`num(T)`

T is a number.

*The following properties hold globally:*

(`native/1`)This predicate is understood natively by CiaoPP.

*The following properties hold globally:*

(`sideff/2`)num(T) is side-effect free.

(`bind_ins/1`)num(T) is binding insensitive.

*If the following properties hold at call time:*

(`nonvar/1`)T is currently a term which is not a free variable.*then the following properties hold globally:*

(`eval/1`)num(T) is evaluable at compile-time.

(`is_det/1`)All calls of the form num(T) are deterministic.

*The following properties hold upon exit:*

(`num/1`)T is a number.

*The following properties hold globally:*

(`test_type/2`)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPEatm/1

The type of atoms, or non-numeric constants. The size of atoms is unbound.**Other properties:** `atm(T)`
`atm(T)`
`atm(T)`

Usage:`atm(T)`

T is an atom.

*The following properties hold globally:*

(`native/1`)This predicate is understood natively by CiaoPP.

*The following properties hold globally:*

(`sideff/2`)atm(T) is side-effect free.

*If the following properties hold at call time:*

(`nonvar/1`)T is currently a term which is not a free variable.*then the following properties hold globally:*

(`eval/1`)atm(T) is evaluable at compile-time.

(`is_det/1`)All calls of the form atm(T) are deterministic.

*The following properties hold upon exit:*

(`atm/1`)T is an atom.

*The following properties hold globally:*

(`test_type/2`)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPEstruct/1

The type of compound terms, or terms with non-zeroary functors. By now there is a limit of 255 arguments.**Other properties:** `struct(T)`
`struct(T)`
`struct(T)`

Usage:`struct(T)`

T is a compound term.

*The following properties hold globally:*

(`native/1`)This predicate is understood natively by CiaoPP.

*The following properties hold globally:*

(`sideff/2`)struct(T) is side-effect free.

*If the following properties hold at call time:*

(`nonvar/1`)T is currently a term which is not a free variable.*then the following properties hold globally:*

(`eval/1`)struct(T) is evaluable at compile-time.

*The following properties hold upon exit:*

(`struct/1`)T is a compound term.

REGTYPEgnd/1

The type of all terms without variables.**Other properties:** `gnd(T)`
`gnd(T)`
`gnd(T)`

Usage:`gnd(T)`

T is ground.

*The following properties hold globally:*

(`native/1`)This predicate is understood natively by CiaoPP.

*The following properties hold globally:*

(`sideff/2`)gnd(T) is side-effect free.

*If the following properties hold at call time:*

(`ground/1`)T is currently ground (it contains no variables).*then the following properties hold globally:*

(`eval/1`)gnd(T) is evaluable at compile-time.

(`is_det/1`)All calls of the form gnd(T) are deterministic.

*The following properties hold upon exit:*

(`gnd/1`)T is ground.

*The following properties hold globally:*

(`test_type/2`)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPEgndstr/1

Usage:`gndstr(T)`

T is a ground compound term.

*The following properties hold globally:*

(`native/1`)This predicate is understood natively by CiaoPP.

*The following properties hold globally:*

(`sideff/2`)gndstr(T) is side-effect free.

*If the following properties hold at call time:*

(`ground/1`)T is currently ground (it contains no variables).*then the following properties hold globally:*

(`eval/1`)gndstr(T) is evaluable at compile-time.

(`is_det/1`)All calls of the form gndstr(T) are deterministic.

*The following properties hold upon exit:*

(`gndstr/1`)T is a ground compound term.

REGTYPEconstant/1

Usage:`constant(T)`

T is an atomic term (an atom or a number).

*The following properties hold globally:*

(`sideff/2`)constant(T) is side-effect free.

*If the following properties hold at call time:*

(`nonvar/1`)T is currently a term which is not a free variable.*then the following properties hold globally:*

(`eval/1`)constant(T) is evaluable at compile-time.

(`is_det/1`)All calls of the form constant(T) are deterministic.

*The following properties hold upon exit:*

(`constant/1`)T is an atomic term (an atom or a number).

REGTYPEcallable/1

Usage:`callable(T)`

T is a term which represents a goal, i.e., an atom or a structure.

*The following properties hold globally:*

(`sideff/2`)callable(T) is side-effect free.

*If the following properties hold at call time:*

(`nonvar/1`)T is currently a term which is not a free variable.*then the following properties hold globally:*

(`eval/1`)callable(T) is evaluable at compile-time.

(`is_det/1`)All calls of the form callable(T) are deterministic.

*The following properties hold upon exit:*

(`nonvar/1`)T is currently a term which is not a free variable.

REGTYPEinternal_module_id/1

For a user file it is a term user/1 with an argument different for each user file, for other modules is just the name of the module (as an atom).

Usage:`internal_module_id(M)`

M is an internal module identifier

REGTYPEoperator_specifier/1

The type and associativity of an operator is described by the following mnemonic atoms:**Other properties:** `operator_specifier(X)`
`operator_specifier(X)`
`operator_specifier(T)`

`xfx`- Infix, non-associative: it is a requirement that both of the two subexpressions which are the arguments of the operator must be of
*lower*precedence than the operator itself. `xfy`- Infix, right-associative: only the first (left-hand) subexpression must be of lower precedence; the right-hand subexpression can be of the
*same*precedence as the main operator. `yfx`- Infix, left-associative: same as above, but the other way around.
`fx`- Prefix, non-associative: the subexpression must be of
*lower*precedence than the operator. `fy`- Prefix, associative: the subexpression can be of the
*same*precedence as the operator. `xf`- Postfix, non-associative: the subexpression must be of
*lower*precedence than the operator. `yf`- Postfix, associative: the subexpression can be of the
*same*precedence as the operator.

Usage:`operator_specifier(X)`

X specifies the type and associativity of an operator.

*The following properties hold globally:*

(`sideff/2`)operator_specifier(X) is side-effect free.

*If the following properties hold at call time:*

(`nonvar/1`)X is currently a term which is not a free variable.*then the following properties hold globally:*

(`eval/1`)operator_specifier(X) is evaluable at compile-time.

(`is_det/1`)All calls of the form operator_specifier(X) are deterministic.

(`relations/2`)Goal operator_specifier(X) produces 7 solutions.

*The following properties hold upon exit:*

(`operator_specifier/1`)T specifies the type and associativity of an operator.

REGTYPElist/1

A list is formed with successive applications of the functor `'.'/2`, and its end is the atom `[]`. Defined as **Other properties:** `list(L)`
`list(L)`
`list(T)`

list([]). list([_1|L]) :- list(L).

Usage:`list(L)`

L is a list.

*The following properties hold globally:*

(`sideff/2`)list(L) is side-effect free.

*If the following properties hold at call time:*

(`ground/1`)L is currently ground (it contains no variables).*then the following properties hold globally:*

(`eval/1`)list(L) is evaluable at compile-time.

(`is_det/1`)All calls of the form list(L) are deterministic.

*The following properties hold upon exit:*

(`list/1`)T is a list.

REGTYPElist/2

L is a list, and for all its elements, T holds.

Usage:`list(L,T)`

L is a list of Ts.

*The following properties hold globally:*

(`sideff/2`)list(L,T) is side-effect free.

*If the following properties hold at call time:*

(`ground/1`)L is currently ground (it contains no variables).

(`ground/1`)T is currently ground (it contains no variables).*then the following properties hold globally:*

(`eval/1`)list(L,T) is evaluable at compile-time.

*The following properties hold upon exit:*

(`list/1`)X is a list.

REGTYPEnlist/2

Usage:`nlist(L,T)`

L is T or a nested list of Ts. Note that if T is term, this type is equivalent to term, this fact explain why we do not have a `nlist/1` type.

*The following properties hold globally:*

(`sideff/2`)nlist(L,T) is side-effect free.

*If the following properties hold at call time:*

(`ground/1`)L is currently ground (it contains no variables).

(`ground/1`)T is currently ground (it contains no variables).*then the following properties hold globally:*

(`eval/1`)nlist(L,T) is evaluable at compile-time.

*The following properties hold upon exit:*

(`term/1`)X is any term.

PROPERTYmember/2

Usage:`member(X,L)`

X is an element of L.

*The following properties hold globally:*

(`sideff/2`)member(X,L) is side-effect free.

(`bind_ins/1`)member(X,L) is binding insensitive.

*If the following properties hold at call time:*

(`list/1`)L is a list.*then the following properties hold globally:*

(`eval/1`)member(X,L) is evaluable at compile-time.

*The following properties hold upon exit:*

(`list/1`)L is a list.

REGTYPEsequence/2

A sequence is formed with zero, one or more occurrences of the operator `','/2`. For example, `a, b, c` is a sequence of three atoms, `a` is a sequence of one atom.*Meta-predicate* with arguments: `sequence(?,pred(1))`.

**Other properties:** `sequence(S,T)`
`sequence(S,T)`
`sequence(E,T)`

Usage:`sequence(S,T)`

S is a sequence of Ts.

*The following properties hold globally:*

(`sideff/2`)sequence(S,T) is side-effect free.

*If the following properties hold at call time:*

(`ground/1`)S is currently ground (it contains no variables).

(`ground/1`)T is currently ground (it contains no variables).*then the following properties hold globally:*

(`eval/1`)sequence(S,T) is evaluable at compile-time.

REGTYPEsequence_or_list/2

Usage:`sequence_or_list(S,T)`

S is a sequence or list of Ts.

*The following properties hold globally:*

(`sideff/2`)sequence_or_list(S,T) is side-effect free.

*If the following properties hold at call time:*

(`ground/1`)S is currently ground (it contains no variables).

(`ground/1`)T is currently ground (it contains no variables).*then the following properties hold globally:*

(`eval/1`)sequence_or_list(S,T) is evaluable at compile-time.

REGTYPEcharacter_code/1

Usage:`character_code(T)`

T is an integer which is a character code.

*The following properties hold globally:*

(`sideff/2`)character_code(T) is side-effect free.

*If the following properties hold at call time:*

(`nonvar/1`)T is currently a term which is not a free variable.*then the following properties hold globally:*

(`eval/1`)character_code(T) is evaluable at compile-time.

*The following properties hold upon exit:*

(`character_code/1`)I is an integer which is a character code.

REGTYPEstring/1

A string is a list of character codes. The usual syntax for strings `"string"` is allowed, which is equivalent to `[0's,0't,0'r,0'i,0'n,0'g]` or `[115,116,114,105,110,103]`. There is also a special Ciao syntax when the list is not complete: `"st"||R` is equivalent to `[0's,0't|R]`.**Other properties:** `string(T)`
`string(T)`
`string(T)`

Usage:`string(T)`

T is a string (a list of character codes).

*The following properties hold globally:*

(`sideff/2`)string(T) is side-effect free.

*If the following properties hold at call time:*

(`ground/1`)T is currently ground (it contains no variables).*then the following properties hold globally:*

(`eval/1`)string(T) is evaluable at compile-time.

*The following properties hold upon exit:*

(`string/1`)T is a string (a list of character codes).

REGTYPEnum_code/1

These are the ASCII codes which can appear in decimal representation of floating point and integer numbers, including scientific notation and fractionary part.

REGTYPEpredname/1

P is a Name/Arity structure denoting a predicate name:

predname(P/A) :- atm(P), nnegint(A).

Usage:`predname(P)`

P is a predicate name.

*The following properties hold globally:*

(`sideff/2`)predname(P) is side-effect free.

*If the following properties hold at call time:*

(`ground/1`)P is currently ground (it contains no variables).*then the following properties hold globally:*

(`eval/1`)predname(P) is evaluable at compile-time.

*The following properties hold upon exit:*

(`predname/1`)P is a predicate name.

REGTYPEatm_or_atm_list/1

Usage:`atm_or_atm_list(T)`

T is an atom or a list of atoms.

*The following properties hold globally:*

(`sideff/2`)atm_or_atm_list(T) is side-effect free.

*If the following properties hold at call time:*

(`ground/1`)T is currently ground (it contains no variables).*then the following properties hold globally:*

(`eval/1`)atm_or_atm_list(T) is evaluable at compile-time.

*The following properties hold upon exit:*

(`atm_or_atm_list/1`)T is an atom or a list of atoms.

PROPERTYcompat/2

This property captures the notion of type or property compatibility. The instantiation or constraint state of the term is compatible with the given property, in the sense that assuming that imposing that property on the term does not render the store inconsistent. For example, terms `X` (i.e., a free variable), `[Y|Z]`, and `[Y,Z]` are all compatible with the regular type `list/1`, whereas the terms `f(a)` and `[1|2]` are not.*Meta-predicate* with arguments: `compat(?,pred(1))`.

**Other properties:** `compat(Term,Prop)`

Usage:`compat(Term,Prop)`

Term is *compatible* with Prop.

PROPERTYinst/2

Usage:`inst(Term,Prop)`

Term is instantiated enough to satisfy Prop.

*The following properties hold globally:*

(`sideff/2`)inst(Term,Prop) is side-effect free.

PROPERTYiso/1

Usage:`iso(G)`

*Complies with the ISO-Prolog standard.*

*The following properties hold globally:*

(`sideff/2`)iso(G) is side-effect free.

PROPERTYdeprecated/1

Specifies that the predicate marked with this global property has been deprecated, i.e., its use is not recommended any more since it will be deleted at a future date. Typically this is done because its functionality has been superseded by another predicate.*Meta-predicate* with arguments: `deprecated(goal)`.

**Other properties:** `deprecated(G)`

Usage:`deprecated(G)`

**DEPRECATED.**

*The following properties hold globally:*

(`sideff/2`)deprecated(G) is side-effect free.

PROPERTYnot_further_inst/2

Usage:`not_further_inst(G,V)`

V is not further instantiated.

*The following properties hold globally:*

(`sideff/2`)not_further_inst(G,V) is side-effect free.

(`no_rtcheck/1`)not_further_inst(G,V) is not checked during run-time checking.

PROPERTYsideff/2

Declares that G is side-effect free (if its execution has no observable result other than its success, its failure, or its abortion), soft (if its execution may have other observable results which, however, do not affect subsequent execution, e.g., input/output), or hard (e.g., assert/retract).

Usage:`sideff(G,X)`

G is side-effect X.

*If the following properties hold at call time:*

(`callable/1`)G is a term which represents a goal, i.e., an atom or a structure.

(`member/2`)X is an element of [free,soft,hard].

*The following properties hold globally:*

(`native/1`)This predicate is understood natively by CiaoPP.

(`sideff/2`)sideff(G,X) is side-effect free.

(`no_rtcheck/1`)sideff(G,X) is not checked during run-time checking.

PROPERTYregtype/1

Usage:`regtype(G)`

Defines a regular type.

*The following properties hold globally:*

(`sideff/2`)regtype(G) is side-effect free.

PROPERTYnative/1

Usage:`native(Pred)`

This predicate is understood natively by CiaoPP.

*The following properties hold globally:*

(`sideff/2`)native(P) is side-effect free.

PROPERTYnative/2

Usage:`native(Pred,Key)`

This predicate is understood natively by CiaoPP as Key.

*The following properties hold globally:*

(`sideff/2`)native(P,K) is side-effect free.

PROPERTYrtcheck/1

Usage:`rtcheck(G)`

Equivalent to rtcheck(G, complete).

*If the following properties hold at call time:*

(`callable/1`)G is a term which represents a goal, i.e., an atom or a structure.

*The following properties hold globally:*

(`sideff/2`)rtcheck(G) is side-effect free.

PROPERTYrtcheck/2

Usage:`rtcheck(G,Status)`

The runtime check of this property is Status.

*If the following properties hold at call time:*

(`callable/1`)G is a term which represents a goal, i.e., an atom or a structure.

(`rtc_status/1`)Status is the status of the runtime-check implementation for a given property. Valid values are:- complete: The implementation of the run-time check for this property is complete. i.e., an error is reported always if the property is violated. Default.
- incomplete: The current run-time check is incomplete, i.e., it is possible that no error is reported even if the property is violated.
- unimplemented: No run-time checker has been implemented (yet) for the property.
- unknown: It has not been determined yet whether the current implementation of the run-time checker is complete or not.
- impossible: The property cannot be checked at run time (for theoretical or practical reasons).

*The following properties hold globally:*

(`sideff/2`)rtcheck(G,Status) is side-effect free.

PROPERTYno_rtcheck/1

This comp pseudo-property is used to declare that the assertion in which it appears should not be checked at run-time. Equivalent to `rtcheck(G, S)` with `S` unimplemented, impossible, etc.*Meta-predicate* with arguments: `no_rtcheck(goal)`.

**Other properties:** `no_rtcheck(G)`

Usage:`no_rtcheck(G)`

G is not checked during run-time checking.

*If the following properties hold at call time:*

(`callable/1`)G is a term which represents a goal, i.e., an atom or a structure.

*The following properties hold globally:*

(`sideff/2`)no_rtcheck(G) is side-effect free.

PROPERTYeval/1

Usage:`eval(Goal)`

Goal is evaluable at compile-time.

PROPERTYequiv/2

Usage:`equiv(Goal1,Goal2)`

Goal1 is equivalent to Goal2.

PROPERTYbind_ins/1

Usage:`bind_ins(Goal)`

Goal is binding insensitive.

PROPERTYerror_free/1

Usage:`error_free(Goal)`

Goal is error free.

PROPERTYmemo/1

Usage:`memo(Goal)`

Goal should be memoized (not unfolded).

PROPERTYfilter/2

Usage:`filter(Vars,Goal)`

Vars should be filtered during global control).

REGTYPEflag_values/1

Usage:`flag_values(X)`

Define the valid flag values

PROPERTYpe_type/1

Usage:`pe_type(Goal)`

Goal will be filtered in partial evaluation time according to the PE types defined in the assertion.

*System library modules:*`native_props`,`terms_check`.*Internal (engine) modules:*`term_basic`,`arithmetic`,`atomic_basic`,`basiccontrol`,`exceptions`,`term_compare`,`term_typing`,`debugger_support`,`hiord_rt`.*Packages:*`prelude`,`initial`,`condcomp`,`assertions`,`assertions/assertions_basic`,`nortchecks`,`nativeprops`.

Generated with LPdoc using Ciao