Re: Instantiating private types with discriminants?

[rick H <rik_nntp@dsl.pipex.com>]

Ludovic Brenta <ludovic@ludovic-brenta.org> wrote:
> rick H writes:
>> Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>> > BTW, You should probably make Put a primitive operation of General_T. Then
>> > the whole could look like simply:
>> >
>> >   Put (Var_A.all); -- Do what have to be done
>>
>> I'm still a bit new to Ada terminology - does "making Put a primitive
>> operation" mean doing this kind of thing with a generic package...
>>    type Fred is new Integer;
>>    package Fred_IO is new Ada.Text_IO.Integer_IO (Fred);
>>    use Fred_IO;
>> If that's right - how would I do this in my example? I'm puzzled
>> because Var_A.all.Data will resolve to either an Integer or a Float at
>> run-time.  Have I got to declare two new packages - one against
>> Integer_IO and one for Float_IO and let the dispatcher get it right
>> at run-time?
> 
> A "primitive operation" of a type T is a subprogram that:
> 
> - takes a parameter of type T or "access T", or returns a result of
> type T or "access T"
> 
> - is declared in the same package specification as T (same declarative
> region, really)
> 
> If these conditions are met, then the operation is primitive.  If, in
> addition, T is tagged, then a call to a primitive operation dispatches
> dynamically at run time according to the exact type T. Essentially, the
> compiler does the tag comparison and dispatching for you. So you could
> write:
> 
> package P is
>   type T is tagged null record;
>   procedure Put (Item : in T); -- primitive operation
> 
>   type Type_A is new T with Data : Integer; end record;
>   procedure Put (Item : in Type_A); -- primitive operation
> 
>   type Type_B is new T with Data : Float; end record;
>   procedure Put (Item : in Type_B); -- also primitive
> end P;
> 
> package body P is
>   procedure Put (Item : in T) is
>   begin
>       null;
>   end Put; -- we could also have declared this procedure abstract
> 
> procedure Put (Item : in Type_A) is
> begin
>   Ada.Integer_Text_IO.Put (Item.Data);
> end Put;
> 
> procedure Put (Item : in Type_B) is
> begin
>   Ada.Float_Text_IO.Put (Item.Data);
> end Put;
> end P;
> 
> with P;
> procedure Simple_Case is
>   Var_A : P.T'Class := ...; --  class-wide type: could be T, Type_A or
> Type_B
> begin
>   P.Put (Var_A); -- dynamic dispatch to suitable version of Put
> end Simple_Case;
> 

Thanks, Ludovic.  Bearing in mind that, in my original example, Var_A is
declared as an *access* to the class-wide type, I tried declaring the
various Put procedures as you showed, and then simply dereferencing
Var_A when calling Put:
   Put (Var_A.all);
However, the compiler (gnat) complained that I cannot use a class-wide
argument in this case.
What I had to do is to create two new types - one to access Type_A and
one to access Type_B.  Then I can call Put without dereferencing Var_A,
but at the expense of having to perform a type-conversion, e.g.
   Put (Type_B_Ptr(Var_A));

Obviously this gets me back to where I was before - having to check the
type prior to converting that type to either Type_A_Ptr or to
Type_B_Ptr...

if Var_A.all in Type_A then
   Put (Type_A_Ptr (Var_A));
elsif Var_A.all in Type_B then
   Put (Type_A_Ptr (Var_A));
end if;



Rick