To: J3                                                     J3/23-223r2
From: John Reid & Hidetoshi Iwashita & Malcolm Cohen
Subject: Formal requirements for generic procedures
Date: 2023-October-24
References: N2217, 23-244.

1. Introduction
===============

At its meeting Jun 12-16, 2023, WG5 decided to approve generic
procedures as described in N2217 for Fortran 202Y. Use cases for
this are set out in N2217. Here we present formal requirements.

Formal specifications will be presented in 23-244.


2. Formal requirements
======================

a. There shall be a mechanism for defining a generic procedure,
   with a single procedure body rather than a set of specific procedures.

b. Such a generic procedure will have a generic name, but no specific
   name.

c. There shall be a mechanism for defining a generic procedure with a
   generic identifier that is an operator name, assignment, or
   input/output.

d. A generic procedure shall have one or more "generic" dummy arguments;
   a generic dummy argument is one that might have more than one value for
   a kind type parameter, more than one rank, or (assuming feasibility)
   more than one type.

NOTE: The proposed template facility has extensive features for handling
      different types; this is not meant to duplicate those. The
      motivating examples for different type are:
        (ex1) algorithms which work the same for real and complex;
        (ex2) algorithms which work the same for an intrinsic type such as
              real, and also for a user-defined type which provides a
              variation on such an intrinsic type.

e. As implied by the above, such a generic procedure implicitly defines an
   anonymous set of specific procedures, one for every combination of type,
   kind type parameter value, and rank. We will call each such combination
   a "generic combination".

f. A local variable of a generic procedure can have the same type, type
   parameters, and rank, as a generic dummy argument. Function result
   variables similarly.

g. There shall be a construct for ad-hoc specialization of executable code
   for the type and/or kind type parameter values of a dummy argument that
   is generic in type and/or kind.

NOTE: We already have such a construct for runtime polymorphism, but this
      requirement means compile-time polymorphism.

h. There shall be a construct for ad-hoc specialization of executable code
   for the rank of a dummy argument that is generic in rank.

NOTE: We already have such a construct for runtime rank variability, but
      this requirement is for compile-time rank variability.

i. If possible, this generic procedure facility should be available for
   generic type-bound procedure definition.

NOTE: This should be straightforward, except perhaps for coming up with
      convincing syntax.

j. If possible, this generic procedure facility should be available within
   a template.

k. If possible, this generic procedure facility should be available as a
   separate module subprogram, i.e. using a submodule.

NOTE: All of the "if possible" requirements depend on feasibility in the
      language design, standard wording, and implementation. If any of
      those aspects are difficult, they should be reconsidered.

===END===