Implicit instantiation (was Re: was Re: Ada / C++ comparison paper anymore)

["Mark Lundquist" <no.spam@getalife.com>]

"Patrick Hohmeyer" <pi3_1415926536@yahoo.ca> wrote in message
news:DK6U7.24955$Yq5.2627743@news20.bellglobal.com...
>
> Ok, an exemple :
>
> procedure X is
>
>    generic
>       type Number is range <>;
>       type Num_Arr is array (Integer range <>) of Number;
>    function Mean(A : Num_Arr) return Number;
>
>    function Mean(A : Num_Arr) return Number is
>       Sum : Integer := 0;
>    begin
>       for I in A'Range loop
>          Sum := Sum + Integer(A(I));
>       end loop;
>       return Number(Sum/A'Length);
>    end Mean;
>
>
> type T_Employes is array(Integer range <>) of Natural;  -- employe numbers
> type T_Employe_S is array(Integer range <>) of Natural; -- employe
salaries
>
> function Sal_Mean is new Mean(Natural,T_Employe_S);
>
> Employes  : T_Employes(1..1000);
> Employe_S : T_Employe_S(1..1000);
> Mean_Sal  : Natural;
>
> begin
>    Mean_Sal := Sal_Mean(Employe_S); -- line 1
>    Mean_Sal := Sal_Mean(Employes);   -- line 2
> end X;
>
> --end code -----------------------
>
> First, I know that identifiers as similiar as Employes and
> Employe_S are bad.
> You can easly mix them and thats exactly the point here.
>
> Line 1 is correct, we calculate the mean salary of our employes.
> But Line 2 calculates the mean of the employe numbers.
> This makes no sense, and thanks to Ada this dont even compile,
> as I haven't defined the Mean function for the employe numbers

The real problem there is that the programmer made a conscious choice to use
the same type (Natural) for two unrelated abstractions.

Next, they put themselves in the way of trouble by a deliberate
choice of extremely error-prone names.

And your point is that they are still protected, because to make it past the
compiler they would have to screw it up in two places (the instantiation and
the call) instead of just one.

Look, your moron of a programmer now already has about a hundred ways to
hose
him/herself; what's the harm of letting them have one more, if that were
the price of a much more powerful language for the rest of us?  Your example
code is a grenade with the pin pulled, with or without implicit
instantiation.  (I trust I don't need to give an example here...)

I would not consider it a "great strength of Ada" for me to have to deal
with labor-intenstive generics for the sake of a check that benefits only
people who go out of their way to program badly.  Ada is engineered for
safety against normal human error, not error compounded by inexcusably lame
programming practice.

Best Regards,
-- mark