Re: Derived private interface

[Adam Beneschan <adam@irvine.com>]

On Jul 7, 7:09 am, Georg Bauhaus <rm.dash-bauh...@futureapps.de>
wrote:

> I guess I'm uneasy with indicators (which I use) because they
> purport to solve some problem, but this is just accidental,
> and ad hoc, and incomplete in several dimensions.  Maybe something
> better is still possible.

I think you're right that this was an ad hoc solution to an unforeseen
problem, and that there may have been better ways to do this back in
Ada 95 if the team had realized the potential problems.  On the other
hand, I'm not all that uneasy with it because I realize that if we
waited to make sure that everything was perfect, the first version of
Ada would have been Ada 2317 or something like that, and we would have
been stuck with C until then.

Your idea below seems sensible, but it's not backward-compatible; if
it were added to the next version of Ada, a lot of legal programs
would become illegal, and that's something the designers try to
avoid.  Perhaps there's a solution involving aspect clauses---since
they're new, it would be easier to make them backward-compatible.  One
idea off the top of my head:

   type T1 is new T0 with record ... end record
       with inherit => (Op1, Op3), override => (Op2, Op4);

(Aspect specifications don't currently allow lists of identifiers, but
this could probably be changed compatibly.)  Then the type declaration
would be illegal if T0 has a primitive operation that isn't listed in
either list, if an operation is listed that isn't a primitive
operation of T0, if there is a conflicting declaration for something
in the "inherit" list, or there is no overriding declaration for
something in the "override" list.  This is just a first attempt, and
it definitely won't work because it doesn't deal with overloaded names
and there are probably problems with private parts.

But maybe we could implement your idea and still make things backward
compatible:

   type T1 is new T0 with record ... end record
      with Georgs_Rules;

Then if the "with Georgs_Rules" is present, the operation declarations
would have to follow your rules, and if it isn't, they'd follow the
old rules.  Then GNAT would add an option that would cause the
compiler to reject any type extension without this aspect clause.
(Somebody else would have to come up with a better name for this
aspect.)

I'm just brainstorming here; I don't have any idea whether a feature
like this would be worthwhile, particularly since it could cause the
language rules to become somewhat messy.

                                   -- Adam