Re: discriminant questions

[ytomino <aghia05@gmail.com>]

> The relevant part is probably 12.5.1(14):
> "The subtype of each discriminant of the actual type shall statically match
> the subtype of the corresponding discriminant of the formal type."
> which I read as *no formal generic discriminants*. I.e. if "statically
> match" means what I think, then "element" in
>    type ref (element : not null access e) is private;
> cannot be matched because "e" is a formal generic parameter.

Thanks. Yes, I did grep RM just now and found the definition of
"statically match". It's written in 4.9.1:

* both are null constraints;
* both are static and have equal corresponding bounds or discriminant
values;
* both are nonstatic and result from the same elaboration of a
constraint of a subtype_indication or the same evaluation of a range
of a discrete_subtype_definition; or
* both are nonstatic and come from the same formal_type_declaration.
<- *A*

4th clause (*A*) is probably applied.
It seems that a formal type is match only itself.
However, it does not explain why does int_ref (having access Integer)
match the_package_use_ref.ref (having access e), since Integer is not
e statically.

(sorry,
> I can not understand the reason that inst1 is error and inst2 is ok.
This is my typo. "inst2 is error and inst3 is ok" is right.)

Should inst3 be error if inst2 is error?

As another reason, if it is disallowed, we can not replace generic
algorithm from Ada 2005 interface to Ada 2012 interface.

for example, from

-- "count" algorithm with Ada 2005 version
generic
   type Element_Type (<>) is private;
   type Cursor is private;
   type Container is private;
   with procedure Iterate (C : Container; Proc : access procedure (P :
Cursor));
   with function Element (P : Cursor) return Element_Type;
procedure Generic_Count (C : Container; Value : Element_Type) return
Count_Type;

to

-- "count" algorithm with Ada 2005 version
generic
   type Element_Type (<>) is private;
   type Cursor is private;
   type Container is private;
   package Iterator_Interfaces is
      new Ada.Iterator_Interfaces (Cursor, others => <>);
   with function Iterate (C : Container)
      return Iterator_Interfaces.Forward_Iterator'Class;
   type Constant_Reference_Type (
      Element : not null access constant Element_Type) with private;
<- *B*
   with function Constant_Reference (C : Container; P : Cursor)
      return Constant_Reference_Type;
procedure Generic_Count (C : Container; Value : Element_Type) return
Count_Type;

There is no way to use a instance of Vectors.Constant_Reference_Type
as *B*.
We have to use Element or Query_Element still in generic.
I feel this is strange and I think designer(s) of new containers did
not intend it.

> As a work-around, make the second package a child or pass the first one as
> a parameter to it.

It means that we have to write plural versions of Generic_Count for
Vectors, for Doubly_Linked_Lists, for Ordered_Sets and more.