Re: Question about generics.

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Tue, 04 Jul 2006 09:29:40 -0400, Stephen Leake wrote:

> That does seem like a reasonable goal. But I think you need to modify
> the language to get there. Perhaps a new class of generic parameters:
> 
> generic 
>     Size : static Integer;
> package Xyzzy_Static is
>   type Index is mod Size;
>   -- etc.
> end Xyzzy_Static;
> 
> Then Xyzzy_Static could only be instantiated with truly static Size
> (in the Ada meaning of 'static').
> 
> Short of that, I think you have to declare the type outside the
> generic package, as you say.
> 
> I often find it better to declare the type outside the package,
> because I want it for things the package doesn't declare. But if you
> intend to put everything into the generic, it would be nice to do it
> your way.
> 
> It would be interesting to raise the 'static' proposal on the Ada
> comment mailing list (where they discuss future changes to the Ada
> language). But to do that right, I'd need more information about why
> you want to do this. Their mostly likely response will be "it's not
> hard to declare the type outside the package". So we need some more
> ammunition about why that's not a good answer.

It is more interesting for cases unrelated to generics:

User-defined static functions:

   function Factorial (N : static Natural) return static Natural;
   type My_Strange_Type is mod Factorial (5);

   function C_Compiler (X : static String) return static Float;
C : constant Float :=
        C_Compiler ("/* some C program */ float x=2.0; for(;;){...");
            -- Evaluated by the compiler at compile-time.

   function Number_Quarks_Requred_On_This_Mashine
             (  OS : static String;
                CPU : static String;
                ...
             )  return static Quark_Number;              

   function To_UTF8 (X : static String) return static String;
   while Current_Line = To_UTF8 ("...") loop
      ...; -- Manual constant folding is always possible, though
   end loop;

   type EEPROM is array (...) of Storage_Elements;
   Boot : static EEPROM := Link (C_Compiler (...));
   for Boot'Address use ...;

if Pure were a qualifier instead of pragma, then static result could be
made implied from static parameters. I have difficulty to classify "static"
as a type qualifier. Is static X is subtype, new type or what.

Dimensioned arithmetic:

type Unit is mod 2**28; -- Encoded powers of base units
type Dimensioned (SI : Unit) record
   Gain : Float;
end record;
function "+" (Left, Right : Dimensioned)  return Dimensioned;
function "-" (Left, Right : Dimensioned)  return Dimensioned;
function "*" (Left, Right : Dimensioned)  return Dimensioned;
function "/" (Left, Right : Dimensioned)  return Dimensioned;
...

type Static_Dimensioned (SI : static Unit) is new Dimensioned (SI);
   -- Statically constrained Dimensioned, the compiler is *required* to
   -- drop the discriminant in the representation of. When converted
   -- back to Dimensioned, the discriminant is reconstructed. Forward
   -- conversion is compile-time type error, when the discriminant
   -- isn't static.

function "+" (Left, Right : Static_Dimensioned)
   return Static_Dimensioned;
function "-" (Left, Right : Static_Dimensioned)
   return Static_Dimensioned;
function "*" (Left, Right : Static_Dimensioned)
   return Static_Dimensioned;
function "/" (Left, Right : Static_Dimensioned)
   return Static_Dimensioned;
...

I think you've got the idea. This gives you dimensioned arithmetic fully
statically checkable, space/time penalty free, which also can handle
unknown dimensions at run-time.

But there are too many problems with this. Note how important are partially
static types like Static_Dimensioned. Just one type qualifier "static" does
not solve the problem. It must be much finer.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de