Next: , Previous: 12, Up: 12


12.1 Generic Declarations

1
A generic_declaration declares a generic unit, which is either a generic subprogram or a generic package. A generic_declaration includes a generic_formal_part declaring any generic formal parameters. A generic formal parameter can be an object; alternatively (unlike a parameter of a subprogram), it can be a type, a subprogram, or a package.

Syntax

2

generic_declaration::= generic_subprogram_declaration generic_package_declaration

3

generic_subprogram_declaration::=
     generic_formal_part  subprogram_specification;

4

generic_package_declaration::=
     generic_formal_part  package_specification;

5

generic_formal_part::= generic {generic_formal_parameter_declaration use_clause}

6

generic_formal_parameter_declaration::=
      formal_object_declaration
    formal_type_declaration
    formal_subprogram_declaration
    formal_package_declaration

7

The only form of subtype_indication allowed within a generic_formal_part is a subtype_mark (that is, the subtype_indication shall not include an explicit constraint). The defining name of a generic subprogram shall be an identifier (not an operator_symbol).
Static Semantics

8/2
A generic_declaration declares a generic unit −− a generic package, generic procedure, or generic function, as appropriate.

9
An entity is a generic formal entity if it is declared by a generic_formal_parameter_declaration. "Generic formal," or simply "formal," is used as a prefix in referring to objects, subtypes (and types), functions, procedures and packages, that are generic formal entities, as well as to their respective declarations. Examples: "generic formal procedure" or a "formal integer type declaration."

Dynamic Semantics

10
The elaboration of a generic_declaration has no effect.

     NOTES

11

 Outside a generic unit a name that denotes the generic_declaration denotes the generic unit. In contrast, within the declarative region of the generic unit, a name that denotes the generic_declaration denotes the current instance.

12

 Within a generic subprogram_body, the name of this program unit acts as the name of a subprogram. Hence this name can be overloaded, and it can appear in a recursive call of the current instance. For the same reason, this name cannot appear after the reserved word new in a (recursive) generic_instantiation.

13

 A default_expression or default_name appearing in a generic_formal_part is not evaluated during elaboration of the generic_formal_part; instead, it is evaluated when used. (The usual visibility rules apply to any name used in a default: the denoted declaration therefore has to be visible at the place of the expression.)
Examples

14
Examples of generic formal parts:

15

     generic     −−  parameterless 

16

     generic
        Size Natural;  −−  formal object 

17

     generic
        Length Integer := 200;          −− formal object with default expression

18

        Area   Integer := Length*Length; −− formal object with default expression

19

     generic
        type Item  is private;                       −− formal type
        type Index is (<>);                          −− formal type
        type Row   is array(Index range <>) of Item; −− formal type
        with function "<"(X, Item) return Boolean;    −− formal subprogram 

20
Examples of generic declarations declaring generic subprograms Exchange and Squaring:

21

     generic
        type Elem is private;
     procedure Exchange(U, in out Elem);

22

     generic
        type Item is private;
        with function "*"(U, Item) return Item is <>;
     function Squaring(X Item) return Item;

23
Example of a generic declaration declaring a generic package:

24

     generic
        type Item   is private;
        type Vector is array (Positive range <>) of Item;
        with function Sum(X, Item) return Item;
     package On_Vectors is
        function Sum  (A, Vector) return Vector;
        function Sigma(A    Vector) return Item;
        Length_Error exception;
     end On_Vectors;