AdaTutor - Generics and Tasking

Generics

It would be easy to write a package that creates a single stack of 10 Integers, and lets us Push and Pop on it.  However, the code would be about the same regardless of the size of the stack, and regardless of the type of objects on the stack.  For example, a second package that creates a stack of 50 Dates would look about the same.  We can write one generic package, and instantiate it for any size and almost any type we need.  The specification is:

   generic
      Size : Positive;
      type Dummy is private;
   package Stack_Package is
      procedure Push(Object : in Dummy);
      function Pop return Dummy;
   end Stack_Package;

Since both Size and type Dummy are generic, both must be specified when we instantiate the package:

   package Stack_Of_10_Integers is new Stack_Package(10, Integer);
   package Stack_Of_50_Dates    is new Stack_Package(50, Date);

Generic objects like Size may be given default values.  A default value is used only if we don't specify that parameter in the instantiation.  For example:

generic
   Size : Positive := 10;
   type Dummy is private;
package Stack_Package is
   procedure Push(Object : in Dummy);
   function Pop return Dummy;
end Stack_Package;

package Stack_Of_10_Integers is new Stack_Package(Dummy => Integer);
package Stack_Of_50_Dates    is new Stack_Package(50, Date);

In the above example, we specified a generic type with

type Dummy is private;

Actually, there are a number of ways to specify a generic type.  How we specify the generic type determines what actual types we may use in the instantiation, and what we may do with objects of that type in the body of our generic package or subprogram.  Let's look at the alternatives.

If the generic part says type Dummy is private; then, in our subprogram or package body, what we may do with objects of type Dummy is similar to what we may do with objects of a private type outside an ordinary package: create them, assign them, test them for equality or inequality, and call other subprograms already available to us.  Although this list is short, we can instantiate with almost any type at all: Dates, Floats, Strings (see the next paragraph), Rainbow_Colors, and any type for which we can assign objects and test them for equality.  That means any type except a limited type.  We can't instantiate Stack_Package for type Ada.Text_IO.File_Type (a limited private type), or for task types (a limited type discussed later), because in our package body we're allowed to assign and test for equality objects of type Dummy.

We can't create objects of an unconstrained type like String.  So, in Ada 83, if our package or subprogram creates objects of type Dummy, we can't instantiate it for type String; we must use a constrained subtype of String.  Thus we could write subtype Name is String(1 .. 30); and then instantiate our package with package Stack_Of_50_Names is new Stack_Package(50, Name);.  In Ada 95 we can instantiate with an unconstrained type if and only if the formal type name in the generic part of the specification (Dummy in our example) is followed by (<>).  In that case, the subprogram or package body must initialize any objects of that type that it creates, in order to constrain them.

We can instantiate our package or subprogram even for limited types like Ada.Text_IO.File_Type if the generic part says type Dummy is limited private;.  However, the only things our package or subprogram body could do with objects of that type is create them and call other subprograms already available to us.  Ordinarily, that's not very useful.

If the generic part says type Dummy is (<>); then we can instantiate the package or subprogram for any discrete type.  That means any enumeration or integer type: Character, Boolean, Counter, No_Of_Apples, etc.  In the body, attributes like 'First are available.

If the generic part says type Dummy is range <>; then we can instantiate for any integer type.  In the body, we can do things that can be done with all integer types, such as add, etc.

If the generic part says type Dummy is digits <>; then we can instantiate for any floating point type, such as Float or the Real we created.

If the generic part says type Dummy is delta <>; then we can instantiate for any fixed point type, to be discussed in the section on More Records and Types.

In Ada 95, some additional forms are allowed; beginners shouldn't expect to grasp them until later.  If the generic part says type Dummy is tagged private; then we can instantiate with any tagged type, to be covered in the section on More Records and Types.

If the generic part says type Dummy is new X; or type Dummy is new X with private; then we can instantiate with type X or with any type derived from X.  If with private is included, then we must instantiate with a tagged type.

In both cases above, as with type Dummy is private; and type Dummy is limited private; we can follow Dummy with (<>) to allow instantiating with unconstrained types.  The body must initialize any objects of an unconstrained type that it creates.  We can also replace is in the generic part with is private to allow instantiating with abstract types, to be covered later.

If the generic part says type Dummy is mod <>; then we can instantiate with any modular type, to be covered in the section on More Records and Types.

Finally, if the generic part says with package Dummy is new P (<>); where P is the name of a generic package, then we can instantiate with any package that we obtained by instantiating P.

A generic package body looks just like an ordinary package body:

   package body Stack_Package is
      procedure Push(Object : in Dummy) is separate;
      function Pop return Dummy is separate;
   end Stack_Package;

   separate (Stack_Package)
   procedure Push(Object : in Dummy) is
      ...
   end Push;

   (etc.)

Note that we simplified our Stack_Package example by ignoring the possibilities of stack overflow and underflow.  Ordinarily, these would be handled by exceptions.

The specification of a generic subprogram must be given separately from the body.  For example, we can't eliminate the highlighted line in the following function:

   generic
      type Dummy_Float is digits <>;
      type Dummy_Vector is array (Integer range <>) of Dummy_Float;
   function Sum(V : in Dummy_Vector) return Dummy_Float;
   function Sum(V : in Dummy_Vector) return Dummy_Float is
      Answer : Dummy_Float := 0.0;
   begin
      for I in V'Range loop
         Answer := Answer + V(I);
      end loop;
      return Answer;
   end Sum;

We can instantiate Sum and call our instantiation as follows:

   type Vector is array(Integer range <>) of Float;
   V1 : Vector(1 .. 10);
   X  : Float;
   function Sumv is new Sum(Float, Vector);
   ...
   X := Sumv(V1);

Question

 generic
    type Dummy is range <>;
 procedure Display(Item : in Dummy);

 type No_Of_Apples is new Integer;
 type Counter is range 0 .. 1_000_000;
 type Answer is (Yes, No, Maybe);
 procedure Display_Apples   is new Display(No_Of_Apples);  -- 1
 procedure Display_Counters is new Display(Counter);       -- 2
 procedure Display_Answers  is new Display(Answer);        -- 3

Which commented line in the above program segment is illegal?

1 - No, when the generic part says type Dummy is range <>;, the procedure may be instantiated for any integer type.  No_Of_Apples is a type derived from Integer, so it's an integer type.

2 - No, when the generic part says type Dummy is range <>;, the procedure may be instantiated for any integer type.  The definition of the user-defined type Counter has the word range, so Counter is an integer type.

3 - You're right!  When the generic part says type Dummy is range <>;, the procedure may be instantiated for any integer type.  Answer is a discrete type, but not an integer type.

< prev   next >