CVS difference for ai05s/ai05-0213-1.txt
--- ai05s/ai05-0213-1.txt 2011/04/26 22:28:13 1.4
+++ ai05s/ai05-0213-1.txt 2011/05/12 22:21:37 1.5
@@ -1,11 +1,12 @@
-!standard 3.10.1(9.3/2) 10-04-28 AI05-0213-1/01
+!standard 3.10.1(8/2) 11-05-11 AI05-0213-1/02
!standard 12.5(2)
!standard 12.5.1(1/2)
!standard 12.5.1(6)
!standard 12.5.1(11)
-!standard 12.5.1(17/2)
+!standard 12.5.1(18)
!standard 13.14(5)
!class amendment 10-04-28
+!status Amendment 2012 11-05-11
!status work item 11-04-26
!status No Action (8-0-2) 10-06-19
!status work item 10-04-28
@@ -20,7 +21,62 @@
!problem
-** TBD **
+Ada 95 provides formal package parameters. One way of using these parameters
+is to define a "signature" for a class of abstractions, such as all set
+abstractions, or all physical unit abstractions, and then build a new
+generic abstraction on top of the original class of abstractions using this
+signature as the template for a formal package parameter.
+
+Unfortunately, it is difficult to use signatures because of the fact that an
+instantiation freezes all of its actual parameters.
+
+For example:
+
+Given the signature for a set abstraction:
+
+generic
+ type Element is private;
+ type Set is private;
+ with function Size(Of_Set : Set) return Natural is <>;
+ with function Union(Left, Right : Set) return Set is <>;
+ with function Intersection(Left, Right : Set) return Set is <>;
+ with function Empty return Set is <>;
+ with function Unit_Set(With_Item : Element) return Set is <>;
+ with function Nth_Element(Of_Set : Set) return Element is <>;
+package Set_Signature is end;
+...
+
+we could define a generic that required some set abstraction, but it
+didn't care which one so long as it implemented the above signature:
+
+generic
+ with package Base_Set is new Set_Signature(<>);
+package Layered_Abstraction is
+ type Cool_Type(Set : access Base_Set.Set) is limited_private;
+ procedure Massage(CT : in out Cool_Type; New_Set : Base_Set.Set);
+ ...
+end Layered_Abstraction;
+
+Now if we want to define a set type and provide the pre-instantiated
+signature for it, we run into trouble:
+
+generic
+ type Elem is private;
+ with function Hash(El : Elem) return Integer;
+package Hashed_Sets is
+
+ type Set is private;
+ function Union(Left, Right : Set) return Set;
+ ...
+
+ package Signature is new Set_Signature(Elem, Set);
+private
+ type Set is record ... end record;
+end Hashed_Sets;
+
+The problem is that we can't do the instantiation of Set_Signature where we
+would want to do so, because the instantiation freezes the type "Set"
+prematurely.
!proposal
@@ -28,7 +84,7 @@
!wording
-Add a new bullet after 3.10.1(9.3/2):
+Add a new bullet after 3.10.1(8/2):
* As a generic actual parameter whose corresponding generic
formal parameter is a formal incomplete type (see 12.5.1).
@@ -60,10 +116,10 @@
is all types, but [it]{the category} can be restricted to only nonlimited
types or to only tagged types. {Similarly, the category for a formal
incomplete type is all types but the category can be restricted to only
- tagged types.} The category determined for a formal derived type is the
- derivation class rooted at the ancestor type.
+ tagged types; unlike other formal types, the actual type does not need
+ to be able to be frozen (see 13.14).} The category determined for a formal
+ derived type is the derivation class rooted at the ancestor type.
-
Replace 12.5.1(6):
If a formal private or derived subtype is definite, then the
actual subtype shall also be definite.
@@ -77,7 +133,7 @@
For a generic formal private {or incomplete} type with a
known_discriminant_part:
-Append after 12.5.1(17/2):
+Append after 12.5.1(18):
The category determined for a formal incomplete type is the
category of all types, unless the formal_type_declaration
@@ -92,22 +148,145 @@
parameter of the instantiation is defaulted, the default_expression or
default_name for that parameter causes freezing.
- AARM note: Thus, an actual parameter corresponding to an formal
+ AARM note: Thus, an actual parameter corresponding to a formal
incomplete type parameter may denote an incomplete or private type
which is not completely defined at the point of the generic_instantiation.
!discussion
-** TBD **
+This generic formal is used in the definition of the iterator generic (see
+AI05-0139-2) in order to allow that generic to be visibly instantiated in
+containers packages (see AI05-0212-1).
!example
-
-** TBD **
-
---!corrigendum A.4.4(3)
+The set signature shown in the !problem could be written as:
+generic
+ type Element is private;
+ type Set;
+ with function Size(Of_Set : Set) return Natural is <>;
+ with function Union(Left, Right : Set) return Set is <>;
+ with function Intersection(Left, Right : Set) return Set is <>;
+ with function Empty return Set is <>;
+ with function Unit_Set(With_Item : Element) return Set is <>;
+ with function Nth_Element(Of_Set : Set) return Element is <>;
+package Set_Signature is end;
+
+Now the instance shown in the !problem is legal.
+
+!corrigendum 3.10.1(8/2)
+
+@dinsa
+@xbullet<as the @fa<subtype_mark> in an @fa<access_definition>.>
+@dinst
+@xbullet<as a generic actual parameter whose corresponding generic
+formal parameter is a formal incomplete type (see 12.5.1).>
+
+!corrigendum 12.5(2)
+
+@drepl
+@xcode<@fa<formal_type_declaration ::=
+ >@b<@ft<type>>@fa< defining_identifier[discriminant_part] >@b<@ft<is>>@fa< formal_type_definition;>>
+@dby
+@xcode<@fa<formal_type_declaration ::=
+ formal_complete_type_declaration
+ | formal_incomplete_type_declaration>>
+
+@xcode<@fa<formal_complete_type_declaration ::=
+ >@b<@ft<type>>@fa< defining_identifier[discriminant_part] >@b<@ft<is>>@fa< formal_type_definition
+ [aspect_specification];>>
+
+@xcode<@fa<formal_incomplete_type_declaration ::=
+ >@b<@ft<type>>@fa< defining_identifier[discriminant_part] [>@b<@ft<is tagged>>@fa<];>>
+
+
+!corrigendum 12.5(6)
+
+@drepl
+The form of a @fa<formal_type_definition> @i<determines a category (of types)>
+to which the formal type belongs. For a @fa<formal_private_type_definition> the
+reserved words @b<tagged> and @b<limited> indicate the category of types (see
+12.5.1). For a @fa<formal_derived_type_definition> the category of types is the
+derivation class rooted at the ancestor type. For other formal types, the name
+of the syntactic category indicates the category of types; a
+@fa<formal_discrete_type_definition> defines a discrete type, and so on.
+@dby
+The form of a @fa<formal_type_definition> @i<determines a category (of types)>
+to which the formal type belongs. For a @fa<formal_private_type_definition> the
+reserved words @b<tagged> and @b<limited> indicate the category of types (see
+12.5.1). The reserved word @b<tagged> also plays this role in the case of a
+@fa<formal_incomplete_type_declaration>.
+For a @fa<formal_derived_type_definition> the category of types is the
+derivation class rooted at the ancestor type. For other formal types, the name
+of the syntactic category indicates the category of types; a
+@fa<formal_discrete_type_definition> defines a discrete type, and so on.
+
+
+!corrigendum 12.5.1(1)
+
+@drepl
+In its most general form, the category determined for a formal private type
+is all types, but it can be restricted to only nonlimited types or to only
+tagged types. The category determined for a formal derived type is the
+derivation class rooted at the ancestor type.
+@dby
+In its most general form, the category determined for a formal private type
+is all types, but the category can be restricted to only nonlimited
+types or to only tagged types. Similarly, the category for a formal
+incomplete type is all types but the category can be restricted to only
+tagged types; unlike other formal types, the actual type does not need
+to be able to be frozen (see 13.14). The category determined for a formal
+derived type is the derivation class rooted at the ancestor type.
+
+!corrigendum 12.5.1(6)
+
+@drepl
+If the formal subtype is definite, then the
+actual subtype shall also be definite.
+@dby
+If a formal private or derived subtype is definite, then the
+actual subtype shall also be definite.
+
+A @fa<formal_incomplete_type_declaration> declares a formal incomplete type.
+The only view of a formal incomplete type is an incomplete view.
+Thus, a formal incomplete type is subject to the same
+usage restrictions as any other incomplete type - see 3.10.1.
+
+!corrigendum 12.5.1(11)
+
+@drepl
+The declaration of a formal derived type shall not have a @fa<known_discriminant_part>.
+For a generic formal private type with a @fa<known_discriminant_part>:
+@dby
+The declaration of a formal derived type shall not have a @fa<known_discriminant_part>.
+For a generic formal private or incomplete type with a @fa<known_discriminant_part>:
+
+!corrigendum 12.5.1(18)
+
+@dinsa
+The presence of the reserved word @b<abstract> determines whether the actual type
+may be abstract.
+@dinst
+The category determined for a formal incomplete type is the
+category of all types, unless the @fa<formal_type_declaration>
+includes the reserved word @b<tagged>; in this case, it is the
+category of all tagged types.
+
+!corrigendum 13.14(5)
+
+@drepl
+@xbullet<The occurrence of a @fa<generic_instantiation> causes freezing; also, if
+a parameter of the instantiation is defaulted, the @fa<default_expression> or
+@fa<default_name> for that parameter causes freezing.>
+@dby
+@xbullet<The occurrence of a @fa<generic_instantiation> causes freezing, except that
+a @fa<name> which is a generic actual parameter whose corresponding
+generic formal parameter is a formal incomplete type (see 12.5.1)
+does not cause freezing. In addition, if a
+parameter of the instantiation is defaulted, the @fa<default_expression> or
+@fa<default_name> for that parameter causes freezing.>
!ACATS test
Questions? Ask the ACAA Technical Agent