Re: Instantiating private types with discriminants?

["Ludovic Brenta" <ludovic@ludovic-brenta.org>]

rick H a écrit :

> Hello,
>
> I'm slowly learning Ada for my own amusement, and I've ground to a halt
> trying to understand something.  If some kind sole could explain it to
> me, I'd be very grateful.
>
> I've defined two types, each with a descriminant, and each with its own
> access type.  One of the type's implementations is, however, private:
>
> package Discrim is
>    type Type_A (Param : Integer := 100) is null record;
>    type Type_A_Ptr is access Type_A;
>
>    --  same as above, but implementation now private...
>    type Type_B (Param : Integer := 100) is private;
>    type Type_B_Ptr is access Type_B;
> private
>    type Type_B (Param : Integer := 100) is null record;
> end Discrim;
>
>
> When I use "new" on two variables declared as Type_A_Ptr and Type_B_Ptr,
> one requires a type conversion for the discriminant, whereas the other
> requires a qualified expression:
>
> with Discrim; use Discrim;
> procedure Use_Discrim is
>    A : Type_A_Ptr;                   --  public  implementation
>    B : Type_B_Ptr;                   --  private implementation
> begin
>    A := new Type_A'(Param => 100);   --  qualified expression
>    B := new Type_B (Param => 123);   --  type conversion
> end Use_Discrim;
>
> So, my question to the experts is: Why does "privatising" a type's
> details change the way that you "new" instantiations of it?

Actually, the declaration of B is not a type conversion; it is an
allocator that uses a subtype_mark, as opposed to a
qualified_expression (see ARM 4.8(2)).

Use_Discrim sees all the components of Type_A (there is only one: the
discriminant), and so the qualified_expression is legal. But you could
also use an allocator with a subtype_mark, so it is incorrect to say
that A *requires* a qualified_expression; it only *allows* one:

A := new Type_A (Param => 100); -- legal

In contrast, Use_Discrim does not see the components of Type_B other
than the discriminant, so doesn't know if there are any, and so the
qualified_expression'aggregate (defined in 4.7(2)) would be illegal,
since aggregates must contain one expression for each component, per
4.3.1(9).

-- 
Ludovic Brenta.