Basic data types and properties

Author(s): Daniel Cabeza, Manuel Hermenegildo.

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 can be used both as type testing builtins within programs (by calling them explicitly) and as properties in assertions.

Usage and interface

Library usage:
These predicates are builtin in Ciao, so nothing special has to be done to use them.
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, 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.
Imports:
- System library modules:
  assertions/native_props, terms_check.
- Packages:
  prelude, nonpure, assertions, nortchecks, nativeprops.

Documentation on exports

REGTYPE

term/1:

The most general type (includes all possible terms).

(True) Usage:term(X)

X is any term.

The following properties hold globally:
(basic_props:native/1)This predicate is understood natively by CiaoPP.

General properties:

True:term(X)

The following properties hold globally:
(basic_props:sideff/2)term(X) is side-effect free.

True:term(X)

The following properties hold globally:
(basic_props:eval/1)term(X) is evaluable at compile-time.

True:term(X)

The following properties hold globally:
(basic_props:equiv/2)term(X) is equivalent to true.

REGTYPE

int/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.

(True) Usage:int(T)

T is an integer.

The following properties hold globally:
(basic_props:native/1)This predicate is understood natively by CiaoPP.

General properties:

True:int(T)

The following properties hold globally:
(basic_props:sideff/2)int(T) is side-effect free.

True:int(T)

If the following properties hold at call time:
(term_typing:nonvar/1)T is currently a term which is not a free variable.
then the following properties hold globally:
(basic_props:eval/1)int(T) is evaluable at compile-time.
(native_props:is_det/1)All calls of the form int(T) are deterministic.

Trust:int(T)

The following properties hold upon exit:
(basic_props:int/1)T is an integer.

Trust:

The following properties hold globally:
(native_props:test_type/2)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPE

nnegint/1:

The type of non-negative integers, i.e., natural numbers.

(True) Usage:nnegint(T)

T is a non-negative integer.

The following properties hold globally:
(basic_props:native/1)This predicate is understood natively by CiaoPP.

General properties:

True:nnegint(T)

The following properties hold globally:
(basic_props:sideff/2)nnegint(T) is side-effect free.

True:nnegint(T)

If the following properties hold at call time:
(term_typing:nonvar/1)T is currently a term which is not a free variable.
then the following properties hold globally:
(basic_props:eval/1)nnegint(T) is evaluable at compile-time.

Trust:nnegint(T)

The following properties hold upon exit:
(basic_props:nnegint/1)T is a non-negative integer.

Trust:

The following properties hold globally:
(native_props:test_type/2)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPE

flt/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

(True) Usage:flt(T)

T is a float.

The following properties hold globally:
(basic_props:native/1)This predicate is understood natively by CiaoPP.

General properties:

True:flt(T)

The following properties hold globally:
(basic_props:sideff/2)flt(T) is side-effect free.

True:flt(T)

If the following properties hold at call time:
(term_typing:nonvar/1)T is currently a term which is not a free variable.
then the following properties hold globally:
(basic_props:eval/1)flt(T) is evaluable at compile-time.
(native_props:is_det/1)All calls of the form flt(T) are deterministic.

Trust:flt(T)

The following properties hold upon exit:
(basic_props:flt/1)T is a float.

Trust:

The following properties hold globally:
(native_props:test_type/2)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPE

num/1:

The type of numbers, that is, integer or floating-point.

(True) Usage:num(T)

T is a number.

The following properties hold globally:
(basic_props:native/1)This predicate is understood natively by CiaoPP.

General properties:

True:num(T)

The following properties hold globally:
(basic_props:sideff/2)num(T) is side-effect free.
(basic_props:bind_ins/1)num(T) is binding insensitive.

True:num(T)

If the following properties hold at call time:
(term_typing:nonvar/1)T is currently a term which is not a free variable.
then the following properties hold globally:
(basic_props:eval/1)num(T) is evaluable at compile-time.
(native_props:is_det/1)All calls of the form num(T) are deterministic.

Trust:num(T)

The following properties hold upon exit:
(basic_props:num/1)T is a number.

Trust:

The following properties hold globally:
(native_props:test_type/2)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPE

atm/1:

The type of atoms, or non-numeric constants. The size of atoms is unbound.

(True) Usage:atm(T)

T is an atom.

The following properties hold globally:
(basic_props:native/1)This predicate is understood natively by CiaoPP.

General properties:

True:atm(T)

The following properties hold globally:
(basic_props:sideff/2)atm(T) is side-effect free.

True:atm(T)

If the following properties hold at call time:
(term_typing:nonvar/1)T is currently a term which is not a free variable.
then the following properties hold globally:
(basic_props:eval/1)atm(T) is evaluable at compile-time.
(native_props:is_det/1)All calls of the form atm(T) are deterministic.

Trust:atm(T)

The following properties hold upon exit:
(basic_props:atm/1)T is an atom.

Trust:

The following properties hold globally:
(native_props:test_type/2)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPE

struct/1:

The type of compound terms, or terms with non-zeroary functors. By now there is a limit of 255 arguments.

(True) Usage:struct(T)

T is a compound term.

The following properties hold globally:
(basic_props:native/1)This predicate is understood natively by CiaoPP.

General properties:

True:struct(T)

The following properties hold globally:
(basic_props:sideff/2)struct(T) is side-effect free.

True:struct(T)

If the following properties hold at call time:
(term_typing:nonvar/1)T is currently a term which is not a free variable.
then the following properties hold globally:
(basic_props:eval/1)struct(T) is evaluable at compile-time.

Trust:struct(T)

The following properties hold upon exit:
(basic_props:struct/1)T is a compound term.

REGTYPE

gnd/1:

The type of all terms without variables.

(True) Usage:gnd(T)

T is ground.

The following properties hold globally:
(basic_props:native/1)This predicate is understood natively by CiaoPP.

General properties:

True:gnd(T)

The following properties hold globally:
(basic_props:sideff/2)gnd(T) is side-effect free.

True:gnd(T)

If the following properties hold at call time:
(term_typing:ground/1)T is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)gnd(T) is evaluable at compile-time.
(native_props:is_det/1)All calls of the form gnd(T) are deterministic.

Trust:gnd(T)

The following properties hold upon exit:
(basic_props:gnd/1)T is ground.

Trust:

The following properties hold globally:
(native_props:test_type/2)Indicates the type of test that a predicate performs. Required by the nonfailure analyisis.

REGTYPE

gndstr/1:

(True) Usage:gndstr(T)

T is a ground compound term.

The following properties hold globally:
(basic_props:native/1)This predicate is understood natively by CiaoPP.

General properties:

True:gndstr(T)

The following properties hold globally:
(basic_props:sideff/2)gndstr(T) is side-effect free.

True:gndstr(T)

If the following properties hold at call time:
(term_typing:ground/1)T is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)gndstr(T) is evaluable at compile-time.
(native_props:is_det/1)All calls of the form gndstr(T) are deterministic.

Trust:gndstr(T)

The following properties hold upon exit:
(basic_props:gndstr/1)T is a ground compound term.

REGTYPE

constant/1:

(True) Usage:constant(T)

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

General properties:

True:constant(T)

The following properties hold globally:
(basic_props:sideff/2)constant(T) is side-effect free.

True:constant(T)

If the following properties hold at call time:
(term_typing:nonvar/1)T is currently a term which is not a free variable.
then the following properties hold globally:
(basic_props:eval/1)constant(T) is evaluable at compile-time.
(native_props:is_det/1)All calls of the form constant(T) are deterministic.

Trust:constant(T)

The following properties hold upon exit:
(basic_props:constant/1)T is an atomic term (an atom or a number).

REGTYPE

callable/1:

(True) Usage:callable(T)

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

General properties:

True:callable(T)

The following properties hold globally:
(basic_props:sideff/2)callable(T) is side-effect free.

True:callable(T)

If the following properties hold at call time:
(term_typing:nonvar/1)T is currently a term which is not a free variable.
then the following properties hold globally:
(basic_props:eval/1)callable(T) is evaluable at compile-time.
(native_props:is_det/1)All calls of the form callable(T) are deterministic.

Trust:callable(T)

The following properties hold upon exit:
(term_typing:nonvar/1)T is currently a term which is not a free variable.

REGTYPE

operator_specifier/1:

The type and associativity of an operator is described by the following mnemonic atoms:

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.

(True) Usage:operator_specifier(X)

X specifies the type and associativity of an operator.

General properties:

True:operator_specifier(X)

The following properties hold globally:
(basic_props:sideff/2)operator_specifier(X) is side-effect free.

True:operator_specifier(X)

If the following properties hold at call time:
(term_typing:nonvar/1)X is currently a term which is not a free variable.
then the following properties hold globally:
(basic_props:eval/1)operator_specifier(X) is evaluable at compile-time.
(native_props:is_det/1)All calls of the form operator_specifier(X) are deterministic.
(native_props:relations/2)Goal operator_specifier(X) produces 7 solutions.

Trust:operator_specifier(T)

The following properties hold upon exit:
(basic_props:operator_specifier/1)T specifies the type and associativity of an operator.

REGTYPE

list/1:

A list is formed with successive applications of the functor '.'/2, and its end is the atom []. Defined as

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

(True) Usage:list(L)

L is a list.

General properties:

True:list(L)

The following properties hold globally:
(basic_props:sideff/2)list(L) is side-effect free.

True:list(L)

If the following properties hold at call time:
(term_typing:ground/1)L is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)list(L) is evaluable at compile-time.
(native_props:is_det/1)All calls of the form list(L) are deterministic.

Trust:list(T)

The following properties hold upon exit:
(basic_props:list/1)T is a list.

REGTYPE

list/2:

list(L,T)

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

(True) Usage:list(L,T)

L is a list of Ts.

Meta-predicate with arguments: list(?,(pred 1)).
General properties:

True:list(L,T)

The following properties hold globally:
(basic_props:sideff/2)list(L,T) is side-effect free.

True:list(L,T)

If the following properties hold at call time:
(term_typing:ground/1)L is currently ground (it contains no variables).
(term_typing:ground/1)T is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)list(L,T) is evaluable at compile-time.

Trust:list(X,T)

The following properties hold upon exit:
(basic_props:list/1)X is a list.

REGTYPE

nlist/2:

(True) 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

Meta-predicate with arguments: nlist(?,(pred 1)).
General properties:

True:nlist(L,T)

The following properties hold globally:
(basic_props:sideff/2)nlist(L,T) is side-effect free.

True:nlist(L,T)

If the following properties hold at call time:
(term_typing:ground/1)L is currently ground (it contains no variables).
(term_typing:ground/1)T is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)nlist(L,T) is evaluable at compile-time.

Trust:nlist(X,T)

The following properties hold upon exit:
(basic_props:term/1)X is any term.

PROPERTY

member/2:

(True) Usage:member(X,L)

X is an element of L.

General properties:

True:member(X,L)

The following properties hold globally:
(basic_props:sideff/2)member(X,L) is side-effect free.
(basic_props:bind_ins/1)member(X,L) is binding insensitive.

True:member(X,L)

If the following properties hold at call time:
(basic_props:list/1)L is a list.
then the following properties hold globally:
(basic_props:eval/1)member(X,L) is evaluable at compile-time.

Trust:member(_X,L)

The following properties hold upon exit:
(basic_props:list/1)L is a list.

Trust:member(X,L)

If the following properties hold at call time:
(term_typing:ground/1)L is currently ground (it contains no variables).
then the following properties hold upon exit:
(term_typing:ground/1)X is currently ground (it contains no variables).

REGTYPE

sequence/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.

(True) Usage:sequence(S,T)

S is a sequence of Ts.

Meta-predicate with arguments: sequence(?,(pred 1)).
General properties:

True:sequence(S,T)

The following properties hold globally:
(basic_props:sideff/2)sequence(S,T) is side-effect free.

True:sequence(S,T)

If the following properties hold at call time:
(term_typing:ground/1)S is currently ground (it contains no variables).
(term_typing:ground/1)T is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)sequence(S,T) is evaluable at compile-time.

Trust:sequence(E,T)

The following properties hold upon exit:
(term_typing:nonvar/1)E is currently a term which is not a free variable.
(term_typing:ground/1)T is currently ground (it contains no variables).

REGTYPE

sequence_or_list/2:

(True) Usage:sequence_or_list(S,T)

S is a sequence or list of Ts.

Meta-predicate with arguments: sequence_or_list(?,(pred 1)).
General properties:

True:sequence_or_list(S,T)

The following properties hold globally:
(basic_props:sideff/2)sequence_or_list(S,T) is side-effect free.

True:sequence_or_list(S,T)

If the following properties hold at call time:
(term_typing:ground/1)S is currently ground (it contains no variables).
(term_typing:ground/1)T is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)sequence_or_list(S,T) is evaluable at compile-time.

Trust:sequence_or_list(E,T)

The following properties hold upon exit:
(term_typing:nonvar/1)E is currently a term which is not a free variable.
(term_typing:ground/1)T is currently ground (it contains no variables).

REGTYPE

character_code/1:

(True) Usage:character_code(T)

T is an integer which is a character code.

General properties:

True:character_code(T)

The following properties hold globally:
(basic_props:sideff/2)character_code(T) is side-effect free.

True:character_code(T)

If the following properties hold at call time:
(term_typing:nonvar/1)T is currently a term which is not a free variable.
then the following properties hold globally:
(basic_props:eval/1)character_code(T) is evaluable at compile-time.

Trust:character_code(I)

The following properties hold upon exit:
(basic_props:character_code/1)I is an integer which is a character code.

REGTYPE

string/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].

(True) Usage:string(T)

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

General properties:

True:string(T)

The following properties hold globally:
(basic_props:sideff/2)string(T) is side-effect free.

True:string(T)

If the following properties hold at call time:
(term_typing:ground/1)T is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)string(T) is evaluable at compile-time.

Trust:string(T)

The following properties hold upon exit:
(basic_props:string/1)T is a string (a list of character codes).

REGTYPE

num_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.

REGTYPE

predname/1:

(True) Usage:predname(P)

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

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

General properties:

True:predname(P)

The following properties hold globally:
(basic_props:sideff/2)predname(P) is side-effect free.

True:predname(P)

If the following properties hold at call time:
(term_typing:ground/1)P is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)predname(P) is evaluable at compile-time.

Trust:predname(P)

The following properties hold upon exit:
(basic_props:predname/1)
P is a Name/Arity structure denoting a predicate name:
```
predname(P/A) :-
        atm(P),
        nnegint(A).
```

REGTYPE

atm_or_atm_list/1:

(True) Usage:atm_or_atm_list(T)

T is an atom or a list of atoms.

General properties:

True:atm_or_atm_list(T)

The following properties hold globally:
(basic_props:sideff/2)atm_or_atm_list(T) is side-effect free.

True:atm_or_atm_list(T)

If the following properties hold at call time:
(term_typing:ground/1)T is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)atm_or_atm_list(T) is evaluable at compile-time.

Trust:atm_or_atm_list(T)

The following properties hold upon exit:
(basic_props:atm_or_atm_list/1)T is an atom or a list of atoms.

PROPERTY

compat/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.

(True) Usage:compat(Term,Prop)

Term is compatible with Prop

Meta-predicate with arguments: compat(?,(pred 1)).
General properties:

True:compat(Term,Prop)

If the following properties hold at call time:
(term_typing:ground/1)Term is currently ground (it contains no variables).
(term_typing:ground/1)Prop is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)compat(Term,Prop) is evaluable at compile-time.

PROPERTY

inst/2:

(True) Usage:inst(Term,Prop)

Term is instantiated enough to satisfy Prop.

Meta-predicate with arguments: inst(?,(pred 1)).
General properties:

True:inst(Term,Prop)

The following properties hold globally:
(basic_props:sideff/2)inst(Term,Prop) is side-effect free.

True:inst(Term,Prop)

If the following properties hold at call time:
(term_typing:ground/1)Term is currently ground (it contains no variables).
(term_typing:ground/1)Prop is currently ground (it contains no variables).
then the following properties hold globally:
(basic_props:eval/1)inst(Term,Prop) is evaluable at compile-time.

PROPERTY

iso/1:

(True) Usage:iso(G)

Complies with the ISO-Prolog standard.

Meta-predicate with arguments: iso(goal).
General properties:

True:iso(G)

The following properties hold globally:
(basic_props:sideff/2)iso(G) is side-effect free.

PROPERTY

deprecated/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.

(True) Usage:deprecated(G)

DEPRECATED.

Meta-predicate with arguments: deprecated(goal).
General properties:

True:deprecated(G)

The following properties hold globally:
(basic_props:sideff/2)deprecated(G) is side-effect free.

PROPERTY

not_further_inst/2:

(True) Usage:not_further_inst(G,V)

V is not further instantiated.

Meta-predicate with arguments: not_further_inst(goal,?).
General properties:

True:not_further_inst(G,V)

The following properties hold globally:
(basic_props:sideff/2)not_further_inst(G,V) is side-effect free.
(basic_props:no_rtcheck/1)Declares that the assertion in which this comp property appears must not be checked at run-time. Equivalent to rtcheck(G, impossible).

PROPERTY

sideff/2:

sideff(G,X)

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).

(True) Usage:sideff(G,X)

G is side-effect X.

If the following properties hold at call time:
(basic_props:callable/1)G is a term which represents a goal, i.e., an atom or a structure.
(basic_props:member/2)X is an element of [free,soft,hard].

Meta-predicate with arguments: sideff(goal,?).
General properties:

True:sideff(G,X)

The following properties hold globally:
(basic_props:native/1)This predicate is understood natively by CiaoPP.
(basic_props:sideff/2)sideff(G,X) is side-effect free.
(basic_props:no_rtcheck/1)Declares that the assertion in which this comp property appears must not be checked at run-time. Equivalent to rtcheck(G, impossible).

PROPERTY

regtype/1:

(True) Usage:regtype G

Defines a regular type.

Meta-predicate with arguments: regtype goal.
General properties:

True:regtype G

The following properties hold globally:
(basic_props:sideff/2)regtype G is side-effect free.

PROPERTY

native/1:

(True) Usage:native(Pred)

This predicate is understood natively by CiaoPP.

Meta-predicate with arguments: native(goal).
General properties:

True:native(P)

The following properties hold globally:
(basic_props:sideff/2)native(P) is side-effect free.

PROPERTY

native/2:

(True) Usage:native(Pred,Key)

This predicate is understood natively by CiaoPP as Key.

Meta-predicate with arguments: native(goal,?).
General properties:

True:native(P,K)

The following properties hold globally:
(basic_props:sideff/2)native(P,K) is side-effect free.

PROPERTY

rtcheck/1:

(True) Usage:rtcheck(G)

Equivalent to rtcheck(G, complete).

If the following properties hold at call time:
(basic_props:callable/1)G is a term which represents a goal, i.e., an atom or a structure.

Meta-predicate with arguments: rtcheck(goal).
General properties:

True:rtcheck(G)

The following properties hold globally:
(basic_props:sideff/2)rtcheck(G) is side-effect free.

PROPERTY

rtcheck/2:

(True) Usage:rtcheck(G,Status)

The runtime check of the property have the status Status.

If the following properties hold at call time:
(basic_props:callable/1)G is a term which represents a goal, i.e., an atom or a structure.
(basic_props:rtc_status/1)
Status of the runtime-check implementation for a given property. Valid values are:
- unimplemented: No run-time checker has been implemented for the property. Althought it can be implemented further.
- incomplete: The current run-time checker is incomplete, which means, under certain circunstances, no error is reported if the property is violated.
- unknown: We do not know if current implementation of run-time checker is complete or not.
- complete: The opposite of incomplete, error is reported always that the property is violated. Default.
- impossible: The property must not be run-time checked (for theoretical or practical reasons).

Meta-predicate with arguments: rtcheck(goal,?).
General properties:

True:rtcheck(G,Status)

The following properties hold globally:
(basic_props:sideff/2)rtcheck(G,Status) is side-effect free.

PROPERTY

no_rtcheck/1:

(True) Usage:no_rtcheck(G)

Declares that the assertion in which this comp property appears must not be checked at run-time. Equivalent to rtcheck(G, impossible).

If the following properties hold at call time:
(basic_props:callable/1)G is a term which represents a goal, i.e., an atom or a structure.

Meta-predicate with arguments: no_rtcheck(goal).
General properties:

True:no_rtcheck(G)

The following properties hold globally:
(basic_props:sideff/2)no_rtcheck(G) is side-effect free.

PROPERTY

eval/1:

(True) Usage:eval(Goal)

Goal is evaluable at compile-time.

Meta-predicate with arguments: eval(goal).

PROPERTY

equiv/2:

(True) Usage:equiv(Goal1,Goal2)

Goal1 is equivalent to Goal2.

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

PROPERTY

bind_ins/1:

(True) Usage:bind_ins(Goal)

Goal is binding insensitive.

Meta-predicate with arguments: bind_ins(goal).

PROPERTY

error_free/1:

(True) Usage:error_free(Goal)

Goal is error free.

Meta-predicate with arguments: error_free(goal).

PROPERTY

memo/1:

(True) Usage:memo(Goal)

Goal should be memoized (not unfolded).

Meta-predicate with arguments: memo(goal).

PROPERTY

filter/2:

(True) Usage:filter(Vars,Goal)

Vars should be filtered during global control).

REGTYPE

flag_values/1:

(True) Usage:flag_values(X)

Define the valid flag values

PROPERTY

pe_type/1:

(True) Usage:pe_type(Goal)

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

Meta-predicate with arguments: pe_type(goal).

Known bugs and planned improvements

Run-time checks have been reported not to work with this code. That means that either the assertions here, or the code that implements the run-time checks are erroneous.

Basic data types and properties

Usage and interface

Documentation on exports

Known bugs and planned improvements

Module Sections

Global Links

Indices