To: J3                                                     J3/25-140
From: generics
Subject: Miscellaneous edits to incorporate templates
Date: 2025-May-19
References: 25-112, 25-135, 25-136, 25-137, 25-138, 25-139,
            24-125r5, 24-126r4, 24-127r4

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

This is the 6th of 6 papers that provide edits for the approved syntax
for templates. This paper describes various edits occurring outside the
new new clause introduced in papers 1-5 that are necessary to incorporate
the syntax and semantics for templates.

2. Edits required for deferred arguments
========================================


* Insert new glossary term in 3.7

  [deferred argument association]
  association between an instantiation argument and a deferred
  argument (Sec. ?)

* Insert new glossary term

  [deferred argument]
  named entity that appears in a <deferred-arg-list> (R???) (Sec. ?)

* Insert new glossary term 3.34.x

  [deferred constant]
  a deferred argument with the PARAMETER attribute

* Insert new glossary term

  [instantiation argument]
  entity that determines deferred argument association

* Insert new glossary term

  [ultimately defined prior]

  {could shorten to "defined prior" but that might be too confusing
  compared to "previously defined"}

  "an entity that is accessed by host association and whose definition
  appears before the scoping unit in which it is reference or is
  ultimately defined prior in the host scoping unit"

* 3.120 Add TEMPLATE construct and REQUIREMENT construct to the list in the
  definition so that it now reads:

  "BLOCK construct, derived-type definition, interface body, program
  unit (3.113), subprogram, template construct, or requirement
  construct, excluding all nested scoping units in it"

 * 3.139 Modify subprogram to include templated functions and
         subroutines to read:

  "<function-subprogram> (R1532), <subroutine-subprogram> (R1537),
  <templated-function-subprogram> (R???), or
  <templated-subroutine-subprogram> (R???)"

* 5.4.1.1 General

  Modify first sentence of paragraph 2 to read:

  "A type is either an intrinsic type, a derived type, or a deferred type."

* 5.4.1.3 Derived type

  Add new subclause

  "5.4.1.3+ Deferred type

  Deferred types are deferred arguments that are types in templates,
  templated procedures, or requirements.  Deferred types are described
  further in tt.xx. "

* 7.3.2.1 Type specifier syntax

  Extend R702 <type-spec> to include <deferred-type>  such that it reads:

   " R702 <type-spec> <<is>> <intrinsic-type-spec>
       <<or>> <derived-type-spec>
       <<or>> <deferred-type>
       <<or>> <enum-type-spec>
       <<or>> <enumeration-type-spec> "

  Modify C703 to include <deferred-type> such that it reads:

  "(R702) The <derived-type-spec> or <deferred-type> shall not specify
   an abstract type (7.5.7) except when it appears as an
   <instantiation-arg>."

  Extend R703 <declaration-type-spec> to include <deferred-type> such
  that it reads:

    "R703 <declaration-type-spec> <<is>> <intrinsic-type-spec>
       <<or>> TYPE ( <intrinsic-type-spec> )
       <<or>> TYPE ( <derived-type-spec> )
       <<or>> TYPE ( <deferred-type> )
       <<or>> TYPE ( <enum-type-spec> )
       <<or>> TYPE ( <enumeration-type-spec> )
       <<or>> CLASS ( <derived-type-spec> )
       <<or>> CLASS ( <deferred-type> )
       <<or>> CLASS ( * )
       <<or>> TYPE ( * )
       <<or>> TYPEOF ( <data-ref> )
       <<or>> CLASSOF ( <data-ref> )"


  Change C705 wording to be consintent with constraints just after it:

  "C705 (R703) CLASS(<derived-type-spec>) shall specify an extensible
  type (7.5.7)."

{This is just a wording change, but the original is so glaringly
different than the nigh identical constraint that follows, that
generics subgroup thought it should be updated.}

  After C705 introduce a new constraint:

   "C705+ (R703) CLASS(<deferred-type>) shall specify an extensible
  type (7.5.7)."

  After C706 introduce a new constraint

   "C706+ (R703) TYPE(<deferred-type>) shall not specify an abstract type
   (7.5.7)."

* 7.5.2.1 Syntax of a derived-type definition

  Insert new constraint on R728:

   "C737b (R728) <parent-type-name> shall not be a <deferred-type>."

* 8.5.2 Accessibility attribute

  In C817, insert "or template" after "module", so that it now reads:

  "C817 An access-spec shall appear only in the specification-part of a
       module or template construct."

* 8.6.1 Accessibility Statement

  Change C873 to allow for templates:

  "C873 (R831) An <access-stmt> shall appear only in the
        <specification-part> of a module or template. Only one
        accessibility statement with an omitted <access-id-list> is
        permitted in the <specification-part> of a module or
        template."

  Change C874 to allow for templates:

   "C874 (R831) Each <access-name> shall be the name of a module,
         variable, procedure, nonintrinsic type, named constant other
         than a deferred constant, namelist group, requirement, or
         template."

    In 2nd sentence of paragraph 1, insert "or template" after
         "in the module" in both locations such that the sentence now
         reads:

    "An access-stmt without an access-id list specifies the default
    accessibility of the identifiers of entities declared in the
    module or template, and of entities accessed from a module whose
    name does not appear in any access-stmt in the module or
    template."

  In last sentence of paragraph 1, insert "or template" after
         "in a module" such that the sentence now reads:

    "If no such statement appears in a module or template, the default
    is public accessibility."

  In 1st sentence of paragraph 2, insert "or template" after "in
       the module" such that the sentence now reads:

    "If an identifier is accessed by use association and not declared
    in the module or template, and the name of every module from which
    it is accessed appears in an access-stmt in the scoping unit, its
    default accessibility is PRIVATE if the access-spec in every such
    access-stmt is PRIVATE, or PUBLIC if the access-spec in any such
    access-stmt is PUBLIC."

* 8.5.8.1 General

  Change last entry for <array-spec> from:
    "<<or>>   <assumed-rank-spec>"
  To:
    "<<or>>   <assumed-or-implied-rank-spec>"

* 8.5.8.2 Explicit-shape array

Modify R818 to disambiguate lower and upper explicit bounds such that
       it reads:

"R818 <explicit-shape-bounds-spec>
     <<is>> [ <lower-explicit-bounds-expr> : ] <upper-explicit-bounds-expr>
     <<or>> <lower-bound> : <explicit-bounds-expr>
     <<or>> <explicit-bounds-expr> : <upper-bound>
 R818b <lower-explicit-bounds-expr> <<is>> <explicit-bounds-expr>
 R818c <upper-explicit-bounds-expr> <<is>> <explicit-bounds-expr>
"

* 8.5.8.6 Implied-shape array

  Modify the first sentence from:
    "An implied-shape array is a named constant that takes its shape
    from the constant-expr in its declaration."
  To:
    "An implied-shape array is a named constant that takes its shape
    from a constant expression. If it is a deferred constant, it takes
    its shape from the associated instantiation argument, otherwise it
    takes its shape from the constant expression in its declaration."

{Note that this change is a bit larger than strictly necessary.  It is
needed for deferred constants, but it seems natural to include
ordinary constant here.}

  Delete the first sentence in the last paragraph which reads:

    The extent of each dimension of an implied-shape array is the same
    as the extent of the corresponding dimension of the constant-expr.

* 8.5.8.7 Assumed-rank entity

  Change name of section to "Assumed-rank or implied-rank entities"

  Modify text in former 8.5.8.7 (Assumed-rank entity) to use new
       syntax term <assumed-or-implied-rank-spec> such that it now reads:

   "An assumed-rank entity is a dummy data object whose rank is
    assumed from its effective argument, or the associate name of a
    RANK DEFAULT block in a SELECT RANK construct; this rank can be
    zero. The bounds and shape of an assumed-rank entity with the
    ALLOCATABLE or POINTER attribute are determined as specified in
    8.5.8.4. An assumed-rank entity is declared with an <array-spec>
    that is an <assumed-or-implied-rank-spec>.

    R827 assumed-or-implied-rank-spec is ..

    C839 An assumed-rank entity shall be an associate name or a dummy
         data object that does not have the CODIMENSION or VALUE
         attribute.

    C840 An assumed-rank variable name shall not appear in a
         designator or expression except as an actual argument that
         corresponds to a dummy argument that is assumed-rank, the
         argument of the function C_LOC or C_SIZEOF from the intrinsic
         module ISO_C_BINDING (18.2), the first dummy argument of an
         intrinsic inquiry function, or the selector of a SELECT RANK
         statement.

    C841 If an assumed-size or nonallocatable nonpointer assumed-rank
         array is an actual argument that corresponds to a dummy
         argument that is an INTENT (OUT) assumed-rank array, it shall
         not be polymorphic, finalizable, of a type with an
         allocatable ultimate component, or of a type for which
         default initialization is specified.

* Insert new section after 8.5.8.7.1:

    "8.5.8.7.2 Implied-rank entity

     An implied-rank entity is an entity whose rank becomes defined
     only within the instantiation of a template.  The following are
     implied-rank entities:

       - deferred constant declared with <assumed-or-implied-rank-spec>

       - variable, dummy argument, or deferred constant whose rank is
         declared to be a deferred integer, scalar constant expression

       - variable, dummy argument, or deferred constant whose shape is
         declared to be a deferred integer, rank-1 array expression.

{UTI: Also make sure it works with SELECT GENERIC RANK and spell out
      what can be done with implied-rank entities.  Contingent on
      edits for auto-generic procedures.}

    NOTE

        The following are examples of implied-rank entities

        TEMPLATE EXAMPLE(C, S, N)
           DEFERRED INTEGER, PARAMETER :: S(*)
           DEFERRED INTEGER, PARAMETER :: C(..) ! implied-rank
           INTEGER, PARAMETER :: B(S) = 1       ! implied-rank
	   REAL, PARAMETER, RANK(RANK(C)) :: D  ! implied rank
        END TEMPLATE

* 8.5.17  RANK clause

{UTI: Do we want to allow RANK(*)?  Not strictly necessary given that
      we have DIMENSION(..).  Low priority.}

  Replace constraint C864 which states:
    C864  An entity declared with a rank-clause shall be a dummy data
          object or have the ALLOCATABLE or POINTER attribute.
  With:
    C864  An entity declared with a rank-clause shall be a named constant,
          dummy data object or have the ALLOCATABLE or POINTER attribute.

{This change is a bit larger than strictly necessary for generic
programming.  We only need to allow it for deferred constants, but it
seems natural to allow for ordinary named constants as well.}

  Amend the last sentence of the section to allow for the deferred
  constant case, such that the paragraph now reads:

    "If the rank is zero the entity is scalar; otherwise, if it has
    the ALLOCATABLE or POINTER attribute, it specifies that it is a
    deferred-shape array; otherwise, if it is a named constant, it
    specifies that it is an implied-shape array with all lower
    bounds equal to one; otherwise, it specifies that it is an
    assumed-shape array with all the lower bounds equal to one".

* 8.6.1 Accessibility statement

Modify C873 to include templates such that it reads:

  "C873 An <access-stmt> shall appear only in the <specification-part> of a
  module or template construct. Only one accessibility statement with
  an omitted <access-id-list> is permitted in the <specification-part>
  of a module or template construct."

* 10.1.12 Constant expression

  Extend list in normative text for "constant expression" to include
  "deferred constant"


{UTI: The following section was well intended but cast too large of a
      shadow. We should elsewhere specify similar sentiments but
      restricted to RANK and KIND with regards to TKR resolution.}

* Insert new section 10.1.12+: Deferred constant expressions

  "<deferred-const-expr> <<is>> <constant-expr>

  An expression is a <deferred-const-expr> if one or more of its
  primaries is a deferred constant.

  A <deferred-const-expr> is not equal to any other <constant-expr> unless
  <constant-expr> is syntactically equivalent."

  deferred integer, parameter :: C
  deferred integer, parameter :: R
  integer, parameter :: R2 = C

  real, rank(R), allocatable :: x

  select rank (x)
  rank is (0)
  rank is (1)
  rank is (2)
  rank is (3)
  ...
  end select rank

  real, rank(C), allocatable :: y
  real, rank(R2), allocatable :: z

  if (rank(x) == rank(y)) then
     ...
  end if
  if (rank(z) == rank(y)) then
     ...
  end if

  template tmpl(C)

* 11.1.11.1 Purpose and form of the SELECT TYPE construct

  Extend R1156 to include <deferred-type>, such that it now reads:


  "R1156 <type-guard-stmt>
      <<is>> TYPE IS ( <type-spec> ) [ <select-construct-name> ]
      <<or>> CLASS IS ( <derived-type-spec> ) [ <select-construct-name> ]
      <<or>> CLASS IS ( <deferred-type> ) [ <select-construct-name> ]
      <<or>> CLASS DEFAULT [ <select-construct-name> ]"

  Add constraint to R1156:
    C1169b (R1156) <deferred-type> shall specify an extensible type.

* 15.5.1 Syntax of a procedure reference

{UTI: spelling of <inline-instantiate> vs <inline-instantiation>}

  Extend R1522 <procedure-designator> with <deferred-proc> and
  <inline-instantiate> such that it reads:

   "R1522 <procedure-designator> <<is>> <procedure-name>
                                 <<or>> <proc-component-ref>
                                 <<or>> <data-ref> % binding-name
                                 <<or>> <deferred-proc>
                                 <<or>> <inline-instantiate>

  Extend R1524 <actual-arg> with <deferred-proc> and
  <inline-instantiate> such that it reads:

   "R1524 actual-arg <<is>> <expr>
                     <<or>> <variable>
                     <<or>> <procedure-name>
                     <<or>> <proc-component-ref>
                     <<or>> <conditional-arg>
		     <<or>> <alt-return-spec>
		     <<or>> <deferred-proc>
		     <<or>> <inline-instantiate>

{UTI - the section distinction between 2 & 3 here are probably fiction at
this point.}

3. Edits required for templates and instantiation
=================================================

* 5.1 High level syntax

  Extend R508 <specification-construct> to include new syntax terms:
     <template>, <require-stmt>, <requirement> and
     <instantiation-stmt>, such that it now reads:

   "R508 <specification-construct> <<is>> <derived-type-def>
                                   <<or>> <enum-def>
                                   <<or>> <enumeration-type-def>
                                   <<or>> <generic-stmt>
                                   <<or>> <interface-block>
                                   <<or>> <parameter-stmt>
                                   <<or>> <procedure-declaration-stmt>
                                   <<or>> <other-specification-stmt>
                                   <<or>> <type-declaration-stmt>
                                   <<or>> <template>
                                   <<or>> <require-stmt>
                                   <<or>> <requirement>
                                   <<or>> <instantiate-stmt>
   "

{ Allowing REQUIRE outside of templates is not something that has been
  discussed in plenary, but seems to be a natural thing to allow to
  generics subgroup.  It would provide a means for library developer
  to ensure that their product meets certain requirements without
  regard to any specific (external) template.}

  Extend R512 to include templated procedures such that it now reads:


   "R512 <internal-subprogram>
         <<is>> <function-subprogram>
         <<or>> <subroutine-subprogram>
         <<or>> <templated-subroutine-subprogram>
         <<or>> <templated-function-subprogram>"


* 8.7 IMPLICIT Statement

  Change last sentence of paragraph 3 on page 127 and add 2 new
  paragraphs to specify that there is no default mapping inside
  templates and templated procedures. It should now read:

   "If a mapping is not specified for a letter, the default mapping of
     - a program unit, or
     - an interface body outside a template scoping unit or templated
       subprogram
    is default integer if the letter is I, J, ..., or N and default real
    otherwise.

    If a mapping is not specified for a letter, the default mapping for
    a BLOCK construct, internal subprogram, or module subprogram is the
    mapping in the host scoping unit.

    The mapping for a template construct, a templated subprogram, or
    an interface body that appears within a template or templated
    subprogram is the null mapping.
   "

* 8.8p2 IMPORT Statement

  Modify sentence 2 in p2 to include deferred interface blocks, such
  that it now reads:

    "This is the default for an interface body that is not a module
     procedure interface body or an interface body that appears in a
     deferred interface block."

  Modify sentence 2 in p4 to include deferred interface blocks, such
  that it now reads:

    "This is the default for a derived-type definition, internal
     subprogram, module procedure interface body, module subprogram,
     submodule, or an interface body that appears in a deferred
     interface block."


* 14.2.1 Module syntax and semantics

  Extend list in R1408 to include templated procedures, such that it
  now reads:

    "R1408 <module-subprogram>
              <<is>> <function-subprogram>
              <<or>> <subroutine-subprogram>
              <<or>> <separate-module-subprogram>
              <<or>> <templated-function-subprogram>
              <<or>> <templated-subroutine-subprogram>"

* 15.4.3.2 Interface block

  Extend list in R1503 to include deferred interface, such that it
  now reads:

    "R1503 <interface-stmt> <<is>> INTERFACE [ <generic-spec> ]
                            <<or>> ABSTRACT INTERFACE
                            <<or>> DEFERRED INTERFACE"

  Change last sentence of para 2 to include DEFERRED interfaces such
  that it now reads:

    "An interface block without ABSTRACT, DEFERRED, or a generic
     specification is a specific interface block."


  After para 2, insert new paragraph:

    "An interface block introduced by DEFERRED INTERFACE is a deferred
     interface block. An interface body in a deferred interface block
     specifies a deferred procedure."

<<< Got here on 2025-04-21.  Need to decide right section for below. >>>

* 15.4.3.4.5 Restrictions on generic declarations

 [317:10+] Insert new paragraphs to address deferred arguments:

   "A kind-type parameter whose value depends on a deferred argument
    is only the same as another kind-type parameter declared with
    a syntactically equivalent expression.

    An entity whose rank depends on a deferred argument only has
    the same rank as another entity if that entity has its rank
    declared with a syntactically equivalent expression.  If the rank
    of an implied-rank entity is not declared with a rank clause, it
    does not have the same rank as any other entity."


{ UTI: Is "depends on" acceptable terminology here? }
{ UTI: We should define "syntactically equivalent" }
{ UTI: Prevent specifying rank and bounds for deferred constants I.e.

       DEFERRED INTEGER, PARAMTER :: C(*)
       DEFERRED INTEGER, PARAMETER, RANK(SIZE(C)) :: D(C)

       REQUIREMENT R(C, F)
          DEFERRED INTEGER, PARAMETER :: C
          DEFERRED INTERFACE
             INTEGER FUNCTION F(X)
                INTEGER, RANK(C+1) :: X
             END FUNCTION
	  END INTERFACE
       END REQUIREMENT
       DEFERRED INTEGER, PARAMETER :: A
       DEFERRED INTEGER, PARAMETER, RANK(A) :: B
       REQUIRES R(A, F)
       ...
       PRINT *, F(B) ! Should be compile time error
}


  NOTE Some examples of implied-rank entities are shown in the
       following example template. C is explicitly declared
       as implied-rank. B is implied-rank because its rank depends on
       the size of the deferred argument S. X, Y and Z are implied-rank
       because their ranks depend on the value of the deferred argument N.

    TEMPLATE EXAMPLE(C, S, N)
      DEFERRED INTEGER, PARAMETER :: C(..) ! implied-shape & implied-rank
      DEFERRED INTEGER, PARAMETER :: S(*), N
      INTEGER, PARAMETER :: B(S) = 1 ! explicit-shape & implied-rank
    CONTAINS
      SUBROUTINE SUB(X)
        INTEGER, RANK(N) :: X ! assumed-shape & implied-rank
        INTEGER :: Y([(i, i = 1, N)]) ! explicit-shape & implied-rank
        INTEGER, RANK(N), ALLOCATABLE :: Z ! deferred-shape & implied-rank
        call sub_explicit(C) ! valid, element order association
        ! call sub_assumed(C) ! invalid, rank expressions don't match
        ! call sub_same_rank(C) ! invalid, rank expressions don't match

        call sub_explicit(X) ! valid, element order association
        ! call sub_assumed(X) ! invalid, rank expressions don't match
        call sub_same_rank(X) ! valid, rank expressions match

        call sub_explicit(Y) ! valid, element order association
        ! call sub_assumed(Y) ! invalid, rank expressions don't match
        ! call sub_same_rank(Y) ! invalid, rank expressions don't match
      END SUBROUTINE
      SUBROUTINE SUB_EXPLICIT(X)
        INTEGER :: X(10)
      END SUBROUTINE
      SUBROUTINE SUB_ASSUMED(X)
        INTEGER :: X(:)
      END SUBROUTINE
      SUBROUTINE SUB_SAME_RANK(X)
        INTEGER, RANK(N) :: X
      END SUBROUTINE
    END TEMPLATE

* 15.5.2.5 Ordinary dummy variables

[326:6] After first sentence of p3, insert a new sentence about for
        compatibility of dummy arguments with deferred kind:

    "If a kind-type parameter of the actual argument or its
     corresponding dummy argument depends on a deferred constant, then
     both shall have syntactically equivalent declarations for that
     kind-type parameter."

{deferred kind}

[327:12] After p15 introduce new paragraph to address deferred rank
         entities:

    "If the rank of the actual argument or its corresponding dummy
     argument depend on a deferred constant, then their ranks agree if
     and only if they are declared with syntactically equivalent
     expressions."


{deferred rank}

* 15.6.2.1 General

{<prefix-spec> for templated procedures.}

R1530 extended to include TEMPLATE.

C???? (R1530) TEMPLATE shall not appear except in a
              <templated-function-stmt> or a
              <templated-subroutine-stmt>.

* 15.6.2.2 Function subprogram

  Change constraint C1573 to refer to rule R1532 instead of R1536.

  {<end-function-stmt> is reused for templated procedures. Therefore
  the constraint must be attached to a different rule to be applicable
  in both situations.}

* 15.6.2.3 Subroutine subprogram

  Change constraint C1576 to refer to rule R1537 instead of R1540.

  {<end-subroutine-stmt> is reused for templated procedures. Therefore
  the constraint must be attached to a different rule to be applicable
  in both situations.}




* 16.9.57 CO_REDUCE(A,OPERATION,...)

[382:36] After second sentence in paragraph insert:

"It shall not be of a deferred type."



* A.2 Processor Dependencies

  [555:15+] Insert new bullet:
    * the names of the dummy arguments of a deferred procedure without
      an explicit specification;

{ need refernence for above bullet }

===END===