[ Term I/O | The ECLiPSe Built-In Predicates | Reference Manual | Alphabetic Index ]

# print(+Stream, ?Term)

The term Term is written on the output stream Stream according to the current operator declarations, using the predicate portray/2 or portray/1 if it exists.

Stream
  Integer (stream number) or Atom (reserved or user-defined symbolic stream name).
Term
  Prolog term.

## Description

Used to print the term Term on the output stream Stream according to the current operator declarations, i.e. the same as write/2, however the user has the possibility to influence the way the term is printed. If the predicate portray/2 is visible in the module where print/2 was called from, it is used by print/2 in the following way:

* If Term is a variable, it is printed using write/2.

* If Term is a nonvariable or an attributed variable, then portray(Stream, Term) is called. If it succeeds, so does print/2. Otherwise, if Term is atomic, it is written using write/2 and the predicate succeeds. If Term is a compound term, its main functor is printed using write/2 and print/2 is called recursively on its arguments.

Note that when this predicate is used to print a list, only the elements of the list, i.e. the heads, are passed to the recursive calls of print/2, but not the list tails. Thus e.g. a list [1,2,3] will be passed once to portray/2 as a whole and then the elements 1, 2, 3, but not [2,3], [3] and [].

If portray/2 is not visible but portray/1 is, it is called instead of portray/2, but then the Stream argument cannot be passed to it, and it is therefore the responsibility of portray/1 itself to print the data to the correct stream. portray/1, 2 is used by the system when printing out the answer binding in the top-level loop to the answer_output stream) and in the debugger, when the output command is set to print, to the debug_output stream.

As usual, the output is buffered, so it may need to be flushed (e.g. explicitly using flush/1).

Note The output of print/2 is not necessarily in a form acceptable to read/1,2 and there is no 'printq' predicate.

### Modes and Determinism

- print(+, ?) is det

### Modules

This predicate is sensitive to its module context (tool predicate, see @/2).

### Exceptions

(4) instantiation fault
  Stream is not instantiated.
(5) type error
  Stream is not an atom or an integer.
(192) illegal stream mode
  Stream is not an output steam.
(193) illegal stream specification
  Stream is not a stream specification.

## Examples

    Success:
        [eclipse]: [user].
         portray(S, a) :- write(S, b).

         p(a).
         user   compiled 148 bytes in 0.00 seconds

        yes.
        [eclipse]: write(write(a)), nl, print(output, print(a)).
        write(a)
        print(b)
        yes.
        [eclipse]: trace.

        yes.
        Debugger switched on - creep mode
        [eclipse]: p(a).
          (1) 0  CALL   p(a) (dbg)?- output: write        ('o' typed)
          (1) 0  CALL   p(a) (dbg)?- output: display
          (1) 0  CALL   p(a) (dbg)?- output: print/writeq
          (1) 0  CALL   p(b) (dbg)?- creep
          (1) 0  EXIT   p(b) (dbg)?- creep

        yes.

    Error:
         print(S, a(b,c)).         (Error 4).
         print("str", a(b,c)).     (Error 5).
         print(input, X).          (Error 192).
         print(nostr, X + 2).      (Error 193).

## See Also

display / 1, display / 2, print / 1, write / 1, write / 2, writeq / 1, writeq / 2