Re: Ada 200X

["Robert I. Eachus" <rieachus@attbi.com>]

Vinzent Hoefler wrote:

 > This is where the "inherited" keyword comes handy...

I got to this point and suddenly realized why none of what Vinzent said 
was tracking.  Everything he said had nothing to do with Ada. In Ada 
most methods are inherited by default.

There is a special exception for functions which return a value of the 
tagged type which is being derived from.  In that case the function is 
inherited as an abstract operation, so that if you want to use it you 
must provide a body.  This is because you normally will need additional 
initialization code in the child.  If not:

       type Foo is tagged record
         ...
       end record;

       function Create(...) return Foo;
       procedure Print(F: in Foo);
       ...
       type Bar is new Foo with null record;
       -- at this point there is a Create which returns Bar, but it
       -- doesn't work.  There is an implicitly declared Print, and
       -- it can be called immediately.

       function Create(...) return Bar;
       ...
       function Create(...) return Bar is
       -- It would be nice to be able to say here:
       -- begin return Foo(Bar'(Create(...)); end Create;
       -- but the rules of the language don't allow downward conversions
       -- of tagged types, even if the child has no new fields. :-(

However, for the Print procedure I don't have to do anything special. 
It can be called on an object of type Bar by anyone who has a with 
clause for the package declaring Bar, even if there is no with clause 
for the package specifying the Print procedure.

So Vinzent if you try to reimplement this hierarchy in Ada you will 
learn a lot, including how easy it is.  But you will also find that some 
things which are classes in other languages are better handled as 
mix-ins in Ada.  Mix-ins are perfect for attributes and behavior that 
cut across a normal class hierarchy.  For example you could make 
radio_buttons a mix-in instead of a separate class.  Then for objects 
(windows) that need radio buttons you can mix in as many buttons as a 
particular window type or singleton instance needs.