This section describes the basic term reading and writing predicates. The predicates format/[1,2] and writef/2 provide formatted output. Writing to Prolog data structures such as atoms or code-lists is supported by with_output_to/2 and format/3.
Reading is sensitive to the Prolog flag character_escapes, 
which controls the interpretation of the \
ignore (ignore the attribute), dots 
(write the attributes as {...}), write (simply 
hand the attributes recursively to write_term/2) 
and portray (hand the attributes to attr_portray_hook/2).string causes string 
objects to be printed between back quotes and symbol_char 
causes the backquote to be printed unquoted. In all other cases the 
backquote is printed as a quoted atom.true (default), write {}(X) as {X}. 
See also
dotlists and ignore_ops.portray,
portray/1 
is called for each blob encountered. See section 
12.4.10.true and quoted(true) is active, special 
characters in quoted atoms and strings are emitted as ISO escape 
sequences. Default is taken from the reference module (see below).true and character_escapes(true) and
quoted(true) are active escapted characters are written 
using
\uXXXX or \UXXXXXXXX syntax. The default 
depends on the Prolog flag character_escapes_unicodetrue (default), cyclic terms are written as
@(Template, Substitutions), where Substitutions 
is a list
Var = Value. If cycles is false,
max_depth is not given, and Term is cyclic, write_term/2 
raises a domain_error.106The 
cycles option and the cyclic term representation using the @-term are 
copied from SICStus Prolog. However, the default in SICStus is set to false 
and SICStus writes an infinite term if not protected by, e.g., the depth_limit 
option. See also the cycles option in
read_term/2.true (default false), write lists using the 
dotted term notation rather than the list notation.107Copied 
from ECLiPSe. Note that as of version 7, the list 
constructor is
'[|]'. Using dotlists(true), write_term/2 
writes a list using‘.’as constructor. This is intended for 
communication with programs such as other Prolog systems, that rely on 
this notation. See also the option no_lists(true) to use 
the actual SWI-Prolog list functor.true (default false), add a fullstop token 
to the output. The dot is preceded by a space if needed and followed by 
a space (default) or newline if the nl(true) option is also 
given.108Compatible with ECLiPSetrue, the generic term representation (<functor>(<args> 
... )) will be used for all terms. Otherwise (default), operators will 
be used where appropriate.109In 
traditional systems this flag also stops the syntactic sugar notation 
for lists and brace terms. In SWI-Prolog, these are controlled by the 
separate options dotlists and brace_terms.
?- write_term(a(s(s(s(s(0)))), [a,b,c,d,e,f]),
              [max_depth(3)]).
a(s(s(...)), [a, b|...])
true.
Used by the top level and debugger to limit screen output. See also the Prolog flags answer_write_options and debugger_write_options.
user). This defines 
the default value for the character_escapes 
option as well as the operator definitions to use. If Module 
does not exist it is
not created and the user module is used. See also op/3 
and read_term/2, 
providing the same option.fullstop option.dotlists(true), 
but uses the SWI-Prolog list functor, which is by default '[|]' 
instead of the ISO Prolog '.'. Used by display/1.true, terms of the format $VAR(N), where N 
is an integer that fits in 64-bit,110Larger 
integers are ignored. As no term that fits into memory can have that 
many variables, this is not a restriction. will be written 
as a variable name. For N in 0..25 it emits A..Z. For higher 
numbers it emits An..Zn, where
n is N//26. For negative numbers it emits S_N, 
which is used for representing shared sub-terms and cyclic terms.
If N is an atom that is syntactically a valid variable it is written without quotes. This extension allows for writing variables with user-provided names.
The default for this flag is false unless the
portrayed option is enabled. See also numbervars/3 
and the option variable_names.
true (default false), do not reset the 
logic that inserts extra spaces that separate tokens where needed. This 
is intended to solve the problems with the code below. Calling write_value(.) 
writes .., which cannot be read. By adding partial(true) 
to the option list, it correctly emits . .. Similar 
problems appear when emitting operators using multiple calls to write_term/3.
write_value(Value) :-
        write_term(Value, [partial(true)]),
        write('.'), nl.
In addition, if the priority is not 1200 or 999 this assumes we are printing an operant of an operator. If Term is an atom that is also an operator it will always be embraced.111If the priority is 1200 it is assumed to be a toplevel term and if the priority is 999 it is assumed to be a list element or argument of a compound term.
portrayed(Bool). Deprecated.portray(true), but calls Goal rather 
than the predefined hook portray/1. Goal 
is called through call/3, 
where the first argument is Goal, the second is the term to 
be printed and the 3rd argument is the current write option list. The 
write option list is copied from the write_term call, but the list is 
guaranteed to hold an option priority that reflects the 
current priority.true, the hook portray/1 
is called before printing a term that is not a variable. If portray/1 
succeeds, the term is considered printed. See also print/1. 
The default is false. This option is an extension to the 
ISO write_term options. If this option is set, the numbervars 
option defaults to true.
        format('~w = ', [VarName]),
        write_term(Value, [quoted(true), priority(699)])
true, atoms and strings that need quotes will be quoted. 
The default is false. If character_escapes 
is
true (default) characters in the quoted atom or string are 
escaped using backslash (\\u0020) 
are escaped. For those characters for which an ISO Prolog single 
character escape, e.g.,
\t is defined, this is used. Otherwise the output depends 
on the option character_escapes_unicode. If this flag 
applies(default) the widely accepted \uXXXX or \UXXXXXXXX 
is used. Otherwise the ISO Prolog \x<hex>\ syntax is 
used.standard, adding only space 
where needed for proper tokenization by read_term/3. 
Currently, the only other value is next_argument, adding a 
space after a comma used to separate arguments in a term or list.The implementation binds the variables from List to a term
'$VAR'(Name). Like write_canonical/1, 
terms that where already bound to '$VAR'(X) 
before write_term/2 
are printed normally, unless the option numbervars(true) is 
also provided. If the option numbervars(true) is used, the 
user is responsible for avoiding collisions between assigned names and 
numbered names. See also the variable_names option of
read_term/2.
Possible variable attributes (see section 8.1) are ignored. In most cases one should use copy_term/3 to obtain a copy that is free of attributed variables and handle the associated constraints as appropriate for the use-case.
write_term(Term, Options). In addition to valid options for
write_term/2, 
it processes the option:
ignore_ops,
quoted, quote_non_ascii, brace_terms(false) 
and
numbervars after numbervars/4 
using the singletons option.
Note that due to the use of numbervars/4, 
non-ground terms must be written using a single write_canonical/1 
call. This used to be the case anyhow, as garbage collection between 
multiple calls to one of the write predicates can change the _<NNN> 
identity of the variables.
write_term(Term, [quoted(true), numbervars(true)]).write(Term), nl.. The output stream is 
locked, which implies no output from other threads can appear between 
the term and newline.write(Stream, Term), nl(Stream).. The output 
stream is locked, which implies no output from other threads can appear 
between the term and newline.
print(Term) :-
    current_prolog_flag(print_write_options, Options), !,
    write_term(Term, Options).
print(Term) :-
    write_term(Term, [ portray(true),
                       numbervars(true),
                       quoted(true)
                     ]).
The print/1 
predicate is used primarily through the ~p escape sequence 
of format/2, 
which is commonly used in the recipes used by
print_message/2 
to emit messages.
The classical definition of this predicate is equivalent to the ISO 
predicate write_term/2 
using the options portray(true) and
numbervars(true). The portray(true) option 
allows the user to implement application-specific printing of terms 
printed during debugging to facilitate easy understanding of the output. 
See also
portray/1 
and library(portray_text). SWI-Prolog adds quoted(true) 
to (1) facilitate the copying/pasting of terms that are not affected by
portray/1 
and to (2) allow numbers, atoms and strings to be more easily 
distinguished, e.g., 42, '42' and "42".
end_of_file. This is the same as read_term/2 
using an empty option list.
[NOTE] You might have found this while looking for a predicate 
to read input from a file or the user. Quite likely this is not what you 
need in this case. This predicate is for reading a Prolog term 
which may span multiple lines and must end in a full stop (dot 
character followed by a layout character). The predicates for reading 
and writing Prolog terms are particularly useful for storing Prolog data 
in a file or transferring them over a network communication channel 
(socket) to another Prolog process. The libraries provide a wealth of 
predicates to read data in other formats. See e.g., library(readutil),
library(pure_input) or libraries from the extension 
packages to read XML, JSON, YAML, etc.
dec10 (report and restart).true (default), call
prolog:comment_hook(Comments, TermPos, Term) if this 
multifile hook is defined (see prolog:comment_hook/3). 
This is used to drive PlDoc.process_comment(false).
The singletons option of read_term/3 
is initialised from the active style-checking mode. The module 
option is initialised to the current compilation module (see prolog_load_context/2).
true, read `...` to a string 
object (see
section 5.2). The default 
depends on the Prolog flag
back_quotes.\ escape sequences in quoted atoms. See 
the Prolog flag character_escapes 
in current_prolog_flag/2. 
(SWI-Prolog).true (default false), re-instantiate 
templates as produced by the corresponding write_term/2 
option. Note that the default is false to avoid 
misinterpretation of @(Template, Substitutions), while the 
default of write_term/2 
is true because emitting cyclic terms without using the 
template construct produces an infinitely large term (read: it will 
generate an error after producing a huge amount of output).true (default false), read .(a,[]) 
as a list, even if lists are internally constructed a different functor 
([|](Head,Tail)). This is primarily intended to read the 
output from write_canonical/1 
from other Prolog systems. See
section 5.1.user is used because new modules by 
default inherit from userquasi_quotation(+Syntax, 
+Quotation, +VarDict, -Result), where Syntax is the 
term in
{|Syntax||..|}, Quotation is a list of character 
codes that represent the quotation, VarDict is a list of
Name=Variable and Result is a variable 
that shares with the place where the quotation must be inserted. This 
option is intended to support tools that manipulate Prolog source text.variable_names, but only reports the variables occurring 
only once in the Term read (ISO). If Vars is the 
constant
warning, singleton variables are reported using print_message/2. 
The variables appear in the order they have been read. The latter option 
provides backward compatibility and is used to read terms from source 
files. Not all singleton variables are reported as a warning. See
section 2.15.1.10 
for the rules that apply for warning about a singleton variable.112As 
of version 7.7.17, all variables starting with an underscore 
except for the truly anonymous variable are returned in Vars. 
Older versions only reported those that would have been reported if warning 
is used.error (default), throw an exception on a syntax error. 
Other values are fail, which causes a message to be printed 
using
print_message/2, 
after which the predicate fails, quiet which causes the 
predicate to fail silently, and dec10 which causes syntax 
errors to be printed, after which read_term/[2,3] 
continues reading the next term. Using dec10, read_term/[2,3] 
never fails. (Quintus, SICStus).").{...}, as used in DCG rules. Arg 
describes the argument.|none.key_value_position/7 terms. The
key_value_position/7 terms appear in the order of the 
input. Because maps do not preserve ordering, the key is provided in the 
position description.term_position/5 that would 
be created, except that the key and value positions do not need an 
intermediate list and the key is provided in Key to enable 
synchronisation of the file position data with the data structure.{|Syntax||Content|},
SyntaxTerm is the parsed term representation from Syntax, 
e.g., {|string(X)||Hello {{X}}|} produces Syntax
string(X) and SyntaxPos describes the layout of 
this term. ContentPos is always a term From-To 
describing the character range of Content.113The 
layout of the term produced by the quasi quotation parser is not 
available. Future versions may provide an interface that allows 
contributing a layout term.
true, demand variables to start with an underscore. See
section 2.15.1.8.~! ?-. A sequence
~! is replaced by the current history event number.
!history.
!help.
user.
user_input.
Most applications will use the read_term/2 
option variable_names to get access to the names of the 
variables in Term. SWI-Prolog calls read_term_with_history/2 
as follows:
    read_term_with_history(
        Goal,
        [ show(h),
          help('!h'),
          no_save([trace, end_of_file]),
          prompt('~! ?-'),
          variable_names(Bindings)
        ]).
user_input 
stream.
Old is first unified with the current prompt. On success the 
prompt will be set to New (an atom). A prompt is printed if 
data is read from user_input, the cursor is at the left 
margin and the user_input is considered to be connected to 
a terminal. See the tty(Bool) property of stream_property/2 
and set_stream/2.
The default prompt is '|: '. Note that the toplevel loop 
(see
prolog/0) 
sets the prompt for the first prompt (see prompt1/1) 
to
'?- ', possibly decorated by the history event number,
break level and debug mode. If the first line does not complete 
the term, subsequent lines are prompted for using the prompt as defined 
by prompt/2.