Re: Announce: Grace project site operational

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

On Wed, 15 May 2002 14:30:30 -0400, Hyman Rosen <hyrosen@mail.com>
wrote:

>Dmitry A. Kazakov wrote:
> > I believe that an improvement of Ada's ADT/OO gears is
> > much more important than any investments in inherently
> > flawed generics-templates-macros.
>
>There were no macros in my C++ code, and there are no macros
>in Ada. Generics/templates are not inherently flawed.

In short, generics are macros.

>> Generally, I dislike any type-based solution of the unit problem.
>> I believe that the right way is a subtype-based, OO-ish one.
>
>Yes, that seems to go along with your "inherently flawed".
>You're wrong, because units exist, even in the real world,
>only to serve as type tags. The operations on them are just
>pure arithmetic on the values they represent; the unit itself
>plays no part in the calculation. (Aside from the silly biased
>temperature units, which are just dispensed with by working in
>Kelvin.)

I do not see why the above should serve an argument against a
subtype-based solution. Generics are bad for units because they
enforce dimensioned values be of unrelated types. Note that it has
nothing to do with strong typing and compile-time checks. All that can
be done with subtypes.

>I fail to see the need for any OO approach to units.
>What are you placing in derived types which is different from
>the base type?

Nothing. The derived type is just another subtype to enforce
compile-time type checking. For instance, a discriminant-based
variant:

   type Measure (SI : Unit := Unitless) is record
      Gain : Number;
   end record;)

You can derive a subtype from it by constraining:

   subtype Speed is Measure (Velocity);
   subtype Length is Measure (Distance);

Now:

   X : Speed;
   Y : Length;

   X := Y; -- Constraint_Error

It is absolutely safe, and a decent Ada compiler should give you
warning at compile time.

>Why do you want run-time dispatching?

How do you write a Put for dimensioned values? It shall be class-wide
= work on all unit [sub]types. Do you want to make it generic and
instantiate each time? Consider a real-world application. There is a
roller dynamometer. It has thousands of sensors and actors, many of
them are just analogue inputs/outputs. It has a human interface with
hundreds virtual instruments capable to indicate readings in any unit.
The operator can configure measurement channels dynamically. Nobody
knows which unit will have the input channel 1208 next day. Nobody
knows whether the gauge X on the panel Y will show the velocity in
km/h or in mph. With a type-based units implementation you will be
lost.

A real unit solution should combine compile-time checks and effective
removal of unit information when it is statically known, with an
ability to deal with measures of unknown dimension with checks at
run-time.