AARM95 - Formal Subprograms
Author: JTC1/SC22/WG9/ARG, by Randall Brukardt, ARG Editor

Contents Index Previous Next

# 12.6 Formal Subprograms

1
[ 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
default_name ::= name

#### Name Resolution Rules

5
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
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.
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.

#### 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.
NOTES
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