Re: Another Idea for Ada 20XX

[Wes Groleau <wgroleau@usa.com>]

Richard Riehle wrote:

>          package Metric_Number is
>               type Metric_Type is private;
>               -- export services for arithmetic on this type
>               function "+"(L,  R : Metric_Type) return Metric_Type;
>               -- more arithmetic and boolean functions
>          private
>               -- full definition for the Metric_Type;
>               -- helper type to avoid recursion during implementation
>          end Metric_Number;

However, you have a proliferation of combination functions.

  function "*" (Left   : Some_Metric_Type;
                Right  : Another_Metric_Type)
                return : One_More_Metric_Type;

  function "/" (Left   : Some_Metric_Type;
                Right  : Another_Metric_Type)
                return : One_More_Metric_Type;

With a reasonably complete facility, the number of
left/right/return combinations is huge.  Especially
if you allow mixed unit addition:

  function "+" (Left   : Meters;
                Right  : Kilometers)
                return : Meters;

Also, this method does not allow attributes
and it makes literals slightly more clumsy at best,
worse if you consider all the possible ways you can
misspell a unit name or use an unrecognized abbreviation
for it.  (Of course the latter might also be a problem
in a "language feature.")

I once used an enumerated type for supported units,
another for all allowed ways of writing them,
a lookup table for standard_form (allowed_written_form),
and loads of lookup tables for conversion factors,
which type comes from what, etc.  That allowed having
only one actual type, and only one moderately sized
function per operator, but the tables took up a lot
of space.  Extension and inheritance might have helped
some but not a lot.  In that particular application,
the lack of attributes turned out to be only a minor
inconvenience, but I would think it would mean a lot
in other cases.

Defining a new metric type by inheritance would require
knowing all units in the inheritance tree that it could
interact with, and providing or overriding the operators
to work AND disabling all the operators that would make
illegal operations.

So I think it wouldn't help any over a non-inherited way.

-- 
Wes Groleau
http://freepages.rootsweb.com/~wgroleau