Displaying Integers

Now let's write a program called Add that computes 2 + 2 and displays the
result. You may think that we could take the Hello program and substitute
2 + 2 for "Hello!", but that won't work.
(We never said Ada is easy!) Why won't it work? Because Ada.Text_IO
doesn't have a procedure Put_Line that takes an Integer parameter. One
correct program is this:

It's called a generic package because it has an empty
box (<>) in place of the type. We can make a
new, ready-to-use package from Integer_IO by
giving the type: package My_Int_IO is new
Integer_IO(Integer); we could have used any name
in place of My_Int_IO. Note that we've declared
our new package locally inside the procedure
Add. My_Int_IO now has the same procedures and
functions as Integer_IO, but with the empty box
filled in with the type Integer.
Since Integer_IO (and therefore My_Int_IO) doesn't have a Put_Line, we call
My_Int_IO.Put and then Ada.Text_IO.New_Line. Note that our program says
use My_Int_IO; after declaring My_Int_IO. When the compiler
sees the call
Put(2 + 2); it writes code to call My_Int_IO.Put rather than Ada.Text_IO.Put,
because My_Int_IO.Put takes a parameter of type Integer. The compiler then
finds New_Line in Ada.Text_IO and writes a call to Ada.Text_IO.New_Line.

Question

False.
Since Integer_IO is generic, a program can't call its procedures and
functions. The program must specify the type and create an instance of
Integer_IO, such as My_Int_IO. It can then call Put in My_Int_IO.
Note also
that we can't use a generic package like Integer_IO, but only an instance
of it like My_Int_IO.

You're right!
Since Integer_IO is generic, a program can't call its procedures and
functions. The program must specify the type and create an instance of
Integer_IO, such as My_Int_IO. It can then call Put in My_Int_IO.
Note also
that we can't use a generic package like Integer_IO, but only an instance
of it like My_Int_IO.

This process of creating an instance of the generic package Integer_IO for the
type Integer is called generic instantiation.
Later in this course we'll
learn to write our own generic packages, procedures, and functions. However,
we wanted to learn, early in the course, how to instantiate an already written
generic package in order to display integers.

But why does Ada make Ada.Text_IO ready-to-use for Strings, while Integer_IO is
generic, and has to be instantiated for Integers? Because programs normally
use only one type String, but can have several integer types. Right now, we
know of only one integer type, the standard Integer. Later we'll learn about
user-defined types and derived types, and we'll see how there can be many
integer types. Integer_IO can be instantiated for each of these types.

Ada 95 provides a ready-to-use package Ada.Integer_Text_IO,
which is equivalent
to the package we obtain by instantiating Ada.Text_IO.Integer_IO for the type
Integer. Thus, with an Ada 95 compiler, the above program wouldn't have to do
its own instantiation of Integer_IO; instead, it could have added
Ada.Integer_Text_IO to both the with and the use clause.
However not all
Ada 83 compilers provide such a package, and those that do use a non-standard
name, such as IIO.

There's another generic package within Ada.Text_IO called Float_IO. Input and
output of floating point numbers is done by instantiating Float_IO for the type
Float. As with integers, we'll later learn how there can be several floating
point types besides the standard Float; that's why Ada.Text_IO.Float_IO is
generic. (Ada 95 provides us with a ready-to-use package called
Ada.Float_Text_IO, equivalent to the package we obtain by instantiating
Ada.Text_IO.Float_IO for the type Float. However, not all Ada 83 compilers
provide a similar package, and those that do use a non-standard name like FIO.)

Later in this course, when we cover attributes, we'll learn another way to
display Integers (and, in Ada 95, Floats as well), by using the 'Image
attribute.

We're now ready for our first Outside Assignment! Let's compile and run our
two sample programs, Hello and Add. The files HELLO.ADA and ADD.ADA are
already supplied for you, and they're written to work with Ada 83 compilers as
well as Ada 95. (That's why they say simply Text_IO instead of Ada.Text_IO.)