Generic default parameters

[Thomas Wolf <t_wolf@angelfire.com>]

It seems I'm not alone with these ideas... so let's summarize
and see if we can get a halfway decent proposal for the ARG
out of the discussions:

Ada 95 lacks features for:

1. specifying a default type for generic formal type parameters

   The idea would be to allow something like

   generic
      type Something is range <> := Natural;

   and if an instantiation does *not* supply an actual for
   'Something', 'Natural' will be taken.

2. specifying a default for generic formal package parameters:

   generic
      with package X is new Y (<>) := Z;

   where Z of course would have to be an instantiation of Y.

   Or maybe even

   generic
      with package X is new Y (<>) := Y (Param1 => Default1,
                                         Param2 => Default2,
                                         ...);

   i.e., allow the default to be an anonymous instance?
   (I guess, the first variant is sufficient, and the second
   would only unnecessarily complicate matters.)

3. specify a default for a generic formal "in out" object:

   with System.Storage_Pools;
   generic
      type Something is private;
      Pool : in out System.Storage_Pools.Root_Storage_Pool'Class :=
         Some_Default_Pool_Instance;
   package X is
      type Some_Access is access all Something;
      for Some_Access'Storage_Pool use Pool;
      ...

4. providing defaults in a generic renaming:

   generic
     type Something is private;
   package A is ...

   generic package B renames A (Something => Integer);

   or even

   generic
     type Something is range <> := Natural;
   package C is ...

   generic package D renames C (Something => Integer);

5. Linked to (3) above: some way to specify a storage pool that
   is equal to whatever pool the compiler would use if no
   "for Some_Access'Storage_Pool use ..." clause was present, i.e.
   a generic way to refer to the standard storage pool of a type
   without referring to the type. Something like

   generic
      type Something is private;
      Pool : in out System.Storage_Pools.Root_Storage_Pool'Class := <>;
   package X is
      type Some_Access is access all Something;
      for Some_Access'Storage_Pool use Pool;
      ...

   and if an instantiation provides an actual for 'Pool', that will
   be taken as the storage pool of type 'Some_Access', but if an
   instantiation doesn't provide an actual, 'Some_Access' will use
   a standard storage pool.

   Not sure if point (5) makes sense, especially since it would be
   useful only for storage pools, but make no sense at all for other
   types...

Personally, I have encountered several occasions where I would have
liked to have some (or all) of these features. They'd help a lot in
writing general generics (:-) that still are simple to instantiate.
 
Comments, anyone? Would these things be worth to consider for inclusion
in the next Ada revision? 

-- 
-----------------------------------------------------------------
Thomas Wolf                          e-mail: t_wolf@angelfire.com