2/22/23, 4:45 PM Prolog - Inputs and Outputs

Prolog - Inputs and Outputs

In this chapter, we will see some techniques to handle inputs and outputs through prolog. We will
use some built in predicates to do these tasks, and also see file handling techniques.

Following topics will be discussed in detail −

Handling inputs and outputs

File handling using Prolog

Using some external file to read lines and terms

Character manipulation for input and output

Constructing and decomposing atoms

Consulting prolog files into other prolog program techniques.

Handling input and output

So far we have seen that we can write a program and the query on the console to execute. In some
cases, we print something on the console, that are written in our prolog code. So here we will see
that writing and reading tasks in more detail using prolog. So this will be the input and output
handling techniques.

The write() Predicate

To write the output we can use the write() predicate. This predicate takes the parameter as input,
and writes the content into the console by default. write() can also write in files. Let us see some
examples of write() function.

Program
| ?- write(56).
56

yes
| ?- write('hello').
hello

yes
| ?- write('hello'),nl,write('world').

https://www.tutorialspoint.com/prolog/prolog_inputs_and_outputs.htm 1/10
2/22/23, 4:45 PM Prolog - Inputs and Outputs

hello
world

yes
| ?- write("ABCDE")
.
[65,66,67,68,69]

yes

From the above example, we can see that the write() predicate can write the contents into the
console. We can use ’nl’ to create a new line. And from this example, it is clear that, if we want to
print some string on the console, we have to use single quotes (‘string‘). But if we use double quote
(“string”), then it will return a list of ASCII values.

The read() Predicate

The read() predicate is used to read from console. User can write something in the console, that can
be taken as input and process it. The read() is generally used to read from console, but this can also
be used to read from files. Now let us see one example to see how read() works.

Program
cube :-
write('Write a number: '),
read(Number),
process(Number).
process(stop) :- !.
process(Number) :-
C is Number * Number * Number,
write('Cube of '),write(Number),write(': '),write(C),nl, cube.

Output
| ?- [read_write].
compiling D:/TP Prolog/Sample_Codes/read_write.pl for byte code...
D:/TP Prolog/Sample_Codes/read_write.pl compiled, 9 lines read - 1226 bytes written, 12 ms

(15 ms) yes

| ?- cube.
Write a number: 2.
Cube of 2: 8
Write a number: 10.

https://www.tutorialspoint.com/prolog/prolog_inputs_and_outputs.htm 2/10
2/22/23, 4:45 PM Prolog - Inputs and Outputs

Cube of 10: 1000

Write a number: 12.
Cube of 12: 1728
Write a number: 8.
Cube of 8: 512
Write a number: stop
.

(31 ms) yes

| ?-

The tab() Predicate

The tab() is one additional predicate that can be used to put some blank-spaces while we write
something. So it takes a number as an argument, and prints those many number of blank spaces.

Program
| ?- write('hello'),tab(15),write('world').
hello world

yes
| ?- write('We'),tab(5),write('will'),tab(5),write('use'),tab(5),write('tabs').
We will use tabs

yes
| ?-

Reading/Writing Files
In this section, we will see how we can use files to read from, and write into the files. There are
some built-in predicates, that can be used to read from file and write into it.

The tell and told

If we want to write into a file, except the console, we can write the tell() predicate. This
tell()predicate takes filename as argument. If that file is not present, then create a new file, and write
into it. That file will be opened until we write the told command. We can open more than one file
using tell(). When told is called, all files will be closed.

https://www.tutorialspoint.com/prolog/prolog_inputs_and_outputs.htm 3/10
2/22/23, 4:45 PM Prolog - Inputs and Outputs

Prolog Commands
| ?- told('myFile.txt').
uncaught exception: error(existence_error(procedure,told/1),top_level/0)
| ?- told("myFile.txt").
uncaught exception: error(existence_error(procedure,told/1),top_level/0)
| ?- tell('myFile.txt').

yes
| ?- tell('myFile.txt').

yes
| ?- write('Hello World').

yes
| ?- write(' Writing into a file'),tab(5),write('myFile.txt'),nl.

yes
| ?- write("Write some ASCII values").

yes
| ?- told.

yes
| ?-

Output (myFile.txt)
Hello World Writing into a file myFile.txt
[87,114,105,116,101,32,115,111,109,101,32,65,83,67,73,73,32,118,97,108,117,101,115]

Similarly, we can also read from files. Let us see some example of reading from file.

The see and seen

When we want to read from file, not from the keyboard, we have to change current input stream. So
we can use see() predicate. This will take filename as input. When the read operation is completed,
then we will use seen command.

Sample File (sample_predicate.txt)

likes(lili, cat).
likes(jhon,dog).

https://www.tutorialspoint.com/prolog/prolog_inputs_and_outputs.htm 4/10
2/22/23, 4:45 PM Prolog - Inputs and Outputs

Output
| ?- see('sample_predicate.txt'),
read(X),
read(Y),
seen,
read(Z).
the_end.

X = end_of_file
Y = end_of_file
Z = the_end

yes
| ?-

So from this example, we can see that using the see() predicate we can read from the file. Now after
using seen command, the control transfers to the console again. So finally it takes input from
console.

Processing files of terms

We have seen how to read specific contents (few lines) of a file. Now if we want to read/process all
the contents of a file, we need to write a clause to process file (process_file), until we reach the end
of the file.

Program
process_file :-
read(Line),
Line \== end_of_file, % when Line is not not end of file, call process.
process(Line).
process_file :- !. % use cut to stop backtracking

process(Line):- %this will print the line into the console

write(Line),nl,
process_file.

Sample File (sample_predicate.txt)

likes(lili, cat).
likes(jhon,dog).

https://www.tutorialspoint.com/prolog/prolog_inputs_and_outputs.htm 5/10
2/22/23, 4:45 PM Prolog - Inputs and Outputs

domestic(dog).
domestic(cat).

Output
| ?- [process_file].
compiling D:/TP Prolog/Sample_Codes/process_file.pl for byte code...
D:/TP Prolog/Sample_Codes/process_file.pl compiled, 9 lines read - 774 bytes written, 23 m

yes
| ?- see('sample_predicate.txt'), process_file, seen.
likes(lili,cat)
likes(jhon,dog)
domestic(dog)
domestic(cat)

true ?

(15 ms) yes

| ?-

Manipulating characters
Using read() and write() we can read or write the value of atoms, predicates, strings, etc. Now in this
section we will see how to write single characters into the current output stream, or how to read from
current input stream. So there are some predefined predicates to do these tasks.

The put(C) and put_char(C) predicates

We can use put(C) to write one character at a time into the current output stream. The output stream
can be a file or the console. This C can be a character or an ASCII code in other version of Prolog
like SWI prolog, but in GNU prolog, it supports only the ASCII value. To use the character instead of
ASCII, we can use put_char(C).

Program
| ?- put(97),put(98),put(99),put(100),put(101).
abcde

yes
| ?- put(97),put(66),put(99),put(100),put(101).
aBcde

https://www.tutorialspoint.com/prolog/prolog_inputs_and_outputs.htm 6/10
2/22/23, 4:45 PM Prolog - Inputs and Outputs

(15 ms) yes

| ?- put(65),put(66),put(99),put(100),put(101).
ABcde

yes
| ?-put_char('h'),put_char('e'),put_char('l'),put_char('l'),put_char('o').
hello

yes
| ?-

The get_char(C) and get_code(C) predicates

To read a single character from the current input stream, we can use the get_char(C) predicate. This
will take the character. if we want the ASCII code, we can use get_code(C).

Program
| ?- get_char(X).
A.

X = 'A'

yes
uncaught exception: error(syntax_error('user_input:6 (char:689) expression expected')
| ?- get_code(X).
A.

X = 65

yes
uncaught exception: error(syntax_error('user_input:7 (char:14) expression expected'),
| ?-

Constructing Atoms
The atom constructing means from a list of characters, we can make one atom, or from a list of
ASCII values also we can make atoms. To do this, we have to use atom_chars() and atom_codes()
predicates. In both cases, the first argument will be one variable, and the second argument will be a
list. So atom_chars() constructs atom from characters, but atom_codes() construct atoms from
ASCII sequence.
https://www.tutorialspoint.com/prolog/prolog_inputs_and_outputs.htm 7/10
2/22/23, 4:45 PM Prolog - Inputs and Outputs

Example
| ?- atom_chars(X, ['t','i','g','e','r']).

X = tiger

yes
| ?- atom_chars(A, ['t','o','m']).

A = tom

yes
| ?- atom_codes(X, [97,98,99,100,101]).

X = abcde

yes
| ?- atom_codes(A, [97,98,99]).

A = abc

yes
| ?-

Decomposing Atoms
The atom decomposing means from an atom, we can get a sequence of characters, or a sequence
ASCII codes. To do this, we have to use the same atom_chars() and atom_codes() predicates. But
one difference is that, in both cases, the first argument will be one atom, and the second argument
will be a variable. So atom_chars() decomposes atom to characters, but atom_codes() decomposes
atoms to ASCII sequence.

Example
| ?- atom_chars(tiger,X).

X = [t,i,g,e,r]

yes
| ?- atom_chars(tom,A).

A = [t,o,m]

https://www.tutorialspoint.com/prolog/prolog_inputs_and_outputs.htm 8/10
2/22/23, 4:45 PM Prolog - Inputs and Outputs

yes
| ?- atom_codes(tiger,X).

X = [116,105,103,101,114]

yes
| ?- atom_codes(tom,A).

A = [116,111,109]

(16 ms) yes

| ?-

The consult in Prolog

The consulting is a technique, that is used to merge the predicates from different files. We can use
the consult() predicate, and pass the filename to attach the predicates. Let us see one example
program to understand this concept.

Suppose we have two files, namely, prog1.pl and prog2.pl.

Program (prog1.pl)
likes(mary,cat).
likes(joy,rabbit).
likes(tim,duck).

Program (prog2.pl)
likes(suman,mouse).
likes(angshu,deer).

Output
| ?- [prog1].
compiling D:/TP Prolog/Sample_Codes/prog1.pl for byte code...
D:/TP Prolog/Sample_Codes/prog1.pl compiled, 2 lines read - 443 bytes written, 23 ms

yes
| ?- likes(joy,rabbit).

yes

https://www.tutorialspoint.com/prolog/prolog_inputs_and_outputs.htm 9/10
2/22/23, 4:45 PM Prolog - Inputs and Outputs

| ?- likes(suman,mouse).

no
| ?- consult('prog2.pl').
compiling D:/TP Prolog/Sample_Codes/prog2.pl for byte code...
D:/TP Prolog/Sample_Codes/prog2.pl compiled, 1 lines read - 366 bytes written, 20 ms
warning: D:/TP Prolog/Sample_Codes/prog2.pl:1: redefining procedure likes/2
D:/TP Prolog/Sample_Codes/prog1.pl:1: previous definition

yes
| ?- likes(suman,mouse).

yes
| ?- likes(joy,rabbit).

no
| ?-

Now from this output we can understand that this is not as simple as it seems. If two files have
completely different clauses, then it will work fine. But if there are same predicates, then while we
try to consult the file, it will check the predicates from the second file, when it finds some match, it
simply deletes all of the entry of the same predicates from the local database, then load them again
from the second file.

https://www.tutorialspoint.com/prolog/prolog_inputs_and_outputs.htm 10/10