These predicates convert between Prolog constants and lists of character codes. The predicates atom_codes/2, number_codes/2 and name/2 behave the same when converting from a constant to a list of character codes. When converting the other way around, atom_codes/2 will generate an atom, number_codes/2 will generate a number or exception and name/2 will return a number if possible and an atom otherwise.
The ISO standard defines atom_chars/2 to describe the `broken-up' atom as a list of one-character atoms instead of a list of codes. Up to version 3.2.x, SWI-Prolog's atom_chars/2 behaved like atom_codes, compatible with Quintus and SICStus Prolog. As of 3.3.x, SWI-Prolog atom_codes/2 and atom_chars/2 are compliant to the ISO standard.
To ease the pain of all variations in the Prolog community, all SWI-Prolog predicates behave as flexible as possible. This implies the `list-side' accepts either a code-list or a char-list and the `atom-side' accepts all atomic types (atom, number and string).
?- atom_chars(hello, X). X = [h, e, l, l, o]
backcomp.plIf CharList is parsed, it is parsed using the Prolog 
syntax for numbers. Following the ISO standard, it allows for leading 
white space (including newlines) and does not allow for trailing 
white space.101ISO also allows for 
Prolog comments in leading white space. We--and most other 
implementations--believe this is incorrect. We also beleive it would 
have been better not to allow for white space, or to allow for both 
leading and trailing white space. Prolog syntax-based conversion can 
also be achieved using format/3 
and read_from_chars/2. 
A syntax_error exception is raised if CharList 
does not represent a valid Prolog number.
name(N, 
"300"), 400 is N + 100 succeeds). If CodeList is not a 
representation of a number,
Atomic will be unified with the atom with the name given by 
the character code list. If Atomic is an atom or number, the 
unquoted print representation of it as a character code list is unified 
with CodeList.
This predicate is part of the Edinburgh tradition. It should be considered deprecated although, given its long tradition, it is unlikely to be removed from the system. It still has some value for converting input to, depending on the syntax, a number or atom. New code should consider the ISO predicates atom_codes/2, number_codes/2 or the SWI-Prolog predicate atom_number/2.
syntax_error exception is raised. Otherwise Term 
is ``written'' on Atom using write_term/2 
with the option
quoted(true). See also format/3, with_output_to/2 
and
term_string/2.variable_names and return the read term in Term 
and the variable bindings in Bindings. Bindings is 
a list of
Name = Var couples, thus providing 
access to the actual variable names. See also read_term/2. 
If Atom has no valid syntax, a syntax_error 
exception is raised. New code should use
read_term_from_atom/3.?- atomic_concat(name, 42, X). X = name42.
atomic_list_concat(List, 
'', Atom).?- atomic_list_concat([gnu, gnat], ', ', A). A = 'gnu, gnat'
The SWI-Prolog version of this predicate can also be used to split atoms by instantiating Separator and Atom as shown below. We kept this functionality to simplify porting old SWI-Prolog code where this predicate was called concat_atom/3. When used in mode (-,+,+), Separator must be a non-empty atom. See also split_string/4.
?- atomic_list_concat(L, -, 'gnu-gnat'). L = [gnu, gnat]
?- sub_atom(Atom, 0, _, _, Prefix). 
Deprecated.?- sub_atom(abc, 1, 1, A, S). A = 1, S = b
The implementation minimises non-determinism and creation of atoms. This is a flexible predicate that can do search, prefix- and suffix-matching, etc.