- Reference manual
- Built-in Predicates
- Notation of Predicate Descriptions
- Character representation
- Loading Prolog source files
- Editor Interface
- List the program, predicates or clauses
- Verify Type of a Term
- Comparison and Unification of Terms
- Control Predicates
- Meta-Call Predicates
- Delimited continuations
- Exception handling
- Handling signals
- DCG Grammar rules
- Declaring predicate properties
- Examining the program
- Input and output
- Status of streams
- Primitive character I/O
- Term reading and writing
- Analysing and Constructing Terms
- Analysing and Constructing Atoms
- Localization (locale) support
- Character properties
- Character Conversion
- Misc arithmetic support predicates
- Built-in list operations
- Finding all Solutions to a Goal
- Formatted Write
- Global variables
- Terminal Control
- Operating System Interaction
- File System Interaction
- User Top-level Manipulation
- Creating a Protocol of the User Interaction
- Debugging and Tracing Programs
- Obtaining Runtime Statistics
- Execution profiling
- Memory Management
- Windows DDE interface
- Built-in Predicates
- Reference manual
Most list operations are defined in the library
described in section A.15.
Some that are implemented with more low-level primitives are built-in
and described here.
- True if Term is bound to the empty list (
) or a term with functor `
'[|]''119The traditional list functor is the dot (
'.'). This is still the case of the command line option --traditional is given. See also section 5.1. and arity 2 and the second argument is a list.120In versions before 5.0.1, is_list/1 just checked for
[_|_]and proper_list/1 had the role of the current is_list/1. The current definition conforms to the de facto standard. Assuming proper coding standards, there should only be very few cases where a quick-and-dirty is_list/1 is a good choice. Richard O'Keefe pointed at this issue. This predicate acts as if defined by the definition below on acyclic terms. The implementation fails safely if Term represents a cyclic list.
is_list(X) :- var(X), !, fail. is_list(). is_list([_|T]) :- is_list(T).
- [semidet]memberchk(?Elem, +List)
- True when Elem is an element of List. This `chk'
is semi deterministic and typically used to test membership of a list.
typeerror if scanning List encounters a non-list. Note that memberchk/2 does not perform a full list typecheck. For example,
memberchk(a, [a|b])succeeds without error. If List is cyclic and Elem is not a member of List, memberchk/2 eventually raises a
typeerror.121Eventually here means it will scan as many elements as the longest list that may exist given the current stack usage before raising the exception.
- [ISO]length(?List, ?Int)
- True if Int represents the number of elements in List.
This predicate is a true relation and can be used to find the length of
a list or produce a list (holding variables) of length Int.
The predicate is non-deterministic, producing lists of increasing length
List is a partial list and Int is
unbound. It raises errors if
- Int is bound to a non-integer.
- Int is a negative integer.
- List is neither a list nor a partial list. This error condition includes cyclic lists.122ISO demands failure here. We think an error is more appropriate.
This predicate fails if the tail of List is equivalent to Int (e.g.,
length(L,L)).123This is logically correct. An exception would be more appropriate, but to our best knowledge, current practice in Prolog does not describe a suitable candidate exception term.
- [ISO]sort(+List, -Sorted)
- True if Sorted can be unified with a list holding the
elements of List, sorted to the standard order of terms (see
section 4.7). Duplicates
are removed. The implementation is in C, using natural merge sort.124Contributed
by Richard O'Keefe. The sort/2
predicate can sort a cyclic list, returning a non-cyclic version with
the same elements.
Note that List may contain non-ground terms. If Sorted is unbound at call-time, for each consequtive pair of elements in Sorted, the relation
E1 @< E2will hold. However, unifying a variable in Sorted may cause this relation to become invalid, even unifying a variable in Sorted with another (older) variable. See also section 4.7.1.
- sort(+Key, +Order, +List, -Sorted)
- True when Sorted can be unified with a list holding the
List. Key determines which part of each element in
List is used for comparing two term and Order
describes the relation between each set of consecutive elements in
definition of this predicate was established after discussion with
Joachim Schimpf from the ECLiPSe team. ECLiPSe currently only accepts
for the Order argument but this is likely to change. SWI-Prolog extends this predicate to deal with dicts.
If Key is the integer zero (0), the entire term is used to compare two elements. Using Key=0 can be used to sort arbitrary Prolog terms. Other values for Key can only be used with compound terms or dicts (see section 5.4). An integer key extracts the Key-th argument from a compound term. An integer or atom key extracts the value from a dict that is associated with the given key. A type_error is raised if the list element is of the wrong type and an existence_error is raised if the compound has not enough argument or the dict does not contain the requested key.
Deeper nested elements of structures can be selected by using a list of keys for the Key argument.
The Order argument is described in the table below126For compatibility with ECLiPSe, the values
are allowed as synonyms.
Order Ordering Duplicate handling
The sort is stable, which implies that, if duplicates are kept, the order of duplicates is not changed. If duplicates are removed, only the first element of a sequence of duplicates appears in Sorted.
This predicate supersedes most of the other sorting primitives, for example:
sort(List, Sorted) :- sort(0, @<, List, Sorted). msort(List, Sorted) :- sort(0, @=<, List, Sorted). keysort(Pairs, Sorted) :- sort(1, @=<, Pairs, Sorted).
The following example sorts a list of rows, for example resulting from csv_read_file/2) ascending on the 3th column and descending on the 4th column:
sort(4, @>=, Rows0, Rows1), sort(3, @=<, Rows1, Sorted).
- msort(+List, -Sorted)
- Equivalent to sort/2,
but does not remove duplicates. Raises a
type_errorif List is a cyclic list or not a list.
- [ISO]keysort(+List, -Sorted)
- Sort a list of pairs. List must be a list of
Key-Valuepairs, terms whose principal functor is (-)/2. List is sorted on Key according to the standard order of terms (see section 4.7.1). Duplicates are not removed. Sorting is stable with regard to the order of the Values, i.e., the order of multiple elements that have the same Key is not changed.
The keysort/2 predicate is often used together with library
library(pairs). It can be used to sort lists on different or multiple criteria. For example, the following predicates sorts a list of atoms according to their length, maintaining the initial order for atoms that have the same length.
:- use_module(library(pairs)). sort_atoms_by_length(Atoms, ByLength) :- map_list_to_pairs(atom_length, Atoms, Pairs), keysort(Pairs, Sorted), pairs_values(Sorted, ByLength).
- predsort(+Pred, +List, -Sorted)
- Sorts similar to sort/2,
but determines the order of two terms by calling Pred(-Delta,
+E1, +E2) . This call must unify Delta
with one of
. If the built-in predicate compare/3 is used, the result is the same as sort/2. See also keysort/2.