Design issue: Generics vs Private types

[FMOORE@eg.ti.COM.UUCP]

When should generic packages be used to encapsulate data as
opposed to using packages with private data types?

Consider the following two approachs to protecting data:


generic                              ! package COUNTER is
package COUNTER_TYPE is              ! type C_T is private;
   procedure ZERO;                   !   procedure ZERO (ITEM : out C_T);
   procedure INCREMENT;              !   procedure INCREMENT (ITEM : in out
   procedure DISPLAY;                !                          C_T);
end COUNTER_TYPE;                    !   procedure DISPLAY (ITEM : in C_T);
                                     ! private
package body COUNTER_TYPE is         !   type C_T is some_type ...
DATUM : some_type ...                !  -- data hidden as private type
...-- data hidden within body        ! end COUNTER;
end COUNTER_TYPE;                    !
                                     !
package COUNTER1 is new COUNTER_TYPE;! COUNT1, COUNT2 : COUNTER.C_T;
package COUNTER2 is new COUNTER_TYPE;!
                                     !
COUNTER1.ZERO;                       ! COUNTER.ZERO (COUNT1);
COUNTER2.ZERO;                       ! COUNTER.ZERO (COUNT2);
                         etc.        !


I can imagine that the implementation of these two approaches would
vary from compiler to compiler, especially depending upon how a
compiler implements generics.

However, my interest is in expressing designs.  From the point of
view of good design technique, can one approach over the other be
supported?  If so, what design technique / rules are involved?

Thanks for any insight.
Freeman Moore
FMOORE%ti-eg@relay.cs.net