Re: Equality operator overloading in ADA 83

[dewar@merv.cs.nyu.edu (Robert Dewar)]

<<Right now, the RM95 is silent about whether equality composes for
Bounded_String.  The requirement for composability is therefore ambiguous,
which isn't acceptable for any kind of requirements document.>>

The RM leaves many aspects of Ada as implementation defined. There is no
general principle that this is unacceptable. Indeed, trying to remove all
implementation dependencies as Java does is an efficiency disaster -- for
example in the Java case, the requirement for IEEE fpt leads to completely
unaceptable performance on some targets (such as SGI and Alpha), but
in practice no one takes these specs that seriously.

In the Ada world, we prefer to have the spec taken seriously, and explicitily
recognize the implementation dependencies.

So there is no general principle here, other than the general one which
says don't make things impl-dependent unless there is a good reason. So
the question is whether there is a good reason here. Obviously the ARG
on reflection feels that it is better that this not be impl dependent,
but there is a cost -- in the case of bounded string, either there
will be a non-zero efficiency cost at runtime for ALL operatoins on
bounded strings ALL the time, or you need a very special non-Ada kludge
in the compiler -- and we don't like to require these.

I note that very often people assume that because the GNAT library is
written in Ada 95, it can be used with any Ada 95 compiler. In particular
for instance, I often meet people who have been told by sales people for
other compilers not to worry about the informatoin systems annex, since
you can just use the GNAT libraries.

Well this of course is NOT always true, and in particular is not true
at all of the informatoin systems annex stuff (since this requires
fundamentall support from the compiler for high precision deciaml fixed
point which at present only exists in GNAT, and also recognition of
some intrinsics (e.g. the one for DIVIDE).

Well up to now the bounded string implementation has indeed been portable
(I know for example that Aonix has distributed GNAT sources for some of
the library functions for Object Ada, which is perfectly fine, although
they tend necessarily to be out of date versions -- I don't know if
bounded string is such a package).

Now with the version of GNAT in which this problem is "fixed", you will
have to add bounded strings to the list of GNAT packages that are GNAT
specific. No big deal, and certainly not a disadvantage for us, but 
something we like to avoid where possible.

Robert Dewar
Ada Core Technologis