2 Glossary


To abolish a predicate is to retract all the predicate’s clauses and to remove all information about it from the Prolog system, to make it as if that predicate had never existed.


A special case of breakpoint, the advice breakpoint. It is distinguished from spypoints in that it is intended for non-interactive debugging, such as checking of program invariants, collecting information, profiling, etc.


An alphanumeric character is any of the lowercase characters from ‘a’ to ‘z’, the uppercase characters from ‘A’ to ‘Z’, the numerals from ‘0’ to ‘9’, or underscore (‘_’).


An ancestor of a goal is any goal that the system is trying to solve when it calls that goal. The most distant ancestor is the goal that was typed at the top-level prompt.

anonymous variable

An anonymous variable is one that has no unique name, and whose value is therefore inaccessible. An anonymous variable is denoted by an underscore (‘_’).


See predicate, structure, and arity.


The arity of a structure is its number of arguments. For example, the structure customer(jones,85) has an arity of 2.


A character sequence used to uniquely denote some entity in the problem domain. A number is not an atom. Examples of legal atoms are:

hello   *   :=   '#$%'   'New York'   'don\'t'

See ref-syn-trm-ato. Atoms are recognized by the built-in predicate atom/1. Each Prolog atom is represented internally by a unique integer, represented in C as an SP_atom.

atomic term

Synonym for constant.


A collection of information on the control flow of the program, gathered by the debugger. Also the display of this information produced by the debugger. The backtrace includes data on goals that were called but not exited and also on goals that exited nondeterminately.


The process of reviewing the goals that have been satisfied and attempting to resatisfy these goals by finding alternative solutions.


The process of assigning a value to a variable; used in unification.

blocked goal

A goal that is suspended because it is not instantiated enough.


The body of a clause consists of the part of a Prolog clause following the ‘:-’ symbol.


A description of certain invocations in the program where the user wants the debugger to stop, or to perform some other actions. A breakpoint is specific if it applies to the calls of a specific predicate, possibly under some conditions; otherwise, it is generic. Depending on the intended usage, breakpoints can be classified as debugger breakpoints, also known as spypoints, or advice breakpoints, also called advice-points; see Advanced Debugging.

breakpoint spec

A term describing a breakpoint. Composed of a test part, specifying the conditions under which the breakpoint should be applied, and an action part, specifying the effects of the breakpoint on the execution.


A byte-list is a list of bytes, i.e. integers in [0,…,255].


A temporary workspace in Emacs that contains a file being edited.

built-in predicate

A predicate that comes with the system and that does not have to be explicitly loaded before it is used.

callable term

A callable term is either a compound term or an atom. Callable terms are recognized by the built-in predicate callable/1.

character code

An integer that is the numeric representation of a character in the character code set.

character code set

A subset of the set {0, …, 2^31-1} that can be handled in input/output. SICStus Prolog fixes the character code set to a superset of Unicode, which includes the ASCII code set, i.e. codes 0..127, and these codes are interpreted as ASCII characters

character-conversion mapping

SICStus Prolog maintains a character-conversion mapping, which is used while reading terms and programs. Initially, the mapping prescribes no character conversions. It can be modified by the built-in predicate char_conversion(In, Out), following which In will be converted to Out. Character coversion can be switched off by the char_conversion Prolog flag.

Please note: the mapping is global, as opposed to being local to the current module, Prolog text, or otherwise.

character-type mapping

A function mapping each element of the character code set to one of the character categories (whitespace, letter, symbol-char, etc.), required for parsing tokens.


A memory block representing outstanding choices for some goals or disjunctions.


A fact or a rule. A rule comprises a head and a body. A fact consists of a head only, and is equivalent to a rule with the body true.


A code-list is a list of character codes.

conditional compilation

Conditionally including or excluding parts of a file at compile time.


Virtual code representation of compiled code. A reasonable compromise between performance and space requirement. A valid value for the compiling Prolog flag.


To load a program (or a portion thereof) into Prolog through the compiler. Compiled code runs more quickly than interpreted code, and provides better precision for execution profiling and coverage analysis. On the other hand, you cannot debug compiled code in as much detail as interpreted code.

compound term

A compound term is a term that is an atom together with one or more arguments. For example, in the term father(X), father is the name, and X is the first and only argument. The argument to a compound term can be another compound term, as in father(father(X)). Compound terms are recognized by the built-in predicate compound/1.


A series of goals connected by the connective “and” (that is, a series of goals whose principal operator is ‘,’).

console-based executable

An executable that inherits the standard streams from the process that invoked it, e.g. a UNIX shell or a DOS-prompt.


An integer (for example: 1, 20, -10), a floating-point number (for example: 12.35), or an atom. Constants are recognized by the built-in predicate atomic/1.


To load a program (or a portion thereof) into Prolog through the interpreter. Interpreted code runs more slowly than compiled code, and does not provide as good precision for execution profiling and coverage analysis. On the other hand, you can debug interpreted code in more detail than compiled code.

control structure

A built-in predicate that is “part of the language” in the sense that it is treated specially in certain language features. The set of such control structures and language features is enuemrated in ref-sem-ctr.


What the debugger does in trace mode, also known as single-stepping. It goes to the next port of a procedure box and prints the goal, then prompts you for input. See Basic Debug.


The point on the screen at which typed characters appear. This is usually highlighted by a line or rectangle the size of one space, which may or may not blink.


Written as !. A built-in predicate that succeeds when encountered; if backtracking should later return to the cut, the goal that matched the head of the clause containing the cut fails immediately.


The Prolog database comprises all of the clauses that have been loaded or asserted into the Prolog system or that have been asserted, except those clauses that have been retracted or abolished.


A compound term denoting a unique reference to a dynamic clause. Recognized by the built-in predicate db_reference/1.


A mode of program execution in which the debugger stops to print the current goal only at predicates that have spypoints set on them (see leap).


Interpreted representation of compiled code. A valid value for the compiling Prolog flag.


A declaration looks like a directive, but is not executed but rather conveys information about predicates about to be loaded.

deinit function

A function in a foreign resource that is called prior to unloading the resource.


A predicate is determinate if it can supply only one answer.

development system

A stand-alone executable with the full programming environment, including top-level, compiler, debugger etc. The default sicstus executable is a development system; new development systems containing prelinked foreign resources can also be created.


A directive is a goal preceded by the prefix operator ‘:-’, whose intuitive meaning is “execute this as a query, but don’t print out any variable bindings.”


A series of goals connected by the connective “or” (that is, a series of goals whose principal operator is ‘;’).


A control structure of the form (Iterators do Body). It expresses a simple iteration. See ref-sem-ctr-dol.

dynamic predicate

A predicate that can be modified while a program is running. The semantics of such updates is described in ref-mdb-bas. A predicate must explicitly be declared to be dynamic or it must be added to the database via one of the assertion predicates.

encoded string

A sequence of bytes representing a sequence of possibly wide character codes, using the UTF-8 encoding.

escape sequence

A sequence of characters beginning with ‘\’ inside certain syntactic tokens (see ref-syn-syn-esc).


A module exports a predicate so that other modules can import it.

extended runtime system

A stand-alone executable. In addition to the normal set of built-in runtime system predicates, extended runtime systems include the compiler. Extended runtime systems require the extended runtime library, available from SICS as an add-on product.


A clause with no conditions—that is, with an empty body. A fact is a statement that a relationship exists between its arguments. Some examples, with possible interpretations, are:

king(louis, france).   % Louis was king of France.
have_beaks(birds).     % Birds have beaks.
employee(nancy, data_processing, 55000).  
                     % Nancy is an employee in the
                     % data processing department.
file specification

An atom or a compound term denoting the name of a file. The rules for mapping such terms to absolute file names are described in ref-fdi.

floundered query

A query where all unsolved goals are blocked.

foreign predicate

A predicate that is defined in a language other than Prolog, and explicitly bound to Prolog predicates by the Foreign Language Interface.

foreign resource

A named set of foreign predicates.


The functor of a compound term is its name and arity. For example, the compound term foo(a,b) is said to have “the functor foo of arity two”, which is generally written foo/2.

The functor of a constant is the term itself paired with zero. For example, the constant nl is said to have “the functor nl of arity zero”, which is generally written nl/0.

garbage collection

The freeing up of space for computation by making the space occupied by terms that are no longer available for use by the Prolog system.

generalized predicate spec

A generalized predicate spec corresponds to the argument type pred_spec_tree (see mpg-ref-aty-ety) and is a term of one of the following forms. It is always interpreted wrt. a given module context:


all predicates called Name no matter what arity, where Name is an atom for a specific name or a variable for all names, or


the predicate of that name and arity, or


specifying a particular module Module instead of the default module, where Module is an atom for a specific module or a variable for all modules, or


the set of all predicates covered by the Specs.

glue code

Interface code between the Prolog engine and foreign predicates. Automatically generated by the foreign language interface as part of building a linked foreign resource.


A simple goal is a predicate call. When called, it will either succeed or fail.

A compound goal is a formula consisting of simple goals connected by connectives such as “and” (‘,’) or “or” (‘;’).

A goal typed at the top-level is called a query.


A term is ground when it is free of (unbound) variables. Ground terms are recognized by the built-in predicate ground/1.

guarded clause

A clause of the form

Head :- Goals, !, Goals.

The head of a clause is the single goal, which will be satisfied if the conditions in the body (if any) are true; the part of a rule before the ‘:-’ symbol. The head of a list is the first element of the list.

extendible predicate

An extendible predicate is a multifile predicate, to which new clauses can be added by the user.

hook predicate

A hook predicate is a predicate that somehow alters or customizes the behavior of a hookable predicate. Please note: any exception thrown by a hook predicate is caught locally and printed as an error message.

hookable predicate

A hookable predicate is a built-in predicate whose behavior is somehow altered or customized by a hook predicate.

interactive stream

A stream with the interactive stream property. Certain behavior of interactive streams are optimized for the case where a human is at the other end of the stream.


Exported predicates in a module can be imported by other modules. Once a predicate has been imported by a module, it can be called, or exported, as if it were defined in that module.

There are two kinds of importation: predicate-importation, in which only specified predicates are imported from a module; and module-importation, in which all the predicates exported by a module are imported.


The process of filtering a set of potentially matching clauses of a predicate given a goal. For interpreted and compiled code, indexing is done on the principal functor of the first argument. Indexing is coarse wrt. large integers and floats.

init function

A function in a foreign resource that is called upon loading the resource.


An initialization is a goal that is executed when the file in which the initialization is declared is loaded. An initialization is declared as a directive :- initialization Goal. They are executed in input order.


A variable is instantiated if it is bound to a non-variable term; that is, to an atomic term or a compound term.


Load a program or set of clauses into Prolog through the interpreter (also known as consulting). Interpreted code runs more slowly than compiled code, does not provide as good precision for execution profiling and coverage analysis. On the other hand, more extensive facilities are available for debugging interpreted code.

invocation box

Same as procedure box.


A compound term expressing how a do-loop should be iterated. See ref-sem-ctr-dol.

large integer

An integer that is not a small integer.

layout term

In the context of handling line number information for source code, a source term Source gets associated to a layout term Layout, which is one of the following:


What the debugger does in debug mode. The debugger shows only the ports of predicates that have spypoints on them. It then normally prompts you for input, at which time you may leap again to the next spypoint (see trace).


Determines how frequently the debugger will stop and prompt you for input when you are tracing. A port at which the debugger stops is called a “leashed port”.

linked foreign resource

A foreign resource that is ready to be installed in an atomic operation, normally represented as a shared object or DLL.


A partial list is either a variable, or a compound term whose principal functor is the list constructor ('.'/2) and whose second argument is a partial list. Often it is implied that the partial list is not a variable.

A proper list is either the empty list, i.e. the atom [], or a compound term whose principal functor is the list constructor ('.'/2) and whose second argument is a proper list.

A partial list or a proper list that is a compound term is said to be non-empty.

In many cases list is used to denote both the case of a proper list and the case of a, most often non-variable, partial list.

A cyclic list is a compound term whose principal functor is the list constructor ('.'/2) and whose second argument is a cyclic list, e.g. what could be constructed using L='.'(a,L), or L=[a,b|L]. Passing a cyclic list as an argument to a predicate that expects a partial or proper list should be avoided as not all predictes are prepared to handle such input.

A list is often written using list syntax, e.g. using [a,b] to denote the (proper) list '.'(a,'.'(b,[])), or using [a,b|Tail] to denote the (partial) list '.'(a,'.'(b,Tail)).


To load a Prolog clause or set of clauses, in source or binary form, from a file or set of files.


The process of interpreting a callable term as a goal. This is done e.g. by the built-in predicate call/1.

meta-logical predicate

A predicate that performs operations that require reasoning about the current instantiation of terms or decomposing terms into their constituents. Such operations cannot be expressed using predicate definitions with a finite number of clauses.


A meta-predicate is one that calls one or more of its arguments; more generally, any predicate that needs to assume some module in order to operate is called a meta-predicate. Some arguments of a meta-predicate are subject to module name expansion.


Every predicate belongs to a module. The name of a module is an atom. Some predicates in a module are exported. The default module is user.

module name expansion

The process by which certain arguments of meta-predicates get prefixed by the source module. See ref-mod-mne.


A module-file is a file that is headed with a module declaration of the form:

:- module(ModuleName, ExportedPredList).

which must appear as the first term in the file. When a module-file or its corresponding object file is loaded, all predicates defined in the module are removed, and all predicate imported into the module are unimported.

multifile predicate

A predicate whose definition is to be spread over more than one file. Such a predicate must be preceded by an explicit multifile declaration in all files containing clauses for it.

mutable term

A special form of compound term subject to destructive assignment. See ref-lte-mut. Mutable terms are recognized by the built-in predicate mutable/1.

name clash

A name clash occurs when a module attempts to define or import a predicate that it has already defined or imported.


A test to ensure that binding a variable does not bind it to a term where that variable occurs.

one-char atom

An atom that consists of a single character.


A notational convenience that allows you to express any compound term in a different format. For example, if likes in

| ?- likes(sue, cider).

is declared an infix operator, the query above could be written:

| ?- sue likes cider.

An operator does not have to be associated with a predicate. However, certain built-in predicates are declared as operators. For example,

| ?- =..(X, Y).

can be written as

| ?- X =.. Y.

because =.. has been declared an infix operator.

Those predicates that correspond to built-in operators are written using infix notation in the list of built-in predicates at the beginning of the part that contains the reference pages.

Some built-in operators do not correspond to built-in predicates; for example, arithmetic operators. See ref-syn-ops-bop for a list of built-in operators.


A compound term K-V. Pairs are used by the built-in predicate keysort/2 and by many library modules.


The parent of the current goal is a goal that, in its attempt to obtain a successful solution to itself, is calling the current goal.


One of the seven key points of interest in the execution of a Prolog predicate. See Procedure Box for a definition.

prelinked foreign resource

A linked foreign resource that is linked into a stand-alone executable as part of building the executable.


A number associated with each Prolog operator, which is used to disambiguate the structure of the term represented by an expression containing a number of operators. Operators of lower precedence are applied before those of higher precedence; the operator with the highest precedence is considered the principal functor of the expression. To disambiguate operators of the same precedence, the associativity type is also necessary. See ref-syn-ops.


A functor that specifies some relationship existing in the problem domain. For example, < /2 is a built-in predicate specifying the relationship of one number being less than another. In contrast, the functor + /2 is not (normally used as) a predicate.

A predicate is either built-in or is implemented by a procedure.

predicate spec

A compound term name/arity or module:name/arity denoting a predicate.


A set of clauses in which the head of each clause has the same predicate. For instance, a group of clauses of the following form:

connects(san_francisco, oakland, bart_train).
connects(san_francisco, fremont, bart_train).
connects(concord, daly_city, bart_train).

is identified as belonging to the predicate connects/3.

procedure box

A way of visualizing the execution of a Prolog procedure, A procedure box is entered and exited via ports.


The process of gathering execution statistics of the program, essentially counting the number of times selected program points have been reached.


A set of procedures designed to perform a given task.

PO file

A PO (Prolog object) file contains a binary representation of a set of modules, predicates, clauses and directives. They are portable between different platforms, except between 32-bit and 64-bit platforms. They are created by save_files/2, save_modules/2, and save_predicates/2.


A query is a question put by the user to the Prolog system. A query is written as a goal followed by a full-stop in response to the top-level prompt. For example,

| ?- father(edward, ralph).

refers to the predicate father/2. If a query has no variables in it, the system will respond either ‘yes’ or ‘no’. If a query contains variables, the system will try to find values of those variables for which the query is true. For example,

| ?- father(edward, X).
X = ralph

After the system has found one answer, the user can direct the system to look for additional answers to the query by typing ;.


The process in which a running predicate calls itself, presumably with different arguments and for the purpose of solving some subset of the original problem.


The text between the cursor and a previously set mark in an Emacs buffer.


A clause with one or more conditions. For a rule to be true, all of its conditions must also be true. For example,

has_stiff_neck(ralph) :-

This rule states that if the individual ralph is a hacker, he must also have a stiff neck. The constant ralph is replaced in

has_stiff_neck(X) :-

by the variable X. X unifies with anything, so this rule can be used to prove that any hacker has a stiff neck.

runtime kernel

A shared object or DLL containing the SICStus virtual machine and other runtime support for stand-alone executables.

runtime system

A stand-alone executable with a restricted set of built-in predicates and no top-level. Stand-alone applications containing debugged Prolog code and destined for end-users are typically packaged as runtime systems.


A snapshot of the state of Prolog saved in a file by save_program/[1,2].


The relation between the set of Prolog symbols and their combinations (as Prolog terms and clauses), and their meanings. Compare syntax.


A clause or directive.


A predicate that produces a side-effect is one that has any effect on the “outside world” (the user’s terminal, a file, etc.), or that changes the Prolog database.

simple term

A simple term is a constant or a variable. Simple terms are recognized by the built-in predicate simple/1.

skeletal goal

A compound term name(arg, …, arg) or module:name(arg, …, arg) denoting a predicate.

small integer

An integer in the range [-2^28,2^28-1] on 32-bit platforms, or [-2^60,2^60-1] on 64-bit platforms. The start and end of this range is available as the value of the Prolog flags min_tagged_integer and max_tagged_integer, respectively.

source code

The human-readable, as opposed to the machine-executable, representation of a program.

source module

The module that is the context of a file being loaded. For module-files, the source module is named in the file’s module declaration. For other files, the source module is inherited from the context.

SP_atom   since release 4.3

A C type for the internal representation of Prolog atoms. Used in SICStus API functions.

SP_integer   since release 4.3

A C type denoting an integer that is large enough to hold a pointer. Used in SICStus API functions.


A C type denoting a “handle” object providing an interface from C to Prolog terms. Used in SICStus API functions.


A special case of breakpoint, the debugger breakpoint, intended for interactive debugging. Its simplest form, the plain spypoint instructs the debugger to stop at all ports of all invocations of a specified predicate. Conditional spypoints apply to a single predicate, but are more selective: the user can supply applicability tests and prescribe the actions to be carried out by the debugger. A generic spypoint is like a conditional spypoint, but not restricted to a single predicate. See Advanced Debugging.

stand-alone executable

A binary program that can be invoked from the operating system, containing the SICStus runtime kernel. A stand-alone executable is a development system (e.g. the default sicstus executable), or a runtime system. Both kinds are created by the application builder. A stand-alone executable does not itself contain any Prolog code; all Prolog code must be loaded upon startup.

static predicate

A predicate that can be modified only by being reloaded or by being abolished. See dynamic predicate.


A predicate is steadfast if it refuses to give the wrong answer even when the query has an unexpected form, typically with values supplied for arguments intended as output.


An input/output channel. See ref-iou.

stream alias

A name assigned to a stream at the time of opening, which can be referred to in I/O predicates. Must be an atom. There are also three predefined aliases for the standard streams: user_input, user_output and user_error. Although not a stream alias proper, the atom user also stands for the standard input or output stream, depending on context.

stream object

A term denoting an open Prolog stream. See ref-iou.

stream position

A term representing the current position of a stream. This position is determined by the current byte, character and line counts and line position. Standard term comparison on stream position terms works as expected. When SP1 and SP2 refer to positions in the same stream, SP1@<SP2 if and only if SP1 is before SP2 in the stream. You should not otherwise rely on their internal representation.

stream property

A term representing the property of an open Prolog stream. The possible forms of this term are defined in ref-iou-sfh-bos.


A special syntactic notation, which, by default, denotes a code-list, e.g.:


By setting the Prolog flag double_quotes, the meaning of strings can be changed. With an appropriate setting, a string can be made to denote a char-list, or an atom. Strings are not a separate data type.

subterm selector

A list of argument positions selecting a subterm within a term (i.e. the subterm can be reached from the term by successively selecting the argument positions listed in the selector). Example: within the term q, (r, s; t) the subterm s is selected by the selector [2, 1, 2].


The part of Prolog grammar dealing with the way in which symbols are put together to form legal Prolog terms. Compare semantics.

system property

SICStus Prolog stores some information in named variables called system properties. System properties are used as of release 4.1, where previous releases used environment variables.

The default value for a system property is taken from the corresponding environment variable. Any exceptions to this rule is explicitly mentioned in the documentation. See System Properties and Environment Variables for more information.


A basic data object in Prolog. A term can be a constant, a variable, or a compound term.


A mode of program execution in which the debugger creeps to the next port and prints the goal.

type-in module

The module that is the context of queries.

unblocked goal

A goal that is not blocked any more.


A variable is unbound if it has not yet been instantiated.


The process of matching a goal with the head of a clause during the evaluation of a query, or of matching arbitrary terms with one another during program execution.

The rules governing the unification of terms are:

unit clause

See fact.


A logical variable is a name that stands for objects that may or may not be determined at a specific point in a Prolog program. When the object for which the variable stands is determined in the Prolog program, the variable becomes instantiated. A logical variable may be unified with a constant, a compound term, or another variable. Variables become uninstantiated when the predicate they occur in backtracks past the point at which they were instantiated.

Variables may be written as any sequence of alphanumeric characters starting with either a capital letter or ‘_’; e.g.:

X   Y   Z   Name   Position   _c   _305  One_stop

See ref-syn-trm-var.


Predicate property. The clauses of a volatile predicate are not saved in saved-states.

windowed executable

An executable that pops up its own window when run, and that directs the standard streams to that window.


Same as debug mode, except no debugging information is collected while zipping.

Send feedback on this subject.