Contents Index Previous Next
12.6 Formal Subprograms
1
[
{generic formal subprogram}
{formal subprogram, generic}
Formal subprograms can be used to pass callable entities
to a generic unit.]
Language Design Principles
1.a
Generic formal subprograms are
like renames of the explicit_generic_actual_parameter.
Syntax
2
formal_subprogram_declaration
::= with subprogram_specification [
is subprogram_default];
3
subprogram_default
::= default_name | <>
4
Name Resolution Rules
5
{expected profile (formal subprogram
default_name) [partial]} The expected
profile for the
default_name, if
any, is that of the formal subprogram.
5.a
Ramification: This rule,
unlike others in this clause, is observed at compile time of the generic_declaration.
5.b
The evaluation of the default_name
takes place during the elaboration of each instantiation that uses the default,
as defined in 12.3, ``Generic
Instantiation''.
6
{expected profile (formal subprogram
actual) [partial]} For a generic formal
subprogram, the expected profile for the actual is that of the formal
subprogram.
Legality Rules
7
The profiles of the formal and any named default
shall be mode-conformant.
{mode conformance (required)}
7.a
Ramification: This rule,
unlike others in this clause, is checked at compile time of the generic_declaration.
8
The profiles of the formal and actual shall be
mode-conformant.
{mode conformance (required)}
Static Semantics
9
A formal_subprogram_declaration
declares a generic formal subprogram. The types of the formal parameters
and result, if any, of the formal subprogram are those determined by
the subtype_marks given in the formal_subprogram_declaration;
however, independent of the particular subtypes that are denoted by the
subtype_marks, the nominal subtypes
of the formal parameters and result, if any, are defined to be nonstatic,
and unconstrained if of an array type [(no applicable index constraint
is provided in a call on a formal subprogram)]. In an instance, a formal_subprogram_declaration
declares a view of the actual. The profile of this view takes its subtypes
and calling convention from the original profile of the actual entity,
while taking the formal parameter names
and default_expressions from the
profile given in the formal_subprogram_declaration.
The view is a function or procedure, never an entry.
9.a
Discussion: This rule is
intended to be the same as the one for renamings-as-declarations, where
the formal_subprogram_declaration
is analogous to a renaming-as-declaration, and the actual is analogous
to the renamed view.
10
If a generic unit has a subprogram_default
specified by a box, and the corresponding actual parameter is omitted,
then it is equivalent to an explicit actual parameter that is a usage
name identical to the defining name of the formal.
11
13 The matching rules for formal subprograms
state requirements that are similar to those applying to subprogram_renaming_declarations
(see 8.5.4). In particular, the name of a parameter
of the formal subprogram need not be the same as that of the corresponding parameter
of the actual subprogram; similarly, for these parameters, default_expressions
need not correspond.
12
14 The constraints that apply
to a parameter of a formal subprogram are those of the corresponding
formal parameter of the matching actual subprogram (not those implied
by the corresponding subtype_mark
in the _specification of the formal
subprogram). A similar remark applies to the result of a function. Therefore,
to avoid confusion, it is recommended that the name
of a first subtype be used in any declaration of a formal subprogram.
13
15 The subtype specified
for a formal parameter of a generic formal subprogram can be any visible
subtype, including a generic formal subtype of the same generic_formal_part.
14
16 A formal subprogram is
matched by an attribute of a type if the attribute is a function with
a matching specification. An enumeration literal of a given type matches
a parameterless formal function whose result type is the given type.
15
17 A default_name
denotes an entity that is visible or directly visible at the place of
the generic_declaration; a box used
as a default is equivalent to a name that denotes an entity that is directly
visible at the place of the _instantiation.
15.a
Proof: Visibility and name
resolution are applied to the equivalent explicit actual parameter.
16
18 The actual subprogram cannot be
abstract (see 3.9.3).
Examples
17
Examples of
generic formal subprograms:
18
with function "+"(X, Y : Item) return Item is <>;
with function Image(X : Enum) return String is Enum'Image;
with procedure Update is Default_Update;
19
-- given the generic procedure declaration
20
generic
with procedure Action (X : in Item);
procedure Iterate(Seq : in Item_Sequence);
21
-- and the procedure
22
procedure Put_Item(X : in Item);
23
-- the following instantiation is possible
24
procedure Put_List is new Iterate(Action => Put_Item);
Contents Index Previous Next Legal