Basic data types and properties

Author(s): Daniel Cabeza, Manuel Hermenegildo.

Version: 1.11#222 (2004/5/24, 13:8:7 CEST)

Version of last change: 1.11#166 (2004/2/3, 21:12:16 CET)

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 (basic_props)
• Documentation on exports (basic_props)

Usage and interface (basic_props)

Documentation on exports (basic_props)

REGTYPE: term/1:

The most general type (includes all possible terms).

General properties: term(X)

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

Usage: term(X)

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

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.

General properties: int(T)

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

Usage: int(T)

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

REGTYPE: nnegint/1:

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

General properties: nnegint(T)

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

Usage: nnegint(T)

• Description: T is a non-negative integer.
• The following properties hold globally: This predicate is understood natively by CiaoPP. (basic_props:native/1)

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

General properties: flt(T)

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

Usage: flt(T)

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

REGTYPE: num/1:

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

General properties: num(T)

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

Usage: num(T)

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

REGTYPE: atm/1:

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

General properties: atm(T)

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

Usage: atm(T)

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

REGTYPE: struct/1:

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

General properties: struct(T)

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

Usage: struct(T)

• Description: T is a compound term.
• The following properties hold globally: This predicate is understood natively by CiaoPP. (basic_props:native/1)

REGTYPE: gnd/1:

The type of all terms without variables.

General properties: gnd(T)

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

Usage: gnd(T)

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

REGTYPE: constant/1:

General properties: constant(T)

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

Usage: constant(T)

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

REGTYPE: callable/1:

General properties: callable(T)

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

Usage: callable(T)

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

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.

General properties: operator_specifier(X)

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

Usage: operator_specifier(X)

• Description: X 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).

General properties: list(L)

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

Usage: list(L)

• Description: L is a list.

REGTYPE: list/2:

list(L, T)

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

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

General properties: list(L, T)

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

Usage: list(L, T)

• Description: L is a list of Ts.

PROPERTY: member/2:

General properties: member(X, L)

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

Usage: member(X, L)

• Description: X is an element of L.

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.

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

General properties: sequence(S, T)

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

Usage: sequence(S, T)

• Description: S is a sequence of Ts.

REGTYPE: sequence_or_list/2:

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

General properties: sequence_or_list(S, T)

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

Usage: sequence_or_list(S, T)

• Description: S is a sequence or list of Ts.

REGTYPE: character_code/1:

General properties: character_code(T)

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

character_code(T)

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

Usage: character_code(T)

• Description: T 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].

General properties: string(T)

• The following properties hold upon exit: T is a list of character_codes. (basic_props:list/2)

string(T)

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

Usage: string(T)

• Description: T is a string (a list of character codes).

REGTYPE: predname/1:

General properties: predname(P)

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

Usage: predname(P)

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

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

REGTYPE: atm_or_atm_list/1:

General properties: atm_or_atm_list(T)

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

Usage: atm_or_atm_list(T)

• Description: 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.

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

General properties: compat(Term, Prop)

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

Usage: compat(Term, Prop)

• Description: Term is compatible with Prop

PROPERTY: iso/1:

General properties: iso(G)

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

Usage: iso(G)

• Description: Complies with the ISO-Prolog standard.

PROPERTY: not_further_inst/2:

General properties: not_further_inst(G, V)

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

Usage: not_further_inst(G, V)

• Description: V is not further instantiated.

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

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

General properties: sideff(G, X)

• The following properties hold globally: This predicate is understood natively by CiaoPP. (basic_props:native/1) sideff(G,X) is side-effect free. (basic_props:sideff/2)

Usage: sideff(G, X)

• Description: G is side-effect X.
• If the following properties should hold at call time: X is an element of [free,soft,hard]. (basic_props:member/2)

PROPERTY: regtype/1:

Meta-predicate with arguments: regtype(goal).

General properties: regtype(G)

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

Usage: regtype(G)

• Description: Defines a regular type.

PROPERTY: native/1:

Meta-predicate with arguments: native(goal).

General properties: native(P)

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

Usage: native(Pred)

• Description: This predicate is understood natively by CiaoPP.

PROPERTY: native/2:

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

General properties: native(P, K)

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

Usage: native(Pred, Key)

• Description: This predicate is understood natively by CiaoPP as Key.

PROPERTY: eval/1:

A property, defined as follows:

Go to the first, previous, next, last section, table of contents.