Home Contents Index Summary Previous Next

C Glossary of Terms

anonymous [variable]
The variable _ is called the anonymous variable. Multiple occurrences of _ in a single term are not shared.

arguments
Arguments are terms that appear in a compound term. A1 and a2 are the first and second argument of the term myterm(A1, a2).

arity
Argument count (is number of arguments) of a compound term.

assert
Add a clause to a predicate. Clauses can be added at either end of the clause-list of a predicate. See assert/1 and assertz/1.

atom
Textual constant. Used as name for compound terms, to represent constants or text.

backtracking
Searching process used by Prolog. If a predicate offers multiple clauses to solve a goal, they are tried one-by-one until one succeeds. If a subsequent part of the prove is not satisfied with the resulting variable binding, it may ask for an alternative solution (= binding of the variables), causing Prolog to reject the previously chosen clause and try the next one.

binding [of a variable]
Current value of the variable. See also backtracking and query.

built-in [predicate]
Predicate that is part of the Prolog system. Built in predicates cannot be redefined by the user, unless this is overruled using redefine_system_predicate/1.

body
Part of a clause behind the neck operator (:-).

clause
`Sentence' of a Prolog program. A clause consists of a head and body separated by the neck operator (:-) or it is a fact. For example:


parent(X) :-
        father(X, _).

Expressed ``X is a parent if X is a father of someone''. See also variable and predicate.

compile
Process where a Prolog program is translated to a sequence of instructions. See also interpreted. SWI-Prolog always compiles your program before executing it.

compound [term]
Also called structure. It consists of a name followed by N arguments, each of which are terms. N is called the arity of the term.

context module
If a term is referring to a predicate in a module, the context module is used to find the target module. The context module of a goal is the module in which the predicate is defined, unless this predicate is module transparent, in which case the context module is inherited from the parent goal. See also module_transparent/1.

dynamic [predicate]
A dynamic predicate is a predicate to which clauses may be asserted and from which clauses may be retracted while the program is running. See also update view.

exported [predicate]
A predicate is said to be exported from a module if it appears in the public list. This implies that the predicate can be imported into another module to make it visible there. See also use_module/[1,2].

fact
Clause without a body. This is called a fact because interpreted as logic, there is no condition to be satisfied. The example below states john is a person.


person(john).

fail
A goal is said to haved failed if it could not be proven.

float
Computers cripled representation of a real number. Represented as `IEEE double'.

foreign
Computer code expressed in other languages than Prolog. SWI-Prolog can only cooperate directly with the C and C++ computer languages.

functor
Combination of name and arity of a compound term. The term foo(a, b, c) is said to be a term belonging to the functor foo/3. foo/0 is used to refer to the atom foo.

goal
Question stated to the Prolog engine. A goal is either an atom or a compound term. A goal succeeds, in which case the variables in the compound terms have a binding or fails if Prolog fails to prove the goal.

hashing
Indexing technique used for quick lookup.

head
Part of a clause before the neck instruction. This is an atom or compound term.

imported [predicate]
A predicate is said to be imported into a module if it is defined in another module and made available in this module. See also chapter 5.

indexing
Indexing is a technique used to quickly select candidate clauses of a predicate for a specific goal. In most Prolog systems, including SWI-Prolog, indexing is done on the first argument of the head. If this argument is instantiated to an atom, integer, float or compound term with functor, hashing is used quickly select all clauses of which the first argument may unify with the first argument of the goal.

integer
Whole number. On most current machines, SWI-Prolog integers are represented as `32-bit signed values', ranging from -2147483648 to 2147483647. See also current_prolog_flag/2.

interpreted
As opposed to compiled, interpreted means the Prolog system attempts to prove a goal by directly reading the clauses rather than executing instructions from an (abstract) instruction set that is not or only indirectly related to Prolog.

meta predicate
A predicate that reasons about other predicates, either by calling them, (re)defining them or querying properties.

module
Collection of predicates. Each module defines a name-space for predicates. built-in predicates are accessible from all modules. Predicates can be published (exported) and imported to make their definition available to other modules.

module transparent [predicate]
A predicate that does not change the context module. Sometimes also called a meta predicate.

multifile [predicate]
Predicate for which the definition is distributed over multiple source-files. See multi_file/1.

neck
Operator (:-) separating head from body in a clause.

operator
Symbol (atom) that may be placed before its operant (prefix), after its operant (postfix) or between its two operants (infix).

In Prolog, the expression a+b is exactly the same as the canonical term +(a,b).

operant
Argument of an operator.

precedence
The priority of an operator. Operator precedence is used to interpret a+b*c as +(a, *(b,c)).

predicate
Collection of clauses with the same functor (name/arity). If a goal is proved, the system looks for a predicate with the same functor, then used indexing to select candidate clauses and then tries these clauses one-by-one. See also backtracking.

priority
In the context of operators a synonym for precedence.

program
Collection of predicates.

property
Attribute of an object. SWI-Prolog defines various *_property predicates to query the status of predicates, clauses. etc.

prove
Process where Prolog attempts to prove a query using the available predicates.

public list
List of predicates exported from a module.

query
See goal.

retract
Remove a clause from a predicate. See also dynamic, update view and assert.

shared
Two variables are called shared after they are unified. This implies if either of them is bound, the other is bound to the same value:


?- A = B, A = a.

A = a,
B = a

singleton [variable]
Variable appearing only one time in a clause. SWI-Prolog normally warns for this to avoid you making spelling mistakes. If a variable appears on purpose only once in a clause, write it as _ (see anonymous) or make sure the first character is a _. See also the style_check/1 option singletons.

solution
Bindings resulting from a successfully proven goal.

structure
Synonym for compound term.

string
Used for the following representations of text: a packed array (see section 4.23, SWI-Prolog specific), a list of character codes or a list of one-character atoms.

succeed
A goal is said to have succeeded if it has been proven.

term
Value in Prolog. A term is either a variable, atom, integer, float or compound term. In addition, SWI-Prolog also defines the type string

transparent
See module transparent.

unify
Prolog process to make two terms equal by assigning variables in one term to values at the corresponding location of the other term. For example:


?- foo(a, B) = foo(A, b).

A = a,
B = b

Unlike assignment (which does not exist in Prolog), unification is not directed.

update view
How Prolog behaves when a dynamic predicate is changed while it is running. There are two models. In most older Prolog systems the change becomes immediately visible to the goal, in modern systems including SWI-Prolog, the running goal is not affected. Only new goals `see' the new definition.

variable
A Prolog variable is a value that `is not yet bound'. After binding a variable, it cannot be modified. Backtracking to a point in the execution before the variable was bound will turn it back into a variable:


?- A = b, A = c.
No
?- (A = b; true; A = c).
A = b ;
A = _G283 ;
A = c ;
No

See also unify.