Re: User-defined type attributes (replacing genericity)

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

On Fri, 14 Mar 2008 15:31:40 +0100, Georg Bauhaus wrote:

> On Fri, 2008-03-14 at 10:00 +0100, Dmitry A. Kazakov wrote:
> 
>> Right, but this also implies that there is no need to have generics at all.
>> A class-wide object does all what needed:
>> 
>>    generic
>>       type S is new T with private;
>>    procedure Foo (X : in out S);
>> 
>> can be replaced by:
>> 
>>    procedure Foo (X : in out T'Class);
> 
> I assume your answer to what follows will be that Ada semantics
> should be put under programmer control,

What's wrong with having control over the semantics?

> that range should be and interface type, etc. ;-)

Shouldn't it?

> But anyway, even that doesn't change things.
> 
> I just looked at the effects. Not promising on two accounts,
> but more rattling regularity. Which might have its place.
> 
> Replacing genericity means every generic instance is replaced
> with an invocation of just one procedure.

No, only calls to instances of generic bodies.

> However, for objects of
> specially crafted types. One type needs to be available for
> mimicking each generic.
> 
> I had two types
> 
>     type Simple is range 1 .. 100;
>     -- predefined "<="
> 
>     type Data is record
>        amount: Natural;
>        wpi: Float;
>     end record;
> 
>     function "<="(a, b: Data) return Boolean;
> 
> According to the suggestion to abandon generics I have had instead,
> basically,
> 
>    procedure Foo (X, Y, Z : in out T'Class) is
>       function Is_Highest(V: T) return Boolean is
>       begin
>          return X <= V and then Y <= V and then Z <= V;
>       end Is_Highest;
>    begin
>       ...
> 
> The comparison function "<=" needs to be one of the primitive
> operations of all types in T'Class. (Hence a wrapper type becomes
> necessary for range type Simple.)

No, what you need is an interface implemented by both. You need to declare
Simple implementing Ordered. That will tell the compiler that the
predefined "<=" is an implementation of Ordered's "<=".

> (I'll leave out the problem of local variables of type T'Class.)
> (I'll leave out required variance programming work, too.)
> 
> With generics, I got two nicely specialized instances of Foo,
> one for the range type, the other for the composite type.
> The effect is that function Is_Highest will use "<=" as I
> would expect for a range type. Small code, obvious, and
> efficient. Similarly, the "<=" of the Data instance's
> Is_Highest function corresponds directly to both the definition
> and to the expectation.
> 
> Without generics, there is only one Is_Highest, as might be
> expected. 

Why there have to be two? The whole idea of generics was to have *one*
generic body. This is why it is called generic [programming].

> Inlining did not help. In fact, I wouldn't expect inlining to be
> readily available with 'Class---unless of course
> replacing generics should also entail compilers that look at
> the entire program. Then, maybe, a few more thing can be
> "optimized" at compile time.

You mixing two different problems. BTW, I answered both in my earlier
posts. So I repeat it short. If you want to constrain the dispatching table
to the diagonal you do it

   procedure Foo (X, Y, Z : in out T)

This requires X, Y, Z to have exactly same type. The language of
constraints is a different theme. Do not sell a limitation of generics to a
certain type of constraint as genuine advantage.

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