Re: Simple Question 3

[Vincent Marciante <marciant_remove@li.net>]

I don't remember the RM paragraph reference but the
"problem" is not to do with the definition of what
a primative subprogram is, it is that primative 
functions derived from a tagged type that return a value 
of the derived type do not/can not _inherit_ their 
implementation from the ancestor type.  A new 
implementation must be provided - that is made 
explicit by forcing the declaration of those 
functions to appear for any derived types.

(or something like that ;)

Vinny


Stephen Cole wrote:
> 
> "Stephen Cole" <s_k_cole@yahoo.com> wrote in message
> news:9q49v5$6dj$1@trog.dera.gov.uk...
> > Hi
> >
> > Question 3.....
> >
> > package MyTstTypes is
> >    type MyRcd is tagged
> >       record
> >          a: Integer;
> >          b: Float;
> >       end record;
> >
> >    function Unit return MyRcd;
> >
> >    type MyNewRcd is new MyRcd with
> >       record
> >          c: Integer;
> >       end record;
> >
> > --   function Unit return MyNewRcd;
> >
> >    type MyNewRcd2 is new MyNewRcd with
> >       record
> >          d: Float;
> >       end record;
> >
> > end MyTstTypes;
> >
> > The compiler complains with the following text....
> >
> > "mytsttypes.ads:10:09: type must be declared abstract or "Unit"
> overridden"
> >
> > It wants me to define a version of Unit() for each derived type?! Why?
> >
> >
> 
> Look....people...my confusion is deeper than that. Its about this whole
> question of what a primitive operation is! Is it a function/procedure which
> takes a derived type parameter and/or returns a derived type? Or is it just
> functions which return a derived type only? Or what? The rules seem a bit
> fuzzy and inconsistent here. Why does returning a derived type seem to have
> more rules about what must be later declared in a derived type, than
> function/procedures that just take that derived type as a parameter?
> 
> Example
> Look at the following code....
> 
> package MyTest is
> 
>    type MyTestType1 is tagged
>       record
>          a: Integer;
>          b: Float;
>       end record;
> 
>    function UnitA(a: MyTestType1) return Integer;
>    function UnitB(a: MyTestType1) return MyTestType1;
>    function UnitC return MyTestType1;
> 
>    type MyTestType2 is new MyTestType1 with
>       record
>          c: Integer;
>       end record;
> 
> end MyTest;
> 
> UnitA() does not get flagged by the compiler as needing to be declared for
> MyTestType2. But UnitB() and UnitC() do! But they all hold enough type
> information for the compiler to be "intelligent" enough to know where static
> matching takes place or not. The way the compiler is behaving, its as if it
> only takes into account "out" parameters and does not care what "in"
> parameters look like. My case is futher confussed by the use of class wide
> types. But I'll come back to that if you can answer this static-only case
> for me first.
> 
> Thanks.