Should the compiler accept this?

Should the compiler accept this?

[Stephen Cole]

Hi

Simple question 2......

package MyTstTypes is
   type MyRcd is abstract tagged
      record
         a: Integer;
         b: Float;
      end record;

   function Hello(A: MyRcd) return Integer is abstract;

   type MyNewRcd is new MyRcd with
      record
         c: Integer;
      end record;

   function Hello(A: MyNewRcd) return Integer;

   type MyNewRcd2 is new MyNewRcd with
      record
         d: Float;
      end record;

   function Add(A: MyRcd'class) return Integer;

end MyTstTypes;

The compiler is not complaining about it, but according to the rules of Ada
and not just what the compiler accepts, should I be defining a function
Hello() for derived type MyNewRcd2?? Or can I always assume that the Hello()
defined for type MyNewRcd will actually catch calls to Hello() made with an
actual MyNewRcd2 type variable passed as a parameter to Add()?

Re: Should the compiler accept this?

[Ted Dennison]

In article <9q1uah$6ir$1@trog.dera.gov.uk>, Stephen Cole says...
>The compiler is not complaining about it, but according to the rules of Ada
>and not just what the compiler accepts, should I be defining a function
>Hello() for derived type MyNewRcd2?? Or can I always assume that the Hello()
>defined for type MyNewRcd will actually catch calls to Hello() made with an
>actual MyNewRcd2 type variable passed as a parameter to Add()?

The only time you *have* to define an overriding subprogram is when the parent's
version of the subprogram was abstract. Otherwise, you can just let it dispatch
to the parent's subprogram (which it will do).

---
T.E.D.    homepage   - http://www.telepath.com/dennison/Ted/TED.html

No trees were killed in the sending of this message. 
However a large number of electrons were terribly inconvenienced.

Re: Should the compiler accept this?

[Ed Falis]

Stephen Cole wrote:

> The compiler is not complaining about it, but according to the rules of Ada
> and not just what the compiler accepts, should I be defining a function
> Hello() for derived type MyNewRcd2?? Or can I always assume that the Hello()
> defined for type MyNewRcd will actually catch calls to Hello() made with an
> actual MyNewRcd2 type variable passed as a parameter to Add()?

No, because you're deriving MyNewRcd2 from MyNewRcd, which does provide
a concrete version of Hello, and which is inheritied by MyNewRcd2.  If
you'd derived MyNewRcd2 directly from MyRcd, you would have had to
provide a specific concrete Hello for it.

- Ed

Re: Should the compiler accept this?

[Stephen Cole]

Thanks!